Merge pull request #229 from rastala/master

version 1.0.17

Dockerfiles/1.0.10/Dockerfile

@@ -0,0 +1,29 @@
+FROM continuumio/miniconda:4.5.11
+
+# install git
+RUN apt-get update && apt-get upgrade -y && apt-get install -y git
+
+# create a new conda environment named azureml
+RUN conda create -n azureml -y -q Python=3.6
+
+# install additional packages used by sample notebooks. this is optional
+RUN ["/bin/bash", "-c", "source activate azureml && conda install -y tqdm cython matplotlib scikit-learn"]
+
+# install azurmel-sdk components
+RUN ["/bin/bash", "-c", "source activate azureml && pip install azureml-sdk[notebooks]==1.0.10"]
+
+# clone Azure ML GitHub sample notebooks
+RUN cd /home && git clone -b "azureml-sdk-1.0.10" --single-branch https://github.com/Azure/MachineLearningNotebooks.git
+
+# generate jupyter configuration file
+RUN ["/bin/bash", "-c", "source activate azureml && mkdir ~/.jupyter && cd ~/.jupyter && jupyter notebook --generate-config"]
+
+# set an emtpy token for Jupyter to remove authentication. 
+# this is NOT recommended for production environment
+RUN echo "c.NotebookApp.token = ''" >> ~/.jupyter/jupyter_notebook_config.py
+
+# open up port 8887 on the container
+EXPOSE 8887
+
+# start Jupyter notebook server on port 8887 when the container starts
+CMD /bin/bash -c "cd /home/MachineLearningNotebooks && source activate azureml && jupyter notebook --port 8887 --no-browser --ip 0.0.0.0 --allow-root"

Dockerfiles/1.0.15/Dockerfile

@@ -0,0 +1,29 @@
+FROM continuumio/miniconda:4.5.11
+
+# install git
+RUN apt-get update && apt-get upgrade -y && apt-get install -y git
+
+# create a new conda environment named azureml
+RUN conda create -n azureml -y -q Python=3.6
+
+# install additional packages used by sample notebooks. this is optional
+RUN ["/bin/bash", "-c", "source activate azureml && conda install -y tqdm cython matplotlib scikit-learn"]
+
+# install azurmel-sdk components
+RUN ["/bin/bash", "-c", "source activate azureml && pip install azureml-sdk[notebooks]==1.0.15"]
+
+# clone Azure ML GitHub sample notebooks
+RUN cd /home && git clone -b "azureml-sdk-1.0.15" --single-branch https://github.com/Azure/MachineLearningNotebooks.git
+
+# generate jupyter configuration file
+RUN ["/bin/bash", "-c", "source activate azureml && mkdir ~/.jupyter && cd ~/.jupyter && jupyter notebook --generate-config"]
+
+# set an emtpy token for Jupyter to remove authentication. 
+# this is NOT recommended for production environment
+RUN echo "c.NotebookApp.token = ''" >> ~/.jupyter/jupyter_notebook_config.py
+
+# open up port 8887 on the container
+EXPOSE 8887
+
+# start Jupyter notebook server on port 8887 when the container starts
+CMD /bin/bash -c "cd /home/MachineLearningNotebooks && source activate azureml && jupyter notebook --port 8887 --no-browser --ip 0.0.0.0 --allow-root"

Dockerfiles/1.0.2/Dockerfile

@@ -0,0 +1,29 @@
+FROM continuumio/miniconda:4.5.11
+
+# install git
+RUN apt-get update && apt-get upgrade -y && apt-get install -y git
+
+# create a new conda environment named azureml
+RUN conda create -n azureml -y -q Python=3.6
+
+# install additional packages used by sample notebooks. this is optional
+RUN ["/bin/bash", "-c", "source activate azureml && conda install -y tqdm cython matplotlib scikit-learn"]
+
+# install azurmel-sdk components
+RUN ["/bin/bash", "-c", "source activate azureml && pip install azureml-sdk[notebooks]==1.0.2"]
+
+# clone Azure ML GitHub sample notebooks
+RUN cd /home && git clone -b "azureml-sdk-1.0.2" --single-branch https://github.com/Azure/MachineLearningNotebooks.git
+
+# generate jupyter configuration file
+RUN ["/bin/bash", "-c", "source activate azureml && mkdir ~/.jupyter && cd ~/.jupyter && jupyter notebook --generate-config"]
+
+# set an emtpy token for Jupyter to remove authentication. 
+# this is NOT recommended for production environment
+RUN echo "c.NotebookApp.token = ''" >> ~/.jupyter/jupyter_notebook_config.py
+
+# open up port 8887 on the container
+EXPOSE 8887
+
+# start Jupyter notebook server on port 8887 when the container starts
+CMD /bin/bash -c "cd /home/MachineLearningNotebooks && source activate azureml && jupyter notebook --port 8887 --no-browser --ip 0.0.0.0 --allow-root"

Dockerfiles/1.0.6/Dockerfile

@@ -0,0 +1,29 @@
+FROM continuumio/miniconda:4.5.11
+
+# install git
+RUN apt-get update && apt-get upgrade -y && apt-get install -y git
+
+# create a new conda environment named azureml
+RUN conda create -n azureml -y -q Python=3.6
+
+# install additional packages used by sample notebooks. this is optional
+RUN ["/bin/bash", "-c", "source activate azureml && conda install -y tqdm cython matplotlib scikit-learn"]
+
+# install azurmel-sdk components
+RUN ["/bin/bash", "-c", "source activate azureml && pip install azureml-sdk[notebooks]==1.0.6"]
+
+# clone Azure ML GitHub sample notebooks
+RUN cd /home && git clone -b "azureml-sdk-1.0.6" --single-branch https://github.com/Azure/MachineLearningNotebooks.git
+
+# generate jupyter configuration file
+RUN ["/bin/bash", "-c", "source activate azureml && mkdir ~/.jupyter && cd ~/.jupyter && jupyter notebook --generate-config"]
+
+# set an emtpy token for Jupyter to remove authentication. 
+# this is NOT recommended for production environment
+RUN echo "c.NotebookApp.token = ''" >> ~/.jupyter/jupyter_notebook_config.py
+
+# open up port 8887 on the container
+EXPOSE 8887
+
+# start Jupyter notebook server on port 8887 when the container starts
+CMD /bin/bash -c "cd /home/MachineLearningNotebooks && source activate azureml && jupyter notebook --port 8887 --no-browser --ip 0.0.0.0 --allow-root"

Dockerfiles/1.0.8/Dockerfile

@@ -0,0 +1,29 @@
+FROM continuumio/miniconda:4.5.11
+
+# install git
+RUN apt-get update && apt-get upgrade -y && apt-get install -y git
+
+# create a new conda environment named azureml
+RUN conda create -n azureml -y -q Python=3.6
+
+# install additional packages used by sample notebooks. this is optional
+RUN ["/bin/bash", "-c", "source activate azureml && conda install -y tqdm cython matplotlib scikit-learn"]
+
+# install azurmel-sdk components
+RUN ["/bin/bash", "-c", "source activate azureml && pip install azureml-sdk[notebooks]==1.0.8"]
+
+# clone Azure ML GitHub sample notebooks
+RUN cd /home && git clone -b "azureml-sdk-1.0.8" --single-branch https://github.com/Azure/MachineLearningNotebooks.git
+
+# generate jupyter configuration file
+RUN ["/bin/bash", "-c", "source activate azureml && mkdir ~/.jupyter && cd ~/.jupyter && jupyter notebook --generate-config"]
+
+# set an emtpy token for Jupyter to remove authentication. 
+# this is NOT recommended for production environment
+RUN echo "c.NotebookApp.token = ''" >> ~/.jupyter/jupyter_notebook_config.py
+
+# open up port 8887 on the container
+EXPOSE 8887
+
+# start Jupyter notebook server on port 8887 when the container starts
+CMD /bin/bash -c "cd /home/MachineLearningNotebooks && source activate azureml && jupyter notebook --port 8887 --no-browser --ip 0.0.0.0 --allow-root"

NBSETUP.md

@@ -1,10 +1,11 @@
-# Notebook setup
+# Setting up environment
 
 ---
 
-To run the notebooks in this repository use one of these methods:
+To run the notebooks in this repository use one of following options.
 
-## Use Azure Notebooks - Jupyter based notebooks in the Azure cloud
+## **Option 1: Use Azure Notebooks**
+Azure Notebooks is a hosted Jupyter-based notebook service in the Azure cloud. Azure Machine Learning Python SDK is already pre-installed in the Azure Notebooks `Python 3.6` kernel.
 
 1. [![Azure Notebooks](https://notebooks.azure.com/launch.png)](https://aka.ms/aml-clone-azure-notebooks)
 [Import sample notebooks ](https://aka.ms/aml-clone-azure-notebooks) into Azure Notebooks
@@ -15,20 +16,91 @@ To run the notebooks in this repository use one of these methods:
 
     ![set kernel to Python 3.6](images/python36.png)
 
-## **Use your own notebook server**
+## **Option 2: Use your own notebook server**
 
-Video walkthrough:
+### Quick installation
+We recommend you create a Python virtual environment ([Miniconda](https://conda.io/miniconda.html) preferred but [virtualenv](https://virtualenv.pypa.io/en/latest/) works too) and install the SDK in it.
+```sh
+# install just the base SDK
+pip install azureml-sdk
+
+# clone the sample repoistory
+git clone https://github.com/Azure/MachineLearningNotebooks.git
+
+# below steps are optional
+# install the base SDK and a Jupyter notebook server
+pip install azureml-sdk[notebooks]
+
+# install the data prep component
+pip install azureml-dataprep
+
+# install model explainability component
+pip install azureml-sdk[explain]
+
+# install automated ml components
+pip install azureml-sdk[automl]
+
+# install experimental features (not ready for production use)
+pip install azureml-sdk[contrib]
+```
+
+Note the _extras_ (the keywords inside the square brackets) can be combined. For example:
+```sh
+# install base SDK, Jupyter notebook and automated ml components
+pip install azureml-sdk[notebooks,automl]
+```
+
+### Full instructions
+[Install the Azure Machine Learning SDK](https://docs.microsoft.com/en-us/azure/machine-learning/service/quickstart-create-workspace-with-python)
+
+Please make sure you start with the [Configuration](configuration.ipynb) notebook to create and connect to a workspace.
+
+
+### Video walkthrough:
 
 [![Get Started video](images/yt_cover.png)](https://youtu.be/VIsXeTuW3FU)
 
-1. Setup a Jupyter Notebook server and [install the Azure Machine Learning SDK](https://docs.microsoft.com/en-us/azure/machine-learning/service/quickstart-create-workspace-with-python)
-1. Clone [this repository](https://aka.ms/aml-notebooks)
-1. You may need to install other packages for specific notebook
-    - For example, to run the Azure Machine Learning Data Prep notebooks, install the extra dataprep SDK:
-    ```bash
-     pip install azureml-dataprep
-    ```
 
-1. Start your notebook server
-1. Follow the instructions in the [Configuration](configuration.ipynb) notebook to create and connect to a workspace
-1. Open one of the sample notebooks
+## **Option 3: Use Docker**
+
+You need to have Docker engine installed locally and running. Open a command line window and type the following command. 
+
+__Note:__ We use version `1.0.10` below as an exmaple, but you can replace that with any available version number you like.
+
+```sh
+# clone the sample repoistory
+git clone https://github.com/Azure/MachineLearningNotebooks.git
+
+# change current directory to the folder 
+# where Dockerfile of the specific SDK version is located.
+cd MachineLearningNotebooks/Dockerfiles/1.0.10
+
+# build a Docker image with the a name (azuremlsdk for example) 
+# and a version number tag (1.0.10 for example).
+# this can take several minutes depending on your computer speed and network bandwidth.
+docker build . -t azuremlsdk:1.0.10
+
+# launch the built Docker container which also automatically starts
+# a Jupyter server instance listening on port 8887 of the host machine
+docker run -it -p 8887:8887 azuremlsdk:1.0.10
+```
+
+Now you can point your browser to http://localhost:8887. We recommend that you start from the `configuration.ipynb` notebook at the root directory.
+
+If you need additional Azure ML SDK components, you can either modify the Docker files before you build the Docker images to add additional steps, or install them through command line in the live container after you build the Docker image. For example:
+
+```sh
+# install dataprep components
+pip install azureml-dataprep
+
+# install the core SDK and automated ml components
+pip install azureml-sdk[automl]
+
+# install the core SDK and model explainability component
+pip install azureml-sdk[explain]
+
+# install the core SDK and experimental components
+pip install azureml-sdk[contrib]
+```
+Drag and Drop
+The image will be downloaded by Fatkun

README.md

@@ -1,9 +1,6 @@
 # Azure Machine Learning service example notebooks
 
-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/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.
 
 ![Azure ML workflow](https://raw.githubusercontent.com/MicrosoftDocs/azure-docs/master/articles/machine-learning/service/media/overview-what-is-azure-ml/aml.png)
 
@@ -11,30 +8,32 @@ and maintaining the complete data science workflow from the cloud.
 ```sh
 pip install azureml-sdk
 ```
-Read more detailed instructions on [how to set up your environment](./NBSETUP.md).
+Read more detailed instructions on [how to set up your environment](./NBSETUP.md) using Azure Notebook service, your own Jupyter notebook server, or Docker.
 
 ## How to navigate and use the example notebooks?
 You should always run the [Configuration](./configuration.ipynb) notebook first when setting up a notebook library on a new machine or in a new environment. It configures your notebook library to connect to an Azure Machine Learning workspace, and sets up your workspace and compute to be used by many of the other examples. 
 
 If you want to...
 
- * ...try out and explore Azure ML, start with image classification tutorials [part 1 training](./tutorials/img-classification-part1-training.ipynb) and [part 2 deployment](./tutorials/img-classification-part2-deploy.ipynb).
+ * ...try out and explore Azure ML, start with image classification tutorials: [Part 1 (Training)](./tutorials/img-classification-part1-training.ipynb) and [Part 2 (Deployment)](./tutorials/img-classification-part2-deploy.ipynb).
+ * ...prepare your data and do automated machine learning, start with regression tutorials: [Part 1 (Data Prep)](./tutorials/regression-part1-data-prep.ipynb) and [Part 2 (Automated ML)](./tutorials/regression-part2-automated-ml.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 model as 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 [register and manage models, and create Docker images](./how-to-use-azureml/deployment/register-model-create-image-deploy-service/register-model-create-image-deploy-service.ipynb), and [production deploy models on Azure Kubernetes Cluster](./how-to-use-azureml/deployment/production-deploy-to-aks/production-deploy-to-aks.ipynb).
- * ...deploy models as batch scoring service, first [train a model within Notebook](./how-to-use-azureml/training/train-within-notebook/train-within-notebook.ipynb), learn how to [register and manage models](./how-to-use-azureml/deployment/register-model-create-image-deploy-service/register-model-create-image-deploy-service.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](./how-to-use-azureml/machine-learning-pipelines/pipeline-mpi-batch-prediction.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 [register and manage models, and create Docker images](./how-to-use-azureml/deployment/register-model-create-image-deploy-service/register-model-create-image-deploy-service.ipynb), and [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), learn how to [register and manage models](./how-to-use-azureml/deployment/register-model-create-image-deploy-service/register-model-create-image-deploy-service.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](./how-to-use-azureml/machine-learning-pipelines/pipeline-mpi-batch-prediction.ipynb).
  * ...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) and [model data collection](./how-to-use-azureml/deployment/enable-data-collection-for-models-in-aks/enable-data-collection-for-models-in-aks.ipynb).
 
 ## Tutorials
 
-The [Tutorials](./tutorials) folder contains notebooks for the tutorials described in the [Azure Machine Learning documentation](https://aka.ms/aml-docs)
+The [Tutorials](./tutorials) folder contains notebooks for the tutorials described in the [Azure Machine Learning documentation](https://aka.ms/aml-docs).
   
 ## How to use Azure ML
 
 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](./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
+- [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
@@ -44,9 +43,8 @@ The [How to use Azure ML](./how-to-use-azureml) folder contains specific example
 ## Documentation
 
  * Quickstarts, end-to-end tutorials, and how-tos on the [official documentation site for Azure Machine Learning service](https://docs.microsoft.com/en-us/azure/machine-learning/service/).
-
- * [Python SDK reference]( https://docs.microsoft.com/en-us/python/api/overview/azure/ml/intro?view=azure-ml-py)
-
+ * [Python SDK reference](https://docs.microsoft.com/en-us/python/api/overview/azure/ml/intro?view=azure-ml-py)
+ * Azure ML Data Prep SDK [overview](https://aka.ms/data-prep-sdk), [Python SDK reference](https://aka.ms/aml-data-prep-apiref), and [tutorials and how-tos](https://aka.ms/aml-data-prep-notebooks).
 
 ---
 

configuration.ipynb

@@ -96,7 +96,7 @@
       "source": [
         "import azureml.core\n",
         "\n",
-        "print(\"This notebook was created using version 1.0.10 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.0.17 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -373,4 +373,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 2
-}
+}

googleade5d7141b3f2910.html

@@ -0,0 +1 @@
+google-site-verification: googleade5d7141b3f2910.html

how-to-use-azureml/README.md

@@ -4,8 +4,9 @@ Learn how to use Azure Machine Learning services for experimentation and model m
 
 As a pre-requisite, run the [configuration Notebook](../configuration.ipynb) notebook first to set up your Azure ML Workspace. Then, run the notebooks in following recommended order.
 
- * [train-within-notebook](./training/train-within-notebook): Train a model hile tracking run history, and learn how to deploy the model as web service to Azure Container Instance.
- * [train-on-local](./training/train-on-local): Learn how to submit a run and use Azure ML managed run configuration.
+* [train-within-notebook](./training/train-within-notebook): Train a model hile tracking run history, and learn how to deploy the model as web service to Azure Container Instance.
+* [train-on-local](./training/train-on-local): Learn how to submit a run to local computer and use Azure ML managed run configuration.
+* [train-on-amlcompute](./training/train-on-amlcompute): Use a 1-n node Azure ML managed compute cluster for remote runs on Azure CPU or GPU infrastructure.
 * [train-on-remote-vm](./training/train-on-remote-vm): Use Data Science Virtual Machine as a target for remote runs.
 * [logging-api](./training/logging-api): Learn about the details of logging metrics to run history.
 * [register-model-create-image-deploy-service](./deployment/register-model-create-image-deploy-service): Learn about the details of model management.
@@ -13,4 +14,4 @@ As a pre-requisite, run the [configuration Notebook](../configuration.ipynb) not
 * [enable-data-collection-for-models-in-aks](./deployment/enable-data-collection-for-models-in-aks) Learn about data collection APIs for deployed model.
 * [enable-app-insights-in-production-service](./deployment/enable-app-insights-in-production-service) Learn how to use App Insights with production web service.
  
-Find quickstarts, end-to-end tutorials, and how-tos on the [official documentation site for Azure Machine Learning service](https://docs.microsoft.com/en-us/azure/machine-learning/service/).
+Find quickstarts, end-to-end tutorials, and how-tos on the [official documentation site for Azure Machine Learning service](https://docs.microsoft.com/en-us/azure/machine-learning/service/).

how-to-use-azureml/automated-machine-learning/README.md

@@ -25,7 +25,7 @@ Below are the three execution environments supported by AutoML.
 
 1. [![Azure Notebooks](https://notebooks.azure.com/launch.png)](https://aka.ms/aml-clone-azure-notebooks)
 [Import sample notebooks ](https://aka.ms/aml-clone-azure-notebooks) into Azure Notebooks.
-1. Follow the instructions in the [configuration](configuration.ipynb) notebook to create and connect to a workspace.
+1. Follow the instructions in the [configuration](../../configuration.ipynb) notebook to create and connect to a workspace.
 1. Open one of the sample notebooks.
 
  <a name="databricks"></a>
@@ -90,7 +90,7 @@ bash automl_setup_linux.sh
 ```
 
 ### 4. Running configuration.ipynb
-- Before running any samples you next need to run the configuration notebook. Click on configuration.ipynb notebook
+- Before running any samples you next need to run the configuration notebook. Click on [configuration](../../configuration.ipynb) notebook
 - Execute the cells in the notebook to Register Machine Learning Services Resource Provider and create a workspace. (*instructions in notebook*)
 
 ### 5. Running Samples
@@ -99,9 +99,6 @@ bash automl_setup_linux.sh
 
 <a name="samples"></a>
 # Automated ML SDK Sample Notebooks
-- [configuration.ipynb](configuration.ipynb)
-    - Create new Azure ML Workspace
-    - Save Workspace configuration file
 
 - [auto-ml-classification.ipynb](classification/auto-ml-classification.ipynb)
     - Dataset: scikit learn's [digit dataset](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html#sklearn.datasets.load_digits)
@@ -169,6 +166,9 @@ bash automl_setup_linux.sh
     - How to specifying sample_weight
     - The difference that it makes to test results
 
+- [auto-ml-subsampling-local.ipynb](subsampling/auto-ml-subsampling-local.ipynb)
+    - How to enable subsampling
+
 - [auto-ml-dataprep.ipynb](dataprep/auto-ml-dataprep.ipynb)
     - Using DataPrep for reading data
 
@@ -229,6 +229,9 @@ If a sample notebook fails with an error that property, method or library does n
 1) Check that you have selected correct kernel in jupyter notebook.  The kernel is displayed in the top right of the notebook page.  It can be changed using the `Kernel | Change Kernel` menu option.  For Azure Notebooks, it should be `Python 3.6`.  For local conda environments, it should be the conda envioronment name that you specified in automl_setup.  The default is azure_automl.  Note that the kernel is saved as part of the notebook.  So, if you switch to a new conda environment, you will have to select the new kernel in the notebook.
 2) Check that the notebook is for the SDK version that you are using.  You can check the SDK version by executing `azureml.core.VERSION` in a jupyter notebook cell.  You can download previous version of the sample notebooks from GitHub by clicking the `Branch` button, selecting the `Tags` tab and then selecting the version.
 
+## Numpy import fails on Windows
+Some Windows environments see an error loading numpy with the latest Python version 3.6.8.  If you see this issue, try with Python version 3.6.7.
+
 ## Remote run: DsvmCompute.create fails 
 There are several reasons why the DsvmCompute.create can fail.  The reason is usually in the error message but you have to look at the end of the error message for the detailed reason.  Some common reasons are:
 1) `Compute name is invalid, it should start with a letter, be between 2 and 16 character, and only include letters (a-zA-Z), numbers (0-9) and \'-\'.`  Note that underscore is not allowed in the name.

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

@@ -2,7 +2,7 @@ name: azure_automl
 dependencies:
   # The python interpreter version.
   # Currently Azure ML only supports 3.5.2 and later.
-- python=3.6
+- python>=3.5.2,<3.6.8
 - nb_conda
 - matplotlib==2.1.0
 - numpy>=1.11.0,<1.15.0
@@ -12,20 +12,9 @@ dependencies:
 - scikit-learn>=0.18.0,<=0.19.1
 - pandas>=0.22.0,<0.23.0
 - tensorflow>=1.12.0
+- py-xgboost<=0.80
 
-# Required for azuremlftk
-- dill
-- pyodbc
-- statsmodels 
-- numexpr  
-- keras
-- distributed>=1.21.5,<1.24
-  
 - pip:
-
-  # Required for azuremlftk
-  - https://azuremlpackages.blob.core.windows.net/forecasting/azuremlftk-0.1.18323.5a1-py3-none-any.whl
-
   # Required packages for AzureML execution, history, and data preparation.
   - azureml-sdk[automl,notebooks,explain]
   - pandas_ml

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

@@ -2,7 +2,7 @@ name: azure_automl
 dependencies:
   # The python interpreter version.
   # Currently Azure ML only supports 3.5.2 and later.
-- python=3.6
+- python>=3.5.2,<3.6.8
 - nb_conda
 - matplotlib==2.1.0
 - numpy>=1.15.3
@@ -12,20 +12,9 @@ dependencies:
 - scikit-learn>=0.18.0,<=0.19.1
 - pandas>=0.22.0,<0.23.0
 - tensorflow>=1.12.0
+- py-xgboost<=0.80
 
-# Required for azuremlftk
-- dill
-- pyodbc
-- statsmodels 
-- numexpr  
-- keras
-- distributed>=1.21.5,<1.24
-  
 - pip:
-
-  # Required for azuremlftk
-  - https://azuremlpackages.blob.core.windows.net/forecasting/azuremlftk-0.1.18323.5a1-py3-none-any.whl
-
   # Required packages for AzureML execution, history, and data preparation.
   - azureml-sdk[automl,notebooks,explain]
   - pandas_ml

how-to-use-azureml/automated-machine-learning/classification-with-deployment/auto-ml-classification-with-deployment.ipynb

@@ -84,9 +84,9 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for experiment\n",
-        "experiment_name = 'automl-local-classification'\n",
+        "experiment_name = 'automl-classification-deployment'\n",
         "# project folder\n",
-        "project_folder = './sample_projects/automl-local-classification'\n",
+        "project_folder = './sample_projects/automl-classification-deployment'\n",
         "\n",
         "experiment=Experiment(ws, experiment_name)\n",
         "\n",
@@ -103,23 +103,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -289,8 +272,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "experiment_name = 'automl-local-classification'\n",
-        "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "ml_run = AutoMLRun(experiment = experiment, run_id = local_run.id)"
       ]

how-to-use-azureml/automated-machine-learning/classification-with-whitelisting/auto-ml-classification-with-whitelisting.ipynb

@@ -100,23 +100,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -81,8 +81,8 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# Choose a name for the experiment and specify the project folder.\n",
-        "experiment_name = 'automl-local-classification'\n",
-        "project_folder = './sample_projects/automl-local-classification'\n",
+        "experiment_name = 'automl-classification'\n",
+        "project_folder = './sample_projects/automl-classification'\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
@@ -99,23 +99,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

how-to-use-azureml/automated-machine-learning/dataprep-remote-execution/auto-ml-dataprep-remote-execution.ipynb

@@ -49,23 +49,6 @@
         "Currently, Data Prep only supports __Ubuntu 16__ and __Red Hat Enterprise Linux 7__. We are working on supporting more linux distros."
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -49,23 +49,6 @@
         "Currently, Data Prep only supports __Ubuntu 16__ and __Red Hat Enterprise Linux 7__. We are working on supporting more linux distros."
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

how-to-use-azureml/automated-machine-learning/exploring-previous-runs/auto-ml-exploring-previous-runs.ipynb

@@ -70,23 +70,6 @@
         "ws = Workspace.from_config()"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -47,30 +47,6 @@
         "## Setup\n"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "To use the *forecasting* task in AutoML, you need to have the **azuremlftk** package installed in your environment. The following cell tests whether this package is installed locally and, if not, gives you instructions for installing it.  "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "try:\n",
-        "    import ftk\n",
-        "    print('Using FTK version ' + ftk.__version__)\n",
-        "except ImportError:\n",
-        "    print(\"Unable to import forecasting package. This notebook does not work without this package.\\n\"\n",
-        "          + \"Please open a command prompt and run `pip install azuremlftk` to install the package. \\n\"\n",
-        "          + \"Make sure you install the package into AutoML's Python environment.\\n\\n\"\n",
-        "          + \"For instance, if AutoML is installed in a conda environment called `python36`, run:\\n\"\n",
-        "          + \"> activate python36\\n> pip install azuremlftk\")"
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,

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

@@ -38,7 +38,7 @@
         "3. Find and train a forecasting model using local compute\n",
         "4. Evaluate the performance of the model\n",
         "\n",
-        "The examples in the follow code samples use the [University of Chicago's Dominick's Finer Foods dataset](https://research.chicagobooth.edu/kilts/marketing-databases/dominicks) to forecast orange juice sales. Dominick's was a grocery chain in the Chicago metropolitan area."
+        "The examples in the follow code samples use the University of Chicago's Dominick's Finer Foods dataset to forecast orange juice sales. Dominick's was a grocery chain in the Chicago metropolitan area."
       ]
     },
     {
@@ -48,30 +48,6 @@
         "## Setup"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "To use the *forecasting* task in AutoML, you need to have the **azuremlftk** package installed in your environment. The following cell tests whether this package is installed locally and, if not, gives you instructions for installing it."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "try:\n",
-        "    import ftk\n",
-        "    print('Using FTK version ' + ftk.__version__)\n",
-        "except ImportError:\n",
-        "    print(\"Unable to import forecasting package. This notebook does not work without this package.\\n\"\n",
-        "          + \"Please open a command prompt and run `pip install azuremlftk` to install the package. \\n\"\n",
-        "          + \"Make sure you install the package into AutoML's Python environment.\\n\\n\"\n",
-        "          + \"For instance, if AutoML is installed in a conda environment called `python36`, run:\\n\"\n",
-        "          + \"> activate python36\\n> pip install azuremlftk\")"
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -171,8 +147,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Data Splitting\n",
-        "For the purposes of demonstration and later forecast evaluation, we now split the data into a training and a testing set. The test set will contain the final 20 weeks of observed sales for each time-series."
+        "For demonstration purposes, we extract sales time-series for just a few of the stores:"
       ]
     },
     {
@@ -181,19 +156,37 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "ntest_periods = 20\n",
+        "use_stores = [2, 5, 8]\n",
+        "data_subset = data[data.Store.isin(use_stores)]\n",
+        "nseries = data_subset.groupby(grain_column_names).ngroups\n",
+        "print('Data subset contains {0} individual time-series.'.format(nseries))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Data Splitting\n",
+        "We now split the data into a training and a testing set for later forecast evaluation. The test set will contain the final 20 weeks of observed sales for each time-series. The splits should be stratified by series, so we use a group-by statement on the grain columns."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "n_test_periods = 20\n",
         "\n",
         "def split_last_n_by_grain(df, n):\n",
-        "    \"\"\"\n",
-        "    Group df by grain and split on last n rows for each group\n",
-        "    \"\"\"\n",
+        "    \"\"\"Group df by grain and split on last n rows for each group.\"\"\"\n",
         "    df_grouped = (df.sort_values(time_column_name) # Sort by ascending time\n",
         "                  .groupby(grain_column_names, group_keys=False))\n",
         "    df_head = df_grouped.apply(lambda dfg: dfg.iloc[:-n])\n",
         "    df_tail = df_grouped.apply(lambda dfg: dfg.iloc[-n:])\n",
         "    return df_head, df_tail\n",
         "\n",
-        "X_train, X_test = split_last_n_by_grain(data, ntest_periods)"
+        "X_train, X_test = split_last_n_by_grain(data_subset, n_test_periods)"
       ]
     },
     {
@@ -211,24 +204,7 @@
         "\n",
         "AutoML will currently train a single, regression-type model across **all** time-series in a given training set. This allows the model to generalize across related series.\n",
         "\n",
-        "You are almost ready to start an AutoML training job. We will first need to create a validation set from the existing training set (i.e. for hyper-parameter tuning): "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "nvalidation_periods = 20\n",
-        "X_train, X_validate = split_last_n_by_grain(X_train, nvalidation_periods)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "We also need to separate the target column from the rest of the DataFrame: "
+        "You are almost ready to start an AutoML training job. First, we need to separate the target column from the rest of the DataFrame: "
       ]
     },
     {
@@ -238,8 +214,7 @@
       "outputs": [],
       "source": [
         "target_column_name = 'Quantity'\n",
-        "y_train = X_train.pop(target_column_name).values\n",
-        "y_validate = X_validate.pop(target_column_name).values "
+        "y_train = X_train.pop(target_column_name).values"
       ]
     },
     {
@@ -248,22 +223,31 @@
       "source": [
         "## Train\n",
         "\n",
-        "The AutoMLConfig object defines the settings and data for an AutoML training job. Here, we set necessary inputs like the task type, the number of AutoML iterations to try, and the training and validation data. \n",
+        "The AutoMLConfig object defines the settings and data for an AutoML training job. Here, we set necessary inputs like the task type, the number of AutoML iterations to try, the training data, and cross-validation parameters. \n",
         "\n",
-        "For forecasting tasks, there are some additional parameters that can be set: the name of the column holding the date/time and the grain column names. A time column is required for forecasting, while the grain is optional. If a grain is not given, the forecaster assumes that the whole dataset is a single time-series. We also pass a list of columns to drop prior to modeling. The _logQuantity_ column is completely correlated with the target quantity, so it must be removed to prevent a target leak. \n",
+        "For forecasting tasks, there are some additional parameters that can be set: the name of the column holding the date/time, the grain column names, and the maximum forecast horizon. A time column is required for forecasting, while the grain is optional. If a grain is not given, AutoML assumes that the whole dataset is a single time-series. We also pass a list of columns to drop prior to modeling. The _logQuantity_ column is completely correlated with the target quantity, so it must be removed to prevent a target leak.\n",
+        "\n",
+        "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 maximum 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 organizaion that needs to estimate the next month of sales would set the horizon accordingly.   \n",
+        "\n",
+        "Finally, a note about the cross-validation (CV) procedure for time-series data. AutoML uses out-of-sample error estimates to select a best pipeline/model, so it is important that the CV fold splitting is done correctly. Time-series can violate the basic statistical assumptions of the canonical K-Fold CV strategy, so AutoML implements a [rolling origin validation](https://robjhyndman.com/hyndsight/tscv/) procedure to create CV folds for time-series data. To use this procedure, you just need to specify the desired number of CV folds in the AutoMLConfig object. It is also possible to bypass CV and use your own validation set by setting the *X_valid* and *y_valid* parameters of AutoMLConfig.\n",
+        "\n",
+        "Here is a summary of AutoMLConfig parameters used for training the OJ model:\n",
         "\n",
         "|Property|Description|\n",
         "|-|-|\n",
         "|**task**|forecasting|\n",
         "|**primary_metric**|This is the metric that you want to optimize.<br> Forecasting supports the following primary metrics <br><i>spearman_correlation</i><br><i>normalized_root_mean_squared_error</i><br><i>r2_score</i><br><i>normalized_mean_absolute_error</i>\n",
         "|**iterations**|Number of iterations. In each iteration, Auto ML trains a specific pipeline on the given data|\n",
-        "|**X**|Training matrix of features, shape = [n_training_samples, n_features]|\n",
-        "|**y**|Target values, shape = [n_training_samples, ]|\n",
-        "|**X_valid**|Validation matrix of features, shape = [n_validation_samples, n_features]|\n",
-        "|**y_valid**|Target values for validation, shape = [n_validation_samples, ]\n",
+        "|**X**|Training matrix of features as a pandas DataFrame, shape = [n_training_samples, n_features]|\n",
+        "|**y**|Target values as a numpy.ndarray, shape = [n_training_samples, ]|\n",
+        "|**n_cross_validations**|Number of cross-validation folds to use for model/pipeline selection|\n",
         "|**enable_ensembling**|Allow AutoML to create ensembles of the best performing models\n",
         "|**debug_log**|Log file path for writing debugging information\n",
-        "|**path**|Relative path to the project folder.  AutoML stores configuration files for the experiment under this folder. You can specify a new empty folder. "
+        "|**path**|Relative path to the project folder.  AutoML stores configuration files for the experiment under this folder. You can specify a new empty folder.|\n",
+        "|**time_column_name**|Name of the datetime column in the input data|\n",
+        "|**grain_column_names**|Name(s) of the columns defining individual series in the input data|\n",
+        "|**drop_column_names**|Name(s) of columns to drop prior to modeling|\n",
+        "|**max_horizon**|Maximum desired forecast horizon in units of time-series frequency|"
       ]
     },
     {
@@ -272,10 +256,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "automl_settings = {\n",
+        "time_series_settings = {\n",
         "    'time_column_name': time_column_name,\n",
         "    'grain_column_names': grain_column_names,\n",
-        "    'drop_column_names': ['logQuantity']\n",
+        "    'drop_column_names': ['logQuantity'],\n",
+        "    'max_horizon': n_test_periods\n",
         "}\n",
         "\n",
         "automl_config = AutoMLConfig(task='forecasting',\n",
@@ -284,12 +269,11 @@
         "                             iterations=10,\n",
         "                             X=X_train,\n",
         "                             y=y_train,\n",
-        "                             X_valid=X_validate,\n",
-        "                             y_valid=y_validate,\n",
+        "                             n_cross_validations=5,\n",
         "                             enable_ensembling=False,\n",
         "                             path=project_folder,\n",
         "                             verbosity=logging.INFO,\n",
-        "                            **automl_settings)"
+        "                             **time_series_settings)"
       ]
     },
     {

how-to-use-azureml/automated-machine-learning/missing-data-blacklist-early-termination/auto-ml-missing-data-blacklist-early-termination.ipynb

@@ -102,23 +102,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -74,9 +74,9 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for experiment\n",
-        "experiment_name = 'automl-local-classification'\n",
+        "experiment_name = 'automl-model-explanation'\n",
         "# project folder\n",
-        "project_folder = './sample_projects/automl-local-classification-model-explanation'\n",
+        "project_folder = './sample_projects/automl-model-explanation'\n",
         "\n",
         "experiment=Experiment(ws, experiment_name)\n",
         "\n",
@@ -93,23 +93,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics=True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -96,23 +96,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -104,23 +104,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -130,7 +113,7 @@
         "1. Create a Linux DSVM in Azure, following these [quick instructions](https://docs.microsoft.com/en-us/azure/machine-learning/desktop-workbench/how-to-create-dsvm-hdi). Make sure you use the Ubuntu flavor (not CentOS). Make sure that disk space is available under `/tmp` because AutoML creates files under `/tmp/azureml_run`s. The DSVM should have more cores than the number of parallel runs that you plan to enable. It should also have at least 4GB per core.\n",
         "2. Enter the IP address, user name and password below.\n",
         "\n",
-        "**Note:** By default, SSH runs on port 22 and you don't need to change the port number below. If you've configured SSH to use a different port, change `dsvm_ssh_port` accordinglyaddress. [Read more](https://render.githubusercontent.com/documentation/sdk/ssh-issue.md) on changing SSH ports for security reasons."
+        "**Note:** By default, SSH runs on port 22 and you don't need to change the port number below. If you've configured SSH to use a different port, change `dsvm_ssh_port` accordinglyaddress. [Read more](https://docs.microsoft.com/en-us/azure/virtual-machines/troubleshooting/detailed-troubleshoot-ssh-connection) on changing SSH ports for security reasons."
       ]
     },
     {

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

@@ -67,6 +67,7 @@
       "source": [
         "import logging\n",
         "import os\n",
+        "import csv\n",
         "\n",
         "from matplotlib import pyplot as plt\n",
         "import numpy as np\n",
@@ -89,7 +90,7 @@
         "\n",
         "# Choose a name for the run history container in the workspace.\n",
         "experiment_name = 'automl-remote-amlcompute'\n",
-        "project_folder = './sample_projects/automl-remote-amlcompute'\n",
+        "project_folder = './project'\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
@@ -106,23 +107,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -171,6 +155,51 @@
         "     # For a more detailed view of current AmlCompute status, use get_status()."
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Data\n",
+        "For remote executions, you need to make the data accessible from the remote compute.\n",
+        "This can be done by uploading the data to DataStore.\n",
+        "In this example, we upload scikit-learn's [load_digits](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html) data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "data_train = datasets.load_digits()\n",
+        "\n",
+        "if not os.path.isdir('data'):\n",
+        "    os.mkdir('data')\n",
+        "    \n",
+        "if not os.path.exists(project_folder):\n",
+        "    os.makedirs(project_folder)\n",
+        "    \n",
+        "pd.DataFrame(data_train.data).to_csv(\"data/X_train.tsv\", index=False, header=False, quoting=csv.QUOTE_ALL, sep=\"\\t\")\n",
+        "pd.DataFrame(data_train.target).to_csv(\"data/y_train.tsv\", index=False, header=False, sep=\"\\t\")\n",
+        "\n",
+        "ds = ws.get_default_datastore()\n",
+        "ds.upload(src_dir='./data', target_path='bai_data', overwrite=True, show_progress=True)\n",
+        "\n",
+        "from azureml.core.runconfig import DataReferenceConfiguration\n",
+        "dr = DataReferenceConfiguration(datastore_name=ds.name, \n",
+        "                   path_on_datastore='bai_data', \n",
+        "                   path_on_compute='/tmp/azureml_runs',\n",
+        "                   mode='download', # download files from datastore to compute target\n",
+        "                   overwrite=False)"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -188,29 +217,13 @@
         "conda_run_config.environment.docker.enabled = True\n",
         "conda_run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE\n",
         "\n",
+        "# set the data reference of the run coonfiguration\n",
+        "conda_run_config.data_references = {ds.name: dr}\n",
+        "\n",
         "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'], conda_packages=['numpy'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Data\n",
-        "For remote executions you should author a `get_data.py` file containing a `get_data()` function. This file should be in the root directory of the project. You can encapsulate code to read data either from a blob storage or local disk in this file.\n",
-        "In this example, the `get_data()` function returns data using scikit-learn's [load_digits](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html) method."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "if not os.path.exists(project_folder):\n",
-        "    os.makedirs(project_folder)"
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -219,17 +232,13 @@
       "source": [
         "%%writefile $project_folder/get_data.py\n",
         "\n",
-        "from sklearn import datasets\n",
-        "from scipy import sparse\n",
-        "import numpy as np\n",
+        "import pandas as pd\n",
         "\n",
         "def get_data():\n",
-        "    \n",
-        "    digits = datasets.load_digits()\n",
-        "    X_train = digits.data\n",
-        "    y_train = digits.target\n",
+        "    X_train = pd.read_csv(\"/tmp/azureml_runs/bai_data/X_train.tsv\", delimiter=\"\\t\", header=None, quotechar='\"')\n",
+        "    y_train = pd.read_csv(\"/tmp/azureml_runs/bai_data/y_train.tsv\", delimiter=\"\\t\", header=None, quotechar='\"')\n",
         "\n",
-        "    return { \"X\" : X_train, \"y\" : y_train }"
+        "    return { \"X\" : X_train.values, \"y\" : y_train[0].values }\n"
       ]
     },
     {

how-to-use-azureml/automated-machine-learning/remote-execution-with-datastore/auto-ml-remote-execution-with-datastore.ipynb

@@ -99,23 +99,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics=True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -123,7 +106,7 @@
         "### Create a Remote Linux DSVM\n",
         "Note: If creation fails with a message about Marketplace purchase eligibilty, go to portal.azure.com, start creating DSVM there, and select \"Want to create programmatically\" to enable programmatic creation. Once you've enabled it, you can exit without actually creating VM.\n",
         "\n",
-        "**Note**: By default SSH runs on port 22 and you don't need to specify it. But if for security reasons you can switch to a different port (such as 5022), you can append the port number to the address. [Read more](https://render.githubusercontent.com/documentation/sdk/ssh-issue.md) on this."
+        "**Note**: By default SSH runs on port 22 and you don't need to specify it. But if for security reasons you can switch to a different port (such as 5022), you can append the port number to the address. [Read more](https://docs.microsoft.com/en-us/azure/virtual-machines/troubleshooting/detailed-troubleshoot-ssh-connection) on this."
       ]
     },
     {

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

@@ -68,6 +68,7 @@
         "import logging\n",
         "import os\n",
         "import time\n",
+        "import csv\n",
         "\n",
         "from matplotlib import pyplot as plt\n",
         "import numpy as np\n",
@@ -90,7 +91,7 @@
         "\n",
         "# Choose a name for the run history container in the workspace.\n",
         "experiment_name = 'automl-remote-dsvm'\n",
-        "project_folder = './sample_projects/automl-remote-dsvm'\n",
+        "project_folder = './project'\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
@@ -107,23 +108,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -153,6 +137,44 @@
         "    time.sleep(90) # Wait for ssh to be accessible"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Data\n",
+        "For remote executions, you need to make the data accessible from the remote compute.\n",
+        "This can be done by uploading the data to DataStore.\n",
+        "In this example, we upload scikit-learn's [load_digits](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html) data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "data_train = datasets.load_digits()\n",
+        "\n",
+        "if not os.path.isdir('data'):\n",
+        "    os.mkdir('data')\n",
+        "    \n",
+        "if not os.path.exists(project_folder):\n",
+        "    os.makedirs(project_folder)\n",
+        "    \n",
+        "pd.DataFrame(data_train.data).to_csv(\"data/X_train.tsv\", index=False, header=False, quoting=csv.QUOTE_ALL, sep=\"\\t\")\n",
+        "pd.DataFrame(data_train.target).to_csv(\"data/y_train.tsv\", index=False, header=False, sep=\"\\t\")\n",
+        "\n",
+        "ds = ws.get_default_datastore()\n",
+        "ds.upload(src_dir='./data', target_path='re_data', overwrite=True, show_progress=True)\n",
+        "\n",
+        "from azureml.core.runconfig import DataReferenceConfiguration\n",
+        "dr = DataReferenceConfiguration(datastore_name=ds.name, \n",
+        "                   path_on_datastore='re_data', \n",
+        "                   path_on_compute='/tmp/azureml_runs',\n",
+        "                   mode='download', # download files from datastore to compute target\n",
+        "                   overwrite=False)"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -168,29 +190,13 @@
         "# Set compute target to the Linux DSVM\n",
         "conda_run_config.target = dsvm_compute\n",
         "\n",
+        "# set the data reference of the run coonfiguration\n",
+        "conda_run_config.data_references = {ds.name: dr}\n",
+        "\n",
         "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'], conda_packages=['numpy'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Data\n",
-        "For remote executions you should author a `get_data.py` file containing a `get_data()` function. This file should be in the root directory of the project. You can encapsulate code to read data either from a blob storage or local disk in this file.\n",
-        "In this example, the `get_data()` function returns data using scikit-learn's [load_digits](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html) method."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "if not os.path.exists(project_folder):\n",
-        "    os.makedirs(project_folder)"
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -199,17 +205,13 @@
       "source": [
         "%%writefile $project_folder/get_data.py\n",
         "\n",
-        "from sklearn import datasets\n",
-        "from scipy import sparse\n",
-        "import numpy as np\n",
+        "import pandas as pd\n",
         "\n",
         "def get_data():\n",
-        "    \n",
-        "    digits = datasets.load_digits()\n",
-        "    X_train = digits.data[100:,:]\n",
-        "    y_train = digits.target[100:]\n",
+        "    X_train = pd.read_csv(\"/tmp/azureml_runs/re_data/X_train.tsv\", delimiter=\"\\t\", header=None, quotechar='\"')\n",
+        "    y_train = pd.read_csv(\"/tmp/azureml_runs/re_data/y_train.tsv\", delimiter=\"\\t\", header=None, quotechar='\"')\n",
         "\n",
-        "    return { \"X\" : X_train, \"y\" : y_train }"
+        "    return { \"X\" : X_train.values, \"y\" : y_train[0].values }\n"
       ]
     },
     {

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

@@ -75,7 +75,7 @@
         "experiment_name = 'non_sample_weight_experiment'\n",
         "sample_weight_experiment_name = 'sample_weight_experiment'\n",
         "\n",
-        "project_folder = './sample_projects/automl-local-classification'\n",
+        "project_folder = './sample_projects/sample_weight'\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "sample_weight_experiment=Experiment(ws, sample_weight_experiment_name)\n",
@@ -93,23 +93,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

how-to-use-azureml/automated-machine-learning/sparse-data-train-test-split/auto-ml-sparse-data-train-test-split.ipynb

@@ -79,9 +79,9 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for the experiment\n",
-        "experiment_name = 'automl-local-missing-data'\n",
+        "experiment_name = 'sparse-data-train-test-split'\n",
         "# project folder\n",
-        "project_folder = './sample_projects/automl-local-missing-data'\n",
+        "project_folder = './sample_projects/sparse-data-train-test-split'\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
@@ -98,23 +98,6 @@
         "outputDf.T"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Opt-in diagnostics for better experience, quality, and security of future releases."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.telemetry import set_diagnostics_collection\n",
-        "set_diagnostics_collection(send_diagnostics = True)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -0,0 +1,201 @@
+{
+  "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": [
+        "# Automated Machine Learning\n",
+        "_**Classification with Local Compute**_\n",
+        "\n",
+        "## Contents\n",
+        "1. [Introduction](#Introduction)\n",
+        "1. [Setup](#Setup)\n",
+        "1. [Data](#Data)\n",
+        "1. [Train](#Train)\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Introduction\n",
+        "\n",
+        "In this example we will explore AutoML's subsampling feature. This is useful for training on large datasets to speed up the convergence.\n",
+        "\n",
+        "The setup is quiet similar to a normal classification, with the exception of the `enable_subsampling` option. Keep in mind that even with the `enable_subsampling` flag set, subsampling will only be run for large datasets (>= 50k rows) and large (>= 85) or no iteration restrictions.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setup\n",
+        "\n",
+        "As part of the setup you have already created an Azure ML `Workspace` object. For AutoML you will need to create an `Experiment` object, which is a named object in a `Workspace` used to run experiments."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import logging\n",
+        "\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "\n",
+        "import azureml.core\n",
+        "from azureml.core.experiment import Experiment\n",
+        "from azureml.core.workspace import Workspace\n",
+        "from azureml.train.automl import AutoMLConfig\n",
+        "from azureml.train.automl.run import AutoMLRun"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ws = Workspace.from_config()\n",
+        "\n",
+        "# Choose a name for the experiment and specify the project folder.\n",
+        "experiment_name = 'automl-subsampling'\n",
+        "project_folder = './sample_projects/automl-subsampling'\n",
+        "\n",
+        "experiment = Experiment(ws, experiment_name)\n",
+        "\n",
+        "output = {}\n",
+        "output['SDK version'] = azureml.core.VERSION\n",
+        "output['Subscription ID'] = ws.subscription_id\n",
+        "output['Workspace Name'] = ws.name\n",
+        "output['Resource Group'] = ws.resource_group\n",
+        "output['Location'] = ws.location\n",
+        "output['Project Directory'] = project_folder\n",
+        "output['Experiment Name'] = experiment.name\n",
+        "pd.set_option('display.max_colwidth', -1)\n",
+        "pd.DataFrame(data = output, index = ['']).T"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Data\n",
+        "\n",
+        "We will create a simple dataset using the numpy sin function just for this example. We need just over 50k rows."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "base = np.arange(60000)\n",
+        "cos = np.cos(base)\n",
+        "y = np.round(np.sin(base)).astype('int')\n",
+        "\n",
+        "# Exclude the first 100 rows from training so that they can be used for test.\n",
+        "X_train = np.hstack((base.reshape(-1, 1), cos.reshape(-1, 1)))\n",
+        "y_train = y"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train\n",
+        "\n",
+        "Instantiate an `AutoMLConfig` object to specify the settings and data used to run the experiment.\n",
+        "\n",
+        "|Property|Description|\n",
+        "|-|-|\n",
+        "|**enable_subsampling**|This enables subsampling as an option. However it does not guarantee subsampling will be used. It also depends on how large the dataset is and how many iterations it's expected to run at a minimum.|\n",
+        "|**iterations**|Number of iterations. Subsampling requires a lot of iterations at smaller percent so in order for subsampling to be used we need to set iterations to be a high number.|\n",
+        "|**experiment_timeout_minutes**|The experiment timeout, it's set to 5 right now to shorten the demo but it should probably be higher if we want to finish all the iterations.|\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "automl_config = AutoMLConfig(task = 'classification',\n",
+        "                             debug_log = 'automl_errors.log',\n",
+        "                             primary_metric = 'accuracy',\n",
+        "                             iterations = 85,\n",
+        "                             experiment_timeout_minutes = 5,\n",
+        "                             n_cross_validations = 2,\n",
+        "                             verbosity = logging.INFO,\n",
+        "                             X = X_train, \n",
+        "                             y = y_train,\n",
+        "                             enable_subsampling=True,\n",
+        "                             path = project_folder)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Call the `submit` method on the experiment object and pass the run configuration. Execution of local runs is synchronous. Depending on the data and the number of iterations this can run for a while.\n",
+        "In this example, we specify `show_output = True` to print currently running iterations to the console."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "local_run = experiment.submit(automl_config, show_output = True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "rogehe"
+      }
+    ],
+    "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.6"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

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

@@ -21,6 +21,9 @@ Notebook 6 is an Automated ML sample notebook for Classification.
 
 Learn more about [how to use Azure Databricks as a development environment](https://docs.microsoft.com/azure/machine-learning/service/how-to-configure-environment#azure-databricks) for Azure Machine Learning service.
 
+**Databricks as a Compute Target from AML Pipelines**
+You can use Azure Databricks as a compute target from [Azure Machine Learning Pipelines](https://docs.microsoft.com/en-us/azure/machine-learning/service/concept-ml-pipelines). Take a look at this notebook for details: [aml-pipelines-use-databricks-as-compute-target.ipynb](aml-pipelines-use-databricks-as-compute-target.ipynb). 
+
 For more on SDK concepts, please refer to [notebooks](https://github.com/Azure/MachineLearningNotebooks).
 
 **Please let us know your feedback.**

how-to-use-azureml/azure-databricks/aml-pipelines-use-databricks-as-compute-target.ipynb

@@ -0,0 +1,714 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Copyright (c) Microsoft Corporation. All rights reserved.  \n",
+    "Licensed under the MIT License."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Using Databricks as a Compute Target from Azure Machine Learning Pipeline\n",
+    "To use Databricks as a compute target from [Azure Machine Learning Pipeline](https://docs.microsoft.com/en-us/azure/machine-learning/service/concept-ml-pipelines), a [DatabricksStep](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.databricks_step.databricksstep?view=azure-ml-py) is used. This notebook demonstrates the use of DatabricksStep in Azure Machine Learning Pipeline.\n",
+    "\n",
+    "The notebook will show:\n",
+    "1. Running an arbitrary Databricks notebook that the customer has in Databricks workspace\n",
+    "2. Running an arbitrary Python script that the customer has in DBFS\n",
+    "3. Running an arbitrary Python script that is available on local computer (will upload to DBFS, and then run in Databricks) \n",
+    "4. Running a JAR job that the customer has in DBFS.\n",
+    "\n",
+    "## Before you begin:\n",
+    "\n",
+    "1. **Create an Azure Databricks workspace** in the same subscription where you have your Azure Machine Learning workspace. You will need details of this workspace later on to define DatabricksStep. [Click here](https://ms.portal.azure.com/#blade/HubsExtension/Resources/resourceType/Microsoft.Databricks%2Fworkspaces) for more information.\n",
+    "2. **Create PAT (access token)**: Manually create a Databricks access token at the Azure Databricks portal. See [this](https://docs.databricks.com/api/latest/authentication.html#generate-a-token) for more information.\n",
+    "3. **Add demo notebook to ADB**: This notebook has a sample you can use as is. Launch Azure Databricks attached to your Azure Machine Learning workspace and add a new notebook. \n",
+    "4. **Create/attach a Blob storage** for use from ADB"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Add demo notebook to ADB Workspace\n",
+    "Copy and paste the below code to create a new notebook in your ADB workspace."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "# direct access\n",
+    "dbutils.widgets.get(\"myparam\")\n",
+    "p = getArgument(\"myparam\")\n",
+    "print (\"Param -\\'myparam':\")\n",
+    "print (p)\n",
+    "\n",
+    "dbutils.widgets.get(\"input\")\n",
+    "i = getArgument(\"input\")\n",
+    "print (\"Param -\\'input':\")\n",
+    "print (i)\n",
+    "\n",
+    "dbutils.widgets.get(\"output\")\n",
+    "o = getArgument(\"output\")\n",
+    "print (\"Param -\\'output':\")\n",
+    "print (o)\n",
+    "\n",
+    "n = i + \"/testdata.txt\"\n",
+    "df = spark.read.csv(n)\n",
+    "\n",
+    "display (df)\n",
+    "\n",
+    "data = [('value1', 'value2')]\n",
+    "df2 = spark.createDataFrame(data)\n",
+    "\n",
+    "z = o + \"/output.txt\"\n",
+    "df2.write.csv(z)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Azure Machine Learning and Pipeline SDK-specific imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import azureml.core\n",
+    "from azureml.core.runconfig import JarLibrary\n",
+    "from azureml.core.compute import ComputeTarget, DatabricksCompute\n",
+    "from azureml.exceptions import ComputeTargetException\n",
+    "from azureml.core import Workspace, Experiment\n",
+    "from azureml.pipeline.core import Pipeline, PipelineData\n",
+    "from azureml.pipeline.steps import DatabricksStep\n",
+    "from azureml.core.datastore import Datastore\n",
+    "from azureml.data.data_reference import DataReference\n",
+    "\n",
+    "# Check core SDK version number\n",
+    "print(\"SDK version:\", azureml.core.VERSION)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initialize Workspace\n",
+    "\n",
+    "Initialize a workspace object from persisted configuration. Make sure the config file is present at .\\config.json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ws = Workspace.from_config()\n",
+    "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Attach Databricks compute target\n",
+    "Next, you need to add your Databricks workspace to Azure Machine Learning as a compute target and give it a name. You will use this name to refer to your Databricks workspace compute target inside Azure Machine Learning.\n",
+    "\n",
+    "- **Resource Group** - The resource group name of your Azure Machine Learning workspace\n",
+    "- **Databricks Workspace Name** - The workspace name of your Azure Databricks workspace\n",
+    "- **Databricks Access Token** - The access token you created in ADB\n",
+    "\n",
+    "**The Databricks workspace need to be present in the same subscription as your AML workspace**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replace with your account info before running.\n",
+    " \n",
+    "db_compute_name=os.getenv(\"DATABRICKS_COMPUTE_NAME\", \"<my-databricks-compute-name>\") # Databricks compute name\n",
+    "db_resource_group=os.getenv(\"DATABRICKS_RESOURCE_GROUP\", \"<my-db-resource-group>\") # Databricks resource group\n",
+    "db_workspace_name=os.getenv(\"DATABRICKS_WORKSPACE_NAME\", \"<my-db-workspace-name>\") # Databricks workspace name\n",
+    "db_access_token=os.getenv(\"DATABRICKS_ACCESS_TOKEN\", \"<my-access-token>\") # Databricks access token\n",
+    " \n",
+    "try:\n",
+    "    databricks_compute = DatabricksCompute(workspace=ws, name=db_compute_name)\n",
+    "    print('Compute target {} already exists'.format(db_compute_name))\n",
+    "except ComputeTargetException:\n",
+    "    print('Compute not found, will use below parameters to attach new one')\n",
+    "    print('db_compute_name {}'.format(db_compute_name))\n",
+    "    print('db_resource_group {}'.format(db_resource_group))\n",
+    "    print('db_workspace_name {}'.format(db_workspace_name))\n",
+    "    print('db_access_token {}'.format(db_access_token))\n",
+    " \n",
+    "    config = DatabricksCompute.attach_configuration(\n",
+    "        resource_group = db_resource_group,\n",
+    "        workspace_name = db_workspace_name,\n",
+    "        access_token= db_access_token)\n",
+    "    databricks_compute=ComputeTarget.attach(ws, db_compute_name, config)\n",
+    "    databricks_compute.wait_for_completion(True)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Connections with Inputs and Outputs\n",
+    "The DatabricksStep supports Azure Bloband ADLS for inputs and outputs. You also will need to define a [Secrets](https://docs.azuredatabricks.net/user-guide/secrets/index.html) scope to enable authentication to external data sources such as Blob and ADLS from Databricks.\n",
+    "\n",
+    "- Databricks documentation on [Azure Blob](https://docs.azuredatabricks.net/spark/latest/data-sources/azure/azure-storage.html)\n",
+    "- Databricks documentation on [ADLS](https://docs.databricks.com/spark/latest/data-sources/azure/azure-datalake.html)\n",
+    "\n",
+    "### Type of Data Access\n",
+    "Databricks allows to interact with Azure Blob and ADLS in two ways.\n",
+    "- **Direct Access**: Databricks allows you to interact with Azure Blob or ADLS URIs directly. The input or output URIs will be mapped to a Databricks widget param in the Databricks notebook.\n",
+    "- **Mounting**: You will be supplied with additional parameters and secrets that will enable you to mount your ADLS or Azure Blob input or output location in your Databricks notebook."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Direct Access: Python sample code\n",
+    "If you have a data reference named \"input\" it will represent the URI of the input and you can access it directly in the Databricks python notebook like so:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "dbutils.widgets.get(\"input\")\n",
+    "y = getArgument(\"input\")\n",
+    "df = spark.read.csv(y)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Mounting: Python sample code for Azure Blob\n",
+    "Given an Azure Blob data reference named \"input\" the following widget params will be made available in the Databricks notebook:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "# This contains the input URI\n",
+    "dbutils.widgets.get(\"input\")\n",
+    "myinput_uri = getArgument(\"input\")\n",
+    "\n",
+    "# How to get the input datastore name inside ADB notebook\n",
+    "# This contains the name of a Databricks secret (in the predefined \"amlscope\" secret scope) \n",
+    "# that contians an access key or sas for the Azure Blob input (this name is obtained by appending \n",
+    "# the name of the input with \"_blob_secretname\". \n",
+    "dbutils.widgets.get(\"input_blob_secretname\") \n",
+    "myinput_blob_secretname = getArgument(\"input_blob_secretname\")\n",
+    "\n",
+    "# This contains the required configuration for mounting\n",
+    "dbutils.widgets.get(\"input_blob_config\")\n",
+    "myinput_blob_config = getArgument(\"input_blob_config\")\n",
+    "\n",
+    "# Usage\n",
+    "dbutils.fs.mount(\n",
+    "  source = myinput_uri,\n",
+    "  mount_point = \"/mnt/input\",\n",
+    "  extra_configs = {myinput_blob_config:dbutils.secrets.get(scope = \"amlscope\", key = myinput_blob_secretname)})\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Mounting: Python sample code for ADLS\n",
+    "Given an ADLS data reference named \"input\" the following widget params will be made available in the Databricks notebook:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "# This contains the input URI\n",
+    "dbutils.widgets.get(\"input\") \n",
+    "myinput_uri = getArgument(\"input\")\n",
+    "\n",
+    "# This contains the client id for the service principal \n",
+    "# that has access to the adls input\n",
+    "dbutils.widgets.get(\"input_adls_clientid\") \n",
+    "myinput_adls_clientid = getArgument(\"input_adls_clientid\")\n",
+    "\n",
+    "# This contains the name of a Databricks secret (in the predefined \"amlscope\" secret scope) \n",
+    "# that contains the secret for the above mentioned service principal\n",
+    "dbutils.widgets.get(\"input_adls_secretname\") \n",
+    "myinput_adls_secretname = getArgument(\"input_adls_secretname\")\n",
+    "\n",
+    "# This contains the refresh url for the mounting configs\n",
+    "dbutils.widgets.get(\"input_adls_refresh_url\") \n",
+    "myinput_adls_refresh_url = getArgument(\"input_adls_refresh_url\")\n",
+    "\n",
+    "# Usage \n",
+    "configs = {\"dfs.adls.oauth2.access.token.provider.type\": \"ClientCredential\",\n",
+    "           \"dfs.adls.oauth2.client.id\": myinput_adls_clientid,\n",
+    "           \"dfs.adls.oauth2.credential\": dbutils.secrets.get(scope = \"amlscope\", key =myinput_adls_secretname),\n",
+    "           \"dfs.adls.oauth2.refresh.url\": myinput_adls_refresh_url}\n",
+    "\n",
+    "dbutils.fs.mount(\n",
+    "  source = myinput_uri,\n",
+    "  mount_point = \"/mnt/output\",\n",
+    "  extra_configs = configs)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Use Databricks from Azure Machine Learning Pipeline\n",
+    "To use Databricks as a compute target from Azure Machine Learning Pipeline, a DatabricksStep is used. Let's define a datasource (via DataReference) and intermediate data (via PipelineData) to be used in DatabricksStep."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use the default blob storage\n",
+    "def_blob_store = Datastore(ws, \"workspaceblobstore\")\n",
+    "print('Datastore {} will be used'.format(def_blob_store.name))\n",
+    "\n",
+    "# We are uploading a sample file in the local directory to be used as a datasource\n",
+    "def_blob_store.upload_files(files=[\"./testdata.txt\"], target_path=\"dbtest\", overwrite=False)\n",
+    "\n",
+    "step_1_input = DataReference(datastore=def_blob_store, path_on_datastore=\"dbtest\",\n",
+    "                                     data_reference_name=\"input\")\n",
+    "\n",
+    "step_1_output = PipelineData(\"output\", datastore=def_blob_store)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Add a DatabricksStep\n",
+    "Adds a Databricks notebook as a step in a Pipeline.\n",
+    "- ***name:** Name of the Module\n",
+    "- **inputs:** List of input connections for data consumed by this step. Fetch this inside the notebook using dbutils.widgets.get(\"input\")\n",
+    "- **outputs:** List of output port definitions for outputs produced by this step. Fetch this inside the notebook using dbutils.widgets.get(\"output\")\n",
+    "- **existing_cluster_id:** Cluster ID of an existing Interactive cluster on the Databricks workspace. If you are providing this, do not provide any of the parameters below that are used to create a new cluster such as spark_version, node_type, etc.\n",
+    "- **spark_version:** Version of spark for the databricks run cluster. default value: 4.0.x-scala2.11\n",
+    "- **node_type:** Azure vm node types for the databricks run cluster. default value: Standard_D3_v2\n",
+    "- **num_workers:** Specifies a static number of workers for the databricks run cluster\n",
+    "- **min_workers:** Specifies a min number of workers to use for auto-scaling the databricks run cluster\n",
+    "- **max_workers:** Specifies a max number of workers to use for auto-scaling the databricks run cluster\n",
+    "- **spark_env_variables:** Spark environment variables for the databricks run cluster (dictionary of {str:str}). default value: {'PYSPARK_PYTHON': '/databricks/python3/bin/python3'}\n",
+    "- **notebook_path:** Path to the notebook in the databricks instance. If you are providing this, do not provide python script related paramaters or JAR related parameters.\n",
+    "- **notebook_params:** Parameters  for the databricks notebook (dictionary of {str:str}). Fetch this inside the notebook using dbutils.widgets.get(\"myparam\")\n",
+    "- **python_script_path:** The path to the python script in the DBFS or S3. If you are providing this, do not provide python_script_name which is used for uploading script from local machine.\n",
+    "- **python_script_params:** Parameters for the python script (list of str)\n",
+    "- **main_class_name:** The name of the entry point in a JAR module. If you are providing this, do not provide any python script or notebook related parameters.\n",
+    "- **jar_params:** Parameters for the JAR module (list of str)\n",
+    "- **python_script_name:** name of a python script on your local machine (relative to source_directory). If you are providing this do not provide python_script_path which is used to execute a remote python script; or any of the JAR or notebook related parameters.\n",
+    "- **source_directory:** folder that contains the script and other files\n",
+    "- **hash_paths:** list of paths to hash to detect a change in source_directory (script file is always hashed)\n",
+    "- **run_name:** Name in databricks for this run\n",
+    "- **timeout_seconds:** Timeout for the databricks run\n",
+    "- **runconfig:** Runconfig to use. Either pass runconfig or each library type as a separate parameter but do not mix the two\n",
+    "- **maven_libraries:** maven libraries for the databricks run\n",
+    "- **pypi_libraries:** pypi libraries for the databricks run\n",
+    "- **egg_libraries:** egg libraries for the databricks run\n",
+    "- **jar_libraries:** jar libraries for the databricks run\n",
+    "- **rcran_libraries:** rcran libraries for the databricks run\n",
+    "- **compute_target:** Azure Databricks compute\n",
+    "- **allow_reuse:** Whether the step should reuse previous results when run with the same settings/inputs\n",
+    "- **version:** Optional version tag to denote a change in functionality for the step\n",
+    "\n",
+    "\\* *denotes required fields*  \n",
+    "*You must provide exactly one of num_workers or min_workers and max_workers paramaters*  \n",
+    "*You must provide exactly one of databricks_compute or databricks_compute_name parameters*\n",
+    "\n",
+    "## Use runconfig to specify library dependencies\n",
+    "You can use a runconfig to specify the library dependencies for your cluster in Databricks. The runconfig will contain a databricks section as follows:\n",
+    "\n",
+    "```yaml\n",
+    "environment:\n",
+    "# Databricks details\n",
+    "  databricks:\n",
+    "# List of maven libraries.\n",
+    "    mavenLibraries:\n",
+    "    - coordinates: org.jsoup:jsoup:1.7.1\n",
+    "      repo: ''\n",
+    "      exclusions:\n",
+    "      - slf4j:slf4j\n",
+    "      - '*:hadoop-client'\n",
+    "# List of PyPi libraries\n",
+    "    pypiLibraries:\n",
+    "    - package: beautifulsoup4\n",
+    "      repo: ''\n",
+    "# List of RCran libraries\n",
+    "    rcranLibraries:\n",
+    "    -\n",
+    "# Coordinates.\n",
+    "      package: ada\n",
+    "# Repo\n",
+    "      repo: http://cran.us.r-project.org\n",
+    "# List of JAR libraries\n",
+    "    jarLibraries:\n",
+    "    -\n",
+    "# Coordinates.\n",
+    "      library: dbfs:/mnt/libraries/library.jar\n",
+    "# List of Egg libraries\n",
+    "    eggLibraries:\n",
+    "    -\n",
+    "# Coordinates.\n",
+    "      library: dbfs:/mnt/libraries/library.egg\n",
+    "```\n",
+    "\n",
+    "You can then create a RunConfiguration object using this file and pass it as the runconfig parameter to DatabricksStep.\n",
+    "```python\n",
+    "from azureml.core.runconfig import RunConfiguration\n",
+    "\n",
+    "runconfig = RunConfiguration()\n",
+    "runconfig.load(path='<directory_where_runconfig_is_stored>', name='<runconfig_file_name>')\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1. Running the demo notebook already added to the Databricks workspace\n",
+    "Create a notebook in the Azure Databricks workspace, and provide the path to that notebook as the value associated with the environment variable \"DATABRICKS_NOTEBOOK_PATH\". This will then set the variable notebook_path when you run the code cell below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "notebook_path=os.getenv(\"DATABRICKS_NOTEBOOK_PATH\", \"<my-databricks-notebook-path>\") # Databricks notebook path\n",
+    "\n",
+    "dbNbStep = DatabricksStep(\n",
+    "    name=\"DBNotebookInWS\",\n",
+    "    inputs=[step_1_input],\n",
+    "    outputs=[step_1_output],\n",
+    "    num_workers=1,\n",
+    "    notebook_path=notebook_path,\n",
+    "    notebook_params={'myparam': 'testparam'},\n",
+    "    run_name='DB_Notebook_demo',\n",
+    "    compute_target=databricks_compute,\n",
+    "    allow_reuse=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Build and submit the Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#PUBLISHONLY\n",
+    "#steps = [dbNbStep]\n",
+    "#pipeline = Pipeline(workspace=ws, steps=steps)\n",
+    "#pipeline_run = Experiment(ws, 'DB_Notebook_demo').submit(pipeline)\n",
+    "#pipeline_run.wait_for_completion()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### View Run Details"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#PUBLISHONLY\n",
+    "#from azureml.widgets import RunDetails\n",
+    "#RunDetails(pipeline_run).show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. Running a Python script from DBFS\n",
+    "This shows how to run a Python script in DBFS. \n",
+    "\n",
+    "To complete this, you will need to first upload the Python script in your local machine to DBFS using the [CLI](https://docs.azuredatabricks.net/user-guide/dbfs-databricks-file-system.html). The CLI command is given below:\n",
+    "\n",
+    "```\n",
+    "dbfs cp ./train-db-dbfs.py dbfs:/train-db-dbfs.py\n",
+    "```\n",
+    "\n",
+    "The code in the below cell assumes that you have completed the previous step of uploading the script `train-db-dbfs.py` to the root folder in DBFS."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_script_path = os.getenv(\"DATABRICKS_PYTHON_SCRIPT_PATH\", \"<my-databricks-python-script-path>\") # Databricks python script path\n",
+    "\n",
+    "dbPythonInDbfsStep = DatabricksStep(\n",
+    "    name=\"DBPythonInDBFS\",\n",
+    "    inputs=[step_1_input],\n",
+    "    num_workers=1,\n",
+    "    python_script_path=python_script_path,\n",
+    "    python_script_params={'--input_data'},\n",
+    "    run_name='DB_Python_demo',\n",
+    "    compute_target=databricks_compute,\n",
+    "    allow_reuse=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Build and submit the Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#PUBLISHONLY\n",
+    "#steps = [dbPythonInDbfsStep]\n",
+    "#pipeline = Pipeline(workspace=ws, steps=steps)\n",
+    "#pipeline_run = Experiment(ws, 'DB_Python_demo').submit(pipeline)\n",
+    "#pipeline_run.wait_for_completion()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### View Run Details"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#PUBLISHONLY\n",
+    "#from azureml.widgets import RunDetails\n",
+    "#RunDetails(pipeline_run).show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Running a Python script in Databricks that currenlty is in local computer\n",
+    "To run a Python script that is currently in your local computer, follow the instructions below. \n",
+    "\n",
+    "The commented out code below code assumes that you have `train-db-local.py` in the `scripts` subdirectory under the current working directory.\n",
+    "\n",
+    "In this case, the Python script will be uploaded first to DBFS, and then the script will be run in Databricks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_script_name = \"train-db-local.py\"\n",
+    "source_directory = \".\"\n",
+    "\n",
+    "dbPythonInLocalMachineStep = DatabricksStep(\n",
+    "    name=\"DBPythonInLocalMachine\",\n",
+    "    inputs=[step_1_input],\n",
+    "    num_workers=1,\n",
+    "    python_script_name=python_script_name,\n",
+    "    source_directory=source_directory,\n",
+    "    run_name='DB_Python_Local_demo',\n",
+    "    compute_target=databricks_compute,\n",
+    "    allow_reuse=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Build and submit the Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "steps = [dbPythonInLocalMachineStep]\n",
+    "pipeline = Pipeline(workspace=ws, steps=steps)\n",
+    "pipeline_run = Experiment(ws, 'DB_Python_Local_demo').submit(pipeline)\n",
+    "pipeline_run.wait_for_completion()"
+   ]
+  },
+  {
+   "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()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4. Running a JAR job that is alreay added in DBFS\n",
+    "To run a JAR job that is already uploaded to DBFS, follow the instructions below. You will first upload the JAR file to DBFS using the [CLI](https://docs.azuredatabricks.net/user-guide/dbfs-databricks-file-system.html).\n",
+    "\n",
+    "The commented out code in the below cell assumes that you have uploaded `train-db-dbfs.jar` to the root folder in DBFS. You can upload `train-db-dbfs.jar` to the root folder in DBFS using this commandline so you can use `jar_library_dbfs_path = \"dbfs:/train-db-dbfs.jar\"`:\n",
+    "\n",
+    "```\n",
+    "dbfs cp ./train-db-dbfs.jar dbfs:/train-db-dbfs.jar\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "main_jar_class_name = \"com.microsoft.aeva.Main\"\n",
+    "jar_library_dbfs_path = os.getenv(\"DATABRICKS_JAR_LIB_PATH\", \"<my-databricks-jar-lib-path>\") # Databricks jar library path\n",
+    "\n",
+    "dbJarInDbfsStep = DatabricksStep(\n",
+    "    name=\"DBJarInDBFS\",\n",
+    "    inputs=[step_1_input],\n",
+    "    num_workers=1,\n",
+    "    main_class_name=main_jar_class_name,\n",
+    "    jar_params={'arg1', 'arg2'},\n",
+    "    run_name='DB_JAR_demo',\n",
+    "    jar_libraries=[JarLibrary(jar_library_dbfs_path)],\n",
+    "    compute_target=databricks_compute,\n",
+    "    allow_reuse=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Build and submit the Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#PUBLISHONLY\n",
+    "#steps = [dbJarInDbfsStep]\n",
+    "#pipeline = Pipeline(workspace=ws, steps=steps)\n",
+    "#pipeline_run = Experiment(ws, 'DB_JAR_demo').submit(pipeline)\n",
+    "#pipeline_run.wait_for_completion()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### View Run Details"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#PUBLISHONLY\n",
+    "#from azureml.widgets import RunDetails\n",
+    "#RunDetails(pipeline_run).show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Next: ADLA as a Compute Target\n",
+    "To use ADLA as a compute target from Azure Machine Learning Pipeline, a AdlaStep is used. This [notebook](./aml-pipelines-use-adla-as-compute-target.ipynb) demonstrates the use of AdlaStep in Azure Machine Learning Pipeline."
+   ]
+  }
+ ],
+ "metadata": {
+  "authors": [
+   {
+    "name": "diray"
+   }
+  ],
+  "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.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

how-to-use-azureml/azure-databricks/amlsdk/build-model-run-history-03.ipynb

@@ -11,13 +11,6 @@
         "Licensed under the MIT License."
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![04ACI](files/tables/image2.JPG)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -60,14 +53,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# import the Workspace class and check the azureml SDK version\n",
-        "from azureml.core import Workspace\n",
-        "\n",
-        "ws = Workspace.from_config(auth = auth)\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')"
+        "# Set auth to be used by workspace related APIs.\n",
+        "# For automation or CI/CD ServicePrincipalAuthentication can be used.\n",
+        "# https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.authentication.serviceprincipalauthentication?view=azure-ml-py\n",
+        "auth = None"
       ]
     },
     {
@@ -79,7 +68,7 @@
         "# import the Workspace class and check the azureml SDK version\n",
         "from azureml.core import Workspace\n",
         "\n",
-        "ws = Workspace.from_config()\n",
+        "ws = Workspace.from_config(auth = auth)\n",
         "print('Workspace name: ' + ws.name, \n",
         "      'Azure region: ' + ws.location, \n",
         "      'Subscription id: ' + ws.subscription_id, \n",
@@ -350,9 +339,6 @@
     "authors": [
       {
         "name": "pasha"
-      },
-      {
-        "name": "wamartin"
       }
     ],
     "kernelspec": {
@@ -370,9 +356,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.7.0"
+      "version": "3.6.6"
     },
-    "name": "03.Build_model_runHistory",
+    "name": "build-model-run-history-03",
     "notebookId": 3836944406456339
   },
   "nbformat": 4,

how-to-use-azureml/azure-databricks/amlsdk/deploy-to-aci-04.ipynb

@@ -20,13 +20,6 @@
         "Please Register Azure Container Instance(ACI) using Azure Portal: https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-manager-supported-services#portal in your subscription before using the SDK to deploy your ML model to ACI."
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![04ACI](files/tables/image3.JPG)"
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -45,15 +38,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core import Workspace\n",
-        "\n",
-        "#'''\n",
-        "ws = Workspace.from_config(auth = auth)\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",
-        "#'''"
+        "# Set auth to be used by workspace related APIs.\n",
+        "# For automation or CI/CD ServicePrincipalAuthentication can be used.\n",
+        "# https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.authentication.serviceprincipalauthentication?view=azure-ml-py\n",
+        "auth = None"
       ]
     },
     {
@@ -63,18 +51,12 @@
       "outputs": [],
       "source": [
         "from azureml.core import Workspace\n",
-        "import azureml.core\n",
         "\n",
-        "# Check core SDK version number\n",
-        "print(\"SDK version:\", azureml.core.VERSION)\n",
-        "\n",
-        "#'''\n",
-        "ws = Workspace.from_config()\n",
+        "ws = Workspace.from_config(auth = auth)\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",
-        "#'''"
+        "      'Resource group: ' + ws.resource_group, sep = '\\n')"
       ]
     },
     {
@@ -293,24 +275,14 @@
       "outputs": [],
       "source": [
         "#comment to not delete the web service\n",
-        "#myservice.delete()"
+        "myservice.delete()"
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {
     "authors": [
       {
         "name": "pasha"
-      },
-      {
-        "name": "wamartin"
       }
     ],
     "kernelspec": {
@@ -328,9 +300,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.7.0"
+      "version": "3.6.6"
     },
-    "name": "04.DeploytoACI",
+    "name": "deploy-to-aci-04",
     "notebookId": 3836944406456376
   },
   "nbformat": 4,

how-to-use-azureml/azure-databricks/amlsdk/deploy-to-aks-existingimage-05.ipynb

@@ -0,0 +1,236 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Azure ML & Azure Databricks notebooks by Parashar Shah.\n",
+        "\n",
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "This notebook uses image from ACI notebook for deploying to AKS."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "\n",
+        "# Check core SDK version number\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Set auth to be used by workspace related APIs.\n",
+        "# For automation or CI/CD ServicePrincipalAuthentication can be used.\n",
+        "# https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.authentication.serviceprincipalauthentication?view=azure-ml-py\n",
+        "auth = None"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Workspace\n",
+        "\n",
+        "ws = Workspace.from_config(auth = auth)\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": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# List images by ws\n",
+        "\n",
+        "from azureml.core.image import ContainerImage\n",
+        "for i in ContainerImage.list(workspace = ws):\n",
+        "    print('{}(v.{} [{}]) stored at {} with build log {}'.format(i.name, i.version, i.creation_state, i.image_location, i.image_build_log_uri))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.image import Image\n",
+        "myimage = Image(workspace=ws, name=\"aciws\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#create AKS compute\n",
+        "#it may take 20-25 minutes to create a new cluster\n",
+        "\n",
+        "from azureml.core.compute import AksCompute, ComputeTarget\n",
+        "\n",
+        "# Use the default configuration (can also provide parameters to customize)\n",
+        "prov_config = AksCompute.provisioning_configuration()\n",
+        "\n",
+        "aks_name = 'ps-aks-demo2' \n",
+        "\n",
+        "# Create the cluster\n",
+        "aks_target = ComputeTarget.create(workspace = ws, \n",
+        "                                  name = aks_name, \n",
+        "                                  provisioning_configuration = prov_config)\n",
+        "\n",
+        "aks_target.wait_for_completion(show_output = True)\n",
+        "\n",
+        "print(aks_target.provisioning_state)\n",
+        "print(aks_target.provisioning_errors)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.webservice import Webservice\n",
+        "help( Webservice.deploy_from_image)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.webservice import Webservice, AksWebservice\n",
+        "from azureml.core.image import ContainerImage\n",
+        "\n",
+        "#Set the web service configuration (using default here with app insights)\n",
+        "aks_config = AksWebservice.deploy_configuration(enable_app_insights=True)\n",
+        "\n",
+        "#unique service name\n",
+        "service_name ='ps-aks-service'\n",
+        "\n",
+        "# Webservice creation using single command, there is a variant to use image directly as well.\n",
+        "aks_service = Webservice.deploy_from_image(\n",
+        "  workspace=ws, \n",
+        "  name=service_name,\n",
+        "  deployment_config = aks_config,\n",
+        "  image = myimage,\n",
+        "  deployment_target = aks_target\n",
+        "    )\n",
+        "\n",
+        "aks_service.wait_for_deployment(show_output=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "aks_service.deployment_status"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#for using the Web HTTP API \n",
+        "print(aks_service.scoring_uri)\n",
+        "print(aks_service.get_keys())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import json\n",
+        "\n",
+        "#get the some sample data\n",
+        "test_data_path = \"AdultCensusIncomeTest\"\n",
+        "test = spark.read.parquet(test_data_path).limit(5)\n",
+        "\n",
+        "test_json = json.dumps(test.toJSON().collect())\n",
+        "\n",
+        "print(test_json)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#using data defined above predict if income is >50K (1) or <=50K (0)\n",
+        "aks_service.run(input_data=test_json)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#comment to not delete the web service\n",
+        "aks_service.delete()\n",
+        "#image.delete()\n",
+        "#model.delete()\n",
+        "aks_target.delete() "
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "pasha"
+      }
+    ],
+    "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.6"
+    },
+    "name": "deploy-to-aks-existingimage-05",
+    "notebookId": 1030695628045968
+  },
+  "nbformat": 4,
+  "nbformat_minor": 1
+}

how-to-use-azureml/azure-databricks/amlsdk/ingest-data-02.ipynb

@@ -11,13 +11,6 @@
         "Licensed under the MIT License."
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![04ACI](files/tables/image1.JPG)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -42,7 +35,7 @@
       "outputs": [],
       "source": [
         "# Download AdultCensusIncome.csv from Azure CDN. This file has 32,561 rows.\n",
-        "basedataurl = \"https://amldockerdatasets.azureedge.net\"\n",
+        "dataurl = \"https://amldockerdatasets.azureedge.net/AdultCensusIncome.csv\"\n",
         "datafile = \"AdultCensusIncome.csv\"\n",
         "datafile_dbfs = os.path.join(\"/dbfs\", datafile)\n",
         "\n",
@@ -50,7 +43,7 @@
         "    print(\"found {} at {}\".format(datafile, datafile_dbfs))\n",
         "else:\n",
         "    print(\"downloading {} to {}\".format(datafile, datafile_dbfs))\n",
-        "    urllib.request.urlretrieve(os.path.join(basedataurl, datafile), datafile_dbfs)"
+        "    urllib.request.urlretrieve(dataurl, datafile_dbfs)"
       ]
     },
     {
@@ -152,9 +145,6 @@
     "authors": [
       {
         "name": "pasha"
-      },
-      {
-        "name": "wamartin"
       }
     ],
     "kernelspec": {
@@ -172,9 +162,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.7.0"
+      "version": "3.6.6"
     },
-    "name": "02.Ingest_data",
+    "name": "ingest-data-02",
     "notebookId": 3836944406456362
   },
   "nbformat": 4,

how-to-use-azureml/azure-databricks/amlsdk/installation-and-configuration-01.ipynb

@@ -35,13 +35,6 @@
         "print(\"SDK version:\", azureml.core.VERSION)"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![04ACI](files/tables/image2b.JPG)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -67,6 +60,18 @@
         "# workspace_region = \"<your-resource group-region>\""
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Set auth to be used by workspace related APIs.\n",
+        "# For automation or CI/CD ServicePrincipalAuthentication can be used.\n",
+        "# https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.authentication.serviceprincipalauthentication?view=azure-ml-py\n",
+        "auth = None"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -82,6 +87,7 @@
         "                      subscription_id = subscription_id,\n",
         "                      resource_group = resource_group, \n",
         "                      location = workspace_region,\n",
+        "                      auth = auth,\n",
         "                      exist_ok=True)"
       ]
     },
@@ -103,12 +109,13 @@
       "source": [
         "ws = Workspace(workspace_name = workspace_name,\n",
         "               subscription_id = subscription_id,\n",
-        "               resource_group = resource_group)\n",
+        "               resource_group = resource_group,\n",
+        "               auth = auth)\n",
         "\n",
         "# persist the subscription id, resource group name, and workspace name in aml_config/config.json.\n",
         "ws.write_config()\n",
-        "##if you need to give a different path/filename please use this\n",
-        "##write_config(path=\"/databricks/driver/aml_config/\",file_name=<alias_conf.cfg>)"
+        "#if you need to give a different path/filename please use this\n",
+        "#write_config(path=\"/databricks/driver/aml_config/\",file_name=<alias_conf.cfg>)"
       ]
     },
     {
@@ -129,29 +136,19 @@
         "# import the Workspace class and check the azureml SDK version\n",
         "from azureml.core import Workspace\n",
         "\n",
-        "ws = Workspace.from_config()\n",
+        "ws = Workspace.from_config(auth = auth)\n",
         "#ws = Workspace.from_config(<full path>)\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": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {
     "authors": [
       {
         "name": "pasha"
-      },
-      {
-        "name": "wamartin"
       }
     ],
     "kernelspec": {
@@ -169,10 +166,10 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.7.0"
+      "version": "3.6.6"
     },
-    "name": "01.Installation_and_Configuration",
-    "notebookId": 3836944406456490
+    "name": "installation-and-configuration-01",
+    "notebookId": 3688394266452835
   },
   "nbformat": 4,
   "nbformat_minor": 1

how-to-use-azureml/azure-databricks/automl/automl-databricks-local-01.ipynb

@@ -123,13 +123,6 @@
         "ws.get_details()"
       ]
     },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -257,7 +250,16 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Load Training Data Using DataPrep"
+        "## Registering Datastore"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Datastore is the way to save connection information to a storage service (e.g. Azure Blob, Azure Data Lake, Azure SQL) information to your workspace so you can access them without exposing credentials in your code. The first thing you will need to do is register a datastore, you can refer to our [python SDK documentation](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.datastore.datastore?view=azure-ml-py) on how to register datastores. __Note: for best security practices, please do not check in code that contains registering datastores with secrets into your source control__\n",
+        "\n",
+        "The code below registers a datastore pointing to a publicly readable blob container."
       ]
     },
     {
@@ -266,19 +268,82 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "#Automated ML requires a dataflow, which is different from dataframe.\n",
-        "#If your data is in a dataframe, please use read_pandas_dataframe to convert a dataframe to dataflow before usind dprep.\n",
+        "from azureml.core import Datastore\n",
         "\n",
+        "datastore_name = 'demo_training'\n",
+        "Datastore.register_azure_blob_container(\n",
+        "    workspace = ws, \n",
+        "    datastore_name = datastore_name, \n",
+        "    container_name = 'automl-notebook-data', \n",
+        "    account_name = 'dprepdata'\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Below is an example on how to register a private blob container\n",
+        "```python\n",
+        "datastore = Datastore.register_azure_blob_container(\n",
+        "    workspace = ws, \n",
+        "    datastore_name = 'example_datastore', \n",
+        "    container_name = 'example-container', \n",
+        "    account_name = 'storageaccount',\n",
+        "    account_key = 'accountkey'\n",
+        ")\n",
+        "```\n",
+        "The example below shows how  to register an Azure Data Lake store. Please make sure you have granted the necessary permissions for the service principal to access the data lake.\n",
+        "```python\n",
+        "datastore = Datastore.register_azure_data_lake(\n",
+        "    workspace = ws,\n",
+        "    datastore_name = 'example_datastore',\n",
+        "    store_name = 'adlsstore',\n",
+        "    tenant_id = 'tenant-id-of-service-principal',\n",
+        "    client_id = 'client-id-of-service-principal',\n",
+        "    client_secret = 'client-secret-of-service-principal'\n",
+        ")\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load Training Data Using DataPrep"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Automated ML takes a Dataflow as input.\n",
+        "\n",
+        "If you are familiar with Pandas and have done your data preparation work in Pandas already, you can use the `read_pandas_dataframe` method in dprep to convert the DataFrame to a Dataflow.\n",
+        "```python\n",
+        "df = pd.read_csv(...)\n",
+        "# apply some transforms\n",
+        "dprep.read_pandas_dataframe(df, temp_folder='/path/accessible/by/both/driver/and/worker')\n",
+        "```\n",
+        "\n",
+        "If you just need to ingest data without doing any preparation, you can directly use AzureML Data Prep (Data Prep) to do so. The code below demonstrates this scenario. Data Prep also has data preparation capabilities, we have many [sample notebooks](https://github.com/Microsoft/AMLDataPrepDocs) demonstrating the capabilities.\n",
+        "\n",
+        "You will get the datastore you registered previously and pass it to Data Prep for reading. The data comes from the digits dataset: `sklearn.datasets.load_digits()`. `DataPath` points to a specific location within a datastore. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
         "import azureml.dataprep as dprep\n",
-        "# You can use `auto_read_file` which intelligently figures out delimiters and datatypes of a file.\n",
-        "# The data referenced here was pulled from `sklearn.datasets.load_digits()`.\n",
-        "simple_example_data_root = 'https://dprepdata.blob.core.windows.net/automl-notebook-data/'\n",
-        "X_train = dprep.auto_read_file(simple_example_data_root + 'X.csv').skip(1)  # Remove the header row.\n",
+        "from azureml.data.datapath import DataPath\n",
         "\n",
-        "# You can also use `read_csv` and `to_*` transformations to read (with overridable delimiter)\n",
-        "# and convert column types manually.\n",
-        "# Here we read a comma delimited file and convert all columns to integers.\n",
-        "y_train = dprep.read_csv(simple_example_data_root + 'y.csv').to_long(dprep.ColumnSelector(term='.*', use_regex = True))"
+        "datastore = Datastore.get(workspace = ws, name = datastore_name)\n",
+        "\n",
+        "X_train = dprep.read_csv(DataPath(datastore = datastore, path_on_datastore = 'X.csv')) \n",
+        "y_train = dprep.read_csv(DataPath(datastore = datastore, path_on_datastore = 'y.csv')).to_long(dprep.ColumnSelector(term='.*', use_regex = True))"
       ]
     },
     {
@@ -286,7 +351,7 @@
       "metadata": {},
       "source": [
         "## Review the Data Preparation Result\n",
-        "You can peek the result of a Dataflow at any range using skip(i) and head(j). Doing so evaluates only j records for all the steps in the Dataflow, which makes it fast even against large datasets."
+        "You can peek the result of a Dataflow at any range using `skip(i)` and `head(j)`. Doing so evaluates only j records for all the steps in the Dataflow, which makes it fast even against large datasets."
       ]
     },
     {
@@ -295,7 +360,16 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "X_train.skip(1).head(5)"
+        "X_train.get_profile()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "y_train.get_profile()"
       ]
     },
     {
@@ -333,7 +407,8 @@
         "                             debug_log = 'automl_errors.log',\n",
         "                             primary_metric = 'AUC_weighted',\n",
         "                             iteration_timeout_minutes = 10,\n",
-        "                             iterations = 30,\n",
+        "                             iterations = 5,\n",
+        "                             preprocess = True,\n",
         "                             n_cross_validations = 10,\n",
         "                             max_concurrent_iterations = 2, #change it based on number of worker nodes\n",
         "                             verbosity = logging.INFO,\n",
@@ -349,8 +424,7 @@
       "source": [
         "## Train the Models\n",
         "\n",
-        "Call the `submit` method on the experiment object and pass the run configuration. Execution of local runs is synchronous. Depending on the data and the number of iterations this can run for a while.\n",
-        "In this example, we specify `show_output = True` to print currently running iterations to the console."
+        "Call the `submit` method on the experiment object and pass the run configuration. Execution of local runs is synchronous. Depending on the data and the number of iterations this can run for a while."
       ]
     },
     {
@@ -359,7 +433,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "local_run = experiment.submit(automl_config, show_output = True) # for higher runs please use show_output=False and use the below"
+        "local_run = experiment.submit(automl_config, show_output = False) # for higher runs please use show_output=False and use the below"
       ]
     },
     {
@@ -549,11 +623,11 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.7.0"
+      "version": "3.6.5"
     },
     "name": "auto-ml-classification-local-adb",
-    "notebookId": 817220787969977
+    "notebookId": 587284549713154
   },
   "nbformat": 4,
-  "nbformat_minor": 0
+  "nbformat_minor": 1
 }

how-to-use-azureml/azure-databricks/automl/automl-databricks-local-with-deployment.ipynb

@@ -99,10 +99,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "subscription_id = \"<Your SubscriptionId>\"\n",
-        "resource_group = \"<Resource group - new or existing>\"\n",
-        "workspace_name = \"<workspace to be created>\"\n",
-        "workspace_region = \"<azureregion>\""
+        "subscription_id = \"<Your SubscriptionId>\" #you should be owner or contributor\n",
+        "resource_group = \"<Resource group - new or existing>\" #you should be owner or contributor\n",
+        "workspace_name = \"<workspace to be created>\" #your workspace name\n",
+        "workspace_region = \"<azureregion>\" #your region"
       ]
     },
     {
@@ -134,7 +134,7 @@
         "ws = Workspace.create(name = workspace_name,\n",
         "                      subscription_id = subscription_id,\n",
         "                      resource_group = resource_group, \n",
-        "                      location = workspace_region,\n",
+        "                      location = workspace_region,                      \n",
         "                      exist_ok=True)\n",
         "ws.get_details()"
       ]
@@ -160,7 +160,8 @@
         "               resource_group = resource_group)\n",
         "\n",
         "# Persist the subscription id, resource group name, and workspace name in aml_config/config.json.\n",
-        "ws.write_config()"
+        "ws.write_config()\n",
+        "write_config(path=\"/databricks/driver/aml_config/\",file_name=<alias_conf.cfg>)"
       ]
     },
     {
@@ -262,6 +263,66 @@
         "set_diagnostics_collection(send_diagnostics = True)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Registering Datastore"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Datastore is the way to save connection information to a storage service (e.g. Azure Blob, Azure Data Lake, Azure SQL) information to your workspace so you can access them without exposing credentials in your code. The first thing you will need to do is register a datastore, you can refer to our [python SDK documentation](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.datastore.datastore?view=azure-ml-py) on how to register datastores. __Note: for best security practices, please do not check in code that contains registering datastores with secrets into your source control__\n",
+        "\n",
+        "The code below registers a datastore pointing to a publicly readable blob container."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Datastore\n",
+        "\n",
+        "datastore_name = 'demo_training'\n",
+        "Datastore.register_azure_blob_container(\n",
+        "    workspace = ws, \n",
+        "    datastore_name = datastore_name, \n",
+        "    container_name = 'automl-notebook-data', \n",
+        "    account_name = 'dprepdata'\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Below is an example on how to register a private blob container\n",
+        "```python\n",
+        "datastore = Datastore.register_azure_blob_container(\n",
+        "    workspace = ws, \n",
+        "    datastore_name = 'example_datastore', \n",
+        "    container_name = 'example-container', \n",
+        "    account_name = 'storageaccount',\n",
+        "    account_key = 'accountkey'\n",
+        ")\n",
+        "```\n",
+        "The example below shows how  to register an Azure Data Lake store. Please make sure you have granted the necessary permissions for the service principal to access the data lake.\n",
+        "```python\n",
+        "datastore = Datastore.register_azure_data_lake(\n",
+        "    workspace = ws,\n",
+        "    datastore_name = 'example_datastore',\n",
+        "    store_name = 'adlsstore',\n",
+        "    tenant_id = 'tenant-id-of-service-principal',\n",
+        "    client_id = 'client-id-of-service-principal',\n",
+        "    client_secret = 'client-secret-of-service-principal'\n",
+        ")\n",
+        "```"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -269,6 +330,24 @@
         "## Load Training Data Using DataPrep"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Automated ML takes a Dataflow as input.\n",
+        "\n",
+        "If you are familiar with Pandas and have done your data preparation work in Pandas already, you can use the `read_pandas_dataframe` method in dprep to convert the DataFrame to a Dataflow.\n",
+        "```python\n",
+        "df = pd.read_csv(...)\n",
+        "# apply some transforms\n",
+        "dprep.read_pandas_dataframe(df, temp_folder='/path/accessible/by/both/driver/and/worker')\n",
+        "```\n",
+        "\n",
+        "If you just need to ingest data without doing any preparation, you can directly use AzureML Data Prep (Data Prep) to do so. The code below demonstrates this scenario. Data Prep also has data preparation capabilities, we have many [sample notebooks](https://github.com/Microsoft/AMLDataPrepDocs) demonstrating the capabilities.\n",
+        "\n",
+        "You will get the datastore you registered previously and pass it to Data Prep for reading. The data comes from the digits dataset: `sklearn.datasets.load_digits()`. `DataPath` points to a specific location within a datastore. "
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -276,15 +355,12 @@
       "outputs": [],
       "source": [
         "import azureml.dataprep as dprep\n",
-        "# You can use `auto_read_file` which intelligently figures out delimiters and datatypes of a file.\n",
-        "# The data referenced here was pulled from `sklearn.datasets.load_digits()`.\n",
-        "simple_example_data_root = 'https://dprepdata.blob.core.windows.net/automl-notebook-data/'\n",
-        "X_train = dprep.auto_read_file(simple_example_data_root + 'X.csv').skip(1)  # Remove the header row.\n",
+        "from azureml.data.datapath import DataPath\n",
         "\n",
-        "# You can also use `read_csv` and `to_*` transformations to read (with overridable delimiter)\n",
-        "# and convert column types manually.\n",
-        "# Here we read a comma delimited file and convert all columns to integers.\n",
-        "y_train = dprep.read_csv(simple_example_data_root + 'y.csv').to_long(dprep.ColumnSelector(term='.*', use_regex = True))"
+        "datastore = Datastore.get(workspace = ws, name = datastore_name)\n",
+        "\n",
+        "X_train = dprep.read_csv(DataPath(datastore = datastore, path_on_datastore = 'X.csv')) \n",
+        "y_train = dprep.read_csv(DataPath(datastore = datastore, path_on_datastore = 'y.csv')).to_long(dprep.ColumnSelector(term='.*', use_regex = True))"
       ]
     },
     {
@@ -301,7 +377,16 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "X_train.skip(1).head(5)"
+        "X_train.get_profile()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "y_train.get_profile()"
       ]
     },
     {
@@ -339,14 +424,14 @@
         "                             debug_log = 'automl_errors.log',\n",
         "                             primary_metric = 'AUC_weighted',\n",
         "                             iteration_timeout_minutes = 10,\n",
-        "                             iterations = 5,\n",
-        "                             n_cross_validations = 2,\n",
-        "                             max_concurrent_iterations = 4, #change it based on number of worker nodes\n",
+        "                             iterations = 30,\n",
+        "                             preprocess = True,\n",
+        "                             n_cross_validations = 10,\n",
+        "                             max_concurrent_iterations = 2, #change it based on number of worker nodes\n",
         "                             verbosity = logging.INFO,\n",
         "                             spark_context=sc, #databricks/spark related\n",
         "                             X = X_train, \n",
         "                             y = y_train,\n",
-        "                             enable_cache=False,\n",
         "                             path = project_folder)"
       ]
     },
@@ -356,8 +441,7 @@
       "source": [
         "## Train the Models\n",
         "\n",
-        "Call the `submit` method on the experiment object and pass the run configuration. Execution of local runs is synchronous. Depending on the data and the number of iterations this can run for a while.\n",
-        "In this example, we specify `show_output = True` to print currently running iterations to the console."
+        "Call the `submit` method on the experiment object and pass the run configuration. Execution of local runs is synchronous. Depending on the data and the number of iterations this can run for a while."
       ]
     },
     {
@@ -366,7 +450,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "local_run = experiment.submit(automl_config, show_output = True) # for higher runs please use show_output=False and use the below"
+        "local_run = experiment.submit(automl_config, show_output = False) # for higher runs please use show_output=False and use the below"
       ]
     },
     {
@@ -419,6 +503,7 @@
         "metricslist = {}\n",
         "for run in children:\n",
         "    properties = run.get_properties()\n",
+        "    #print(properties)\n",
         "    metrics = {k: v for k, v in run.get_metrics().items() if isinstance(v, float)}    \n",
         "    metricslist[int(properties['iteration'])] = metrics\n",
         "\n",
@@ -694,11 +779,11 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.7.0"
+      "version": "3.6.5"
     },
     "name": "auto-ml-classification-local-adb",
-    "notebookId": 3888835968049288
+    "notebookId": 2733885892129020
   },
   "nbformat": 4,
-  "nbformat_minor": 0
+  "nbformat_minor": 1
 }

how-to-use-azureml/azure-databricks/testdata.txt

@@ -0,0 +1 @@
+Test1

how-to-use-azureml/azure-databricks/train-db-dbfs.py

@@ -0,0 +1,5 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Licensed under the MIT license.
+
+print("In train.py")
+print("As a data scientist, this is where I use my training code.")

how-to-use-azureml/azure-databricks/train-db-local.py

@@ -0,0 +1,5 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Licensed under the MIT license.
+
+print("In train.py")
+print("As a data scientist, this is where I use my training code.")

how-to-use-azureml/deployment/enable-data-collection-for-models-in-aks/enable-data-collection-for-models-in-aks.ipynb

@@ -397,11 +397,11 @@
       "source": [
         "### b. Connect Blob to Power Bi (Small Data only)\n",
         "1. Download and Open PowerBi Desktop\n",
-        "2. Select \u201cGet Data\u201d and click on \u201cAzure Blob Storage\u201d >> Connect\n",
+        "2. Select \"Get Data\" and click on \"Azure Blob Storage\" >> Connect\n",
         "3. Add your storage account and enter your storage key.\n",
         "4. Select the container where your Data Collection is stored and click on Edit. \n",
-        "5. In the query editor, click under \u201cName\u201d column and add your Storage account Model path into the filter. Note: if you want to only look into files from a specific year or month, just expand the filter path. For example, just look into March data: /modeldata/subscriptionid>/resourcegroupname>/workspacename>/webservicename>/modelname>/modelversion>/identifier>/year>/3\n",
-        "6. Click on the double arrow aside the \u201cContent\u201d column to combine the files. \n",
+        "5. In the query editor, click under \"Name\" column and add your Storage account Model path into the filter. Note: if you want to only look into files from a specific year or month, just expand the filter path. For example, just look into March data: /modeldata/subscriptionid>/resourcegroupname>/workspacename>/webservicename>/modelname>/modelversion>/identifier>/year>/3\n",
+        "6. Click on the double arrow aside the \"Content\" column to combine the files. \n",
         "7. Click OK and the data will preload.\n",
         "8. You can now click Close and Apply and start building your custom reports on your Model Input data."
       ]

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

@@ -44,6 +44,9 @@ In this directory, there are two types of notebooks:
 4. [aml-pipelines-data-transfer.ipynb](https://aka.ms/pl-data-trans)
 5. [aml-pipelines-use-databricks-as-compute-target.ipynb](https://aka.ms/pl-databricks)
 6. [aml-pipelines-use-adla-as-compute-target.ipynb](https://aka.ms/pl-adla)
+7. [aml-pipelines-parameter-tuning-with-hyperdrive.ipynb](https://aka.ms/pl-hyperdrive)
+8. [aml-pipelines-how-to-use-azurebatch-to-run-a-windows-executable.ipynb](https://aka.ms/pl-azbatch)
+9. [aml-pipelines-setup-schedule-for-a-published-pipeline.ipynb](https://aka.ms/pl-schedule)
 
 * The second type of notebooks illustrate more sophisticated scenarios, and are independent of each other. These notebooks include:
 

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

@@ -17,7 +17,7 @@
         "\n",
         "In certain cases, you will need to transfer data from one data location to another. For example, your data may be in Files storage and you may want to move it to Blob storage. Or, if 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 example shows how to move data in an ADLS account to Blob storage."
+        "The below example shows how to move data between an ADLS account, Blob storage, SQL Server, PostgreSQL server. "
       ]
     },
     {
@@ -85,7 +85,9 @@
         "\n",
         "For background on registering your data store, consult this article:\n",
         "\n",
-        "https://docs.microsoft.com/en-us/azure/data-lake-store/data-lake-store-service-to-service-authenticate-using-active-directory"
+        "https://docs.microsoft.com/en-us/azure/data-lake-store/data-lake-store-service-to-service-authenticate-using-active-directory\n",
+        "\n",
+        "### register datastores for Azure Data Lake and Azure Blob storage"
       ]
     },
     {
@@ -146,7 +148,65 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Create DataReferences"
+        "### register datastores for Azure SQL Server and Azure database for PostgreSQL"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "\n",
+        "sql_datastore_name=\"MySqlDatastore\"\n",
+        "server_name=os.getenv(\"SQL_SERVERNAME_62\", \"<my-server-name>\") # Name of SQL server\n",
+        "database_name=os.getenv(\"SQL_DATBASENAME_62\", \"<my-database-name>\") # Name of SQL database\n",
+        "client_id=os.getenv(\"SQL_CLIENTNAME_62\", \"<my-client-id>\") # client id of service principal with permissions to access database\n",
+        "client_secret=os.getenv(\"SQL_CLIENTSECRET_62\", \"<my-client-secret>\") # the secret of service principal\n",
+        "tenant_id=os.getenv(\"SQL_TENANTID_62\", \"<my-tenant-id>\") # tenant id of service principal\n",
+        "\n",
+        "try:\n",
+        "    sql_datastore = Datastore.get(ws, sql_datastore_name)\n",
+        "    print(\"found sql database datastore with name: %s\" % sql_datastore_name)\n",
+        "except HttpOperationError:\n",
+        "    sql_datastore = Datastore.register_azure_sql_database(\n",
+        "        workspace=ws,\n",
+        "        datastore_name=sql_datastore_name,\n",
+        "        server_name=server_name,\n",
+        "        database_name=database_name,\n",
+        "        client_id=client_id,\n",
+        "        client_secret=client_secret,\n",
+        "        tenant_id=tenant_id)\n",
+        "    print(\"registered sql databse datastore with name: %s\" % sql_datastore_name)\n",
+        "\n",
+        "    \n",
+        "psql_datastore_name=\"MyPostgreSqlDatastore\"\n",
+        "server_name=os.getenv(\"PSQL_SERVERNAME_62\", \"<my-server-name>\") # Name of PostgreSQL server \n",
+        "database_name=os.getenv(\"PSQL_DATBASENAME_62\", \"<my-database-name>\") # Name of PostgreSQL database\n",
+        "user_id=os.getenv(\"PSQL_USERID_62\", \"<my-user-id>\") # user id\n",
+        "user_password=os.getenv(\"PSQL_USERPW_62\", \"<my-user-password>\") # user password\n",
+        "\n",
+        "try:\n",
+        "    psql_datastore = Datastore.get(ws, psql_datastore_name)\n",
+        "    print(\"found PostgreSQL database datastore with name: %s\" % psql_datastore_name)\n",
+        "except HttpOperationError:\n",
+        "    psql_datastore = Datastore.register_azure_postgre_sql(\n",
+        "        workspace=ws,\n",
+        "        datastore_name=psql_datastore,\n",
+        "        server_name=server_name,\n",
+        "        database_name=database_name,\n",
+        "        user_id=user_id,\n",
+        "        user_password=user_password)\n",
+        "    print(\"registered PostgreSQL databse datastore with name: %s\" % psql_datastore_name)\n",
+        "    "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create DataReferences\n",
+        "### create DataReferences for Azure Data Lake and Azure Blob storage"
       ]
     },
     {
@@ -174,6 +234,39 @@
         "print(\"obtained adls, blob data references\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### create DataReferences for Azure SQL Server and Azure database for PostgreSQL"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.data.sql_data_reference import SqlDataReference\n",
+        "\n",
+        "sql_datastore = Datastore(workspace=ws, name=\"MySqlDatastore\")\n",
+        "\n",
+        "sql_query_data_ref = SqlDataReference(\n",
+        "    datastore=sql_datastore,\n",
+        "    data_reference_name=\"sql_query_data_ref\",\n",
+        "    sql_query=\"select top 1 * from TestData\")\n",
+        "\n",
+        "\n",
+        "psql_datastore = Datastore(workspace=ws, name=\"MyPostgreSqlDatastore\")\n",
+        "\n",
+        "psql_query_data_ref = SqlDataReference(\n",
+        "    datastore=psql_datastore,\n",
+        "    data_reference_name=\"psql_query_data_ref\",\n",
+        "    sql_query=\"SELECT * FROM testtable\")\n",
+        "\n",
+        "print(\"obtained Sql server, PostgreSQL data references\")"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -251,6 +344,29 @@
         "print(\"data transfer step created\")"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "transfer_sql_to_blob = DataTransferStep(\n",
+        "    name=\"transfer_sql_to_blob\",\n",
+        "    source_data_reference=sql_query_data_ref,\n",
+        "    destination_data_reference=blob_data_ref,\n",
+        "    compute_target=data_factory_compute,\n",
+        "    destination_reference_type='file')\n",
+        "\n",
+        "transfer_psql_to_blob = DataTransferStep(\n",
+        "    name=\"transfer_psql_to_blob\",\n",
+        "    source_data_reference=psql_query_data_ref,\n",
+        "    destination_data_reference=blob_data_ref,\n",
+        "    compute_target=data_factory_compute,\n",
+        "    destination_reference_type='file')\n",
+        "\n",
+        "print(\"data transfer step created for Sql server and PostgreSQL\")"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -264,13 +380,28 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "pipeline = Pipeline(\n",
-        "    description=\"data_transfer_101\",\n",
+        "pipeline_01 = Pipeline(\n",
+        "    description=\"data_transfer_01\",\n",
         "    workspace=ws,\n",
         "    steps=[transfer_adls_to_blob])\n",
         "\n",
-        "pipeline_run = Experiment(ws, \"Data_Transfer_example\").submit(pipeline)\n",
-        "pipeline_run.wait_for_completion()"
+        "pipeline_run_01 = Experiment(ws, \"Data_Transfer_example_01\").submit(pipeline_01)\n",
+        "pipeline_run_01.wait_for_completion()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pipeline_02 = Pipeline(\n",
+        "    description=\"data_transfer_02\",\n",
+        "    workspace=ws,\n",
+        "    steps=[transfer_sql_to_blob,transfer_psql_to_blob])\n",
+        "\n",
+        "pipeline_run_02 = Experiment(ws, \"Data_Transfer_example_02\").submit(pipeline_02)\n",
+        "pipeline_run_02.wait_for_completion()"
       ]
     },
     {
@@ -287,7 +418,17 @@
       "outputs": [],
       "source": [
         "from azureml.widgets import RunDetails\n",
-        "RunDetails(pipeline_run).show()"
+        "RunDetails(pipeline_run_01).show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.widgets import RunDetails\n",
+        "RunDetails(pipeline_run_02).show()"
       ]
     },
     {
@@ -320,7 +461,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.6.7"
+      "version": "3.6.2"
     }
   },
   "nbformat": 4,

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-getting-started.ipynb

@@ -16,10 +16,20 @@
         "\n",
         "## Overview\n",
         "\n",
-        "Read [Azure Machine Learning Pipelines](https://docs.microsoft.com/en-us/azure/machine-learning/service/concept-ml-pipelines) overview, or the [readme article](../README.md) on Azure Machine Learning Pipelines to get more information.\n",
-        " \n",
         "\n",
-        "This Notebook shows basic construction of a **pipeline** that runs jobs unattended in different compute clusters. "
+        "A common scenario when using machine learning components is to have a data workflow that includes the following steps:\n",
+        "\n",
+        "- Preparing/preprocessing a given dataset for training, followed by\n",
+        "- Training a machine learning model on this data, and then\n",
+        "- Deploying this trained model in a separate environment, and finally\n",
+        "- Running a batch scoring task on another data set, using the trained model.\n",
+        "\n",
+        "Azure's Machine Learning pipelines give you a way to combine multiple steps like these into one configurable workflow, so that multiple agents/users can share and/or reuse this workflow. Machine learning pipelines thus provide a consistent, reproducible mechanism for building, evaluating, deploying, and running ML systems.\n",
+        "\n",
+        "To get more information about Azure machine learning pipelines, please read our [Azure Machine Learning Pipelines](https://docs.microsoft.com/en-us/azure/machine-learning/service/concept-ml-pipelines) overview, or the [readme article](../README.md).\n",
+        "\n",
+        "In this notebook, we provide a gentle introduction to Azure machine learning pipelines. We build a pipeline that runs jobs unattended on different compute clusters; in this notebook, you'll see how to use the basic Azure ML SDK APIs for constructing this pipeline.\n",
+        " "
       ]
     },
     {
@@ -45,6 +55,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
+        "import os\n",
         "import azureml.core\n",
         "from azureml.core import Workspace, Experiment, Datastore\n",
         "from azureml.core.compute import AmlCompute\n",
@@ -119,7 +130,7 @@
         "# project folder\n",
         "project_folder = '.'\n",
         "    \n",
-        "print('Sample projects will be created in {}.'.format(project_folder))"
+        "print('Sample projects will be created in {}.'.format(os.path.realpath(project_folder)))"
       ]
     },
     {
@@ -135,7 +146,7 @@
       "metadata": {},
       "source": [
         "### Datastore concepts\n",
-        "A [Datastore](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.datastore(class) is a place where data can be stored that is then made accessible to a compute either by means of mounting or copying the data to the compute target. \n",
+        "A [Datastore](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.datastore(class)?view=azure-ml-py) is a place where data can be stored that is then made accessible to a compute either by means of mounting or copying the data to the compute target. \n",
         "\n",
         "A Datastore can either be backed by an Azure File Storage (default) or by an Azure Blob Storage.\n",
         "\n",
@@ -322,7 +333,7 @@
         "                         script_name=\"train.py\", \n",
         "                         compute_target=aml_compute, \n",
         "                         source_directory=project_folder,\n",
-        "                         allow_reuse=False)\n",
+        "                         allow_reuse=True)\n",
         "print(\"Step1 created\")"
       ]
     },
@@ -375,7 +386,7 @@
         "### Build the pipeline\n",
         "Once we have the steps (or steps collection), we can build the [pipeline](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipeline.pipeline?view=azure-ml-py). By deafult, all these steps will run in **parallel** once we submit the pipeline for run.\n",
         "\n",
-        "A pipeline is created with a list of steps and a workspace. Submit a pipeline using [submit](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.experiment%28class%29?view=azure-ml-py#submit). When submit is called, a [PipelineRun](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipelinerun?view=azure-ml-py) is created which in turn creates [StepRun](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.steprun?view=azure-ml-py) objects for each step in the workflow."
+        "A pipeline is created with a list of steps and a workspace. Submit a pipeline using [submit](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.experiment(class)?view=azure-ml-py#submit-config--tags-none----kwargs-). When submit is called, a [PipelineRun](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipelinerun?view=azure-ml-py) is created which in turn creates [StepRun](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.steprun?view=azure-ml-py) objects for each step in the workflow."
       ]
     },
     {
@@ -403,7 +414,7 @@
       "metadata": {},
       "source": [
         "### Validate the pipeline\n",
-        "You have the option to [validate](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipeline.pipeline?view=azure-ml-py#validate) the pipeline prior to submitting for run. The platform runs validation steps such as checking for circular dependencies and parameter checks etc. even if you do not explicitly call validate method."
+        "You have the option to [validate](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipeline.pipeline?view=azure-ml-py#validate--) the pipeline prior to submitting for run. The platform runs validation steps such as checking for circular dependencies and parameter checks etc. even if you do not explicitly call validate method."
       ]
     },
     {
@@ -436,7 +447,7 @@
         "#        continue_on_node_failure=False, \n",
         "#        regenerate_outputs=False)\n",
         "\n",
-        "pipeline_run1 = Experiment(ws, 'Hello_World1').submit(pipeline1, regenerate_outputs=True)\n",
+        "pipeline_run1 = Experiment(ws, 'Hello_World1').submit(pipeline1, regenerate_outputs=False)\n",
         "print(\"Pipeline is submitted for execution\")"
       ]
     },
@@ -517,7 +528,7 @@
         "## Running a few steps in sequence\n",
         "Now let's see how we run a few steps in sequence. We already have three steps defined earlier. Let's *reuse* those steps for this part.\n",
         "\n",
-        "We will reuse step1, step2, step3, but build the pipeline in such a way that we chain step3 after step2 and step2 after step1. Note that there is no explicit data dependency between these steps, but still steps can be made dependent by using the [run_after](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.builder.pipelinestep?view=azure-ml-py#run-after) construct."
+        "We will reuse step1, step2, step3, but build the pipeline in such a way that we chain step3 after step2 and step2 after step1. Note that there is no explicit data dependency between these steps, but still steps can be made dependent by using the [run_after](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.builder.pipelinestep?view=azure-ml-py#run-after-step-) construct."
       ]
     },
     {

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

@@ -0,0 +1,376 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.  \n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Azure Machine Learning Pipeline with AzureBatchStep"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "This notebook is used to demonstrate the use of AzureBatchStep in Azure Machine Learning Pipeline.\n",
+        "An AzureBatchStep will submit a job to an AzureBatch Compute to run a simple windows executable."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Azure Machine Learning and Pipeline SDK-specific Imports"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "from azureml.core import Workspace, Experiment\n",
+        "from azureml.core.compute import ComputeTarget, BatchCompute\n",
+        "from azureml.core.datastore import Datastore\n",
+        "from azureml.data.data_reference import DataReference\n",
+        "from azureml.exceptions import ComputeTargetException\n",
+        "from azureml.pipeline.core import Pipeline, PipelineData\n",
+        "from azureml.pipeline.steps import AzureBatchStep\n",
+        "\n",
+        "import os\n",
+        "from os import path\n",
+        "from tempfile import mkdtemp\n",
+        "\n",
+        "\n",
+        "# Check core SDK version number\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Initialize Workspace"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Initialize a workspace object from persisted configuration. Make sure the config file is present at .\\config.json\n",
+        "\n",
+        "If you don't have a config.json file, please go through the configuration Notebook located [here](https://github.com/Azure/MachineLearningNotebooks).  \n",
+        "\n",
+        "This sets you up with a working config file that has information on your workspace, subscription id, etc. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ws = Workspace.from_config()\n",
+        "\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": [
+        "## Attach Batch Compute to Workspace"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "To submit jobs to Azure Batch service, you must attach your Azure Batch account to the workspace."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "batch_compute_name = 'mybatchcompute' # Name to associate with new compute in workspace\n",
+        "\n",
+        "# Batch account details needed to attach as compute to workspace\n",
+        "batch_account_name = \"<batch_account_name>\" # Name of the Batch account\n",
+        "batch_resource_group = \"<batch_resource_group>\" # Name of the resource group which contains this account\n",
+        "\n",
+        "try:\n",
+        "    # check if already attached\n",
+        "    batch_compute = BatchCompute(ws, batch_compute_name)\n",
+        "except ComputeTargetException:\n",
+        "    print('Attaching Batch compute...')\n",
+        "    provisioning_config = BatchCompute.attach_configuration(resource_group=batch_resource_group, \n",
+        "                                                            account_name=batch_account_name)\n",
+        "    batch_compute = ComputeTarget.attach(ws, batch_compute_name, provisioning_config)\n",
+        "    batch_compute.wait_for_completion()\n",
+        "    print(\"Provisioning state:{}\".format(batch_compute.provisioning_state))\n",
+        "    print(\"Provisioning errors:{}\".format(batch_compute.provisioning_errors))\n",
+        "\n",
+        "print(\"Using Batch compute:{}\".format(batch_compute.cluster_resource_id))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setup Datastore"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Setting up the Blob storage associated with the workspace.  \n",
+        "The following call retrieves the Azure Blob Store associated with your workspace.  \n",
+        "Note that workspaceblobstore is **the name of this store and CANNOT BE CHANGED and must be used as is**.  \n",
+        "  \n",
+        "If you want to register another Datastore, please follow the instructions from here:\n",
+        "https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-access-data#register-a-datastore"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "datastore = Datastore(ws, \"workspaceblobstore\")\n",
+        "\n",
+        "print('Datastore details:')\n",
+        "print('Datastore Account Name: ' + datastore.account_name)\n",
+        "print('Datastore Workspace Name: ' + datastore.workspace.name)\n",
+        "print('Datastore Container Name: ' + datastore.container_name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setup Input and Output"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "For this example we will upload a file in the provided Datastore. These are some helper methods to achieve that."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def create_local_file(content, file_name):\n",
+        "    # create a file in a local temporary directory\n",
+        "    temp_dir = mkdtemp()\n",
+        "    with open(path.join(temp_dir, file_name), 'w') as f:\n",
+        "        f.write(content)\n",
+        "    return temp_dir\n",
+        "\n",
+        "\n",
+        "def upload_file_to_datastore(datastore, file_name, content):\n",
+        "    dir = create_local_file(content=content, file_name=file_name)\n",
+        "    datastore.upload(src_dir=dir, overwrite=True, show_progress=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Here we associate the input DataReference with an existing file in the provided Datastore. Feel free to upload the file of your choice manually or use the *upload_file_to_datastore* method. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "file_name=\"input.txt\"\n",
+        "\n",
+        "upload_file_to_datastore(datastore=datastore, \n",
+        "                         file_name=file_name, \n",
+        "                         content=\"this is the content of the file\")\n",
+        "\n",
+        "testdata = DataReference(datastore=datastore, \n",
+        "                         path_on_datastore=file_name, \n",
+        "                         data_reference_name=\"input\")\n",
+        "\n",
+        "outputdata = PipelineData(name=\"output\", datastore=datastore)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setup AzureBatch Job Binaries"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "AzureBatch can run a task within the job and here we put a simple .cmd file to be executed. Feel free to put any binaries in the folder, or modify the .cmd file as needed, they will be uploaded once we create the AzureBatch Step."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "binaries_folder = \"azurebatch/job_binaries\"\n",
+        "if not os.path.isdir(binaries_folder):\n",
+        "    os.mkdir(binaries_folder)\n",
+        "\n",
+        "file_name=\"azurebatch.cmd\"\n",
+        "with open(path.join(binaries_folder, file_name), 'w') as f:\n",
+        "        f.write(\"copy \\\"%1\\\" \\\"%2\\\"\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create an AzureBatchStep"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "AzureBatchStep is used to submit a job to the attached Azure Batch compute.\n",
+        "- **name:** Name of the step\n",
+        "- **pool_id:** Name of the pool, it can be an existing pool, or one that will be created when the job is submitted\n",
+        "- **inputs:** List of inputs that will be processed by the job\n",
+        "- **outputs:** List of outputs the job will create\n",
+        "- **executable:** The executable that will run as part of the job\n",
+        "- **arguments:** Arguments for the executable. They can be plain string format, inputs, outputs or parameters\n",
+        "- **compute_target:** The compute target where the job will run.\n",
+        "- **source_directory:** The local directory with binaries to be executed by the job\n",
+        "\n",
+        "Optional parameters:\n",
+        "\n",
+        "- **create_pool:** Boolean flag to indicate whether create the pool before running the jobs\n",
+        "- **delete_batch_job_after_finish:** Boolean flag to indicate whether to delete the job from Batch account after it's finished\n",
+        "- **delete_batch_pool_after_finish:** Boolean flag to indicate whether to delete the pool after the job finishes\n",
+        "- **is_positive_exit_code_failure:** Boolean flag to indicate if the job fails if the task exists with a positive code\n",
+        "- **vm_image_urn:** If create_pool is true and VM uses VirtualMachineConfiguration.  \n",
+        " Value format: 'urn:publisher:offer:sku'.  \n",
+        " Example: urn:MicrosoftWindowsServer:WindowsServer:2012-R2-Datacenter  \n",
+        " For more details:  \n",
+        " https://docs.microsoft.com/en-us/azure/virtual-machines/windows/cli-ps-findimage#table-of-commonly-used-windows-images and  \n",
+        " https://docs.microsoft.com/en-us/azure/virtual-machines/linux/cli-ps-findimage#find-specific-images\n",
+        "- **run_task_as_admin:** Boolean flag to indicate if the task should run with Admin privileges\n",
+        "- **target_compute_nodes:** Assumes create_pool is true, indicates how many compute nodes will be added to the pool\n",
+        "- **source_directory:** Local folder that contains the module binaries, executable, assemblies etc.\n",
+        "- **executable:** Name of the command/executable that will be executed as part of the job\n",
+        "- **arguments:** Arguments for the command/executable\n",
+        "- **inputs:** List of input port bindings\n",
+        "- **outputs:** List of output port bindings\n",
+        "- **vm_size:** If create_pool is true, indicating Virtual machine size of the compute nodes\n",
+        "- **compute_target:** BatchCompute compute\n",
+        "- **allow_reuse:** Whether the module should reuse previous results when run with the same settings/inputs\n",
+        "- **version:** A version tag to denote a change in functionality for the module"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "step = AzureBatchStep(\n",
+        "            name=\"Azure Batch Job\",\n",
+        "            pool_id=\"MyPoolName\", # Replace this with the pool name of your choice\n",
+        "            inputs=[testdata],\n",
+        "            outputs=[outputdata],\n",
+        "            executable=\"azurebatch.cmd\",\n",
+        "            arguments=[testdata, outputdata],\n",
+        "            compute_target=batch_compute,\n",
+        "            source_directory=binaries_folder,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Build and Submit the Pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pipeline = Pipeline(workspace=ws, steps=[step])\n",
+        "pipeline_run = Experiment(ws, 'azurebatch_experiment').submit(pipeline)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Visualize the Running Pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.widgets import RunDetails\n",
+        "RunDetails(pipeline_run).show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "diray"
+      }
+    ],
+    "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/intro-to-pipelines/aml-pipelines-parameter-tuning-with-hyperdrive.ipynb

@@ -0,0 +1,397 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.  \n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Azure Machine Learning Pipeline with  HyperDriveStep\n",
+        "\n",
+        "\n",
+        "This notebook is used to demonstrate the use of HyperDriveStep in AML Pipeline.\n",
+        "\n",
+        "## Azure Machine Learning and Pipeline SDK-specific imports\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import shutil\n",
+        "import urllib\n",
+        "import azureml.core\n",
+        "from azureml.core import Workspace, Experiment\n",
+        "from azureml.core.datastore import Datastore\n",
+        "from azureml.core.compute import ComputeTarget, AmlCompute\n",
+        "from azureml.exceptions import ComputeTargetException\n",
+        "from azureml.data.data_reference import DataReference\n",
+        "from azureml.pipeline.steps import HyperDriveStep\n",
+        "from azureml.pipeline.core import Pipeline\n",
+        "from azureml.train.dnn import TensorFlow\n",
+        "from azureml.train.hyperdrive import *\n",
+        "\n",
+        "# Check core SDK version number\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Initialize workspace\n",
+        "\n",
+        "Initialize a workspace object from persisted configuration. Make sure the config file is present at .\\config.json"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ws = Workspace.from_config()\n",
+        "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create an Azure ML experiment\n",
+        "Let's create an experiment named \"tf-mnist\" and a folder to hold the training scripts. The script runs will be recorded under the experiment in Azure.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "script_folder = './tf-mnist'\n",
+        "os.makedirs(script_folder, exist_ok=True)\n",
+        "\n",
+        "exp = Experiment(workspace=ws, name='tf-mnist')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Download MNIST dataset\n",
+        "In order to train on the MNIST dataset we will first need to download it from Yan LeCun's web site directly and save them in a `data` folder locally."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "os.makedirs('./data/mnist', 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')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Upload MNIST dataset to blob datastore \n",
+        "A [datastore](https://docs.microsoft.com/azure/machine-learning/service/how-to-access-data) is a place where data can be stored that is then made accessible to a Run either by means of mounting or copying the data to the compute target. In the next step, we will use Azure Blob Storage and upload the training and test set into the Azure Blob datastore, which we will then later be mount on a Batch AI cluster for training."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ds = ws.get_default_datastore()\n",
+        "ds.upload(src_dir='./data/mnist', target_path='mnist', overwrite=True, show_progress=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Retrieve or create a Azure Machine Learning compute\n",
+        "Azure Machine Learning Compute is a service for provisioning and managing clusters of Azure virtual machines for running machine learning workloads. Let's create a new Azure Machine Learning Compute in the current workspace, if it doesn't already exist. We will then run the training script on this compute target.\n",
+        "\n",
+        "If we could not find the compute with the given name in the previous cell, then we will create a new compute here. This process is broken down into the following steps:\n",
+        "\n",
+        "1. Create the configuration\n",
+        "2. Create the Azure Machine Learning compute\n",
+        "\n",
+        "**This process will take a few 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.**\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "cluster_name = \"gpucluster\"\n",
+        "\n",
+        "try:\n",
+        "    compute_target = ComputeTarget(workspace=ws, name=cluster_name)\n",
+        "    print('Found existing compute target {}.'.format(cluster_name))\n",
+        "except ComputeTargetException:\n",
+        "    print('Creating a new compute target...')\n",
+        "    compute_config = AmlCompute.provisioning_configuration(vm_size=\"STANDARD_NC6\",\n",
+        "                                                               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",
+        "\n",
+        "print(\"Azure Machine Learning Compute attached\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Copy the training files into the script folder\n",
+        "The TensorFlow training script is already created for you. You can simply copy it into the script folder, together with the utility library used to load compressed data file into numpy array."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# the training logic is in the tf_mnist.py file.\n",
+        "shutil.copy('./tf_mnist.py', script_folder)\n",
+        "\n",
+        "# the utils.py just helps loading data from the downloaded MNIST dataset into numpy arrays.\n",
+        "shutil.copy('./utils.py', script_folder)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create TensorFlow estimator\n",
+        "Next, we construct an `azureml.train.dnn.TensorFlow` estimator object, use the Batch AI cluster as compute target, and pass the mount-point of the datastore to the training code as a parameter.\n",
+        "The TensorFlow estimator is providing a simple way of launching a TensorFlow training job on a compute target. It will automatically provide a docker image that has TensorFlow installed -- if additional pip or conda packages are required, their names can be passed in via the `pip_packages` and `conda_packages` arguments and they will be included in the resulting docker."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "est = TensorFlow(source_directory=script_folder,                 \n",
+        "                 compute_target=compute_target,\n",
+        "                 entry_script='tf_mnist.py', \n",
+        "                 use_gpu=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Intelligent hyperparameter tuning\n",
+        "We have trained the model with one set of hyperparameters, now let's how we can do hyperparameter tuning by launching multiple runs on the cluster. First let's define the parameter space using random sampling.\n",
+        "\n",
+        "In this example we will use random sampling to try different configuration sets of hyperparameters to maximize our primary metric, the best validation accuracy (`validation_acc`)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ps = RandomParameterSampling(\n",
+        "    {\n",
+        "        '--batch-size': choice(25, 50, 100),\n",
+        "        '--first-layer-neurons': choice(10, 50, 200, 300, 500),\n",
+        "        '--second-layer-neurons': choice(10, 50, 200, 500),\n",
+        "        '--learning-rate': loguniform(-6, -1)\n",
+        "    }\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now we will define an early termnination policy. The `BanditPolicy` basically states to check the job every 2 iterations. If the primary metric (defined later) falls outside of the top 10% range, Azure ML terminate the job. This saves us from continuing to explore hyperparameters that don't show promise of helping reach our target metric.\n",
+        "\n",
+        "Refer [here](https://docs.microsoft.com/azure/machine-learning/service/how-to-tune-hyperparameters#specify-an-early-termination-policy) for more information on the BanditPolicy and other policies available."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "early_termination_policy = BanditPolicy(evaluation_interval=2, slack_factor=0.1)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now we are ready to configure a run configuration object, and specify the primary metric `validation_acc` that's recorded in your training runs. If you go back to visit the training script, you will notice that this value is being logged after every epoch (a full batch set). We also want to tell the service that we are looking to maximizing this value. We also set the number of samples to 20, and maximal concurrent job to 4, which is the same as the number of nodes in our computer cluster."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "hd_config = HyperDriveRunConfig(estimator=est, \n",
+        "                                hyperparameter_sampling=ps,\n",
+        "                                policy=early_termination_policy,\n",
+        "                                primary_metric_name='validation_acc', \n",
+        "                                primary_metric_goal=PrimaryMetricGoal.MAXIMIZE, \n",
+        "                                max_total_runs=1,\n",
+        "                                max_concurrent_runs=1)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Add HyperDrive as a step of pipeline\n",
+        "\n",
+        "Let's setup a data reference for inputs of hyperdrive step."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "data_folder = DataReference(\n",
+        "    datastore=ds,\n",
+        "    data_reference_name=\"mnist_data\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### HyperDriveStep\n",
+        "HyperDriveStep can be used to run HyperDrive job as a step in pipeline.\n",
+        "- **name:** Name of the step\n",
+        "- **hyperdrive_run_config:** A HyperDriveRunConfig that defines the configuration for this HyperDrive run\n",
+        "- **estimator_entry_script_arguments:** List of command-line arguments for estimator entry script\n",
+        "- **inputs:** List of input port bindings\n",
+        "- **outputs:** List of output port bindings\n",
+        "- **metrics_output:** Optional value specifying the location to store HyperDrive run metrics as a JSON file\n",
+        "- **allow_reuse:** whether to allow reuse\n",
+        "- **version:** version\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "hd_step = HyperDriveStep(\n",
+        "    name=\"hyperdrive_module\",\n",
+        "    hyperdrive_run_config=hd_config,\n",
+        "    estimator_entry_script_arguments=['--data-folder', data_folder],\n",
+        "    inputs=[data_folder])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Run the pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pipeline = Pipeline(workspace=ws, steps=[hd_step])\n",
+        "pipeline_run = Experiment(ws, 'Hyperdrive_Test').submit(pipeline)"
+      ]
+    },
+    {
+      "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": [
+        "### Wait for the completion of this Pipeline run"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pipeline_run.wait_for_completion()"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "sonnyp"
+      }
+    ],
+    "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/intro-to-pipelines/aml-pipelines-publish-and-run-using-rest-endpoint.ipynb

@@ -306,11 +306,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.authentication import AzureCliAuthentication\n",
+        "from azureml.core.authentication import InteractiveLoginAuthentication\n",
         "import requests\n",
         "\n",
-        "cli_auth = AzureCliAuthentication()\n",
-        "aad_token = cli_auth.get_authentication_header()\n",
+        "auth = InteractiveLoginAuthentication()\n",
+        "aad_token = auth.get_authentication_header()\n",
         "\n",
         "rest_endpoint1 = published_pipeline1.endpoint\n",
         "\n",

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

@@ -0,0 +1,450 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.  \n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "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."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Prerequisites and AML Basics\n",
+        "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.\n",
+        "\n",
+        "### Initialization Steps"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "from azureml.core import Workspace\n",
+        "\n",
+        "# Check core SDK version number\n",
+        "print(\"SDK version:\", azureml.core.VERSION)\n",
+        "\n",
+        "ws = Workspace.from_config()\n",
+        "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Compute Targets\n",
+        "#### Retrieve an already attached Azure Machine Learning Compute"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Run, Experiment, Datastore\n",
+        "\n",
+        "from azureml.widgets import RunDetails\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.compute import AmlCompute, ComputeTarget\n",
+        "aml_compute_target = \"aml-compute\"\n",
+        "try:\n",
+        "    aml_compute = AmlCompute(ws, aml_compute_target)\n",
+        "    print(\"Found existing compute target: {}\".format(aml_compute_target))\n",
+        "except:\n",
+        "    print(\"Creating new compute target: {}\".format(aml_compute_target))\n",
+        "    \n",
+        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_D2_V2\",\n",
+        "                                                                min_nodes = 1, \n",
+        "                                                                max_nodes = 4)    \n",
+        "    aml_compute = ComputeTarget.create(ws, aml_compute_target, provisioning_config)\n",
+        "    aml_compute.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Build and Publish Pipeline\n",
+        "Build a simple pipeline, publish it and add a schedule to run it."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Define a pipeline step\n",
+        "Define a single step pipeline for demonstration purpose."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.steps import PythonScriptStep\n",
+        "\n",
+        "\n",
+        "# project folder\n",
+        "project_folder = 'scripts'\n",
+        "\n",
+        "trainStep = PythonScriptStep(\n",
+        "    name=\"Training_Step\",\n",
+        "    script_name=\"train.py\", \n",
+        "    compute_target=aml_compute_target, \n",
+        "    source_directory=project_folder\n",
+        ")\n",
+        "print(\"TrainStep created\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Build the pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline\n",
+        "\n",
+        "pipeline1 = Pipeline(workspace=ws, steps=[trainStep])\n",
+        "print (\"Pipeline is built\")\n",
+        "\n",
+        "pipeline1.validate()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Publish the pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from datetime import datetime\n",
+        "\n",
+        "timenow = datetime.now().strftime('%m-%d-%Y-%H-%M')\n",
+        "\n",
+        "pipeline_name = timenow + \"-Pipeline\"\n",
+        "print(pipeline_name)\n",
+        "\n",
+        "published_pipeline1 = pipeline1.publish(\n",
+        "    name=pipeline_name, \n",
+        "    description=pipeline_name)\n",
+        "print(\"Newly published pipeline id: {}\".format(published_pipeline1.id))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Schedule Operations\n",
+        "Schedule operations require id of a published pipeline. You can get all published pipelines and do Schedule operations on them, or if you already know the id of the published pipeline, you can use it directly as well.\n",
+        "### Get published pipeline ID"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import PublishedPipeline\n",
+        "\n",
+        "# You could retrieve all pipelines that are published, or \n",
+        "# just get the published pipeline object that you have the ID for.\n",
+        "\n",
+        "# Get all published pipeline objects in the workspace\n",
+        "all_pub_pipelines = PublishedPipeline.get_all(ws)\n",
+        "\n",
+        "# We will iterate through the list of published pipelines and \n",
+        "# use the last ID in the list for Schelue operations: \n",
+        "print(\"Published pipelines found in the workspace:\")\n",
+        "for pub_pipeline in all_pub_pipelines:\n",
+        "    print(pub_pipeline.id)\n",
+        "    pub_pipeline_id = pub_pipeline.id\n",
+        "\n",
+        "print(\"Published pipeline id to be used for Schedule operations: {}\".format(pub_pipeline_id))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a schedule for the pipeline using a recurrence\n",
+        "This schedule will run on a specified recurrence interval."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core.schedule import ScheduleRecurrence, Schedule\n",
+        "\n",
+        "recurrence = ScheduleRecurrence(frequency=\"Day\", interval=2, hours=[22], minutes=[30]) # Runs every other day at 10:30pm\n",
+        "\n",
+        "schedule = Schedule.create(workspace=ws, name=\"My_Schedule\",\n",
+        "                           pipeline_id=pub_pipeline_id, \n",
+        "                           experiment_name='Schedule_Run',\n",
+        "                           recurrence=recurrence,\n",
+        "                           wait_for_provisioning=True,\n",
+        "                           description=\"Schedule Run\")\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": {},
+      "source": [
+        "Note: Set the `wait_for_provisioning` flag to False if you do not want to wait for the call to provision the schedule in the backend."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Get all schedules for a given pipeline\n",
+        "Once you have the published pipeline ID, then you can get all schedules for that pipeline."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "schedules = Schedule.get_all(ws, pipeline_id=pub_pipeline_id)\n",
+        "\n",
+        "# We will iterate through the list of schedules and \n",
+        "# use the last ID in the list for further operations: \n",
+        "print(\"Found these schedules for the pipeline id {}:\".format(pub_pipeline_id))\n",
+        "for schedule in schedules: \n",
+        "    print(schedule.id)\n",
+        "    schedule_id = schedule.id\n",
+        "\n",
+        "print(\"Schedule id to be used for schedule operations: {}\".format(schedule_id))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Get all schedules in your workspace\n",
+        "You can also iterate through all schedules in your workspace if needed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Use active_only=False to get all schedules including disabled schedules\n",
+        "schedules = Schedule.get_all(ws, active_only=True) \n",
+        "print(\"Your workspace has the following schedules set up:\")\n",
+        "for schedule in schedules:\n",
+        "    print(\"{} (Published pipeline: {}\".format(schedule.id, schedule.pipeline_id))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Get the schedule"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "fetched_schedule = Schedule.get(ws, schedule_id)\n",
+        "print(\"Using schedule with id: {}\".format(fetched_schedule.id))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Disable the schedule"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# 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))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Reactivate the schedule"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# 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.activate(wait_for_provisioning=True)\n",
+        "fetched_schedule = Schedule.get(ws, schedule_id)\n",
+        "print(\"Activated schedule {}. New status is: {}\".format(fetched_schedule.id, fetched_schedule.status))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Change recurrence of the schedule"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# 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",
+        "recurrence = ScheduleRecurrence(frequency=\"Hour\", interval=2) # Runs every two hours\n",
+        "\n",
+        "fetched_schedule = Schedule.get(ws, schedule_id)\n",
+        "\n",
+        "fetched_schedule.update(name=\"My_Updated_Schedule\", \n",
+        "                        description=\"Updated_Schedule_Run\", \n",
+        "                        status='Active', \n",
+        "                        wait_for_provisioning=True,\n",
+        "                        recurrence=recurrence)\n",
+        "\n",
+        "fetched_schedule = Schedule.get(ws, fetched_schedule.id)\n",
+        "\n",
+        "print(\"Updated schedule:\", fetched_schedule.id, \n",
+        "      \"\\nNew name:\", fetched_schedule.name,\n",
+        "      \"\\nNew frequency:\", fetched_schedule.recurrence.frequency,\n",
+        "      \"\\nNew status:\", fetched_schedule.status)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a schedule for the pipeline using a Datastore\n",
+        "This schedule will run when additions or modifications are made to Blobs in the Datastore container.\n",
+        "Note: Only Blob Datastores are supported."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.datastore import Datastore\n",
+        "\n",
+        "datastore = Datastore(workspace=ws, name=\"workspaceblobstore\")\n",
+        "\n",
+        "schedule = Schedule.create(workspace=ws, name=\"My_Schedule\",\n",
+        "                           pipeline_id=pub_pipeline_id, \n",
+        "                           experiment_name='Schedule_Run',\n",
+        "                           datastore=datastore,\n",
+        "                           wait_for_provisioning=True,\n",
+        "                           description=\"Schedule Run\")\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": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# 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",
+        "schedule.disable(wait_for_provisioning=True)\n",
+        "schedule = Schedule.get(ws, schedule_id)\n",
+        "print(\"Disabled schedule {}. New status is: {}\".format(schedule.id, schedule.status))"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "diray"
+      }
+    ],
+    "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/intro-to-pipelines/aml-pipelines-use-adla-as-compute-target.ipynb

@@ -13,7 +13,8 @@
       "metadata": {},
       "source": [
         "# AML Pipeline with AdlaStep\n",
-        "This notebook is used to demonstrate the use of AdlaStep in AML Pipeline."
+        "\n",
+        "This notebook is used to demonstrate the use of AdlaStep in AML Pipelines. [AdlaStep](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.adla_step.adlastep?view=azure-ml-py) is used to run U-SQL scripts using Azure Data Lake Analytics service. "
       ]
     },
     {
@@ -30,13 +31,16 @@
       "outputs": [],
       "source": [
         "import os\n",
+        "from msrest.exceptions import HttpOperationError\n",
+        "\n",
         "import azureml.core\n",
         "from azureml.exceptions import ComputeTargetException\n",
         "from azureml.core import Workspace, Experiment\n",
-        "from azureml.pipeline.core import Pipeline, PipelineData\n",
-        "from azureml.pipeline.steps import AdlaStep\n",
+        "from azureml.core.compute import ComputeTarget, AdlaCompute\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 AdlaStep\n",
         "\n",
         "# Check core SDK version number\n",
         "print(\"SDK version:\", azureml.core.VERSION)"
@@ -65,22 +69,57 @@
         "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Attach ADLA account to workspace\n",
+        "\n",
+        "To submit jobs to Azure Data Lake Analytics service, you must first attach your ADLA account to the workspace. You'll need to provide the account name and resource group of ADLA account to complete this part."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
       "metadata": {},
       "outputs": [],
       "source": [
-        "script_folder = '.'\n",
-        "experiment_name = \"adla_101_experiment\"\n",
-        "ws._initialize_folder(experiment_name=experiment_name, directory=script_folder)"
+        "adla_compute_name = 'testadl' # Name to associate with new compute in workspace\n",
+        "\n",
+        "# ADLA account details needed to attach as compute to workspace\n",
+        "adla_account_name = \"<adla_account_name>\" # Name of the Azure Data Lake Analytics account\n",
+        "adla_resource_group = \"<adla_resource_group>\" # Name of the resource group which contains this account\n",
+        "\n",
+        "try:\n",
+        "    # check if already attached\n",
+        "    adla_compute = AdlaCompute(ws, adla_compute_name)\n",
+        "except ComputeTargetException:\n",
+        "    print('attaching adla compute...')\n",
+        "    attach_config = AdlaCompute.attach_configuration(resource_group=adla_resource_group, account_name=adla_account_name)\n",
+        "    adla_compute = ComputeTarget.attach(ws, adla_compute_name, attach_config)\n",
+        "    adla_compute.wait_for_completion()\n",
+        "\n",
+        "print(\"Using ADLA compute:{}\".format(adla_compute.cluster_resource_id))\n",
+        "print(\"Provisioning state:{}\".format(adla_compute.provisioning_state))\n",
+        "print(\"Provisioning errors:{}\".format(adla_compute.provisioning_errors))"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Register Datastore"
+        "## Register Data Lake Storage as Datastore\n",
+        "\n",
+        "To register Data Lake Storage as Datastore in workspace, you'll need account information like account name, resource group and subscription Id. \n",
+        "\n",
+        "> AdlaStep can only work with data stored in the **default** Data Lake Storage of the Data Lake Analytics account provided above. If the data you need to work with is in a non-default storage, you can use a DataTransferStep to copy the data before training. You can find the default storage by opening your Data Lake Analytics account in Azure portal and then navigating to 'Data sources' item under Settings in the left pane.\n",
+        "\n",
+        "### Grant Azure AD application access to Data Lake Storage\n",
+        "\n",
+        "You'll also need to provide an Active Directory application which can access Data Lake Storage. [This document](https://docs.microsoft.com/en-us/azure/data-lake-store/data-lake-store-service-to-service-authenticate-using-active-directory) contains step-by-step instructions on how to create an AAD application and assign to Data Lake Storage. Couple of important notes when assigning permissions to AAD app:\n",
+        "\n",
+        "- Access should be provided at root folder level.\n",
+        "- In 'Assign permissions' pane, select Read, Write, and Execute permissions for 'This folder and all children'. Add as 'An access permission entry and a default permission entry' to make sure application can access any new files created in the future."
       ]
     },
     {
@@ -89,15 +128,15 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from msrest.exceptions import HttpOperationError\n",
+        "datastore_name = 'MyAdlsDatastore' # Name to associate with data store in workspace\n",
         "\n",
-        "datastore_name='MyAdlsDatastore'\n",
-        "subscription_id=os.getenv(\"ADL_SUBSCRIPTION_62\", \"<my-subscription-id>\") # subscription id of ADLS account\n",
-        "resource_group=os.getenv(\"ADL_RESOURCE_GROUP_62\", \"<my-resource-group>\") # resource group of ADLS account\n",
-        "store_name=os.getenv(\"ADL_STORENAME_62\", \"<my-datastore-name>\") # ADLS account name\n",
-        "tenant_id=os.getenv(\"ADL_TENANT_62\", \"<my-tenant-id>\") # tenant id of service principal\n",
-        "client_id=os.getenv(\"ADL_CLIENTID_62\", \"<my-client-id>\") # client id of service principal\n",
-        "client_secret=os.getenv(\"ADL_CLIENT_62_SECRET\", \"<my-client-secret>\") # the secret of service principal\n",
+        "# ADLS storage account details needed to register as a Datastore\n",
+        "subscription_id = os.getenv(\"ADL_SUBSCRIPTION_62\", \"<my-subscription-id>\") # subscription id of ADLS account\n",
+        "resource_group = os.getenv(\"ADL_RESOURCE_GROUP_62\", \"<my-resource-group>\") # resource group of ADLS account\n",
+        "store_name = os.getenv(\"ADL_STORENAME_62\", \"<my-datastore-name>\") # ADLS account name\n",
+        "tenant_id = os.getenv(\"ADL_TENANT_62\", \"<my-tenant-id>\") # tenant id of service principal\n",
+        "client_id = os.getenv(\"ADL_CLIENTID_62\", \"<my-client-id>\") # client id of service principal\n",
+        "client_secret = os.getenv(\"ADL_CLIENT_62_SECRET\", \"<my-client-secret>\") # the secret of service principal\n",
         "\n",
         "try:\n",
         "    adls_datastore = Datastore.get(ws, datastore_name)\n",
@@ -112,16 +151,16 @@
         "        tenant_id=tenant_id, # tenant id of service principal\n",
         "        client_id=client_id, # client id of service principal\n",
         "        client_secret=client_secret) # the secret of service principal\n",
-        "    print(\"registered datastore with name: %s\" % datastore_name)\n"
+        "    print(\"registered datastore with name: %s\" % datastore_name)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Create DataReferences and PipelineData\n",
+        "## Setup inputs and outputs\n",
         "\n",
-        "In the code cell below, replace datastorename with your default datastore name. Copy the file `testdata.txt` (located in the pipeline folder that this notebook is in) to the path on the datastore."
+        "For purpose of this demo, we're going to execute a simple U-SQL script that reads a CSV file and writes portion of content to a new text file. First, let's create our sample input which contains 3 columns: employee Id, name and department Id."
       ]
     },
     {
@@ -130,26 +169,51 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "datastorename = \"MyAdlsDatastore\"\n",
+        "# create a folder to store files for our job\n",
+        "sample_folder = \"adla_sample\"\n",
         "\n",
-        "adls_datastore = Datastore(workspace=ws, name=datastorename)\n",
-        "script_input = DataReference(\n",
+        "if not os.path.isdir(sample_folder):\n",
+        "    os.mkdir(sample_folder)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%writefile $sample_folder/sample_input.csv\n",
+        "1, Noah, 100\n",
+        "3, Liam, 100\n",
+        "4, Emma, 100\n",
+        "5, Jacob, 100\n",
+        "7, Jennie, 100"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Upload this file to Data Lake Storage at location `adla_sample/sample_input.csv` and create a DataReference to refer to this file."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "sample_input = DataReference(\n",
         "    datastore=adls_datastore,\n",
-        "    data_reference_name=\"script_input\",\n",
-        "    path_on_datastore=\"testdata/testdata.txt\")\n",
-        "\n",
-        "script_output = PipelineData(\"script_output\", datastore=adls_datastore)\n",
-        "\n",
-        "print(\"Created Pipeline Data\")"
+        "    data_reference_name=\"employee_data\",\n",
+        "    path_on_datastore=\"adla_sample/sample_input.csv\")"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Setup Data Lake Account\n",
-        "\n",
-        "ADLA can only use data that is located in the default data store associated with that ADLA account. Through Azure portal, check the name of the default data store corresponding to the ADLA account you are using below. Replace the value associated with `adla_compute_name` in the code cell below accordingly."
+        "Create PipelineData object to store output produced by AdlaStep."
       ]
     },
     {
@@ -158,35 +222,23 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "adla_compute_name = 'testadl' # Replace this with your default compute\n",
-        "\n",
-        "from azureml.core.compute import ComputeTarget, AdlaCompute\n",
-        "\n",
-        "def get_or_create_adla_compute(workspace, compute_name):\n",
-        "    try:\n",
-        "        return AdlaCompute(workspace, compute_name)\n",
-        "    except ComputeTargetException as e:\n",
-        "        if 'ComputeTargetNotFound' in e.message:\n",
-        "            print('adla compute not found, creating...')\n",
-        "            provisioning_config = AdlaCompute.provisioning_configuration()\n",
-        "            new_adla_compute = ComputeTarget.create(workspace, compute_name, provisioning_config)\n",
-        "            new_adla_compute.wait_for_completion()\n",
-        "            return new_adla_compute\n",
-        "        else:\n",
-        "            raise e\n",
-        "            \n",
-        "adla_compute = get_or_create_adla_compute(ws, adla_compute_name)\n",
-        "\n",
-        "# CLI:\n",
-        "# Create: az ml computetarget setup adla -n <name>\n",
-        "# BYOC: az ml computetarget attach adla -n <name> -i <resource-id>"
+        "sample_output = PipelineData(\"sample_output\", datastore=adls_datastore)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Once the above code cell completes, run the below to check your ADLA compute status:"
+        "## Write your U-SQL script\n",
+        "\n",
+        "Now let's write a U-Sql script that reads above CSV file and writes the name column to a new file.\n",
+        "\n",
+        "Instead of hard-coding paths in your script, you can use `@@name@@` syntax to refer to inputs, outputs, and parameters.\n",
+        "\n",
+        "- If `name` is the name of an input or output port binding, any occurrences of `@@name@@` in the script are replaced with actual data path of corresponding port binding.\n",
+        "- If `name` matches any key in the `params` dictionary, any occurrences of `@@name@@` will be replaced with corresponding value in the dictionary.\n",
+        "\n",
+        "Note the use of @@ syntax in the below script. Before submitting the job to Data Lake Analytics service, `@@emplyee_data@@` will be replaced with actual path of `sample_input.csv` in Data Lake Storage. Similarly, `@@sample_output@@` will be replaced with a path in Data Lake Storage which will be used to store intermediate output produced by the step."
       ]
     },
     {
@@ -195,58 +247,43 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"ADLA compute state:{}\".format(adla_compute.provisioning_state))\n",
-        "print(\"ADLA compute state:{}\".format(adla_compute.provisioning_errors))\n",
-        "print(\"Using ADLA compute:{}\".format(adla_compute.cluster_resource_id))"
+        "%%writefile $sample_folder/sample_script.usql\n",
+        "\n",
+        "// Read employee information from csv file\n",
+        "@employees = \n",
+        "    EXTRACT EmpId int, EmpName string, DeptId int\n",
+        "    FROM \"@@employee_data@@\"\n",
+        "    USING Extractors.Csv();\n",
+        "\n",
+        "// Export employee names to text file\n",
+        "OUTPUT\n",
+        "(\n",
+        "    SELECT EmpName\n",
+        "    FROM @employees\n",
+        ")\n",
+        "TO \"@@sample_output@@\"\n",
+        "USING Outputters.Text();"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Create an AdlaStep"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "**AdlaStep** is used to run U-SQL script using Azure Data Lake Analytics.\n",
+        "## Create an AdlaStep\n",
+        "\n",
+        "**[AdlaStep](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.adla_step.adlastep?view=azure-ml-py)** is used to run U-SQL script using Azure Data Lake Analytics.\n",
         "\n",
         "- **name:** Name of module\n",
-        "- **script_name:** name of U-SQL script\n",
+        "- **script_name:** name of U-SQL script file\n",
         "- **inputs:** List of input port bindings\n",
         "- **outputs:** List of output port bindings\n",
-        "- **adla_compute:** the ADLA compute to use for this job\n",
+        "- **compute_target:** the ADLA compute to use for this job\n",
         "- **params:** Dictionary of name-value pairs to pass to U-SQL job *(optional)*\n",
         "- **degree_of_parallelism:** the degree of parallelism to use for this job *(optional)*\n",
         "- **priority:** the priority value to use for the current job *(optional)*\n",
         "- **runtime_version:** the runtime version of the Data Lake Analytics engine *(optional)*\n",
-        "- **root_folder:** folder that contains the script, assemblies etc. *(optional)*\n",
-        "- **hash_paths:** list of paths to hash to detect a change (script file is always hashed) *(optional)*\n",
-        "\n",
-        "### Remarks\n",
-        "\n",
-        "You can use `@@name@@` syntax in your script to refer to inputs, outputs, and params.\n",
-        "\n",
-        "* if `name` is the name of an input or output port binding, any occurences of `@@name@@` in the script\n",
-        "are replaced with actual data path of corresponding port binding.\n",
-        "* if `name` matches any key in `params` dict, any occurences of `@@name@@` will be replaced with\n",
-        "corresponding value in dict.\n",
-        "\n",
-        "#### Sample script\n",
-        "\n",
-        "```\n",
-        "@resourcereader =\n",
-        "    EXTRACT query string\n",
-        "    FROM \"@@script_input@@\"\n",
-        "    USING Extractors.Csv();\n",
-        "\n",
-        "\n",
-        "OUTPUT @resourcereader\n",
-        "TO \"@@script_output@@\"\n",
-        "USING Outputters.Csv();\n",
-        "```"
+        "- **source_directory:** folder that contains the script, assemblies etc. *(optional)*\n",
+        "- **hash_paths:** list of paths to hash to detect a change (script file is always hashed) *(optional)*"
       ]
     },
     {
@@ -256,10 +293,11 @@
       "outputs": [],
       "source": [
         "adla_step = AdlaStep(\n",
-        "    name='adla_script_step',\n",
-        "    script_name='test_adla_script.usql',\n",
-        "    inputs=[script_input],\n",
-        "    outputs=[script_output],\n",
+        "    name='extract_employee_names',\n",
+        "    script_name='sample_script.usql',\n",
+        "    source_directory=sample_folder,\n",
+        "    inputs=[sample_input],\n",
+        "    outputs=[sample_output],\n",
         "    compute_target=adla_compute)"
       ]
     },
@@ -276,13 +314,9 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "pipeline = Pipeline(\n",
-        "    description=\"adla_102\",\n",
-        "    workspace=ws, \n",
-        "    steps=[adla_step],\n",
-        "    default_source_directory=script_folder)\n",
+        "pipeline = Pipeline(workspace=ws, steps=[adla_step])\n",
         "\n",
-        "pipeline_run = Experiment(ws, experiment_name).submit(pipeline)\n",
+        "pipeline_run = Experiment(ws, 'adla_sample').submit(pipeline)\n",
         "pipeline_run.wait_for_completion()"
       ]
     },
@@ -302,39 +336,6 @@
         "from azureml.widgets import RunDetails\n",
         "RunDetails(pipeline_run).show()"
       ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Examine the run\n",
-        "You can cycle through the node_run objects and examine job logs, stdout, and stderr of each of the steps."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "step_runs = pipeline_run.get_children()\n",
-        "for step_run in step_runs:\n",
-        "    status = step_run.get_status()\n",
-        "    print('node', step_run.name, 'status:', status)\n",
-        "    if status == \"Failed\":\n",
-        "        joblog = step_run.get_job_log()\n",
-        "        print('job log:', joblog)\n",
-        "        stdout_log = step_run.get_stdout_log()\n",
-        "        print('stdout log:', stdout_log)\n",
-        "        stderr_log = step_run.get_stderr_log()\n",
-        "        print('stderr log:', stderr_log)\n",
-        "        with open(\"logs-\" + step_run.name + \".txt\", \"w\") as f:\n",
-        "            f.write(joblog)\n",
-        "            print(\"Job log written to logs-\"+ step_run.name + \".txt\")\n",
-        "    if status == \"Finished\":\n",
-        "        stdout_log = step_run.get_stdout_log()\n",
-        "        print('stdout log:', stdout_log)"
-      ]
     }
   ],
   "metadata": {

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-use-databricks-as-compute-target.ipynb

@@ -176,7 +176,7 @@
         "### Type of Data Access\n",
         "Databricks allows to interact with Azure Blob and ADLS in two ways.\n",
         "- **Direct Access**: Databricks allows you to interact with Azure Blob or ADLS URIs directly. The input or output URIs will be mapped to a Databricks widget param in the Databricks notebook.\n",
-        "- **Mouting**: You will be supplied with additional parameters and secrets that will enable you to mount your ADLS or Azure Blob input or output location in your Databricks notebook."
+        "- **Mounting**: You will be supplied with additional parameters and secrets that will enable you to mount your ADLS or Azure Blob input or output location in your Databricks notebook."
       ]
     },
     {
@@ -348,6 +348,7 @@
         "\n",
         "## Use runconfig to specify library dependencies\n",
         "You can use a runconfig to specify the library dependencies for your cluster in Databricks. The runconfig will contain a databricks section as follows:\n",
+        "\n",
         "```yaml\n",
         "environment:\n",
         "# Databricks details\n",
@@ -365,14 +366,21 @@
         "      repo: ''\n",
         "# List of RCran libraries\n",
         "    rcranLibraries:\n",
-        "    - package: ada\n",
+        "    -\n",
+        "# Coordinates.\n",
+        "      package: ada\n",
+        "# Repo\n",
         "      repo: http://cran.us.r-project.org\n",
         "# List of JAR libraries\n",
         "    jarLibraries:\n",
-        "    - library: dbfs:/mnt/libraries/library.jar\n",
+        "    -\n",
+        "# Coordinates.\n",
+        "      library: dbfs:/mnt/libraries/library.jar\n",
         "# List of Egg libraries\n",
         "    eggLibraries:\n",
-        "    - library: dbfs:/mnt/libraries/library.egg\n",
+        "    -\n",
+        "# Coordinates.\n",
+        "      library: dbfs:/mnt/libraries/library.egg\n",
         "```\n",
         "\n",
         "You can then create a RunConfiguration object using this file and pass it as the runconfig parameter to DatabricksStep.\n",
@@ -409,7 +417,7 @@
         "    notebook_params={'myparam': 'testparam'},\n",
         "    run_name='DB_Notebook_demo',\n",
         "    compute_target=databricks_compute,\n",
-        "    allow_reuse=False\n",
+        "    allow_reuse=True\n",
         ")"
       ]
     },
@@ -453,14 +461,16 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### 2. Running a Python script that is already added in DBFS\n",
-        "To run a Python script that is already uploaded to DBFS, follow the instructions below. You will first upload the Python script to DBFS using the [CLI](https://docs.azuredatabricks.net/user-guide/dbfs-databricks-file-system.html).\n",
+        "### 2. Running a Python script from DBFS\n",
+        "This shows how to run a Python script in DBFS. \n",
         "\n",
-        "The commented out code in the below cell assumes that you have uploaded `train-db-dbfs.py` to the root folder in DBFS. You can upload `train-db-dbfs.py` to the root folder in DBFS using this commandline so you can use `python_script_path = \"dbfs:/train-db-dbfs.py\"`:\n",
+        "To complete this, you will need to first upload the Python script in your local machine to DBFS using the [CLI](https://docs.azuredatabricks.net/user-guide/dbfs-databricks-file-system.html). The CLI command is given below:\n",
         "\n",
         "```\n",
         "dbfs cp ./train-db-dbfs.py dbfs:/train-db-dbfs.py\n",
-        "```"
+        "```\n",
+        "\n",
+        "The code in the below cell assumes that you have completed the previous step of uploading the script `train-db-dbfs.py` to the root folder in DBFS."
       ]
     },
     {
@@ -469,7 +479,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "python_script_path = \"dbfs:/train-db-dbfs.py\"\n",
+        "python_script_path = os.getenv(\"DATABRICKS_PYTHON_SCRIPT_PATH\", \"<my-databricks-python-script-path>\") # Databricks python script path\n",
         "\n",
         "dbPythonInDbfsStep = DatabricksStep(\n",
         "    name=\"DBPythonInDBFS\",\n",
@@ -479,7 +489,7 @@
         "    python_script_params={'--input_data'},\n",
         "    run_name='DB_Python_demo',\n",
         "    compute_target=databricks_compute,\n",
-        "    allow_reuse=False\n",
+        "    allow_reuse=True\n",
         ")"
       ]
     },
@@ -548,7 +558,7 @@
         "    source_directory=source_directory,\n",
         "    run_name='DB_Python_Local_demo',\n",
         "    compute_target=databricks_compute,\n",
-        "    allow_reuse=False\n",
+        "    allow_reuse=True\n",
         ")"
       ]
     },
@@ -609,7 +619,7 @@
       "outputs": [],
       "source": [
         "main_jar_class_name = \"com.microsoft.aeva.Main\"\n",
-        "jar_library_dbfs_path = \"dbfs:/train-db-dbfs.jar\"\n",
+        "jar_library_dbfs_path = os.getenv(\"DATABRICKS_JAR_LIB_PATH\", \"<my-databricks-jar-lib-path>\") # Databricks jar library path\n",
         "\n",
         "dbJarInDbfsStep = DatabricksStep(\n",
         "    name=\"DBJarInDBFS\",\n",
@@ -620,7 +630,7 @@
         "    run_name='DB_JAR_demo',\n",
         "    jar_libraries=[JarLibrary(jar_library_dbfs_path)],\n",
         "    compute_target=databricks_compute,\n",
-        "    allow_reuse=False\n",
+        "    allow_reuse=True\n",
         ")"
       ]
     },

how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/testdata.txt

@@ -0,0 +1 @@
+Test1

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

@@ -0,0 +1,106 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import numpy as np
+import argparse
+import os
+import tensorflow as tf
+
+from azureml.core import Run
+from utils import load_data
+
+print("TensorFlow version:", tf.VERSION)
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')
+parser.add_argument('--batch-size', type=int, dest='batch_size', default=50, help='mini batch size for training')
+parser.add_argument('--first-layer-neurons', type=int, dest='n_hidden_1', default=100,
+                    help='# of neurons in the first layer')
+parser.add_argument('--second-layer-neurons', type=int, dest='n_hidden_2', default=100,
+                    help='# of neurons in the second layer')
+parser.add_argument('--learning-rate', type=float, dest='learning_rate', default=0.01, help='learning rate')
+args = parser.parse_args()
+
+data_folder = os.path.join(args.data_folder, 'mnist')
+
+print('training dataset is stored here:', data_folder)
+
+X_train = load_data(os.path.join(data_folder, 'train-images.gz'), False) / 255.0
+X_test = load_data(os.path.join(data_folder, 'test-images.gz'), False) / 255.0
+
+y_train = load_data(os.path.join(data_folder, 'train-labels.gz'), True).reshape(-1)
+y_test = load_data(os.path.join(data_folder, 'test-labels.gz'), True).reshape(-1)
+
+print(X_train.shape, y_train.shape, X_test.shape, y_test.shape, sep='\n')
+training_set_size = X_train.shape[0]
+
+n_inputs = 28 * 28
+n_h1 = args.n_hidden_1
+n_h2 = args.n_hidden_2
+n_outputs = 10
+learning_rate = args.learning_rate
+n_epochs = 50
+batch_size = args.batch_size
+
+with tf.name_scope('network'):
+    # construct the DNN
+    X = tf.placeholder(tf.float32, shape=(None, n_inputs), name='X')
+    y = tf.placeholder(tf.int64, shape=(None), name='y')
+    h1 = tf.layers.dense(X, n_h1, activation=tf.nn.relu, name='h1')
+    h2 = tf.layers.dense(h1, n_h2, activation=tf.nn.relu, name='h2')
+    output = tf.layers.dense(h2, n_outputs, name='output')
+
+with tf.name_scope('train'):
+    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=output)
+    loss = tf.reduce_mean(cross_entropy, name='loss')
+    optimizer = tf.train.GradientDescentOptimizer(learning_rate)
+    train_op = optimizer.minimize(loss)
+
+with tf.name_scope('eval'):
+    correct = tf.nn.in_top_k(output, y, 1)
+    acc_op = tf.reduce_mean(tf.cast(correct, tf.float32))
+
+init = tf.global_variables_initializer()
+saver = tf.train.Saver()
+
+# start an Azure ML run
+run = Run.get_context()
+
+with tf.Session() as sess:
+    init.run()
+    for epoch in range(n_epochs):
+
+        # randomly shuffle training set
+        indices = np.random.permutation(training_set_size)
+        X_train = X_train[indices]
+        y_train = y_train[indices]
+
+        # batch index
+        b_start = 0
+        b_end = b_start + batch_size
+        for _ in range(training_set_size // batch_size):
+            # get a batch
+            X_batch, y_batch = X_train[b_start: b_end], y_train[b_start: b_end]
+
+            # update batch index for the next batch
+            b_start = b_start + batch_size
+            b_end = min(b_start + batch_size, training_set_size)
+
+            # train
+            sess.run(train_op, feed_dict={X: X_batch, y: y_batch})
+        # evaluate training set
+        acc_train = acc_op.eval(feed_dict={X: X_batch, y: y_batch})
+        # evaluate validation set
+        acc_val = acc_op.eval(feed_dict={X: X_test, y: y_test})
+
+        # log accuracies
+        run.log('training_acc', np.float(acc_train))
+        run.log('validation_acc', np.float(acc_val))
+        print(epoch, '-- Training accuracy:', acc_train, '\b Validation accuracy:', acc_val)
+        y_hat = np.argmax(output.eval(feed_dict={X: X_test}), axis=1)
+
+    run.log('final_acc', np.float(acc_val))
+
+    os.makedirs('./outputs/model', exist_ok=True)
+    # files saved in the "./outputs" folder are automatically uploaded into run history
+    saver.save(sess, './outputs/model/mnist-tf.model')

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

@@ -0,0 +1,27 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import gzip
+import numpy as np
+import struct
+
+
+# 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
+
+
+# one-hot encode a 1-D array
+def one_hot_encode(array, num_of_classes):
+    return np.eye(num_of_classes)[array.reshape(-1)]

how-to-use-azureml/machine-learning-pipelines/pipeline-batch-scoring/pipeline-batch-scoring.ipynb

@@ -489,11 +489,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.authentication import AzureCliAuthentication\n",
+        "from azureml.core.authentication import InteractiveLoginAuthentication\n",
         "import requests\n",
         "\n",
-        "cli_auth = AzureCliAuthentication()\n",
-        "aad_token = cli_auth.get_authentication_header()"
+        "auth = InteractiveLoginAuthentication()\n",
+        "aad_token = auth.get_authentication_header()\n"
       ]
     },
     {

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

@@ -120,7 +120,7 @@
       "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_mpi.py)). Scripts to split and stitch the video are thin wrappers to calls to `ffmpeg`. \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`. \n",
         "\n",
         "We install `ffmpeg` through conda dependencies."
       ]
@@ -201,6 +201,13 @@
         "              )"
       ]
     },
+    {
+      "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,
@@ -208,8 +215,8 @@
       "outputs": [],
       "source": [
         "# datastore for input video\n",
-        "account_name = \"happypathspublic\"\n",
-        "video_ds = Datastore.register_azure_blob_container(ws, \"videos\", \"videos\",\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",
@@ -238,9 +245,10 @@
       "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=\"orangutan.mp4\", mode=\"download\")"
+        "                            path_on_datastore=video_name, mode=\"download\")"
       ]
     },
     {
@@ -465,11 +473,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.authentication import AzureCliAuthentication\n",
+        "from azureml.core.authentication import InteractiveLoginAuthentication\n",
         "import requests\n",
         "\n",
-        "cli_auth = AzureCliAuthentication()\n",
-        "aad_token = cli_auth.get_authentication_header()"
+        "auth = InteractiveLoginAuthentication()\n",
+        "aad_token = auth.get_authentication_header()\n"
       ]
     },
     {
@@ -542,7 +550,7 @@
         "response = requests.post(rest_endpoint, \n",
         "                         headers=aad_token,\n",
         "                         json={\"ExperimentName\": \"style_transfer\",\n",
-        "                               \"ParameterAssignments\": {\"style\": \"udnie\", \"nodecount\": 4}})   \n",
+        "                               \"ParameterAssignments\": {\"style\": \"udnie\", \"nodecount\": 3}})   \n",
         "run_id = response.json()[\"Id\"]\n",
         "\n",
         "published_pipeline_run_udnie = PipelineRun(ws.experiments[\"style_transfer\"], run_id)\n",

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

@@ -0,0 +1,253 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+    "\n",
+    "Licensed under the MIT License.\n",
+    "\n",
+    "## Authentication in Azure Machine Learning\n",
+    "\n",
+    "This notebook shows you how to authenticate to your Azure ML Workspace using\n",
+    "\n",
+    " 1. Interactive Login Authentication\n",
+    " 2. Azure CLI Authentication\n",
+    " 3. Service Principal 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 Service Principal authentication is suitable for automated workflows, for example as part of Azure Devops build."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from azureml.core import Workspace"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Interactive Authentication\n",
+    "\n",
+    "Interactive authentication is the default mode when using Azure ML SDK.\n",
+    "\n",
+    "When you connect to your workspace using workspace.from_config, you will get an interactive login dialog."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ws = Workspace.from_config()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Also, if you explicitly specify the subscription ID, resource group and resource group, you will get the dialog."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ws = Workspace(subscription_id=\"my-subscription-id\",\n",
+    "               resource_group=\"my-ml-rg\",\n",
+    "               workspace_name=\"my-ml-workspace\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note the user you're authenticated as must have access to the subscription and resource group. If you receive an error\n",
+    "\n",
+    "```\n",
+    "AuthenticationException: You don't have access to xxxxxx-xxxx-xxx-xxx-xxxxxxxxxx subscription. All the subscriptions that you have access to = ...\n",
+    "```\n",
+    "\n",
+    "check that the you used correct login and entered the correct subscription ID."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In some cases, you may see a version of the error message containing text: ```All the subscriptions that you have access to = []```\n",
+    "\n",
+    "In such a case, you may have to specify the tenant ID of the Azure Active Directory you're using. An example would be accessing a subscription as a guest to a tenant that is not your default. You specify the tenant by explicitly instantiating _InteractiveLoginAuthentication_ with tenant ID as argument ([see instructions how to obtain tenant Id](#get-tenant-id))."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from azureml.core.authentication import InteractiveLoginAuthentication\n",
+    "\n",
+    "interactive_auth = InteractiveLoginAuthentication(tenant_id=\"my-tenant-id\")\n",
+    "\n",
+    "ws = Workspace(subscription_id=\"my-subscription-id\",\n",
+    "               resource_group=\"my-ml-rg\",\n",
+    "               workspace_name=\"my-ml-workspace\",\n",
+    "               auth=interactive_auth)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Azure CLI Authentication\n",
+    "\n",
+    "If you have installed azure-cli package, and used ```az login``` command to log in to your Azure Subscription, you can use _AzureCliAuthentication_ class.\n",
+    "\n",
+    "Note that interactive authentication described above won't use existing Azure CLI auth tokens. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from azureml.core.authentication import AzureCliAuthentication\n",
+    "\n",
+    "cli_auth = AzureCliAuthentication()\n",
+    "\n",
+    "ws = Workspace(subscription_id=\"my-subscription-id\",\n",
+    "               resource_group=\"my-ml-rg\",\n",
+    "               workspace_name=\"my-ml-workspace\",\n",
+    "               auth=cli_auth)\n",
+    "\n",
+    "print(\"Found workspace {} at location {}\".format(ws.name, ws.location))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Service Principal Authentication\n",
+    "\n",
+    "When setting up a machine learning workflow as an automated process, we recommend using Service Principal Authentication. This approach decouples the authentication from any specific user login, and allows managed access control.\n",
+    "\n",
+    "Note that you must have administrator privileges over the Azure subscription to complete these steps.\n",
+    "\n",
+    "The first step is to create a service principal. First, go to [Azure Portal](https://portal.azure.com), select **Azure Active Directory** and **App Registrations**. Then select **+New application registration**, give your service principal a name, for example _my-svc-principal_. You can leave application type as is, and specify a dummy value for Sign-on URL, such as _https://invalid_.\n",
+    "\n",
+    "Then click **Create**.\n",
+    "\n",
+    "![service principal creation]<img src=\"images/svc-pr-1.PNG\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The next step is to obtain the _Application ID_ (also called username) and create _password_ for the service principal.\n",
+    "\n",
+    "From the page for your newly created service principal, copy the _Application ID_. Then select **Settings** and **Keys**, write a description for your key, and select duration. Then click **Save**, and copy the _password_ to a secure location.\n",
+    "\n",
+    "![application id and password](images/svc-pr-2.PNG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id =\"get-tenant-id\"></a>\n",
+    "\n",
+    "Also, you need to obtain the tenant ID of your Azure subscription. Go back to **Azure Active Directory**, select **Properties** and copy _Directory ID_.\n",
+    "\n",
+    "![tenant id](images/svc-pr-3.PNG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, you need to give the service principal permissions to access your workspace. Navigate to **Resource Groups**, to the resource group for your Machine Learning Workspace. \n",
+    "\n",
+    "Then select **Access Control (IAM)** and **Add a role assignment**. For _Role_, specify which level of access you need to grant, for example _Contributor_. Start entering your service principal name and once it is found, select it, and click **Save**.\n",
+    "\n",
+    "![add role](images/svc-pr-4.PNG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now you are ready to use the service principal authentication. For example, to connect to your Workspace, see code below and enter your own values for tenant ID, application ID, subscription ID, resource group and workspace.\n",
+    "\n",
+    "**We strongly recommended that you do not insert the secret password to code**. Instead, you can use environment variables to pass it to your code, for example through Azure Key Vault, or through secret build variables in Azure DevOps. For local testing, you can for example use following PowerShell command to set the environment variable.\n",
+    "\n",
+    "```\n",
+    "$env:AZUREML_PASSWORD = \"my-password\"\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from azureml.core.authentication import ServicePrincipalAuthentication\n",
+    "\n",
+    "svc_pr_password = os.environ.get(\"AZUREML_PASSWORD\")\n",
+    "\n",
+    "svc_pr = ServicePrincipalAuthentication(\n",
+    "    tenant_id=\"my-tenant-id\",\n",
+    "    service_principal_id=\"my-application-id\",\n",
+    "    service_principal_password=svc_pr_password)\n",
+    "\n",
+    "\n",
+    "ws = Workspace(\n",
+    "    subscription_id=\"my-subscription-id\",\n",
+    "    resource_group=\"my-ml-rg\",\n",
+    "    workspace_name=\"my-ml-workspace\",\n",
+    "    auth=svc_pr\n",
+    "    )\n",
+    "\n",
+    "print(\"Found workspace {} at location {}\".format(ws.name, ws.location))"
+   ]
+  }
+ ],
+ "metadata": {
+  "authors": [
+   {
+    "name": "roastala"
+   }
+  ],
+  "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

how-to-use-azureml/training-with-deep-learning/README.md

@@ -5,11 +5,14 @@ These examples show you:
 1. [How to use the Estimator pattern in Azure ML](how-to-use-estimator)
 2. [Train using TensorFlow Estimator and tune hyperparameters using Hyperdrive](train-hyperparameter-tune-deploy-with-tensorflow)
 3. [Train using Pytorch Estimator and tune hyperparameters using Hyperdrive](train-hyperparameter-tune-deploy-with-pytorch)
-4. [Distributed training using TensorFlow and Parameter Server](distributed-tensorflow-with-parameter-server)
-5. [Distributed training using TensorFlow and Horovod](distributed-tensorflow-with-horovod)
-6. [Distributed training using Pytorch and Horovod](distributed-pytorch-with-horovod)
-7. [Distributed training using CNTK and custom Docker image](distributed-cntk-with-custom-docker)
-8. [Export run history records to Tensorboard](export-run-history-to-tensorboard)
-9. [Use TensorBoard to monitor training execution](tensorboard)
+4. [Train using Keras and tune hyperparameters using Hyperdrive](train-hyperparameter-tune-deploy-with-keras)
+5. [Train using Chainer Estimator and tune hyperparameters using Hyperdrive](train-hyperparameter-tune-deploy-with-chainer)
+6. [Distributed training using TensorFlow and Parameter Server](distributed-tensorflow-with-parameter-server)
+7. [Distributed training using TensorFlow and Horovod](distributed-tensorflow-with-horovod)
+8. [Distributed training using Pytorch and Horovod](distributed-pytorch-with-horovod)
+9. [Distributed training using CNTK and custom Docker image](distributed-cntk-with-custom-docker)
+10. [Distributed training using Chainer](distributed-chainer)
+11. [Export run history records to Tensorboard](export-run-history-to-tensorboard)
+12. [Use TensorBoard to monitor training execution](tensorboard)
 
 Learn more about how to use `Estimator` class to  [train deep neural networks with Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/service/how-to-train-ml-models).

how-to-use-azureml/training-with-deep-learning/distributed-chainer/chainer_mnist_distributed.py

@@ -0,0 +1,153 @@
+
+import argparse
+
+import chainer
+import chainer.cuda
+import chainer.functions as F
+import chainer.links as L
+from chainer import training
+from chainer.training import extensions
+
+import chainermn
+import chainermn.datasets
+import chainermn.functions
+
+
+chainer.disable_experimental_feature_warning = True
+
+
+class MLP0SubA(chainer.Chain):
+    def __init__(self, comm, n_out):
+        super(MLP0SubA, self).__init__(
+            l1=L.Linear(784, n_out))
+
+    def __call__(self, x):
+        return F.relu(self.l1(x))
+
+
+class MLP0SubB(chainer.Chain):
+    def __init__(self, comm):
+        super(MLP0SubB, self).__init__()
+
+    def __call__(self, y):
+        return y
+
+
+class MLP0(chainermn.MultiNodeChainList):
+    # Model on worker 0.
+    def __init__(self, comm, n_out):
+        super(MLP0, self).__init__(comm=comm)
+        self.add_link(MLP0SubA(comm, n_out), rank_in=None, rank_out=1)
+        self.add_link(MLP0SubB(comm), rank_in=1, rank_out=None)
+
+
+class MLP1Sub(chainer.Chain):
+    def __init__(self, n_units, n_out):
+        super(MLP1Sub, self).__init__(
+            l2=L.Linear(None, n_units),
+            l3=L.Linear(None, n_out))
+
+    def __call__(self, h0):
+        h1 = F.relu(self.l2(h0))
+        return self.l3(h1)
+
+
+class MLP1(chainermn.MultiNodeChainList):
+    # Model on worker 1.
+    def __init__(self, comm, n_units, n_out):
+        super(MLP1, self).__init__(comm=comm)
+        self.add_link(MLP1Sub(n_units, n_out), rank_in=0, rank_out=0)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='ChainerMN example: pipelined neural network')
+    parser.add_argument('--batchsize', '-b', type=int, default=100,
+                        help='Number of images in each mini-batch')
+    parser.add_argument('--epoch', '-e', type=int, default=20,
+                        help='Number of sweeps over the dataset to train')
+    parser.add_argument('--gpu', '-g', action='store_true',
+                        help='Use GPU')
+    parser.add_argument('--out', '-o', default='result',
+                        help='Directory to output the result')
+    parser.add_argument('--unit', '-u', type=int, default=1000,
+                        help='Number of units')
+    args = parser.parse_args()
+
+    # Prepare ChainerMN communicator.
+    if args.gpu:
+        comm = chainermn.create_communicator('hierarchical')
+        data_axis, model_axis = comm.rank % 2, comm.rank // 2
+        data_comm = comm.split(data_axis, comm.rank)
+        model_comm = comm.split(model_axis, comm.rank)
+        device = comm.intra_rank
+    else:
+        comm = chainermn.create_communicator('naive')
+        data_axis, model_axis = comm.rank % 2, comm.rank // 2
+        data_comm = comm.split(data_axis, comm.rank)
+        model_comm = comm.split(model_axis, comm.rank)
+        device = -1
+
+    if model_comm.size != 2:
+        raise ValueError(
+            'This example can only be executed on the even number'
+            'of processes.')
+
+    if comm.rank == 0:
+        print('==========================================')
+        if args.gpu:
+            print('Using GPUs')
+        print('Num unit: {}'.format(args.unit))
+        print('Num Minibatch-size: {}'.format(args.batchsize))
+        print('Num epoch: {}'.format(args.epoch))
+        print('==========================================')
+
+    if data_axis == 0:
+        model = L.Classifier(MLP0(model_comm, args.unit))
+    elif data_axis == 1:
+        model = MLP1(model_comm, args.unit, 10)
+
+    if device >= 0:
+        chainer.cuda.get_device_from_id(device).use()
+        model.to_gpu()
+
+    optimizer = chainermn.create_multi_node_optimizer(
+        chainer.optimizers.Adam(), data_comm)
+    optimizer.setup(model)
+
+    # Original dataset on worker 0 and 1.
+    # Datasets of worker 0 and 1 are split and distributed to all workers.
+    if model_axis == 0:
+        train, test = chainer.datasets.get_mnist()
+        if data_axis == 1:
+            train = chainermn.datasets.create_empty_dataset(train)
+            test = chainermn.datasets.create_empty_dataset(test)
+    else:
+        train, test = None, None
+    train = chainermn.scatter_dataset(train, data_comm, shuffle=True)
+    test = chainermn.scatter_dataset(test, data_comm, shuffle=True)
+
+    train_iter = chainer.iterators.SerialIterator(
+        train, args.batchsize, shuffle=False)
+    test_iter = chainer.iterators.SerialIterator(
+        test, args.batchsize, repeat=False, shuffle=False)
+
+    updater = training.StandardUpdater(train_iter, optimizer, device=device)
+    trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
+    evaluator = extensions.Evaluator(test_iter, model, device=device)
+    evaluator = chainermn.create_multi_node_evaluator(evaluator, data_comm)
+    trainer.extend(evaluator)
+
+    # Some display and output extentions are necessary only for worker 0.
+    if comm.rank == 0:
+        trainer.extend(extensions.LogReport())
+        trainer.extend(extensions.PrintReport(
+            ['epoch', 'main/loss', 'validation/main/loss',
+             'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
+        trainer.extend(extensions.ProgressBar())
+
+    trainer.run()
+
+
+if __name__ == '__main__':
+    main()

how-to-use-azureml/training-with-deep-learning/distributed-chainer/distributed-chainer.ipynb

@@ -0,0 +1,315 @@
+{
+  "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": [
+        "# Distributed Chainer\n",
+        "In this tutorial, you will run a Chainer training example on the [MNIST](http://yann.lecun.com/exdb/mnist/) dataset using ChainerMN distributed training across a GPU cluster."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Prerequisites\n",
+        "* Go through the [Configuration](../../../configuration.ipynb) notebook to install the Azure Machine Learning Python SDK and create an Azure ML `Workspace`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Check core SDK version number\n",
+        "import azureml.core\n",
+        "\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Diagnostics\n",
+        "Opt-in diagnostics for better experience, quality, and security of future releases."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "Diagnostics"
+        ]
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.telemetry import set_diagnostics_collection\n",
+        "\n",
+        "set_diagnostics_collection(send_diagnostics=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Initialize workspace\n",
+        "\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.workspace import Workspace\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')"
+      ]
+    },
+    {
+      "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, we use Azure ML managed compute ([AmlCompute](https://docs.microsoft.com/azure/machine-learning/service/how-to-set-up-training-targets#amlcompute)) for our remote training compute resource. Specifically, the below code creates an `STANDARD_NC6` GPU cluster that autoscales from `0` to `4` nodes.\n",
+        "\n",
+        "**Creation of AmlCompute takes approximately 5 minutes.** If the AmlCompute with that name is already in your workspace, this code will skip the creation process.\n",
+        "\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](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota."
+      ]
+    },
+    {
+      "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 = \"gpucluster\"\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_NC6',\n",
+        "                                                           max_nodes=4)\n",
+        "\n",
+        "    # create the cluster\n",
+        "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
+        "\n",
+        "    compute_target.wait_for_completion(show_output=True)\n",
+        "\n",
+        "# use get_status() to get a detailed status for the current AmlCompute. \n",
+        "print(compute_target.get_status().serialize())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "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": [
+        "## Train model on the remote compute\n",
+        "Now that we have the AmlCompute ready to go, let's run our distributed training job."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a project directory\n",
+        "Create a directory that will contain all the necessary code from your local machine that you will need access to on the remote resource. This includes the training script and any additional files your training script depends on."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "project_folder = './chainer-distr'\n",
+        "os.makedirs(project_folder, exist_ok=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "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 `train_mnist.py`. In practice, you should be able to take any custom Chainer 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 `train_mnist.py` into the project directory."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import shutil\n",
+        "\n",
+        "shutil.copy('train_mnist.py', project_folder)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create an experiment\n",
+        "Create an [Experiment](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#experiment) to track all the runs in your workspace for this distributed Chainer tutorial. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Experiment\n",
+        "\n",
+        "experiment_name = 'chainer-distr'\n",
+        "experiment = Experiment(ws, name=experiment_name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a Chainer estimator\n",
+        "The Azure ML SDK's Chainer estimator enables you to easily submit Chainer training jobs for both single-node and distributed runs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.train.dnn import Chainer\n",
+        "\n",
+        "estimator = Chainer(source_directory=project_folder,\n",
+        "                    compute_target=compute_target,\n",
+        "                    entry_script='train_mnist.py',\n",
+        "                    node_count=2,\n",
+        "                    process_count_per_node=1,\n",
+        "                    distributed_backend='mpi',\n",
+        "                    use_gpu=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The above code specifies that we will run our training script on `2` nodes, with one worker per node. In order to execute a distributed run using MPI, you must provide the argument `distributed_backend='mpi'`. Using this estimator with these settings, Chainer and its dependencies will be installed for you. However, if your script also uses other packages, make sure to install them via the `Chainer` constructor's `pip_packages` or `conda_packages` parameters."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Submit job\n",
+        "Run your experiment by submitting your estimator object. Note that this call is asynchronous."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "run = experiment.submit(estimator)\n",
+        "print(run)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Monitor your run\n",
+        "You can monitor the progress of the run with a Jupyter widget. Like the run submission, the widget is asynchronous and provides live updates every 10-15 seconds until the job completes. You can see that the widget automatically plots and visualizes the loss metric that we logged to the Azure ML run."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.widgets import RunDetails\n",
+        "\n",
+        "RunDetails(run).show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "run.wait_for_completion(show_output=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "minxia"
+      }
+    ],
+    "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.6"
+    },
+    "msauthor": "minxia"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/training-with-deep-learning/distributed-chainer/train_mnist.py

@@ -0,0 +1,125 @@
+# Official ChainerMN example taken from
+# https://github.com/chainer/chainer/blob/master/examples/chainermn/mnist/train_mnist.py
+
+from __future__ import print_function
+
+import argparse
+
+import chainer
+import chainer.functions as F
+import chainer.links as L
+from chainer import training
+from chainer.training import extensions
+
+import chainermn
+
+
+class MLP(chainer.Chain):
+
+    def __init__(self, n_units, n_out):
+        super(MLP, self).__init__(
+            # the size of the inputs to each layer will be inferred
+            l1=L.Linear(784, n_units),  # n_in -> n_units
+            l2=L.Linear(n_units, n_units),  # n_units -> n_units
+            l3=L.Linear(n_units, n_out),  # n_units -> n_out
+        )
+
+    def __call__(self, x):
+        h1 = F.relu(self.l1(x))
+        h2 = F.relu(self.l2(h1))
+        return self.l3(h2)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='ChainerMN example: MNIST')
+    parser.add_argument('--batchsize', '-b', type=int, default=100,
+                        help='Number of images in each mini-batch')
+    parser.add_argument('--communicator', type=str,
+                        default='non_cuda_aware', help='Type of communicator')
+    parser.add_argument('--epoch', '-e', type=int, default=20,
+                        help='Number of sweeps over the dataset to train')
+    parser.add_argument('--gpu', '-g', default=True,
+                        help='Use GPU')
+    parser.add_argument('--out', '-o', default='result',
+                        help='Directory to output the result')
+    parser.add_argument('--resume', '-r', default='',
+                        help='Resume the training from snapshot')
+    parser.add_argument('--unit', '-u', type=int, default=1000,
+                        help='Number of units')
+    args = parser.parse_args()
+
+    # Prepare ChainerMN communicator.
+
+    if args.gpu:
+        if args.communicator == 'naive':
+            print("Error: 'naive' communicator does not support GPU.\n")
+            exit(-1)
+        comm = chainermn.create_communicator(args.communicator)
+        device = comm.intra_rank
+    else:
+        if args.communicator != 'naive':
+            print('Warning: using naive communicator '
+                  'because only naive supports CPU-only execution')
+        comm = chainermn.create_communicator('naive')
+        device = -1
+
+    if comm.rank == 0:
+        print('==========================================')
+        print('Num process (COMM_WORLD): {}'.format(comm.size))
+        if args.gpu:
+            print('Using GPUs')
+        print('Using {} communicator'.format(args.communicator))
+        print('Num unit: {}'.format(args.unit))
+        print('Num Minibatch-size: {}'.format(args.batchsize))
+        print('Num epoch: {}'.format(args.epoch))
+        print('==========================================')
+
+    model = L.Classifier(MLP(args.unit, 10))
+    if device >= 0:
+        chainer.cuda.get_device_from_id(device).use()
+        model.to_gpu()
+
+    # Create a multi node optimizer from a standard Chainer optimizer.
+    optimizer = chainermn.create_multi_node_optimizer(
+        chainer.optimizers.Adam(), comm)
+    optimizer.setup(model)
+
+    # Split and distribute the dataset. Only worker 0 loads the whole dataset.
+    # Datasets of worker 0 are evenly split and distributed to all workers.
+    if comm.rank == 0:
+        train, test = chainer.datasets.get_mnist()
+    else:
+        train, test = None, None
+    train = chainermn.scatter_dataset(train, comm, shuffle=True)
+    test = chainermn.scatter_dataset(test, comm, shuffle=True)
+
+    train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
+    test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
+                                                 repeat=False, shuffle=False)
+
+    updater = training.StandardUpdater(train_iter, optimizer, device=device)
+    trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
+
+    # Create a multi node evaluator from a standard Chainer evaluator.
+    evaluator = extensions.Evaluator(test_iter, model, device=device)
+    evaluator = chainermn.create_multi_node_evaluator(evaluator, comm)
+    trainer.extend(evaluator)
+
+    # Some display and output extensions are necessary only for one worker.
+    # (Otherwise, there would just be repeated outputs.)
+    if comm.rank == 0:
+        trainer.extend(extensions.dump_graph('main/loss'))
+        trainer.extend(extensions.LogReport())
+        trainer.extend(extensions.PrintReport(
+            ['epoch', 'main/loss', 'validation/main/loss',
+             'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
+        trainer.extend(extensions.ProgressBar())
+
+    if args.resume:
+        chainer.serializers.load_npz(args.resume, trainer)
+
+    trainer.run()
+
+
+if __name__ == '__main__':
+    main()

how-to-use-azureml/training-with-deep-learning/distributed-cntk-with-custom-docker/distributed-cntk-with-custom-docker.ipynb

@@ -298,7 +298,7 @@
         "                      process_count_per_node=1,\n",
         "                      distributed_backend='mpi',\n",
         "                      pip_packages=['cntk-gpu==2.6'],\n",
-        "                      custom_docker_base_image='microsoft/mmlspark:gpu-0.12',\n",
+        "                      custom_docker_image='microsoft/mmlspark:gpu-0.12',\n",
         "                      use_gpu=True)"
       ]
     },
@@ -306,7 +306,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "We would like to train our model using a [pre-built Docker container](https://hub.docker.com/r/microsoft/mmlspark/). To do so, specify the name of the docker image to the argument `custom_docker_base_image`. You can only provide images available in public docker repositories such as Docker Hub using this argument. To use an image from a private docker repository, use the constructor's `environment_definition` parameter instead. Finally, we provide the `cntk` package to `pip_packages` to install CNTK 2.6 on our custom image.\n",
+        "We would like to train our model using a [pre-built Docker container](https://hub.docker.com/r/microsoft/mmlspark/). To do so, specify the name of the docker image to the argument `custom_docker_image`. Finally, we provide the `cntk` package to `pip_packages` to install CNTK 2.6 on our custom image.\n",
         "\n",
         "The above code specifies that we will run our training script on `2` nodes, with one worker per node. In order to run distributed CNTK, which uses MPI, you must provide the argument `distributed_backend='mpi'`."
       ]

how-to-use-azureml/training-with-deep-learning/export-run-history-to-tensorboard/export-run-history-to-tensorboard.ipynb

@@ -56,7 +56,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "!pip install azureml-contrib-tensorboard"
+        "!pip install azureml-tensorboard"
       ]
     },
     {
@@ -166,7 +166,7 @@
       "outputs": [],
       "source": [
         "# Export Run History to Tensorboard logs\n",
-        "from azureml.contrib.tensorboard.export import export_to_tensorboard\n",
+        "from azureml.tensorboard.export import export_to_tensorboard\n",
         "import os\n",
         "\n",
         "logdir = 'exportedTBlogs'\n",
@@ -208,7 +208,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.contrib.tensorboard import Tensorboard\n",
+        "from azureml.tensorboard import Tensorboard\n",
         "\n",
         "# The Tensorboard constructor takes an array of runs, so be sure and pass it in as a single-element array here\n",
         "tb = Tensorboard([], local_root=logdir, port=6006)\n",

how-to-use-azureml/training-with-deep-learning/how-to-use-estimator/how-to-use-estimator.ipynb

@@ -291,29 +291,27 @@
       "outputs": [],
       "source": [
         "# use a custom Docker image\n",
-        "from azureml.core import RunConfiguration\n",
-        "\n",
-        "rc = RunConfiguration()\n",
-        "rc.environment.docker.enabled = True\n",
+        "from azureml.core.runconfig import ContainerRegistry\n",
         "\n",
         "# this is an image available in Docker Hub\n",
-        "rc.environment.docker.base_image = 'continuumio/miniconda3'\n",
+        "image_name = 'continuumio/miniconda3'\n",
         "\n",
         "# you can also point to an image in a private ACR\n",
-        "#rc.environment.docker.base_image = \"mycustomimage:1.0\"\n",
-        "#rc.environment.docker.base_image_registry.address = \"myregistry.azurecr.io\"\n",
-        "#rc.environment.docker.base_image_registry.username = \"username\"\n",
-        "#rc.environment.docker.base_image_registry.password = \"password\"\n",
+        "image_registry_details = ContainerRegistry()\n",
+        "image_registry_details.address = \"myregistry.azurecr.io\"\n",
+        "image_registry_details.username = \"username\"\n",
+        "image_registry_details.password = \"password\"\n",
         "\n",
         "# don't let the system build a new conda environment\n",
-        "rc.environment.python.user_managed_dependencies = True\n",
-        "# point to an existing python environment instead\n",
-        "rc.environment.python.interpreter_path = '/opt/conda/bin/python'\n",
+        "user_managed_dependencies = True\n",
         "\n",
         "# submit to a local Docker container. if you don't have Docker engine running locally, you can set compute_target to cpu_cluster.\n",
         "est = Estimator(source_directory='.', compute_target='local', \n",
         "                entry_script='dummy_train.py',\n",
-        "                environment_definition=rc.environment)\n",
+        "                custom_docker_image=image_name,\n",
+        "                image_registry_details=image_registry_details,\n",
+        "                user_managed=user_managed_dependencies\n",
+        "                )\n",
         "\n",
         "run = exp.submit(est)\n",
         "RunDetails(run).show()"

how-to-use-azureml/training-with-deep-learning/tensorboard/tensorboard.ipynb

@@ -57,7 +57,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "!pip install azureml-contrib-tensorboard"
+        "!pip install azureml-tensorboard"
       ]
     },
     {
@@ -239,7 +239,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.contrib.tensorboard import Tensorboard\n",
+        "from azureml.tensorboard import Tensorboard\n",
         "\n",
         "# The Tensorboard constructor takes an array of runs, so be sure and pass it in as a single-element array here\n",
         "tb = Tensorboard([run])\n",
@@ -293,7 +293,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.compute import RemoteCompute\n",
+        "from azureml.core.compute import ComputeTarget, RemoteCompute\n",
         "from azureml.core.compute_target import ComputeTargetException\n",
         "\n",
         "username = os.getenv('AZUREML_DSVM_USERNAME', default='<my_username>')\n",
@@ -305,12 +305,11 @@
         "    attached_dsvm_compute = RemoteCompute(workspace=ws, name=compute_target_name)\n",
         "    print('found existing:', attached_dsvm_compute.name)\n",
         "except ComputeTargetException:\n",
-        "    attached_dsvm_compute = RemoteCompute.attach(workspace=ws,\n",
-        "                                                 name=compute_target_name,\n",
-        "                                                 username=username,\n",
-        "                                                 address=address,\n",
-        "                                                 ssh_port=22,\n",
-        "                                                 private_key_file='./.ssh/id_rsa')\n",
+        "    config = RemoteCompute.attach_configuration(username=username,\n",
+        "                                                address=address,\n",
+        "                                                ssh_port=22,\n",
+        "                                                private_key_file='./.ssh/id_rsa')\n",
+        "    attached_dsvm_compute = ComputeTarget.attach(ws, compute_target_name, config)\n",
         "    \n",
         "    attached_dsvm_compute.wait_for_completion(show_output=True)"
       ]
@@ -407,10 +406,13 @@
         "# choose a name for your cluster\n",
         "cluster_name = \"cpucluster\"\n",
         "\n",
-        "try:\n",
-        "    compute_target = ComputeTarget(workspace=ws, name=cluster_name)\n",
-        "    print('Found existing compute target.')\n",
-        "except ComputeTargetException:\n",
+        "cts = ws.compute_targets\n",
+        "found = False\n",
+        "if cluster_name in cts and cts[cluster_name].type == 'AmlCompute':\n",
+        "   found = True\n",
+        "   print('Found existing compute target.')\n",
+        "   compute_target = cts[cluster_name]\n",
+        "if not found:\n",
         "    print('Creating a new compute target...')\n",
         "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2', \n",
         "                                                           max_nodes=4)\n",
@@ -418,10 +420,10 @@
         "    # create the cluster\n",
         "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
         "\n",
-        "compute_target.wait_for_completion(show_output=True, min_node_count=1, timeout_in_minutes=20)\n",
+        "compute_target.wait_for_completion(show_output=True, min_node_count=None)\n",
         "\n",
         "# use get_status() to get a detailed status for the current cluster. \n",
-        "print(compute_target.get_status().serialize())"
+        "# print(compute_target.get_status().serialize())"
       ]
     },
     {

how-to-use-azureml/training-with-deep-learning/train-hyperparameter-tune-deploy-with-chainer/chainer_mnist.py

@@ -0,0 +1,136 @@
+
+import argparse
+
+import numpy as np
+
+import chainer
+from chainer import backend
+from chainer import backends
+from chainer.backends import cuda
+from chainer import Function, gradient_check, report, training, utils, Variable
+from chainer import datasets, iterators, optimizers, serializers
+from chainer import Link, Chain, ChainList
+import chainer.functions as F
+import chainer.links as L
+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()
+
+
+class MyNetwork(Chain):
+
+    def __init__(self, n_mid_units=100, n_out=10):
+        super(MyNetwork, self).__init__()
+        with self.init_scope():
+            self.l1 = L.Linear(None, n_mid_units)
+            self.l2 = L.Linear(n_mid_units, n_mid_units)
+            self.l3 = L.Linear(n_mid_units, n_out)
+
+    def forward(self, x):
+        h = F.relu(self.l1(x))
+        h = F.relu(self.l2(h))
+        return self.l3(h)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Chainer example: MNIST')
+    parser.add_argument('--batchsize', '-b', type=int, default=100,
+                        help='Number of images in each mini-batch')
+    parser.add_argument('--epochs', '-e', type=int, default=20,
+                        help='Number of sweeps over the dataset to train')
+    parser.add_argument('--output_dir', '-o', default='./outputs',
+                        help='Directory to output the result')
+    parser.add_argument('--gpu_id', '-g', default=0,
+                        help='ID of the GPU to be used. Set to -1 if you use CPU')
+    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)
+
+    gpu_id = args.gpu_id
+    batchsize = args.batchsize
+    epochs = args.epochs
+    run.log('Batch size', np.int(batchsize))
+    run.log('Epochs', np.int(epochs))
+
+    train_iter = iterators.SerialIterator(train, batchsize)
+    test_iter = iterators.SerialIterator(test, batchsize,
+                                         repeat=False, shuffle=False)
+
+    model = MyNetwork()
+
+    if gpu_id >= 0:
+        # Make a specified GPU current
+        chainer.backends.cuda.get_device_from_id(0).use()
+        model.to_gpu()  # Copy the model to the GPU
+
+    # Choose an optimizer algorithm
+    optimizer = optimizers.MomentumSGD(lr=0.01, momentum=0.9)
+
+    # Give the optimizer a reference to the model so that it
+    # can locate the model's parameters.
+    optimizer.setup(model)
+
+    while train_iter.epoch < epochs:
+        # ---------- One iteration of the training loop ----------
+        train_batch = train_iter.next()
+        image_train, target_train = concat_examples(train_batch, gpu_id)
+
+        # Calculate the prediction of the network
+        prediction_train = model(image_train)
+
+        # Calculate the loss with softmax_cross_entropy
+        loss = F.softmax_cross_entropy(prediction_train, target_train)
+
+        # Calculate the gradients in the network
+        model.cleargrads()
+        loss.backward()
+
+        # Update all the trainable parameters
+        optimizer.update()
+        # --------------------- until here ---------------------
+
+        # Check the validation accuracy of prediction after every epoch
+        if train_iter.is_new_epoch:  # If this iteration is the final iteration of the current epoch
+
+            # Display the training loss
+            print('epoch:{:02d} train_loss:{:.04f} '.format(
+                train_iter.epoch, float(to_cpu(loss.array))), end='')
+
+            test_losses = []
+            test_accuracies = []
+            while True:
+                test_batch = test_iter.next()
+                image_test, target_test = concat_examples(test_batch, gpu_id)
+
+                # Forward the test data
+                prediction_test = model(image_test)
+
+                # Calculate the loss
+                loss_test = F.softmax_cross_entropy(prediction_test, target_test)
+                test_losses.append(to_cpu(loss_test.array))
+
+                # Calculate the accuracy
+                accuracy = F.accuracy(prediction_test, target_test)
+                accuracy.to_cpu()
+                test_accuracies.append(accuracy.array)
+
+                if test_iter.is_new_epoch:
+                    test_iter.epoch = 0
+                    test_iter.current_position = 0
+                    test_iter.is_new_epoch = False
+                    test_iter._pushed_position = None
+                    break
+
+            val_accuracy = np.mean(test_accuracies)
+            print('val_loss:{:.04f} val_accuracy:{:.04f}'.format(
+                np.mean(test_losses), val_accuracy))
+
+            run.log("Accuracy", np.float(val_accuracy))
+
+
+if __name__ == '__main__':
+    main()

how-to-use-azureml/training-with-deep-learning/train-hyperparameter-tune-deploy-with-chainer/chainer_mnist_hd.py

@@ -0,0 +1,134 @@
+
+import argparse
+
+import numpy as np
+
+import chainer
+from chainer import backend
+from chainer import backends
+from chainer.backends import cuda
+from chainer import Function, gradient_check, report, training, utils, Variable
+from chainer import datasets, iterators, optimizers, serializers
+from chainer import Link, Chain, ChainList
+import chainer.functions as F
+import chainer.links as L
+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()
+
+
+class MyNetwork(Chain):
+
+    def __init__(self, n_mid_units=100, n_out=10):
+        super(MyNetwork, self).__init__()
+        with self.init_scope():
+            self.l1 = L.Linear(None, n_mid_units)
+            self.l2 = L.Linear(n_mid_units, n_mid_units)
+            self.l3 = L.Linear(n_mid_units, n_out)
+
+    def forward(self, x):
+        h = F.relu(self.l1(x))
+        h = F.relu(self.l2(h))
+        return self.l3(h)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Chainer example: MNIST')
+    parser.add_argument('--batchsize', '-b', type=int, default=100,
+                        help='Number of images in each mini-batch')
+    parser.add_argument('--epochs', '-e', type=int, default=20,
+                        help='Number of sweeps over the dataset to train')
+    parser.add_argument('--output_dir', '-o', default='./outputs',
+                        help='Directory to output the result')
+    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)
+
+    batchsize = args.batchsize
+    epochs = args.epochs
+    run.log('Batch size', np.int(batchsize))
+    run.log('Epochs', np.int(epochs))
+
+    train_iter = iterators.SerialIterator(train, batchsize)
+    test_iter = iterators.SerialIterator(test, batchsize,
+                                         repeat=False, shuffle=False)
+
+    model = MyNetwork()
+
+    gpu_id = -1  # Set to -1 if you use CPU
+    if gpu_id >= 0:
+        # Make a specified GPU current
+        chainer.backends.cuda.get_device_from_id(0).use()
+        model.to_gpu()  # Copy the model to the GPU
+
+    # Choose an optimizer algorithm
+    optimizer = optimizers.MomentumSGD(lr=0.01, momentum=0.9)
+
+    # Give the optimizer a reference to the model so that it
+    # can locate the model's parameters.
+    optimizer.setup(model)
+
+    while train_iter.epoch < epochs:
+        # ---------- One iteration of the training loop ----------
+        train_batch = train_iter.next()
+        image_train, target_train = concat_examples(train_batch, gpu_id)
+
+        # Calculate the prediction of the network
+        prediction_train = model(image_train)
+
+        # Calculate the loss with softmax_cross_entropy
+        loss = F.softmax_cross_entropy(prediction_train, target_train)
+
+        # Calculate the gradients in the network
+        model.cleargrads()
+        loss.backward()
+
+        # Update all the trainable parameters
+        optimizer.update()
+        # --------------------- until here ---------------------
+
+        # Check the validation accuracy of prediction after every epoch
+        if train_iter.is_new_epoch:  # If this iteration is the final iteration of the current epoch
+
+            # Display the training loss
+            print('epoch:{:02d} train_loss:{:.04f} '.format(
+                train_iter.epoch, float(to_cpu(loss.array))), end='')
+
+            test_losses = []
+            test_accuracies = []
+            while True:
+                test_batch = test_iter.next()
+                image_test, target_test = concat_examples(test_batch, gpu_id)
+
+                # Forward the test data
+                prediction_test = model(image_test)
+
+                # Calculate the loss
+                loss_test = F.softmax_cross_entropy(prediction_test, target_test)
+                test_losses.append(to_cpu(loss_test.array))
+
+                # Calculate the accuracy
+                accuracy = F.accuracy(prediction_test, target_test)
+                accuracy.to_cpu()
+                test_accuracies.append(accuracy.array)
+
+                if test_iter.is_new_epoch:
+                    test_iter.epoch = 0
+                    test_iter.current_position = 0
+                    test_iter.is_new_epoch = False
+                    test_iter._pushed_position = None
+                    break
+
+            val_accuracy = np.mean(test_accuracies)
+            print('val_loss:{:.04f} val_accuracy:{:.04f}'.format(
+                np.mean(test_losses), val_accuracy))
+
+            run.log("Accuracy", np.float(val_accuracy))
+
+
+if __name__ == '__main__':
+    main()

how-to-use-azureml/training-with-deep-learning/train-hyperparameter-tune-deploy-with-chainer/train-hyperparameter-tune-deploy-with-chainer.ipynb

@@ -0,0 +1,425 @@
+{
+  "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": [
+        "# Train and hyperparameter tune with Chainer\n",
+        "\n",
+        "In this tutorial, we demonstrate how to use the Azure ML Python SDK to train a Convolutional Neural Network (CNN) on a single-node GPU with Chainer to perform handwritten digit recognition on the popular MNIST dataset. We will also demonstrate how to perform hyperparameter tuning of the model using Azure ML's HyperDrive service."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Prerequisites\n",
+        "* Go through the [Configuration](../../../configuration.ipynb) notebook to install the Azure Machine Learning Python SDK and create an Azure ML `Workspace`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Check core SDK version number\n",
+        "import azureml.core\n",
+        "\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Diagnostics\n",
+        "Opt-in diagnostics for better experience, quality, and security of future releases."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "Diagnostics"
+        ]
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.telemetry import set_diagnostics_collection\n",
+        "\n",
+        "set_diagnostics_collection(send_diagnostics=True)"
+      ]
+    },
+    {
+      "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.workspace import Workspace\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')"
+      ]
+    },
+    {
+      "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, we use Azure ML managed compute ([AmlCompute](https://docs.microsoft.com/azure/machine-learning/service/how-to-set-up-training-targets#amlcompute)) for our remote training compute resource.\n",
+        "\n",
+        "**Creation of AmlCompute takes approximately 5 minutes.** If the AmlCompute with that name is already in your workspace, this code will skip the creation process.\n",
+        "\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](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota."
+      ]
+    },
+    {
+      "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 = \"gpucluster\"\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_NC6', \n",
+        "                                                           max_nodes=4)\n",
+        "\n",
+        "    # create the cluster\n",
+        "    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
+        "\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())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The above code creates a GPU cluster. If you instead want to create a CPU cluster, provide a different VM size to the `vm_size` parameter, such as `STANDARD_D2_V2`."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train model on the remote compute\n",
+        "Now that you have your data and training script prepared, you are ready to train on your remote compute cluster. You can take advantage of Azure compute to leverage GPUs to cut down your training time. "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a project directory\n",
+        "Create a directory that will contain all the necessary code from your local machine that you will need access to on the remote resource. This includes the training script and any additional files your training script depends on."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "project_folder = './chainer-mnist'\n",
+        "os.makedirs(project_folder, exist_ok=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Prepare training script\n",
+        "Now you will need to create your training script. In this tutorial, the training script is already provided for you at `chainer_mnist.py`. In practice, you should be able to take any custom 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 [tracking and metrics](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#metrics) capabilities, you will have to add a small amount of Azure ML code inside your training script. \n",
+        "\n",
+        "In `chainer_mnist.py`, we will log some metrics to our Azure ML run. To do so, we will 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",
+        "Further within `chainer_mnist.py`, we log the batchsize and epochs parameters, and the highest accuracy the model achieves:\n",
+        "```Python\n",
+        "run.log('Batch size', np.int(args.batchsize))\n",
+        "run.log('Epochs', np.int(args.epochs))\n",
+        "\n",
+        "run.log('Accuracy', np.float(val_accuracy))\n",
+        "```\n",
+        "These run metrics will become particularly important when we begin hyperparameter tuning our model in the \"Tune model hyperparameters\" section."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Once your script is ready, copy the training script `chainer_mnist.py` into your project directory."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import shutil\n",
+        "\n",
+        "shutil.copy('chainer_mnist.py', project_folder)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create an experiment\n",
+        "Create an [Experiment](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#experiment) to track all the runs in your workspace for this Chainer tutorial. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Experiment\n",
+        "\n",
+        "experiment_name = 'chainer-mnist'\n",
+        "experiment = Experiment(ws, name=experiment_name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a Chainer estimator\n",
+        "The Azure ML SDK's Chainer estimator enables you to easily submit Chainer training jobs for both single-node and distributed runs. The following code will define a single-node Chainer job."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.train.dnn import Chainer\n",
+        "\n",
+        "script_params = {\n",
+        "    '--epochs': 10,\n",
+        "    '--batchsize': 128,\n",
+        "    '--output_dir': './outputs'\n",
+        "}\n",
+        "\n",
+        "estimator = Chainer(source_directory=project_folder, \n",
+        "                    script_params=script_params,\n",
+        "                    compute_target=compute_target,\n",
+        "                    pip_packages=['numpy', 'pytest'],\n",
+        "                    entry_script='chainer_mnist.py',\n",
+        "                    use_gpu=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The `script_params` parameter is a dictionary containing the command-line arguments to your training script `entry_script`. To leverage the Azure VM's GPU for training, we set `use_gpu=True`."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Submit job\n",
+        "Run your experiment by submitting your estimator object. Note that this call is asynchronous."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "run = experiment.submit(estimator)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Monitor your run\n",
+        "You can monitor the progress of the run with a Jupyter widget. Like the run submission, the widget is asynchronous and provides live updates every 10-15 seconds until the job completes."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.widgets import RunDetails\n",
+        "\n",
+        "RunDetails(run).show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# to get more details of your run\n",
+        "print(run.get_details())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Tune model hyperparameters\n",
+        "Now that we've seen how to do a simple Chainer training run using the SDK, let's see if we can further improve the accuracy of our model. We can optimize our model's hyperparameters using Azure Machine Learning's hyperparameter tuning capabilities."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Start a hyperparameter sweep\n",
+        "First, we will define the hyperparameter space to sweep over. Let's tune the batch size and epochs parameters. In this example we will use random sampling to try different configuration sets of hyperparameters to maximize our primary metric, accuracy.\n",
+        "\n",
+        "Then, we specify the early termination policy to use to early terminate poorly performing runs. Here we use the `BanditPolicy`, which will terminate any run that doesn't fall within the slack factor of our primary evaluation metric. In this tutorial, we will apply this policy every epoch (since we report our `Accuracy` metric every epoch and `evaluation_interval=1`). Notice we will delay the first policy evaluation until after the first `3` epochs (`delay_evaluation=3`).\n",
+        "Refer [here](https://docs.microsoft.com/azure/machine-learning/service/how-to-tune-hyperparameters#specify-an-early-termination-policy) for more information on the BanditPolicy and other policies available."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.train.hyperdrive.runconfig import HyperDriveRunConfig\n",
+        "from azureml.train.hyperdrive.sampling import RandomParameterSampling\n",
+        "from azureml.train.hyperdrive.policy import BanditPolicy\n",
+        "from azureml.train.hyperdrive.run import PrimaryMetricGoal\n",
+        "from azureml.train.hyperdrive.parameter_expressions import choice\n",
+        "    \n",
+        "\n",
+        "param_sampling = RandomParameterSampling( {\n",
+        "    \"--batchsize\": choice(128, 256),\n",
+        "    \"--epochs\": choice(5, 10, 20, 40)\n",
+        "    }\n",
+        ")\n",
+        "\n",
+        "hyperdrive_run_config = HyperDriveRunConfig(estimator=estimator,\n",
+        "                                            hyperparameter_sampling=param_sampling, \n",
+        "                                            primary_metric_name='Accuracy',\n",
+        "                                            primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,\n",
+        "                                            max_total_runs=8,\n",
+        "                                            max_concurrent_runs=4)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Finally, lauch the hyperparameter tuning job."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# start the HyperDrive run\n",
+        "hyperdrive_run = experiment.submit(hyperdrive_run_config)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Monitor HyperDrive runs\n",
+        "You can monitor the progress of the runs with the following Jupyter widget. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "RunDetails(hyperdrive_run).show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "run.wait_for_completion(show_output=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "minxia"
+      }
+    ],
+    "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.6"
+    },
+    "msauthor": "minxia"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/training-with-deep-learning/train-hyperparameter-tune-deploy-with-keras/keras_mnist.py

@@ -0,0 +1,123 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import numpy as np
+import argparse
+import os
+
+import matplotlib.pyplot as plt
+
+import keras
+from keras.models import Sequential, model_from_json
+from keras.layers import Dense
+from keras.optimizers import RMSprop
+from keras.callbacks import Callback
+
+import tensorflow as tf
+
+from azureml.core import Run
+from utils import load_data, one_hot_encode
+
+print("Keras version:", keras.__version__)
+print("Tensorflow version:", tf.__version__)
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')
+parser.add_argument('--batch-size', type=int, dest='batch_size', default=50, help='mini batch size for training')
+parser.add_argument('--first-layer-neurons', type=int, dest='n_hidden_1', default=100,
+                    help='# of neurons in the first layer')
+parser.add_argument('--second-layer-neurons', type=int, dest='n_hidden_2', default=100,
+                    help='# of neurons in the second layer')
+parser.add_argument('--learning-rate', type=float, dest='learning_rate', default=0.001, help='learning rate')
+
+args = parser.parse_args()
+
+data_folder = args.data_folder
+
+print('training dataset is stored here:', data_folder)
+
+X_train = load_data(os.path.join(data_folder, 'train-images.gz'), False) / 255.0
+X_test = load_data(os.path.join(data_folder, 'test-images.gz'), False) / 255.0
+
+y_train = load_data(os.path.join(data_folder, 'train-labels.gz'), True).reshape(-1)
+y_test = load_data(os.path.join(data_folder, 'test-labels.gz'), True).reshape(-1)
+
+training_set_size = X_train.shape[0]
+
+n_inputs = 28 * 28
+n_h1 = args.n_hidden_1
+n_h2 = args.n_hidden_2
+n_outputs = 10
+n_epochs = 20
+batch_size = args.batch_size
+learning_rate = args.learning_rate
+
+y_train = one_hot_encode(y_train, n_outputs)
+y_test = one_hot_encode(y_test, n_outputs)
+print(X_train.shape, y_train.shape, X_test.shape, y_test.shape, sep='\n')
+
+# Build a simple MLP model
+model = Sequential()
+# first hidden layer
+model.add(Dense(n_h1, activation='relu', input_shape=(n_inputs,)))
+# second hidden layer
+model.add(Dense(n_h2, activation='relu'))
+# output layer
+model.add(Dense(n_outputs, activation='softmax'))
+
+model.summary()
+
+model.compile(loss='categorical_crossentropy',
+              optimizer=RMSprop(lr=learning_rate),
+              metrics=['accuracy'])
+
+# start an Azure ML run
+run = Run.get_context()
+
+
+class LogRunMetrics(Callback):
+    # callback at the end of every epoch
+    def on_epoch_end(self, epoch, log):
+        # log a value repeated which creates a list
+        run.log('Loss', log['loss'])
+        run.log('Accuracy', log['acc'])
+
+
+history = model.fit(X_train, y_train,
+                    batch_size=batch_size,
+                    epochs=n_epochs,
+                    verbose=2,
+                    validation_data=(X_test, y_test),
+                    callbacks=[LogRunMetrics()])
+
+score = model.evaluate(X_test, y_test, verbose=0)
+
+# log a single value
+run.log("Final test loss", score[0])
+print('Test loss:', score[0])
+
+run.log('Final test accuracy', score[1])
+print('Test accuracy:', score[1])
+
+plt.figure(figsize=(6, 3))
+plt.title('MNIST with Keras MLP ({} epochs)'.format(n_epochs), fontsize=14)
+plt.plot(history.history['acc'], 'b-', label='Accuracy', lw=4, alpha=0.5)
+plt.plot(history.history['loss'], 'r--', label='Loss', lw=4, alpha=0.5)
+plt.legend(fontsize=12)
+plt.grid(True)
+
+# log an image
+run.log_image('Accuracy vs Loss', plot=plt)
+
+# create a ./outputs/model folder in the compute target
+# files saved in the "./outputs" folder are automatically uploaded into run history
+os.makedirs('./outputs/model', exist_ok=True)
+
+# serialize NN architecture to JSON
+model_json = model.to_json()
+# save model JSON
+with open('./outputs/model/model.json', 'w') as f:
+    f.write(model_json)
+# save model weights
+model.save_weights('./outputs/model/model.h5')
+print("model saved in ./outputs/model folder")

how-to-use-azureml/training-with-deep-learning/train-hyperparameter-tune-deploy-with-keras/utils.py

@@ -0,0 +1,27 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import gzip
+import numpy as np
+import struct
+
+
+# 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
+
+
+# one-hot encode a 1-D array
+def one_hot_encode(array, num_of_classes):
+    return np.eye(num_of_classes)[array.reshape(-1)]

how-to-use-azureml/training/logging-api/logging-api.ipynb

@@ -217,7 +217,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "props = run.upload_file(name='myfile_in_the_cloud.txt', path_or_stream='./myfile.txt')\n",
+        "props = run.upload_file(name='outputs/myfile_in_the_cloud.txt', path_or_stream='./myfile.txt')\n",
         "props.serialize()"
       ]
     },

how-to-use-azureml/training/train-in-spark/iris.csv

@@ -0,0 +1,150 @@
+5.1,3.5,1.4,0.2,Iris-setosa
+4.9,3.0,1.4,0.2,Iris-setosa
+4.7,3.2,1.3,0.2,Iris-setosa
+4.6,3.1,1.5,0.2,Iris-setosa
+5.0,3.6,1.4,0.2,Iris-setosa
+5.4,3.9,1.7,0.4,Iris-setosa
+4.6,3.4,1.4,0.3,Iris-setosa
+5.0,3.4,1.5,0.2,Iris-setosa
+4.4,2.9,1.4,0.2,Iris-setosa
+4.9,3.1,1.5,0.1,Iris-setosa
+5.4,3.7,1.5,0.2,Iris-setosa
+4.8,3.4,1.6,0.2,Iris-setosa
+4.8,3.0,1.4,0.1,Iris-setosa
+4.3,3.0,1.1,0.1,Iris-setosa
+5.8,4.0,1.2,0.2,Iris-setosa
+5.7,4.4,1.5,0.4,Iris-setosa
+5.4,3.9,1.3,0.4,Iris-setosa
+5.1,3.5,1.4,0.3,Iris-setosa
+5.7,3.8,1.7,0.3,Iris-setosa
+5.1,3.8,1.5,0.3,Iris-setosa
+5.4,3.4,1.7,0.2,Iris-setosa
+5.1,3.7,1.5,0.4,Iris-setosa
+4.6,3.6,1.0,0.2,Iris-setosa
+5.1,3.3,1.7,0.5,Iris-setosa
+4.8,3.4,1.9,0.2,Iris-setosa
+5.0,3.0,1.6,0.2,Iris-setosa
+5.0,3.4,1.6,0.4,Iris-setosa
+5.2,3.5,1.5,0.2,Iris-setosa
+5.2,3.4,1.4,0.2,Iris-setosa
+4.7,3.2,1.6,0.2,Iris-setosa
+4.8,3.1,1.6,0.2,Iris-setosa
+5.4,3.4,1.5,0.4,Iris-setosa
+5.2,4.1,1.5,0.1,Iris-setosa
+5.5,4.2,1.4,0.2,Iris-setosa
+4.9,3.1,1.5,0.1,Iris-setosa
+5.0,3.2,1.2,0.2,Iris-setosa
+5.5,3.5,1.3,0.2,Iris-setosa
+4.9,3.1,1.5,0.1,Iris-setosa
+4.4,3.0,1.3,0.2,Iris-setosa
+5.1,3.4,1.5,0.2,Iris-setosa
+5.0,3.5,1.3,0.3,Iris-setosa
+4.5,2.3,1.3,0.3,Iris-setosa
+4.4,3.2,1.3,0.2,Iris-setosa
+5.0,3.5,1.6,0.6,Iris-setosa
+5.1,3.8,1.9,0.4,Iris-setosa
+4.8,3.0,1.4,0.3,Iris-setosa
+5.1,3.8,1.6,0.2,Iris-setosa
+4.6,3.2,1.4,0.2,Iris-setosa
+5.3,3.7,1.5,0.2,Iris-setosa
+5.0,3.3,1.4,0.2,Iris-setosa
+7.0,3.2,4.7,1.4,Iris-versicolor
+6.4,3.2,4.5,1.5,Iris-versicolor
+6.9,3.1,4.9,1.5,Iris-versicolor
+5.5,2.3,4.0,1.3,Iris-versicolor
+6.5,2.8,4.6,1.5,Iris-versicolor
+5.7,2.8,4.5,1.3,Iris-versicolor
+6.3,3.3,4.7,1.6,Iris-versicolor
+4.9,2.4,3.3,1.0,Iris-versicolor
+6.6,2.9,4.6,1.3,Iris-versicolor
+5.2,2.7,3.9,1.4,Iris-versicolor
+5.0,2.0,3.5,1.0,Iris-versicolor
+5.9,3.0,4.2,1.5,Iris-versicolor
+6.0,2.2,4.0,1.0,Iris-versicolor
+6.1,2.9,4.7,1.4,Iris-versicolor
+5.6,2.9,3.6,1.3,Iris-versicolor
+6.7,3.1,4.4,1.4,Iris-versicolor
+5.6,3.0,4.5,1.5,Iris-versicolor
+5.8,2.7,4.1,1.0,Iris-versicolor
+6.2,2.2,4.5,1.5,Iris-versicolor
+5.6,2.5,3.9,1.1,Iris-versicolor
+5.9,3.2,4.8,1.8,Iris-versicolor
+6.1,2.8,4.0,1.3,Iris-versicolor
+6.3,2.5,4.9,1.5,Iris-versicolor
+6.1,2.8,4.7,1.2,Iris-versicolor
+6.4,2.9,4.3,1.3,Iris-versicolor
+6.6,3.0,4.4,1.4,Iris-versicolor
+6.8,2.8,4.8,1.4,Iris-versicolor
+6.7,3.0,5.0,1.7,Iris-versicolor
+6.0,2.9,4.5,1.5,Iris-versicolor
+5.7,2.6,3.5,1.0,Iris-versicolor
+5.5,2.4,3.8,1.1,Iris-versicolor
+5.5,2.4,3.7,1.0,Iris-versicolor
+5.8,2.7,3.9,1.2,Iris-versicolor
+6.0,2.7,5.1,1.6,Iris-versicolor
+5.4,3.0,4.5,1.5,Iris-versicolor
+6.0,3.4,4.5,1.6,Iris-versicolor
+6.7,3.1,4.7,1.5,Iris-versicolor
+6.3,2.3,4.4,1.3,Iris-versicolor
+5.6,3.0,4.1,1.3,Iris-versicolor
+5.5,2.5,4.0,1.3,Iris-versicolor
+5.5,2.6,4.4,1.2,Iris-versicolor
+6.1,3.0,4.6,1.4,Iris-versicolor
+5.8,2.6,4.0,1.2,Iris-versicolor
+5.0,2.3,3.3,1.0,Iris-versicolor
+5.6,2.7,4.2,1.3,Iris-versicolor
+5.7,3.0,4.2,1.2,Iris-versicolor
+5.7,2.9,4.2,1.3,Iris-versicolor
+6.2,2.9,4.3,1.3,Iris-versicolor
+5.1,2.5,3.0,1.1,Iris-versicolor
+5.7,2.8,4.1,1.3,Iris-versicolor
+6.3,3.3,6.0,2.5,Iris-virginica
+5.8,2.7,5.1,1.9,Iris-virginica
+7.1,3.0,5.9,2.1,Iris-virginica
+6.3,2.9,5.6,1.8,Iris-virginica
+6.5,3.0,5.8,2.2,Iris-virginica
+7.6,3.0,6.6,2.1,Iris-virginica
+4.9,2.5,4.5,1.7,Iris-virginica
+7.3,2.9,6.3,1.8,Iris-virginica
+6.7,2.5,5.8,1.8,Iris-virginica
+7.2,3.6,6.1,2.5,Iris-virginica
+6.5,3.2,5.1,2.0,Iris-virginica
+6.4,2.7,5.3,1.9,Iris-virginica
+6.8,3.0,5.5,2.1,Iris-virginica
+5.7,2.5,5.0,2.0,Iris-virginica
+5.8,2.8,5.1,2.4,Iris-virginica
+6.4,3.2,5.3,2.3,Iris-virginica
+6.5,3.0,5.5,1.8,Iris-virginica
+7.7,3.8,6.7,2.2,Iris-virginica
+7.7,2.6,6.9,2.3,Iris-virginica
+6.0,2.2,5.0,1.5,Iris-virginica
+6.9,3.2,5.7,2.3,Iris-virginica
+5.6,2.8,4.9,2.0,Iris-virginica
+7.7,2.8,6.7,2.0,Iris-virginica
+6.3,2.7,4.9,1.8,Iris-virginica
+6.7,3.3,5.7,2.1,Iris-virginica
+7.2,3.2,6.0,1.8,Iris-virginica
+6.2,2.8,4.8,1.8,Iris-virginica
+6.1,3.0,4.9,1.8,Iris-virginica
+6.4,2.8,5.6,2.1,Iris-virginica
+7.2,3.0,5.8,1.6,Iris-virginica
+7.4,2.8,6.1,1.9,Iris-virginica
+7.9,3.8,6.4,2.0,Iris-virginica
+6.4,2.8,5.6,2.2,Iris-virginica
+6.3,2.8,5.1,1.5,Iris-virginica
+6.1,2.6,5.6,1.4,Iris-virginica
+7.7,3.0,6.1,2.3,Iris-virginica
+6.3,3.4,5.6,2.4,Iris-virginica
+6.4,3.1,5.5,1.8,Iris-virginica
+6.0,3.0,4.8,1.8,Iris-virginica
+6.9,3.1,5.4,2.1,Iris-virginica
+6.7,3.1,5.6,2.4,Iris-virginica
+6.9,3.1,5.1,2.3,Iris-virginica
+5.8,2.7,5.1,1.9,Iris-virginica
+6.8,3.2,5.9,2.3,Iris-virginica
+6.7,3.3,5.7,2.5,Iris-virginica
+6.7,3.0,5.2,2.3,Iris-virginica
+6.3,2.5,5.0,1.9,Iris-virginica
+6.5,3.0,5.2,2.0,Iris-virginica
+6.2,3.4,5.4,2.3,Iris-virginica
+5.9,3.0,5.1,1.8,Iris-virginica

how-to-use-azureml/training/train-in-spark/train-in-spark.ipynb

@@ -0,0 +1,278 @@
+{
+  "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": [
+        "# 05. Train in Spark\n",
+        "* Create Workspace\n",
+        "* Create Experiment\n",
+        "* Copy relevant files to the script folder\n",
+        "* Configure and Run"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Prerequisites\n",
+        "Make sure you go through the [configuration notebook](../../../configuration.ipynb) first if you haven't."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Check core SDK version number\n",
+        "import azureml.core\n",
+        "\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "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": [
+        "from azureml.core import Workspace\n",
+        "\n",
+        "ws = Workspace.from_config()\n",
+        "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep='\\n')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create Experiment\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "experiment_name = 'train-on-spark'\n",
+        "\n",
+        "from azureml.core import Experiment\n",
+        "exp = Experiment(workspace=ws, name=experiment_name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## View `train-spark.py`\n",
+        "\n",
+        "For convenience, we created a training script for you. It is printed below as a text, but you can also run `%pfile ./train-spark.py` in a cell to show the file."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "with open('train-spark.py', 'r') as training_script:\n",
+        "    print(training_script.read())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Configure & Run"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "**Note** You can use Docker-based execution to run the Spark job in local computer or a remote VM. Please see the `train-in-remote-vm` notebook for example on how to configure and run in Docker mode in a VM. Make sure you choose a Docker image that has Spark installed, such as `azureml.core.runconfig.DEFAULT_MMLSPARK_CPU_IMAGE`."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Attach an HDI cluster\n",
+        "Here we will use a actual Spark cluster, HDInsight for Spark, to run this job. To use HDI commpute target:\n",
+        " 1. Create a Spark for HDI cluster in Azure. Here are some [quick instructions](https://docs.microsoft.com/en-us/azure/hdinsight/spark/apache-spark-jupyter-spark-sql). Make sure you use the Ubuntu flavor, NOT CentOS.\n",
+        " 2. Enter the IP address, username and password below"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.compute import ComputeTarget, HDInsightCompute\n",
+        "from azureml.exceptions import ComputeTargetException\n",
+        "import os\n",
+        "\n",
+        "try:\n",
+        "    # if you want to connect using SSH key instead of username/password you can provide parameters private_key_file and private_key_passphrase\n",
+        "    attach_config = HDInsightCompute.attach_configuration(address=os.environ.get('hdiservername', '<my_hdi_cluster_name>-ssh.azurehdinsight.net'), \n",
+        "                                                          ssh_port=22, \n",
+        "                                                          username=os.environ.get('hdiusername', '<ssh_username>'), \n",
+        "                                                          password=os.environ.get('hdipassword', '<my_password>'))\n",
+        "    hdi_compute = ComputeTarget.attach(workspace=ws, \n",
+        "                                       name='myhdi', \n",
+        "                                       attach_configuration=attach_config)\n",
+        "\n",
+        "except ComputeTargetException as e:\n",
+        "    print(\"Caught = {}\".format(e.message))\n",
+        "    \n",
+        "        \n",
+        "hdi_compute.wait_for_completion(show_output=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Configure HDI run"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Configure an execution using the HDInsight cluster with a conda environment that has `numpy`."
+      ]
+    },
+    {
+      "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",
+        "# use pyspark framework\n",
+        "hdi_run_config = RunConfiguration(framework=\"pyspark\")\n",
+        "\n",
+        "# Set compute target to the HDI cluster\n",
+        "hdi_run_config.target = hdi_compute.name\n",
+        "\n",
+        "# specify CondaDependencies object to ask system installing numpy\n",
+        "cd = CondaDependencies()\n",
+        "cd.add_conda_package('numpy')\n",
+        "hdi_run_config.environment.python.conda_dependencies = cd"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Submit the script to HDI"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import ScriptRunConfig\n",
+        "\n",
+        "script_run_config = ScriptRunConfig(source_directory = '.',\n",
+        "                                    script= 'train-spark.py',\n",
+        "                                    run_config = hdi_run_config)\n",
+        "run = exp.submit(config=script_run_config)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Monitor the run using a Juypter widget"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.widgets import RunDetails\n",
+        "RunDetails(run).show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Note: if you need to cancel a run, you can follow [these instructions](https://aka.ms/aml-docs-cancel-run)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "After the run is succesfully finished, you can check the metrics logged."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# get all metris logged in the run\n",
+        "metrics = run.get_metrics()\n",
+        "print(metrics)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "aashishb"
+      }
+    ],
+    "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/training/train-in-spark/train-spark.py

@@ -0,0 +1,97 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Licensed under the MIT license.
+
+import numpy as np
+import pyspark
+import os
+import urllib
+import sys
+
+from pyspark.sql.functions import *
+from pyspark.ml.classification import *
+from pyspark.ml.evaluation import *
+from pyspark.ml.feature import *
+from pyspark.sql.types import StructType, StructField
+from pyspark.sql.types import DoubleType, IntegerType, StringType
+
+from azureml.core.run import Run
+
+# initialize logger
+run = Run.get_context()
+
+# start Spark session
+spark = pyspark.sql.SparkSession.builder.appName('Iris').getOrCreate()
+
+# print runtime versions
+print('****************')
+print('Python version: {}'.format(sys.version))
+print('Spark version: {}'.format(spark.version))
+print('****************')
+
+# load iris.csv into Spark dataframe
+schema = StructType([
+    StructField("sepal-length", DoubleType()),
+    StructField("sepal-width", DoubleType()),
+    StructField("petal-length", DoubleType()),
+    StructField("petal-width", DoubleType()),
+    StructField("class", StringType())
+])
+
+data = spark.read.format("com.databricks.spark.csv") \
+    .option("header", "true") \
+    .schema(schema) \
+    .load("iris.csv")
+
+print("First 10 rows of Iris dataset:")
+data.show(10)
+
+# vectorize all numerical columns into a single feature column
+feature_cols = data.columns[:-1]
+assembler = pyspark.ml.feature.VectorAssembler(
+    inputCols=feature_cols, outputCol='features')
+data = assembler.transform(data)
+
+# convert text labels into indices
+data = data.select(['features', 'class'])
+label_indexer = pyspark.ml.feature.StringIndexer(
+    inputCol='class', outputCol='label').fit(data)
+data = label_indexer.transform(data)
+
+# only select the features and label column
+data = data.select(['features', 'label'])
+print("Reading for machine learning")
+data.show(10)
+
+# change regularization rate and you will likely get a different accuracy.
+reg = 0.01
+# load regularization rate from argument if present
+if len(sys.argv) > 1:
+    reg = float(sys.argv[1])
+
+# log regularization rate
+run.log("Regularization Rate", reg)
+
+# use Logistic Regression to train on the training set
+train, test = data.randomSplit([0.70, 0.30])
+lr = pyspark.ml.classification.LogisticRegression(regParam=reg)
+model = lr.fit(train)
+
+# predict on the test set
+prediction = model.transform(test)
+print("Prediction")
+prediction.show(10)
+
+# evaluate the accuracy of the model using the test set
+evaluator = pyspark.ml.evaluation.MulticlassClassificationEvaluator(
+    metricName='accuracy')
+accuracy = evaluator.evaluate(prediction)
+
+print()
+print('#####################################')
+print('Regularization rate is {}'.format(reg))
+print("Accuracy is {}".format(accuracy))
+print('#####################################')
+print()
+
+# log accuracy
+run.log('Accuracy', accuracy)

how-to-use-azureml/training/train-within-notebook/train-within-notebook.ipynb

@@ -81,7 +81,7 @@
         "from azureml.core import Experiment, Workspace\n",
         "\n",
         "# Check core SDK version number\n",
-        "print(\"This notebook was created using version 1.0.10 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.0.2 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")\n",
         "print(\"\")\n",
         "\n",
@@ -138,7 +138,6 @@
         "* We use `start_logging` to create a new run in this experiment\n",
         "* We use `run.log()` to record a parameter, alpha, and an accuracy measure - the Mean Squared Error (MSE) to the run.  We will be able to review and compare these measures in the Azure Portal at a later time.\n",
         "* We store the resulting model in the **outputs** directory, which is automatically captured by AML when the run is complete.\n",
-        "* We use `run.take_snapshot()` to capture *this* notebook so we can reproduce this experiment at a later time.\n",
         "* We use `run.complete()` to indicate that the run is over and results can be captured and finalized"
       ]
     },
@@ -173,9 +172,6 @@
         "# Save the model to the outputs directory for capture\n",
         "joblib.dump(value=regression_model, filename='outputs/model.pkl')\n",
         "\n",
-        "# Take a snapshot of the directory containing this notebook\n",
-        "run.take_snapshot('./')\n",
-        "\n",
         "# Complete the run\n",
         "run.complete()"
       ]
@@ -238,10 +234,7 @@
         "        run.log(name=\"mse\", value=mse)\n",
         "\n",
         "        # Save the model to the outputs directory for capture\n",
-        "        joblib.dump(value=regression_model, filename='outputs/model.pkl')\n",
-        "        \n",
-        "        # Capture this notebook with the run\n",
-        "        run.take_snapshot('./')\n"
+        "        joblib.dump(value=regression_model, filename='outputs/model.pkl')\n"
       ]
     },
     {
@@ -703,4 +696,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 2
-}
+}

pr.md

@@ -34,6 +34,7 @@
 - [Microsoft introduces Azure service to automatically build AI models](https://venturebeat.com/2018/09/24/microsoft-introduces-azure-service-to-automatically-build-ai-models/) (VentureBeat)
 
 ## Community Projects
+- [Use Papermill with Azure ML](https://github.com/jreynolds01/papermill_execution_azureml/)
 - [Fashion MNIST](https://github.com/amynic/azureml-sdk-fashion)
 - Keras on Databricks
 - [Samples from CSS](https://github.com/Azure/AMLSamples)

tutorials/README.md

@@ -1,11 +1,20 @@
 ## Azure Machine Learning service Tutorial
 
-Complete these tutorials to learn how to train and deploy models using Azure Machine Learning services and Python SDK. These Notebooks accompany the [tutorial articles starting here]([https://docs.microsoft.com/en-us/azure/machine-learning/service/tutorial-train-models-with-aml]).
+Complete these tutorials to learn how to train and deploy models using Azure Machine Learning services and Python SDK. These Notebooks accompany the
+two sets of tutorial articles for:
+
+ * [Image classification using MNIST dataset](https://docs.microsoft.com/en-us/azure/machine-learning/service/tutorial-train-models-with-aml)
+ * [Regression using NYC Taxi dataset](https://docs.microsoft.com/en-us/azure/machine-learning/service/tutorial-data-prep)
 
 As a pre-requisite, run the [configuration Notebook](../configuration.ipynb) notebook first to set up your Azure ML Workspace. Then, run the notebooks in following recommended order.
 
- * [Tutorial #1](img-classification-part1-training.ipynb): Train an image classification model with Azure Machine Learning
- * [Tutorial #2](img-classification-part2-deploy.ipynb):  Deploy an image classification model from first tutorial in Azure Container Instance (ACI)
- * [Tutorial #3](regression-part1-data-prep.ipynb): Use data preparation.
+### Image classification
+
+ * [Part 1](img-classification-part1-training.ipynb): Train an image classification model with Azure Machine Learning.
+ * [Part 2](img-classification-part2-deploy.ipynb): Deploy an image classification model from first tutorial in Azure Container Instance (ACI).
+
+ ### Regression
+ * [Part 1](regression-part1-data-prep.ipynb): Prepare the data using Azure Machine Learning Data Prep SDK. 
+ * [Part 2](regression-part2-automated-ml.ipynb): Train a model using Automated Machine Learning.
 
  Also find quickstarts and how-tos on the [official documentation site for Azure Machine Learning service](https://docs.microsoft.com/en-us/azure/machine-learning/service/).

tutorials/img-classification-part1-training.ipynb

@@ -15,7 +15,7 @@
       "source": [
         "# Tutorial #1: Train an image classification model with Azure Machine Learning\n",
         "\n",
-        "In this tutorial, you train a machine learning model both locally and on remote compute resources. You'll use the training and deployment workflow for Azure Machine Learning service (preview) in a Python Jupyter notebook.  You can then use the notebook as a template to train your own machine learning model with your own data. This tutorial is **part one of a two-part tutorial series**.  \n",
+        "In this tutorial, you train a machine learning model on remote compute resources. You'll use the training and deployment workflow for Azure Machine Learning service (preview) in a Python Jupyter notebook.  You can then use the notebook as a template to train your own machine learning model with your own data. This tutorial is **part one of a two-part tutorial series**.  \n",
         "\n",
         "This tutorial trains a simple logistic regression using the [MNIST](http://yann.lecun.com/exdb/mnist/) dataset and [scikit-learn](http://scikit-learn.org) with Azure Machine Learning.  MNIST is a popular dataset consisting of 70,000 grayscale images. Each image is a handwritten digit of 28x28 pixels, representing a number from 0 to 9. The goal is to create a multi-class classifier to identify the digit a given image represents. \n",
         "\n",
@@ -31,9 +31,7 @@
         "\n",
         "## Prerequisites\n",
         "\n",
-        "Use [these instructions](https://aka.ms/aml-how-to-configure-environment) to:  \n",
-        "* Create a workspace and its configuration file (**config.json**)  \n",
-        "* Save your **config.json** to the same folder as this notebook"
+        "See prerequisites in the [Azure Machine Learning documentation](https://docs.microsoft.com/azure/machine-learning/service/tutorial-train-models-with-aml#prerequisites)."
       ]
     },
     {
@@ -96,7 +94,7 @@
       "source": [
         "# load workspace configuration from the config.json file in the current folder.\n",
         "ws = Workspace.from_config()\n",
-        "print(ws.name, ws.location, ws.resource_group, ws.location, sep = '\\t')"
+        "print(ws.name, ws.location, ws.resource_group, ws.location, sep='\\t')"
       ]
     },
     {
@@ -128,10 +126,10 @@
       "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.\n",
+        "### Create or Attach existing compute resource\n",
+        "By using Azure Machine Learning Compute, a managed service, data scientists can train machine learning models on clusters of Azure virtual machines. Examples include VMs with GPU support. In this tutorial, you create Azure Machine Learning Compute as your training environment. The code below creates the compute clusters for you if they don't already exist in your workspace.\n",
         "\n",
-        "**Creation of AmlCompute takes approximately 5 minutes.** If the AmlCompute with that name is already in your workspace this code will skip the creation process."
+        "**Creation of compute takes approximately 5 minutes.** If the AmlCompute with that name is already in your workspace the code will skip the creation process."
       ]
     },
     {
@@ -206,12 +204,13 @@
       "source": [
         "import urllib.request\n",
         "\n",
-        "os.makedirs('./data', exist_ok = True)\n",
+        "data_folder = os.path.join(os.getcwd(), 'data')\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/train-images.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz', filename='./data/train-labels.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename='./data/test-images.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename='./data/test-labels.gz')"
+        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz', filename=os.path.join(data_folder, 'train-images.gz'))\n",
+        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz', filename=os.path.join(data_folder, 'train-labels.gz'))\n",
+        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename=os.path.join(data_folder, 'test-images.gz'))\n",
+        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename=os.path.join(data_folder, 'test-labels.gz'))"
       ]
     },
     {
@@ -233,11 +232,10 @@
         "from utils import load_data\n",
         "\n",
         "# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.\n",
-        "X_train = load_data('./data/train-images.gz', False) / 255.0\n",
-        "y_train = load_data('./data/train-labels.gz', True).reshape(-1)\n",
-        "\n",
-        "X_test = load_data('./data/test-images.gz', False) / 255.0\n",
-        "y_test = load_data('./data/test-labels.gz', True).reshape(-1)\n",
+        "X_train = load_data(os.path.join(data_folder, 'train-images.gz'), False) / 255.0\n",
+        "X_test = load_data(os.path.join(data_folder, 'test-images.gz'), False) / 255.0\n",
+        "y_train = load_data(os.path.join(data_folder, 'train-labels.gz'), True).reshape(-1)\n",
+        "y_test = load_data(os.path.join(data_folder, 'test-labels.gz'), True).reshape(-1)\n",
         "\n",
         "# now let's show some randomly chosen images from the traininng set.\n",
         "count = 0\n",
@@ -279,62 +277,15 @@
         "ds = ws.get_default_datastore()\n",
         "print(ds.datastore_type, ds.account_name, ds.container_name)\n",
         "\n",
-        "ds.upload(src_dir='./data', target_path='mnist', overwrite=True, show_progress=True)"
+        "ds.upload(src_dir=data_folder, target_path='mnist', overwrite=True, show_progress=True)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "You now have everything you need to start training a model. \n",
-        "\n",
-        "## Train a local model\n",
-        "\n",
-        "Train a simple logistic regression model using scikit-learn locally.\n",
-        "\n",
-        "**Training locally can take a minute or two** depending on your computer configuration."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%time\n",
-        "from sklearn.linear_model import LogisticRegression\n",
-        "\n",
-        "clf = LogisticRegression()\n",
-        "clf.fit(X_train, y_train)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Next, make predictions using the test set and calculate the accuracy."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "y_hat = clf.predict(X_test)\n",
-        "print(np.average(y_hat == y_test))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "With just a few lines of code, you have a 92% accuracy.\n",
-        "\n",
         "## Train on a remote cluster\n",
         "\n",
-        "Now you can expand on this simple model by building a model with a different regularization rate. This time you'll train the model on a remote resource.  \n",
-        "\n",
         "For this task, submit the job to the remote training cluster you set up earlier.  To submit a job you:\n",
         "* Create a directory\n",
         "* Create a training script\n",
@@ -352,7 +303,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "script_folder = './sklearn-mnist'\n",
+        "import os\n",
+        "script_folder = os.path.join(os.getcwd(), \"sklearn-mnist\")\n",
         "os.makedirs(script_folder, exist_ok=True)"
       ]
     },
@@ -362,7 +314,7 @@
       "source": [
         "### Create a training script\n",
         "\n",
-        "To submit the job to the cluster, first create a training script. Run the following code to create the training script called `train.py` in the directory you just created. This training adds a regularization rate to the training algorithm, so produces a slightly different model than the local version."
+        "To submit the job to the cluster, first create a training script. Run the following code to create the training script called `train.py` in the directory you just created. "
       ]
     },
     {
@@ -389,7 +341,7 @@
         "parser.add_argument('--regularization', type=float, dest='reg', default=0.01, help='regularization rate')\n",
         "args = parser.parse_args()\n",
         "\n",
-        "data_folder = os.path.join(args.data_folder, 'mnist')\n",
+        "data_folder = args.data_folder\n",
         "print('Data folder:', data_folder)\n",
         "\n",
         "# load train and test set into numpy arrays\n",
@@ -474,7 +426,7 @@
         "* Parameters required from the training script \n",
         "* Python packages needed for training\n",
         "\n",
-        "In this tutorial, this target is AmlCompute. All files in the script folder are uploaded into the cluster nodes for execution. The data_folder is set to use the datastore (`ds.as_mount()`)."
+        "In this tutorial, this target is AmlCompute. All files in the script folder are uploaded into the cluster nodes for execution. The data_folder is set to use the datastore (`ds.path('mnist').as_mount()`)."
       ]
     },
     {
@@ -490,8 +442,8 @@
         "from azureml.train.estimator import Estimator\n",
         "\n",
         "script_params = {\n",
-        "    '--data-folder': ds.as_mount(),\n",
-        "    '--regularization': 0.8\n",
+        "    '--data-folder': ds.path('mnist').as_mount(),\n",
+        "    '--regularization': 0.05\n",
         "}\n",
         "\n",
         "est = Estimator(source_directory=script_folder,\n",
@@ -501,13 +453,29 @@
         "                conda_packages=['scikit-learn'])"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "This is what the mounting point looks like:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(ds.path('mnist').as_mount())"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
         "### Submit the job to the cluster\n",
         "\n",
-        "Run the experiment by submitting the estimator object."
+        "Run the experiment by submitting the estimator object. And you can navigate to Azure portal to monitor the run."
       ]
     },
     {
@@ -534,17 +502,17 @@
         "\n",
         "## Monitor a remote run\n",
         "\n",
-        "In total, the first run takes **approximately 10 minutes**. But for subsequent runs, as long as the script dependencies don't change, the same image is reused and hence the container start up time is much faster.\n",
+        "In total, the first run takes **approximately 10 minutes**. But for subsequent runs, as long as the dependencies (`conda_packages` parameter in the above estimator constructor) don't change, the same image is reused and hence the container start up time is much faster.\n",
         "\n",
         "Here is what's happening while you wait:\n",
         "\n",
-        "- **Image creation**: A Docker image is created matching the Python environment specified by the estimator. The image is uploaded to the workspace. Image creation and uploading takes **about 5 minutes**. \n",
+        "- **Image creation**: A Docker image is created matching the Python environment specified by the estimator. The image is built and stored in the ACR (Azure Container Registry) associated with your workspace. Image creation and uploading takes **about 5 minutes**. \n",
         "\n",
         "  This stage happens once for each Python environment since the container is cached for subsequent runs.  During image creation, logs are streamed to the run history. You can monitor the image creation progress using these logs.\n",
         "\n",
         "- **Scaling**: If the remote cluster requires more nodes to execute the run than currently available, additional nodes are added automatically. Scaling typically takes **about 5 minutes.**\n",
         "\n",
-        "- **Running**: In this stage, the necessary scripts and files are sent to the compute target, then data stores are mounted/copied, then the entry_script is run. While the job is running, stdout and the ./logs directory are streamed to the run history. You can monitor the run's progress using these logs.\n",
+        "- **Running**: In this stage, the necessary scripts and files are sent to the compute target, then data stores are mounted/copied, then the entry_script is run. While the job is running, stdout and the files in the ./logs directory are streamed to the run history. You can monitor the run's progress using these logs.\n",
         "\n",
         "- **Post-Processing**: The ./outputs directory of the run is copied over to the run history in your workspace so you can access these results.\n",
         "\n",
@@ -574,7 +542,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "If you need to cancel a run, you can follow [these instructions](https://aka.ms/aml-docs-cancel-run)."
+        "By the way, if you need to cancel a run, you can follow [these instructions](https://aka.ms/aml-docs-cancel-run)."
       ]
     },
     {
@@ -583,7 +551,7 @@
       "source": [
         "### Get log results upon completion\n",
         "\n",
-        "Model training and monitoring happen in the background. Wait until the model has completed training before running more code. Use `wait_for_completion` to show when the model training is complete."
+        "Model training happens in the background. You can use `wait_for_completion` to block and wait until the model has completed training before running more code. "
       ]
     },
     {
@@ -598,7 +566,8 @@
       },
       "outputs": [],
       "source": [
-        "run.wait_for_completion(show_output=False) # specify True for a verbose log"
+        "# specify show_output to True for a verbose log\n",
+        "run.wait_for_completion(show_output=False) "
       ]
     },
     {
@@ -607,7 +576,7 @@
       "source": [
         "### Display run results\n",
         "\n",
-        "You now have a model trained on a remote cluster.  Retrieve the accuracy of the model:"
+        "You now have a model trained on a remote cluster.  Retrieve all the metrics logged during the run, including the accuracy of the model:"
       ]
     },
     {
@@ -668,7 +637,7 @@
       "source": [
         "# register model \n",
         "model = run.register_model(model_name='sklearn_mnist', model_path='outputs/sklearn_mnist_model.pkl')\n",
-        "print(model.name, model.id, model.version, sep = '\\t')"
+        "print(model.name, model.id, model.version, sep='\\t')"
       ]
     },
     {
@@ -681,8 +650,7 @@
         "\n",
         "> * Set up your development environment\n",
         "> * Access and examine the data\n",
-        "> * Train a simple logistic regression locally using the popular scikit-learn machine learning library\n",
-        "> * Train multiple models on a remote cluster\n",
+        "> * Train multiple models on a remote cluster using the popular scikit-learn machine learning library\n",
         "> * Review training details and register the best model\n",
         "\n",
         "You are ready to deploy this registered model using the instructions in the next part of the tutorial series:\n",
@@ -712,9 +680,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.6.2"
+      "version": "3.6.8"
     },
-    "msauthor": "sgilley"
+    "msauthor": "haining"
   },
   "nbformat": 4,
   "nbformat_minor": 2

tutorials/img-classification-part2-deploy.ipynb

@@ -27,7 +27,7 @@
         "> * Deploy the model to ACI\n",
         "> * Test the deployed model\n",
         "\n",
-        "ACI is not ideal for production deployments, but it is great for testing and understanding the workflow. For scalable production deployments, consider using AKS.\n",
+        "ACI is a great solution for testing and understanding the workflow. For scalable production deployments, consider using Azure Kubernetes Service. For more information, see [how to deploy and where](https://docs.microsoft.com/azure/machine-learning/service/how-to-deploy-and-where).\n",
         "\n",
         "\n",
         "## Prerequisites\n",
@@ -68,10 +68,12 @@
         "import os\n",
         "import urllib.request\n",
         "\n",
-        "os.makedirs('./data', exist_ok=True)\n",
+        "data_folder = os.path.join(os.getcwd(), 'data')\n",
+        "os.makedirs(data_folder, exist_ok = True)\n",
         "\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename='./data/test-images.gz')\n",
-        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename='./data/test-labels.gz')"
+        "\n",
+        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename=os.path.join(data_folder, 'test-images.gz'))\n",
+        "urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename=os.path.join(data_folder, 'test-labels.gz'))"
       ]
     },
     {
@@ -101,7 +103,7 @@
         "import numpy as np\n",
         "import matplotlib.pyplot as plt\n",
         " \n",
-        "import azureml\n",
+        "import azureml.core\n",
         "\n",
         "# display the core SDK version number\n",
         "print(\"Azure ML SDK Version: \", azureml.core.VERSION)"
@@ -127,11 +129,18 @@
       },
       "outputs": [],
       "source": [
+        "from azureml.core import Workspace\n",
+        "from azureml.core.model import Model\n",
+        "import os \n",
         "ws = Workspace.from_config()\n",
         "model=Model(ws, 'sklearn_mnist')\n",
-        "model.download(target_dir='.', exist_ok=True)\n",
+        "\n",
+        "model.download(target_dir=os.getcwd(), exist_ok=True)\n",
+        "\n",
         "# verify the downloaded model file\n",
-        "os.stat('./sklearn_mnist_model.pkl')"
+        "file_path = os.path.join(os.getcwd(), \"sklearn_mnist_model.pkl\")\n",
+        "\n",
+        "os.stat(file_path)"
       ]
     },
     {
@@ -157,10 +166,12 @@
       "outputs": [],
       "source": [
         "from utils import load_data\n",
+        "import os\n",
         "\n",
+        "data_folder = os.path.join(os.getcwd(), 'data')\n",
         "# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the neural network converge faster\n",
-        "X_test = load_data('./data/test-images.gz', False) / 255.0\n",
-        "y_test = load_data('./data/test-labels.gz', True).reshape(-1)"
+        "X_test = load_data(os.path.join(data_folder, 'test-images.gz'), False) / 255.0\n",
+        "y_test = load_data(os.path.join(data_folder, 'test-labels.gz'), True).reshape(-1)"
       ]
     },
     {
@@ -181,7 +192,7 @@
         "import pickle\n",
         "from sklearn.externals import joblib\n",
         "\n",
-        "clf = joblib.load('./sklearn_mnist_model.pkl')\n",
+        "clf = joblib.load( os.path.join(os.getcwd(), 'sklearn_mnist_model.pkl'))\n",
         "y_hat = clf.predict(X_test)"
       ]
     },
@@ -220,7 +231,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# normalize the diagnal cells so that they don't overpower the rest of the cells when visualized\n",
+        "# normalize the diagonal cells so that they don't overpower the rest of the cells when visualized\n",
         "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
         "norm_conf_mx = conf_mx / row_sums\n",
         "np.fill_diagonal(norm_conf_mx, 0)\n",
@@ -282,7 +293,7 @@
         "\n",
         "def init():\n",
         "    global model\n",
-        "    # retreive the path to the model file using the model name\n",
+        "    # retrieve the path to the model file using the model name\n",
         "    model_path = Model.get_model_path('sklearn_mnist')\n",
         "    model = joblib.load(model_path)\n",
         "\n",

tutorials/regression-part1-data-prep.ipynb

@@ -13,14 +13,16 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# Tutorial (part 1): Prepare data for regression modeling"
+        "# Tutorial: Prepare data for regression modeling"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "In this tutorial, you learn how to prep data for regression modeling using the Azure Machine Learning Data Prep SDK. Perform various transformations to filter and combine two different NYC Taxi data sets. The end goal of this tutorial set is to predict the cost of a taxi trip by training a model on data features including pickup hour, day of week, number of passengers, and coordinates. This tutorial is part one of a two-part tutorial series.\n",
+        "In this tutorial, you learn how to prepare data for regression modeling by using the Azure Machine Learning Data Prep SDK. You run various transformations to filter and combine two different NYC taxi data sets.\n",
+        "\n",
+        "This tutorial is **part one of a two-part tutorial series**. After you complete the tutorial series, you can predict the cost of a taxi trip by training a model on data features. These features include the pickup day and time, the number of passengers, and the pickup location.\n",
         "\n",
         "In this tutorial, you:\n",
         "\n",
@@ -29,17 +31,39 @@
         "> * Load two datasets with different field names\n",
         "> * Cleanse data to remove anomalies\n",
         "> * Transform data using intelligent transforms to create new features\n",
-        "> * Save your dataflow object to use in a regression model\n",
-        "\n",
-        "You can prepare your data in Python using the [Azure Machine Learning Data Prep SDK](https://aka.ms/data-prep-sdk)."
+        "> * Save your dataflow object to use in a regression model"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Import packages\n",
-        "Begin by importing the SDK."
+        "## Prerequisites\n",
+        "\n",
+        "To run the notebook you will need:\n",
+        "\n",
+        "* A Python 3.6 notebook server with the following installed:\n",
+        "    * The Azure Machine Learning Data Prep SDK for Python\n",
+        "* The tutorial notebook\n",
+        "\n",
+        "Navigate back to the [tutorial page](https://docs.microsoft.com/azure/machine-learning/service/tutorial-data-prep) for specific environment setup instructions.\n",
+        "\n",
+        "## <a name=\"start\"></a>Set up your development environment\n",
+        "\n",
+        "All the setup for your development work can be accomplished in a Python notebook. Setup includes the following actions:\n",
+        "\n",
+        "* Install the SDK\n",
+        "* Import Python packages\n",
+        "\n",
+        "### Install and import packages\n",
+        "\n",
+        "Use the following to install necessary packages if you don't already have them.\n",
+        "\n",
+        "```shell\n",
+        "pip install azureml-dataprep\n",
+        "```\n",
+        "\n",
+        "Import the SDK."
       ]
     },
     {
@@ -65,17 +89,25 @@
       "metadata": {},
       "outputs": [],
       "source": [
+        "from IPython.display import display\n",
         "dataset_root = \"https://dprepdata.blob.core.windows.net/demo\"\n",
         "\n",
         "green_path = \"/\".join([dataset_root, \"green-small/*\"])\n",
         "yellow_path = \"/\".join([dataset_root, \"yellow-small/*\"])\n",
         "\n",
-        "green_df = dprep.read_csv(path=green_path, header=dprep.PromoteHeadersMode.GROUPED)\n",
-        "# auto_read_file will automatically identify and parse the file type, and is useful if you don't know the file type\n",
-        "yellow_df = dprep.auto_read_file(path=yellow_path)\n",
+        "green_df_raw = dprep.read_csv(path=green_path, header=dprep.PromoteHeadersMode.GROUPED)\n",
+        "# auto_read_file automatically identifies and parses the file type, which is useful when you don't know the file type.\n",
+        "yellow_df_raw = dprep.auto_read_file(path=yellow_path)\n",
         "\n",
-        "green_df.head(5)\n",
-        "yellow_df.head(5)"
+        "display(green_df_raw.head(5))\n",
+        "display(yellow_df_raw.head(5))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "A `Dataflow` object is similar to a dataframe, and represents a series of lazily-evaluated, immutable operations on data. Operations can be added by invoking the different transformation and filtering methods available. The result of adding an operation to a `Dataflow` is always a new `Dataflow` object."
       ]
     },
     {
@@ -89,7 +121,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Now you populate some variables with shortcut transforms that will apply to all dataflows. The variable `drop_if_all_null` will be used to delete records where all fields are null. The variable `useful_columns` holds an array of column descriptions that are retained in each dataflow."
+        "Now you populate some variables with shortcut transforms to apply to all dataflows. The `drop_if_all_null` variable is used to delete records where all fields are null. The `useful_columns` variable holds an array of column descriptions that are kept in each dataflow."
       ]
     },
     {
@@ -110,7 +142,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "You first work with the green taxi data and get it into a valid shape that can be combined with the yellow taxi data. Create a temporary dataflow `tmp_df`, and call the `replace_na()`, `drop_nulls()`, and `keep_columns()` functions using the shortcut transform variables you created. Additionally, rename all the columns in the dataframe to match the names in `useful_columns`."
+        "You first work with the green taxi data to get it into a valid shape that can be combined with the yellow taxi data. Call the `replace_na()`, `drop_nulls()`, and `keep_columns()` functions by using the shortcut transform variables you created. Additionally, rename all the columns in the dataframe to match the names in the `useful_columns` variable."
       ]
     },
     {
@@ -119,7 +151,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df = (green_df\n",
+        "green_df = (green_df_raw\n",
         "    .replace_na(columns=all_columns)\n",
         "    .drop_nulls(*drop_if_all_null)\n",
         "    .rename_columns(column_pairs={\n",
@@ -138,14 +170,14 @@
         "        \"Trip_distance\": \"distance\"\n",
         "     })\n",
         "    .keep_columns(columns=useful_columns))\n",
-        "tmp_df.head(5)"
+        "green_df.head(5)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Overwrite the `green_df` variable with the transforms performed on `tmp_df` in the previous step."
+        "Run the same transformation steps on the yellow taxi data. These functions ensure that null data is removed from the data set, which will help increase machine learning model accuracy."
       ]
     },
     {
@@ -154,23 +186,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "green_df = tmp_df"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Perform the same transformation steps to the yellow taxi data."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "tmp_df = (yellow_df\n",
+        "yellow_df = (yellow_df_raw\n",
         "    .replace_na(columns=all_columns)\n",
         "    .drop_nulls(*drop_if_all_null)\n",
         "    .rename_columns(column_pairs={\n",
@@ -195,14 +211,14 @@
         "        \"trip_distance\": \"distance\"\n",
         "    })\n",
         "    .keep_columns(columns=useful_columns))\n",
-        "tmp_df.head(5)"
+        "yellow_df.head(5)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Again, overwrite `yellow_df` with `tmp_df`, and then call the `append_rows()` function on the green taxi data to append the yellow taxi data, creating a new combined dataframe."
+        "Call the `append_rows()` function on the green taxi data to append the yellow taxi data. A new combined dataframe is created."
       ]
     },
     {
@@ -211,7 +227,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "yellow_df = tmp_df\n",
         "combined_df = green_df.append_rows([yellow_df])"
       ]
     },
@@ -226,7 +241,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Examine the pickup and drop-off coordinates summary statistics to see how the data is distributed. First define a `TypeConverter` object to change the lat/long fields to decimal type. Next, call the `keep_columns()` function to restrict output to only the lat/long fields, and then call `get_profile()`."
+        "Examine the pickup and drop-off coordinates summary statistics to see how the data is distributed. First, define a `TypeConverter` object to change the latitude and longitude fields to decimal type. Next, call the `keep_columns()` function to restrict output to only the latitude and longitude fields, and then call the `get_profile()` function. These function calls create a condensed view of the dataflow to just show the lat/long fields, which makes it easier to evaluate missing or out-of-scope coordinates."
       ]
     },
     {
@@ -243,7 +258,7 @@
         "    \"dropoff_latitude\": decimal_type\n",
         "})\n",
         "combined_df.keep_columns(columns=[\n",
-        "    \"pickup_longitude\", \"pickup_latitude\", \n",
+        "    \"pickup_longitude\", \"pickup_latitude\",\n",
         "    \"dropoff_longitude\", \"dropoff_latitude\"\n",
         "]).get_profile()"
       ]
@@ -252,7 +267,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "From the summary statistics output, you see that there are coordinates that are missing, and coordinates that are not in New York City. Filter out coordinates not in the city border by chaining column filter commands within the `filter()` function, and defining minimum and maximum bounds for each field. Then call `get_profile()` again to verify the transformation."
+        "From the summary statistics output, you see there are missing coordinates and coordinates that aren't in New York City (this is determined from subjective analysis). Filter out coordinates for locations that are outside the city border. Chain the column filter commands within the `filter()` function and define the minimum and maximum bounds for each field. Then call the `get_profile()` function again to verify the transformation."
       ]
     },
     {
@@ -261,11 +276,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df = (combined_df\n",
+        "latlong_filtered_df = (combined_df\n",
         "    .drop_nulls(\n",
         "        columns=[\"pickup_longitude\", \"pickup_latitude\", \"dropoff_longitude\", \"dropoff_latitude\"],\n",
         "        column_relationship=dprep.ColumnRelationship(dprep.ColumnRelationship.ANY)\n",
-        "    ) \n",
+        "    )\n",
         "    .filter(dprep.f_and(\n",
         "        dprep.col(\"pickup_longitude\") <= -73.72,\n",
         "        dprep.col(\"pickup_longitude\") >= -74.09,\n",
@@ -276,28 +291,12 @@
         "        dprep.col(\"dropoff_latitude\") <= 40.88,\n",
         "        dprep.col(\"dropoff_latitude\") >= 40.53\n",
         "    )))\n",
-        "tmp_df.keep_columns(columns=[\n",
-        "    \"pickup_longitude\", \"pickup_latitude\", \n",
+        "latlong_filtered_df.keep_columns(columns=[\n",
+        "    \"pickup_longitude\", \"pickup_latitude\",\n",
         "    \"dropoff_longitude\", \"dropoff_latitude\"\n",
         "]).get_profile()"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Overwrite `combined_df` with the transformations you made to `tmp_df`."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "combined_df = tmp_df"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -309,7 +308,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Look at the data profile for the `store_forward` column."
+        "Look at the data profile for the `store_forward` column. This field is a boolean flag that is `Y` when the taxi did not have a connection to the server after the trip, and thus had to store the trip data in memory, and later forward it to the server when connected."
       ]
     },
     {
@@ -318,14 +317,14 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "combined_df.keep_columns(columns='store_forward').get_profile()"
+        "latlong_filtered_df.keep_columns(columns='store_forward').get_profile()"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "From the data profile output of `store_forward`, you see that the data is inconsistent and there are missing/null values. Replace these values using the `replace()` and `fill_nulls()` functions, and in both cases change to the string \"N\"."
+        "Notice that the data profile output in the `store_forward` column shows that the data is inconsistent and there are missing or null values. Use the `replace()` and `fill_nulls()` functions to replace these values with the string \"N\":"
       ]
     },
     {
@@ -334,14 +333,14 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "combined_df = combined_df.replace(columns=\"store_forward\", find=\"0\", replace_with=\"N\").fill_nulls(\"store_forward\", \"N\")"
+        "replaced_stfor_vals_df = latlong_filtered_df.replace(columns=\"store_forward\", find=\"0\", replace_with=\"N\").fill_nulls(\"store_forward\", \"N\")"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Execute another `replace` function, this time on the `distance` field. This reformats distance values that are incorrectly labeled as `.00`, and fills any nulls with zeros. Convert the `distance` field to numerical format."
+        "Execute the `replace` function on the `distance` field. The function reformats distance values that are incorrectly labeled as `.00`, and fills any nulls with zeros. Convert the `distance` field to numerical format. These incorrect data points are likely anomolies in the data collection system on the taxi cabs."
       ]
     },
     {
@@ -350,15 +349,15 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "combined_df = combined_df.replace(columns=\"distance\", find=\".00\", replace_with=0).fill_nulls(\"distance\", 0)\n",
-        "combined_df = combined_df.to_number([\"distance\"])"
+        "replaced_distance_vals_df = replaced_stfor_vals_df.replace(columns=\"distance\", find=\".00\", replace_with=0).fill_nulls(\"distance\", 0)\n",
+        "replaced_distance_vals_df = replaced_distance_vals_df.to_number([\"distance\"])"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Split the pick up and drop off datetimes into respective date and time columns. Use `split_column_by_example()` to perform the split. In this case, the optional `example` parameter of `split_column_by_example()` is omitted. Therefore the function will automatically determine where to split based on the data."
+        "Split the pickup and dropoff datetime values into the respective date and time columns. Use the `split_column_by_example()` function to make the split. In this case, the optional `example` parameter of the `split_column_by_example()` function is omitted. Therefore, the function automatically determines where to split based on the data."
       ]
     },
     {
@@ -367,10 +366,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df = (combined_df\n",
+        "time_split_df = (replaced_distance_vals_df\n",
         "    .split_column_by_example(source_column=\"pickup_datetime\")\n",
         "    .split_column_by_example(source_column=\"dropoff_datetime\"))\n",
-        "tmp_df.head(5)"
+        "time_split_df.head(5)"
       ]
     },
     {
@@ -386,21 +385,21 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df_renamed = (tmp_df\n",
+        "renamed_col_df = (time_split_df\n",
         "    .rename_columns(column_pairs={\n",
         "        \"pickup_datetime_1\": \"pickup_date\",\n",
         "        \"pickup_datetime_2\": \"pickup_time\",\n",
         "        \"dropoff_datetime_1\": \"dropoff_date\",\n",
         "        \"dropoff_datetime_2\": \"dropoff_time\"\n",
         "    }))\n",
-        "tmp_df_renamed.head(5)"
+        "renamed_col_df.head(5)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Overwrite `combined_df` with the executed transformations, and then call `get_profile()` to see full summary statistics after all transformations."
+        "Call the `get_profile()` function to see the full summary statistics after all cleansing steps."
       ]
     },
     {
@@ -409,8 +408,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "combined_df = tmp_df_renamed\n",
-        "combined_df.get_profile()"
+        "renamed_col_df.get_profile()"
       ]
     },
     {
@@ -424,9 +422,11 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Split the pickup and drop-off date further into day of week, day of month, and month. To get day of week, use the `derive_column_by_example()` function. This function takes as a parameter an array of example objects that define the input data, and the desired output. The function then automatically determines your desired transformation. For pickup and drop-off time columns, split into hour, minute, and second using the `split_column_by_example()` function with no example parameter.\n",
+        "Split the pickup and dropoff date further into the day of the week, day of the month, and month values. To get the day of the week value, use the `derive_column_by_example()` function. The function takes an array parameter of example objects that define the input data, and the preferred output. The function automatically determines your preferred transformation. For the pickup and dropoff time columns, split the time into the hour, minute, and second by using the `split_column_by_example()` function with no example parameter.\n",
         "\n",
-        "Once you have generated these new features, delete the original fields in favor of the newly generated features using `drop_columns()`. Rename all remaining fields to accurate descriptions."
+        "After you generate the new features, use the `drop_columns()` function to delete the original fields as the newly generated features are preferred. Rename the rest of the fields to use meaningful descriptions.\n",
+        "\n",
+        "Transforming the data in this way to create new time-based features will improve machine learning model accuracy. For example, generating a new feature for the weekday will help establish a relationship between the day of the week and the taxi fare price, which is often more expensive on certain days of the week due to high demand."
       ]
     },
     {
@@ -435,10 +435,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df = (combined_df\n",
+        "transformed_features_df = (renamed_col_df\n",
         "    .derive_column_by_example(\n",
-        "        source_columns=\"pickup_date\", \n",
-        "        new_column_name=\"pickup_weekday\", \n",
+        "        source_columns=\"pickup_date\",\n",
+        "        new_column_name=\"pickup_weekday\",\n",
         "        example_data=[(\"2009-01-04\", \"Sunday\"), (\"2013-08-22\", \"Thursday\")]\n",
         "    )\n",
         "    .derive_column_by_example(\n",
@@ -446,17 +446,17 @@
         "        new_column_name=\"dropoff_weekday\",\n",
         "        example_data=[(\"2013-08-22\", \"Thursday\"), (\"2013-11-03\", \"Sunday\")]\n",
         "    )\n",
-        "          \n",
+        "\n",
         "    .split_column_by_example(source_column=\"pickup_time\")\n",
         "    .split_column_by_example(source_column=\"dropoff_time\")\n",
-        "    # the following two split_column_by_example calls reference the generated column names from the above two calls\n",
+        "    # The following two calls to split_column_by_example reference the column names generated from the previous two calls.\n",
         "    .split_column_by_example(source_column=\"pickup_time_1\")\n",
         "    .split_column_by_example(source_column=\"dropoff_time_1\")\n",
         "    .drop_columns(columns=[\n",
-        "        \"pickup_date\", \"pickup_time\", \"dropoff_date\", \"dropoff_time\", \n",
+        "        \"pickup_date\", \"pickup_time\", \"dropoff_date\", \"dropoff_time\",\n",
         "        \"pickup_date_1\", \"dropoff_date_1\", \"pickup_time_1\", \"dropoff_time_1\"\n",
         "    ])\n",
-        "          \n",
+        "\n",
         "    .rename_columns(column_pairs={\n",
         "        \"pickup_date_2\": \"pickup_month\",\n",
         "        \"pickup_date_3\": \"pickup_monthday\",\n",
@@ -470,14 +470,14 @@
         "        \"dropoff_time_2\": \"dropoff_second\"\n",
         "    }))\n",
         "\n",
-        "tmp_df.head(5)"
+        "transformed_features_df.head(5)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "From the data above, you see that the pickup and drop-off date and time components produced from the derived transformations are correct. Drop the `pickup_datetime` and `dropoff_datetime` columns as they are no longer needed."
+        "Notice that the data shows that the pickup and dropoff date and time components produced from the derived transformations are correct. Drop the `pickup_datetime` and `dropoff_datetime` columns because they're no longer needed (granular time features like hour, minute and second are more useful for model training)."
       ]
     },
     {
@@ -486,7 +486,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df = tmp_df.drop_columns(columns=[\"pickup_datetime\", \"dropoff_datetime\"])"
+        "processed_df = transformed_features_df.drop_columns(columns=[\"pickup_datetime\", \"dropoff_datetime\"])"
       ]
     },
     {
@@ -502,7 +502,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "type_infer = tmp_df.builders.set_column_types()\n",
+        "type_infer = processed_df.builders.set_column_types()\n",
         "type_infer.learn()\n",
         "type_infer"
       ]
@@ -511,7 +511,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "The inference results look correct based on the data, now apply the type conversions to the dataflow."
+        "The inference results look correct based on the data. Now apply the type conversions to the dataflow."
       ]
     },
     {
@@ -520,15 +520,15 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df = type_infer.to_dataflow()\n",
-        "tmp_df.get_profile()"
+        "type_converted_df = type_infer.to_dataflow()\n",
+        "type_converted_df.get_profile()"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Before packaging the dataflow, perform two final filters on the data set. To eliminate incorrect data points, filter the dataflow on records where both the `cost` and `distance` are greater than zero."
+        "Before you package the dataflow, run two final filters on the data set. To eliminate incorrectly captured data points, filter the dataflow on records where both the `cost` and `distance` variable values are greater than zero. This step will significantly improve machine learning model accuracy, because data points with a zero cost or distance represent major outliers that throw off prediction accuracy."
       ]
     },
     {
@@ -537,15 +537,15 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "tmp_df = tmp_df.filter(dprep.col(\"distance\") > 0)\n",
-        "tmp_df = tmp_df.filter(dprep.col(\"cost\") > 0)"
+        "final_df = type_converted_df.filter(dprep.col(\"distance\") > 0)\n",
+        "final_df = final_df.filter(dprep.col(\"cost\") > 0)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "At this point, you have a fully transformed and prepared dataflow object to use in a machine learning model. The DataPrep SDK includes object serialization functionality, which is used as follows."
+        "You now have a fully transformed and prepared dataflow object to use in a machine learning model. The SDK includes object serialization functionality, which is used as shown in the following code."
       ]
     },
     {
@@ -557,8 +557,7 @@
         "import os\n",
         "file_path = os.path.join(os.getcwd(), \"dflows.dprep\")\n",
         "\n",
-        "dflow_prepared = tmp_df\n",
-        "package = dprep.Package([dflow_prepared])\n",
+        "package = dprep.Package([final_df])\n",
         "package.save(file_path)"
       ]
     },
@@ -573,7 +572,9 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Delete the file `dflows.dprep` (whether you are running locally or in Azure Notebooks) in your current directory if you do not wish to continue with part two of the tutorial. If you continue on to part two, you will need the `dflows.dprep` file in the current directory."
+        "To continue with part two of the tutorial, you need the **dflows.dprep** file in the current directory.\n",
+        "\n",
+        "If you don't plan to continue to part two, delete the **dflows.dprep** file in your current directory. Delete this file whether you're running the execution locally or in [Azure Notebooks](https://notebooks.azure.com/)."
       ]
     },
     {

tutorials/regression-part2-automated-ml.ipynb

@@ -11,20 +11,19 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# Tutorial (part 2): Use automated machine learning to build your regression model \n",
+        "# Tutorial: Use automated machine learning to build your regression model\n",
         "\n",
         "This tutorial is **part two of a two-part tutorial series**. In the previous tutorial, you [prepared the NYC taxi data for regression modeling](regression-part1-data-prep.ipynb).\n",
         "\n",
-        "Now, you're ready to start building your model with Azure Machine Learning service. In this part of the tutorial, you will use the prepared data and automatically generate a regression model to predict taxi fare prices. Using the automated ML capabilities of the service, you define your machine learning goals and constraints, launch the automated machine learning process and then allow the algorithm selection and hyperparameter-tuning to happen for you. The automated ML technique iterates over many combinations of algorithms and hyperparameters until it finds the best model based on your criterion.\n",
+        "Now you're ready to start building your model with Azure Machine Learning service. In this part of the tutorial, you use the prepared data and automatically generate a regression model to predict taxi fare prices. By using the automated machine learning capabilities of the service, you define your machine learning goals and constraints. You launch the automated machine learning process. Then allow the algorithm selection and hyperparameter tuning to happen for you. The automated machine learning technique iterates over many combinations of algorithms and hyperparameters until it finds the best model based on your criterion.\n",
         "\n",
-        "In this tutorial, you learn how to:\n",
+        "In this tutorial, you learn the following tasks:\n",
         "\n",
-        "> * Setup a Python environment and import the SDK packages\n",
+        "> * Set up a Python environment and import the SDK packages\n",
         "> * Configure an Azure Machine Learning service workspace\n",
         "> * Auto-train a regression model \n",
         "> * Run the model locally with custom parameters\n",
         "> * Explore the results\n",
-        "> * Register the best model\n",
         "\n",
         "If you don\u00e2\u20ac\u2122t have an Azure subscription, create a [free account](https://aka.ms/AMLfree) before you begin. \n",
         "\n",
@@ -33,17 +32,40 @@
         "\n",
         "## Prerequisites\n",
         "\n",
-        "> * [Run the data preparation tutorial](regression-part1-data-prep.ipynb)\n",
+        "To run the notebook you will need:\n",
         "\n",
-        "> * Automated machine learning configured environment e.g. Azure notebooks, Local Python environment or Data Science Virtual Machine. [Setup](https://docs.microsoft.com/azure/machine-learning/service/samples-notebooks) automated machine learning."
+        "* [Run the data preparation tutorial](regression-part1-data-prep.ipynb).\n",
+        "* A Python 3.6 notebook server with the following installed:\n",
+        "    * The Azure Machine Learning SDK for Python with `automl` and `notebooks` extras\n",
+        "    * `matplotlib`\n",
+        "* The tutorial notebook\n",
+        "* A machine learning workspace\n",
+        "* The configuration file for the workspace in the same directory as the notebook\n",
+        "\n",
+        "Navigate back to the [tutorial page](https://docs.microsoft.com/azure/machine-learning/service/tutorial-auto-train-models) for specific environment setup instructions.\n",
+        "\n",
+        "## <a name=\"start\"></a>Set up your development environment\n",
+        "\n",
+        "All the setup for your development work can be accomplished in a Python notebook. Setup includes the following actions:\n",
+        "\n",
+        "* Install the SDK\n",
+        "* Import Python packages\n",
+        "* Configure your workspace"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Import packages\n",
-        "Import Python packages you need in this tutorial."
+        "### Install and import packages\n",
+        "\n",
+        "If you are following the tutorial in your own Python environment, use the following to install necessary packages.\n",
+        "\n",
+        "```shell\n",
+        "pip install azureml-sdk[automl,notebooks] matplotlib\n",
+        "```\n",
+        "\n",
+        "Import the Python packages you need in this tutorial:"
       ]
     },
     {
@@ -55,7 +77,8 @@
         "import azureml.core\n",
         "import pandas as pd\n",
         "from azureml.core.workspace import Workspace\n",
-        "import logging"
+        "import logging\n",
+        "import os"
       ]
     },
     {
@@ -64,9 +87,11 @@
       "source": [
         "### Configure workspace\n",
         "\n",
-        "Create a workspace object from the existing workspace. A `Workspace` is a class that accepts your Azure subscription and resource information, and creates a cloud resource to monitor and track your model runs. `Workspace.from_config()` reads the file **aml_config/config.json** and loads the details into an object named `ws`.  `ws` is used throughout the rest of the code in this tutorial.\n",
+        "Create a workspace object from the existing workspace. A `Workspace` is a class that accepts your Azure subscription and resource information. It also creates a cloud resource to monitor and track your model runs.\n",
         "\n",
-        "Once you have a workspace object, specify a name for the experiment and create and register a local directory with the workspace. The history of all runs is recorded under the specified experiment."
+        "`Workspace.from_config()` reads the file **aml_config/config.json** and loads the details into an object named `ws`.  `ws` is used throughout the rest of the code in this tutorial.\n",
+        "\n",
+        "After you have a workspace object, specify a name for the experiment. Create and register a local directory with the workspace. The history of all runs is recorded under the specified experiment and in the [Azure portal](https://portal.azure.com)."
       ]
     },
     {
@@ -81,8 +106,6 @@
         "# project folder\n",
         "project_folder = './automated-ml-regression'\n",
         "\n",
-        "import os\n",
-        "\n",
         "output = {}\n",
         "output['SDK version'] = azureml.core.VERSION\n",
         "output['Subscription ID'] = ws.subscription_id\n",
@@ -101,7 +124,7 @@
       "source": [
         "## Explore data\n",
         "\n",
-        "Utilize the data flow object created in the previous tutorial. Open and execute the data flow and review the results."
+        "Use the data flow object created in the previous tutorial. To summarize, part 1 of this tutorial cleaned the NYC Taxi data so it could be used in a machine learning model. Now, you use various features from the data set and allow an automated model to build relationships between the features and the price of a taxi trip. Open and run the data flow and review the results:"
       ]
     },
     {
@@ -123,7 +146,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "You prepare the data for the experiment by adding columns to `dflow_X` to be features for our model creation. You define `dflow_y` to be our prediction value; cost.\n"
+        "You prepare the data for the experiment by adding columns to `dflow_x` to be features for our model creation. You define `dflow_y` to be our prediction value, **cost**:\n"
       ]
     },
     {
@@ -142,7 +165,7 @@
       "source": [
         "### Split data into train and test sets\n",
         "\n",
-        "Now you split the data into training and test sets using the `train_test_split` function in the `sklearn` library. This function segregates the data into the x (features) data set for model training and the y (values to predict) data set for testing. The `test_size` parameter determines the percentage of data to allocate to testing. The `random_state` parameter sets a seed to the random generator, so that your train-test splits are always deterministic."
+        "Now you split the data into training and test sets by using the `train_test_split` function in the `sklearn` library. This function segregates the data into the x, **features**, dataset for model training and the y, **values to predict**, dataset for testing. The `test_size` parameter determines the percentage of data to allocate to testing. The `random_state` parameter sets a seed to the random generator, so that your train-test splits are always deterministic:"
       ]
     },
     {
@@ -166,28 +189,28 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "You now have the necessary packages and data ready for auto training for your model. \n",
+        "The purpose of this step is to have data points to test the finished model that haven't been used to train the model, in order to measure true accuracy. In other words, a well-trained model should be able to accurately make predictions from data it hasn't already seen. You now have the necessary packages and data ready for autotraining your model.\n",
         "\n",
         "## Automatically train a model\n",
         "\n",
-        "To automatically train a model:\n",
-        "1. Define settings for the experiment run\n",
-        "1. Submit the experiment for model tuning\n",
+        "To automatically train a model, take the following steps:\n",
+        "1. Define settings for the experiment run. Attach your training data to the configuration, and modify settings that control the training process.\n",
+        "1. Submit the experiment for model tuning. After submitting the experiment, the process iterates through different machine learning algorithms and hyperparameter settings, adhering to your defined constraints. It chooses the best-fit model by optimizing an accuracy metric.\n",
         "\n",
         "\n",
         "### Define settings for autogeneration and tuning\n",
         "\n",
-        "Define the experiment parameters and models settings for autogeneration and tuning. View the full list of [settings](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-auto-train).\n",
+        "Define the experiment parameters and models settings for autogeneration and tuning. View the full list of [settings](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-auto-train). Submitting the experiment with these default settings will take approximately 10-15 min, but if you want a shorter run time, reduce either `iterations` or `iteration_timeout_minutes`.\n",
         "\n",
         "\n",
         "|Property| Value in this tutorial |Description|\n",
         "|----|----|---|\n",
-        "|**iteration_timeout_minutes**|10|Time limit in minutes for each iteration|\n",
-        "|**iterations**|30|Number of iterations. In each iteration, the model trains with the data with a specific pipeline|\n",
-        "|**primary_metric**|spearman_correlation | Metric that you want to optimize.|\n",
-        "|**preprocess**| True | True enables experiment to perform preprocessing on the input.|\n",
+        "|**iteration_timeout_minutes**|10|Time limit in minutes for each iteration. Reduce this value to decrease total runtime.|\n",
+        "|**iterations**|30|Number of iterations. In each iteration, a new machine learning model is trained with your data. This is the primary value that affects total run time.|\n",
+        "|**primary_metric**|spearman_correlation | Metric that you want to optimize. The best-fit model will be chosen based on this metric.|\n",
+        "|**preprocess**| True | By using **True**, the experiment can preprocess the input data (handling missing data, converting text to numeric, etc.)|\n",
         "|**verbosity**| logging.INFO | Controls the level of logging.|\n",
-        "|**n_cross_validationss**|5|Number of cross validation splits\n"
+        "|**n_cross_validationss**|5| Number of cross-validation splits to perform when validation data is not specified.\n"
       ]
     },
     {
@@ -206,6 +229,13 @@
         "}"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Use your defined training settings as a parameter to an `AutoMLConfig` object. Additionally, specify your training data and the type of model, which is `regression` in this case."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -233,7 +263,7 @@
       "source": [
         "### Train the automatic regression model\n",
         "\n",
-        "Start the experiment to run locally. Pass the defined `automated_ml_config` object to the experiment, and set the output to `true` to view progress during the experiment."
+        "Start the experiment to run locally. Pass the defined `automated_ml_config` object to the experiment. Set the output to `True` to view progress during the experiment:"
       ]
     },
     {
@@ -252,6 +282,13 @@
         "local_run = experiment.submit(automated_ml_config, show_output=True)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The output shown updates live as the experiment runs. For each iteration, you see the model type, the run duration, and the training accuracy. The field `BEST` tracks the best running training score based on your metric type."
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -262,7 +299,7 @@
         "\n",
         "### Option 1: Add a Jupyter widget to see results\n",
         "\n",
-        "Use the Jupyter notebook widget to see a graph and a table of all results."
+        "If you use a Jupyter notebook, use this Jupyter notebook widget to see a graph and a table of all results:"
       ]
     },
     {
@@ -285,7 +322,7 @@
       "source": [
         "### Option 2: Get and examine all run iterations in Python\n",
         "\n",
-        "Alternatively, you can retrieve the history of each experiment and explore the individual metrics for each iteration run."
+        "You can also retrieve the history of each experiment and explore the individual metrics for each iteration run. By examining RMSE (root_mean_squared_error) for each individual model run, you see that most iterations are predicting the taxi fair cost within a reasonable margin ($3-4).\n"
       ]
     },
     {
@@ -316,7 +353,7 @@
       "source": [
         "## Retrieve the best model\n",
         "\n",
-        "Select the best pipeline from our iterations. The `get_output` method on `automl_classifier` returns the best run and the fitted model for the last fit invocation. There are overloads on `get_output` that allow you to retrieve the best run and fitted model for any logged metric or a particular iteration."
+        "Select the best pipeline from our iterations. The `get_output` method on `automl_classifier` returns the best run and the fitted model for the last fit invocation. By using the overloads on `get_output`, you can retrieve the best run and fitted model for any logged metric or a particular iteration:"
       ]
     },
     {
@@ -330,34 +367,13 @@
         "print(fitted_model)"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Register the model\n",
-        "\n",
-        "Register the model in your Azure Machine Learning Workspace."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "description = 'Automated Machine Learning Model'\n",
-        "tags = None\n",
-        "local_run.register_model(description=description, tags=tags)\n",
-        "print(local_run.model_id) # Use this id to deploy the model as a web service in Azure"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
         "## Test the best model accuracy\n",
         "\n",
-        "Use the best model to run predictions on the test data set. The function `predict` uses the best model, and predicts the values of y (trip cost) from the `x_test` data set. Print the first 10 predicted cost values from `y_predict`."
+        "Use the best model to run predictions on the test dataset to predict taxi fares. The function `predict` uses the best model and predicts the values of y, **trip cost**, from the `x_test` dataset. Print the first 10 predicted cost values from `y_predict`:"
       ]
     },
     {
@@ -374,7 +390,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Create a scatter plot to visualize the predicted cost values compared to the actual cost values. The following code uses the `distance` feature as the x-axis, and trip `cost` as the y-axis. The first 100 predicted and actual cost values are created as separate series, in order to compare the variance of predicted cost at each trip distance value. Examining the plot shows that the distance/cost relationship is nearly linear, and the predicted cost values are in most cases very close to the actual cost values for the same trip distance."
+        "Create a scatter plot to visualize the predicted cost values compared to the actual cost values. The following code uses the `distance` feature as the x-axis and trip `cost` as the y-axis. To compare the variance of predicted cost at each trip distance value, the first 100 predicted and actual cost values are created as separate series. Examining the plot shows that the distance/cost relationship is nearly linear, and the predicted cost values are in most cases very close to the actual cost values for the same trip distance."
       ]
     },
     {
@@ -407,7 +423,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Calculate the `root mean squared error` of the results. Use the `y_test` dataframe, and convert it to a list to compare to the predicted values. The function `mean_squared_error` takes two arrays of values, and calculates the average squared error between them. Taking the square root of the result gives an error in the same units as the y variable (cost), and indicates roughly how far your predictions are from the actual value. "
+        " Calculate the `root mean squared error` of the results. Use the `y_test` dataframe. Convert it to a list to compare to the predicted values. The function `mean_squared_error` takes two arrays of values and calculates the average squared error between them. Taking the square root of the result gives an error in the same units as the y variable, **cost**. It indicates roughly how far the taxi fare predictions are from the actual fares:"
       ]
     },
     {
@@ -427,7 +443,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Run the following code to calculate MAPE (mean absolute percent error) using the full `y_actual` and `y_predict` data sets. This metric calculates an absolute difference between each predicted and actual value, sums all the differences, and then expresses that sum as a percent of the total of the actual values."
+        "Run the following code to calculate mean absolute percent error (MAPE) by using the full `y_actual` and `y_predict` datasets. This metric calculates an absolute difference between each predicted and actual value and sums all the differences. Then it expresses that sum as a percent of the total of the actual values:"
       ]
     },
     {
@@ -454,21 +470,46 @@
         "print(1 - mean_abs_percent_error)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "From the final prediction accuracy metrics, you see that the model is fairly good at predicting taxi fares from the data set's features, typically within +- $3.00. The traditional machine learning model development process is highly resource-intensive, and requires significant domain knowledge and time investment to run and compare the results of dozens of models. Using automated machine learning is a great way to rapidly test many different models for your scenario."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Clean up resources\n",
+        "\n",
+        ">The resources you created can be used as prerequisites to other Azure Machine Learning service tutorials and how-to articles. \n",
+        "\n",
+        "\n",
+        "If you don't plan to use the resources you created, delete them, so you don't incur any charges:\n",
+        "\n",
+        "1. In the Azure portal, select **Resource groups** on the far left.\n",
+        "\n",
+        "1. From the list, select the resource group you created.\n",
+        "\n",
+        "1. Select **Delete resource group**.\n",
+        "\n",
+        "1. Enter the resource group name. Then select **Delete**."
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
         "## Next steps\n",
         "\n",
-        "In this automated machine learning tutorial, you:\n",
+        "In this automated machine learning tutorial, you did the following tasks:\n",
         "\n",
+        "* Configured a workspace and prepared data for an experiment.\n",
+        "* Trained by using an automated regression model locally with custom parameters.\n",
+        "* Explored and reviewed training results.\n",
         "\n",
-        "> * Configured a workspace and prepared data for an experiment\n",
-        "> * Trained using an automated regression model locally with custom parameters\n",
-        "> * Explored and reviewed training results\n",
-        "> * Registered the best model\n",
-        "\n",
-        "You can also try out the [image classification tutorial](img-classification-part1-training.ipynb)."
+        "[Deploy your model](https://docs.microsoft.com/azure/machine-learning/service/tutorial-deploy-models-with-aml) with Azure Machine Learning."
       ]
     }
   ],