update samples - test

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,30 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: "[Notebook issue]"
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-Provide the following if applicable:
-+ Your Python & SDK version 
-+ Python Scripts or the full notebook name
-+ Pipeline definition 
-+ Environment definition 
-+ Example data 
-+ Any log files. 
-+ Run and Workspace Id 
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. 
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/notebook-issue.md

@@ -1,43 +0,0 @@
----
-name: Notebook issue
-about: Describe your notebook issue
-title: "[Notebook] DESCRIPTIVE TITLE"
-labels: notebook
-assignees: ''
-
----
-
-### DESCRIPTION: Describe clearly + concisely
-
-
-.
-### REPRODUCIBLE: Steps
-
-
-.
-### EXPECTATION: Clear description 
-
-
-.
-### CONFIG/ENVIRONMENT: 
-```Provide where applicable
-
-## Your Python & SDK version:
-
-## Environment definition:
-
-## Notebook name or Python scripts:
-
-## Run and Workspace Id:
-
-## Pipeline definition:
-
-## Example data:
-
-## Any log files:
-
-
-
-
-
-```

README.md

@@ -38,7 +38,6 @@ The [How to use Azure ML](./how-to-use-azureml) folder contains specific example
 - [Machine Learning Pipelines](./how-to-use-azureml/machine-learning-pipelines) - Examples showing how to create and use reusable pipelines for training and batch scoring
 - [Deployment](./how-to-use-azureml/deployment) - Examples showing how to deploy and manage machine learning models and solutions
 - [Azure Databricks](./how-to-use-azureml/azure-databricks) - Examples showing how to use Azure ML with Azure Databricks
-- [Monitor Models](./how-to-use-azureml/monitor-models) - Examples showing how to enable model monitoring services such as DataDrift
 
 ---
 ## Documentation
@@ -53,7 +52,6 @@ The [How to use Azure ML](./how-to-use-azureml) folder contains specific example
 
 Visit following repos to see projects contributed by Azure ML users:
 
- - [AMLSamples](https://github.com/Azure/AMLSamples) Number of end-to-end examples, including face recognition, predictive maintenance, customer churn and sentiment analysis.
  - [Fine tune natural language processing models using Azure Machine Learning service](https://github.com/Microsoft/AzureML-BERT)
  - [Fashion MNIST with Azure ML SDK](https://github.com/amynic/azureml-sdk-fashion)
  

configuration.ipynb

@@ -58,7 +58,7 @@
         "\n",
         "### What is an Azure Machine Learning workspace\n",
         "\n",
-        "An Azure ML Workspace is an Azure resource that organizes and coordinates the actions of many other Azure resources to assist in executing and sharing machine learning workflows.  In particular, an Azure ML Workspace coordinates storage, databases, and compute resources providing added functionality for machine learning experimentation, deployment, inference, and the monitoring of deployed models."
+        "An Azure ML Workspace is an Azure resource that organizes and coordinates the actions of many other Azure resources to assist in executing and sharing machine learning workflows.  In particular, an Azure ML Workspace coordinates storage, databases, and compute resources providing added functionality for machine learning experimentation, deployment, inferencing, and the monitoring of deployed models."
       ]
     },
     {
@@ -103,7 +103,7 @@
       "source": [
         "import azureml.core\n",
         "\n",
-        "print(\"This notebook was created using version 1.0.57 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version  of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

contrib/datadrift/azure-ml-datadrift.ipynb

@@ -33,9 +33,10 @@
       "source": [
         "## Install the DataDrift package\n",
         "\n",
-        "Install the azureml-contrib-datadrift, azureml-opendatasets and lightgbm packages before running this notebook.\n",
+        "Install the azureml-contrib-datadrift, azureml-contrib-opendatasets and lightgbm packages before running this notebook.\n",
         "```\n",
         "pip install azureml-contrib-datadrift\n",
+        "pip install azureml-contrib-datasets\n",
         "pip install lightgbm\n",
         "```"
       ]
@@ -62,7 +63,7 @@
         "import pandas as pd\n",
         "import requests\n",
         "from azureml.contrib.datadrift import DataDriftDetector, AlertConfiguration\n",
-        "from azureml.opendatasets import NoaaIsdWeather\n",
+        "from azureml.contrib.opendatasets import NoaaIsdWeather\n",
         "from azureml.core import Dataset, Workspace, Run\n",
         "from azureml.core.compute import AksCompute, ComputeTarget\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
@@ -258,7 +259,8 @@
         "trainingDataset = Dataset.auto_read_files(dpath, include_path=True)\n",
         "trainingDataset = trainingDataset.register(workspace=ws, name=dataset_name, description=\"dset\", exist_ok=True)\n",
         "\n",
-        "datasets = [(Dataset.Scenario.TRAINING, trainingDataset)]\n",
+        "trainingDataSnapshot = trainingDataset.create_snapshot(snapshot_name=snapshot_name, compute_target=None, create_data_snapshot=True)\n",
+        "datasets = [(Dataset.Scenario.TRAINING, trainingDataSnapshot)]\n",
         "print(\"dataset registration done.\\n\")\n",
         "datasets"
       ]
@@ -572,22 +574,6 @@
         "        time.sleep(3)"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "We need to wait up to 10 minutes for the Model Data Collector to dump the model input and inference data to storage in the Workspace, where it's used by the DataDriftDetector job."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "time.sleep(600)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

contrib/datadrift/azure-ml-datadrift.yml

@@ -3,6 +3,6 @@ dependencies:
 - pip:
   - azureml-sdk
   - azureml-contrib-datadrift
-  - azureml-opendatasets
+  - azureml-contrib-opendatasets
   - lightgbm
   - azureml-widgets

how-to-use-azureml/README.md

@@ -8,7 +8,7 @@ As a pre-requisite, run the [configuration Notebook](../configuration.ipynb) not
 * [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](./track-and-monitor-experiments/logging-api): Learn about the details of logging metrics to run history.
+* [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.
 * [production-deploy-to-aks](./deployment/production-deploy-to-aks) Deploy a model to production at scale on Azure Kubernetes Service.
 * [enable-data-collection-for-models-in-aks](./deployment/enable-data-collection-for-models-in-aks) Learn about data collection APIs for deployed model.

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

@@ -155,11 +155,11 @@ jupyter notebook
 - [auto-ml-subsampling-local.ipynb](subsampling/auto-ml-subsampling-local.ipynb)
     - How to enable subsampling
 
-- [auto-ml-dataset.ipynb](dataprep/auto-ml-dataset.ipynb)
-    - Using Dataset for reading data
+- [auto-ml-dataprep.ipynb](dataprep/auto-ml-dataprep.ipynb)
+    - Using DataPrep for reading data
 
-- [auto-ml-dataset-remote-execution.ipynb](dataprep-remote-execution/auto-ml-dataset-remote-execution.ipynb)
-    - Using Dataset for reading data with remote execution
+- [auto-ml-dataprep-remote-execution.ipynb](dataprep-remote-execution/auto-ml-dataprep-remote-execution.ipynb)
+    - Using DataPrep for reading data with remote execution
 
 - [auto-ml-classification-with-whitelisting.ipynb](classification-with-whitelisting/auto-ml-classification-with-whitelisting.ipynb)
     - Dataset: scikit learn's [digit dataset](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html#sklearn.datasets.load_digits)
@@ -175,19 +175,10 @@ jupyter notebook
     - Example of training an automated ML forecasting model on multiple time-series
 
 - [auto-ml-classification-with-onnx.ipynb](classification-with-onnx/auto-ml-classification-with-onnx.ipynb)
-    - Dataset: scikit learn's [iris dataset](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html)
+    - Dataset: scikit learn's [digit dataset](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html#sklearn.datasets.load_digits)
     - Simple example of using automated ML for classification with ONNX models
     - Uses local compute for training
 
-- [auto-ml-remote-amlcompute-with-onnx.ipynb](remote-amlcompute-with-onnx/auto-ml-remote-amlcompute-with-onnx.ipynb)
-    - Dataset: scikit learn's [iris dataset](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html)
-    - Example of using automated ML for classification using remote AmlCompute for training
-    - Train the models with ONNX compatible config on
-    - Parallel execution of iterations
-    - Async tracking of progress
-    - Cancelling individual iterations or entire run
-    - Retrieving the ONNX models and do the inference with them
-
 - [auto-ml-bank-marketing-subscribers-with-deployment.ipynb](bank-marketing-subscribers-with-deployment/auto-ml-bank-marketing-with-deployment.ipynb)
     - Dataset: UCI's [bank marketing dataset](https://www.kaggle.com/janiobachmann/bank-marketing-dataset)
     - Simple example of using automated ML for classification to predict term deposit subscriptions for a bank

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

@@ -2,7 +2,6 @@ name: azure_automl
 dependencies:
   # The python interpreter version.
   # Currently Azure ML only supports 3.5.2 and later.
-- pip
 - python>=3.5.2,<3.6.8
 - nb_conda
 - matplotlib==2.1.0
@@ -13,13 +12,10 @@ dependencies:
 - scikit-learn>=0.19.0,<=0.20.3
 - pandas>=0.22.0,<=0.23.4
 - py-xgboost<=0.80
-- pyarrow>=0.11.0
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-defaults
-  - azureml-train-automl
+  - azureml-sdk[automl,explain]
   - azureml-widgets
-  - azureml-explain-model
   - pandas_ml
   

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

@@ -2,7 +2,6 @@ name: azure_automl
 dependencies:
   # The python interpreter version.
   # Currently Azure ML only supports 3.5.2 and later.
-- pip
 - nomkl
 - python>=3.5.2,<3.6.8
 - nb_conda
@@ -14,13 +13,10 @@ dependencies:
 - scikit-learn>=0.19.0,<=0.20.3
 - pandas>=0.22.0,<0.23.0
 - py-xgboost<=0.80
-- pyarrow>=0.11.0
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-defaults
-  - azureml-train-automl
+  - azureml-sdk[automl,explain]
   - azureml-widgets
-  - azureml-explain-model
   - pandas_ml
   

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

@@ -69,17 +69,22 @@
       "metadata": {},
       "outputs": [],
       "source": [
+        "import json\n",
         "import logging\n",
         "\n",
         "from matplotlib import pyplot as plt\n",
+        "import numpy as np\n",
         "import pandas as pd\n",
         "import os\n",
+        "from sklearn import datasets\n",
+        "import azureml.dataprep as dprep\n",
+        "from sklearn.model_selection import train_test_split\n",
         "\n",
         "import azureml.core\n",
         "from azureml.core.experiment import Experiment\n",
         "from azureml.core.workspace import Workspace\n",
-        "from azureml.core.dataset import Dataset\n",
-        "from azureml.train.automl import AutoMLConfig"
+        "from azureml.train.automl import AutoMLConfig\n",
+        "from azureml.train.automl.run import AutoMLRun"
       ]
     },
     {
@@ -150,12 +155,11 @@
         "    # Create the cluster.\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
         "    \n",
-        "print('Checking cluster status...')\n",
-        "# Can poll for a minimum number of nodes and for a specific timeout.\n",
-        "# If no min_node_count is provided, it will use the scale settings for the cluster.\n",
-        "compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
+        "    # Can poll for a minimum number of nodes and for a specific timeout.\n",
+        "    # If no min_node_count is provided, it will use the scale settings for the cluster.\n",
+        "    compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
         "    \n",
-        "# For a more detailed view of current AmlCompute status, use get_status()."
+        "     # For a more detailed view of current AmlCompute status, use get_status()."
       ]
     },
     {
@@ -188,7 +192,6 @@
       "source": [
         "from azureml.core.runconfig import RunConfiguration\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
         "\n",
         "# create a new RunConfig object\n",
         "conda_run_config = RunConfiguration(framework=\"python\")\n",
@@ -196,8 +199,10 @@
         "# Set compute target to AmlCompute\n",
         "conda_run_config.target = compute_target\n",
         "conda_run_config.environment.docker.enabled = True\n",
+        "conda_run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE\n",
         "\n",
-        "cd = CondaDependencies.create(conda_packages=['numpy','py-xgboost<=0.80'])\n",
+        "\n",
+        "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'], conda_packages=['numpy','py-xgboost<=0.80'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },
@@ -217,10 +222,11 @@
       "outputs": [],
       "source": [
         "data = \"https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/bankmarketing_train.csv\"\n",
-        "dataset = Dataset.Tabular.from_delimited_files(data)\n",
-        "X_train = dataset.drop_columns(columns=['y'])\n",
-        "y_train = dataset.keep_columns(columns=['y'], validate=True)\n",
-        "dataset.take(5).to_pandas_dataframe()"
+        "dflow = dprep.auto_read_file(data)\n",
+        "dflow.get_profile()\n",
+        "X_train = dflow.drop_columns(columns=['y'])\n",
+        "y_train = dflow.keep_columns(columns=['y'], validate_column_exists=True)\n",
+        "dflow.head()"
       ]
     },
     {
@@ -398,7 +404,7 @@
         "def run(rawdata):\n",
         "    try:\n",
         "        data = json.loads(rawdata)['data']\n",
-        "        data = np.array(data)\n",
+        "        data = numpy.array(data)\n",
         "        result = model.predict(data)\n",
         "    except Exception as e:\n",
         "        result = str(e)\n",
@@ -435,7 +441,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "for p in ['azureml-train-automl', 'azureml-core']:\n",
+        "for p in ['azureml-train-automl', 'azureml-sdk', 'azureml-core']:\n",
         "    print('{}\\t{}'.format(p, dependencies[p]))"
       ]
     },
@@ -445,8 +451,10 @@
       "metadata": {},
       "outputs": [],
       "source": [
+        "from azureml.core.conda_dependencies import CondaDependencies\n",
+        "\n",
         "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn','py-xgboost<=0.80'],\n",
-        "                                 pip_packages=['azureml-train-automl'])\n",
+        "                                 pip_packages=['azureml-sdk[automl]'])\n",
         "\n",
         "conda_env_file_name = 'myenv.yml'\n",
         "myenv.save_to_file('.', conda_env_file_name)"
@@ -466,7 +474,7 @@
         "    content = cefr.read()\n",
         "\n",
         "with open(conda_env_file_name, 'w') as cefw:\n",
-        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-train-automl']))\n",
+        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-sdk']))\n",
         "\n",
         "# Substitute the actual model id in the script file.\n",
         "\n",
@@ -608,6 +616,8 @@
       "outputs": [],
       "source": [
         "# Load the bank marketing datasets.\n",
+        "from sklearn.datasets import load_diabetes\n",
+        "from sklearn.model_selection import train_test_split\n",
         "from numpy import array"
       ]
     },
@@ -618,10 +628,11 @@
       "outputs": [],
       "source": [
         "data = \"https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/bankmarketing_validate.csv\"\n",
-        "dataset = Dataset.Tabular.from_delimited_files(data)\n",
-        "X_test = dataset.drop_columns(columns=['y'])\n",
-        "y_test = dataset.keep_columns(columns=['y'], validate=True)\n",
-        "dataset.take(5).to_pandas_dataframe()"
+        "dflow = dprep.auto_read_file(data)\n",
+        "dflow.get_profile()\n",
+        "X_test = dflow.drop_columns(columns=['y'])\n",
+        "y_test = dflow.keep_columns(columns=['y'], validate_column_exists=True)\n",
+        "dflow.head()"
       ]
     },
     {

how-to-use-azureml/automated-machine-learning/classification-bank-marketing/auto-ml-classification-bank-marketing.yml

@@ -2,8 +2,6 @@ name: auto-ml-classification-bank-marketing
 dependencies:
 - pip:
   - azureml-sdk
-  - azureml-defaults
-  - azureml-explain-model
   - azureml-train-automl
   - azureml-widgets
   - matplotlib

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

@@ -74,12 +74,14 @@
         "from matplotlib import pyplot as plt\n",
         "import pandas as pd\n",
         "import os\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import azureml.dataprep as dprep\n",
         "\n",
         "import azureml.core\n",
         "from azureml.core.experiment import Experiment\n",
         "from azureml.core.workspace import Workspace\n",
-        "from azureml.core.dataset import Dataset\n",
-        "from azureml.train.automl import AutoMLConfig"
+        "from azureml.train.automl import AutoMLConfig\n",
+        "from azureml.train.automl.run import AutoMLRun"
       ]
     },
     {
@@ -150,12 +152,11 @@
         "    # Create the cluster.\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
         "    \n",
-        "print('Checking cluster status...')\n",
-        "# Can poll for a minimum number of nodes and for a specific timeout.\n",
-        "# If no min_node_count is provided, it will use the scale settings for the cluster.\n",
-        "compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
-        "\n",
-        "# For a more detailed view of current AmlCompute status, use get_status()."
+        "    # Can poll for a minimum number of nodes and for a specific timeout.\n",
+        "    # If no min_node_count is provided, it will use the scale settings for the cluster.\n",
+        "    compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
+        "    \n",
+        "     # For a more detailed view of current AmlCompute status, use get_status()."
       ]
     },
     {
@@ -188,7 +189,6 @@
       "source": [
         "from azureml.core.runconfig import RunConfiguration\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
         "\n",
         "# create a new RunConfig object\n",
         "conda_run_config = RunConfiguration(framework=\"python\")\n",
@@ -196,8 +196,10 @@
         "# Set compute target to AmlCompute\n",
         "conda_run_config.target = compute_target\n",
         "conda_run_config.environment.docker.enabled = True\n",
+        "conda_run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE\n",
         "\n",
-        "cd = CondaDependencies.create(conda_packages=['numpy','py-xgboost<=0.80'])\n",
+        "\n",
+        "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'], conda_packages=['numpy','py-xgboost<=0.80'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },
@@ -207,7 +209,7 @@
       "source": [
         "### Load Data\n",
         "\n",
-        "Here create the script to be run in azure compute for loading the data, load the credit card dataset into cards and store the Class column (y) in the y variable and store the remaining data in the x variable. Next split the data using random_split and return X_train and y_train for training the model."
+        "Here create the script to be run in azure compute for loading the data, load the credit card dataset into cards and store the Class column (y) in the y variable and store the remaining data in the x variable. Next split the data  using train_test_split and return X_train and y_train for training the model."
       ]
     },
     {
@@ -217,9 +219,10 @@
       "outputs": [],
       "source": [
         "data = \"https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/creditcard.csv\"\n",
-        "dataset = Dataset.Tabular.from_delimited_files(data)\n",
-        "X = dataset.drop_columns(columns=['Class'])\n",
-        "y = dataset.keep_columns(columns=['Class'], validate=True)\n",
+        "dflow = dprep.auto_read_file(data)\n",
+        "dflow.get_profile()\n",
+        "X = dflow.drop_columns(columns=['Class'])\n",
+        "y = dflow.keep_columns(columns=['Class'], validate_column_exists=True)\n",
         "X_train, X_test = X.random_split(percentage=0.8, seed=223)\n",
         "y_train, y_test = y.random_split(percentage=0.8, seed=223)"
       ]
@@ -442,7 +445,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "for p in ['azureml-train-automl', 'azureml-core']:\n",
+        "for p in ['azureml-train-automl', 'azureml-sdk', 'azureml-core']:\n",
         "    print('{}\\t{}'.format(p, dependencies[p]))"
       ]
     },
@@ -453,7 +456,7 @@
       "outputs": [],
       "source": [
         "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn','py-xgboost<=0.80'],\n",
-        "                                 pip_packages=['azureml-train-automl'])\n",
+        "                                 pip_packages=['azureml-sdk[automl]'])\n",
         "\n",
         "conda_env_file_name = 'myenv.yml'\n",
         "myenv.save_to_file('.', conda_env_file_name)"
@@ -473,7 +476,7 @@
         "    content = cefr.read()\n",
         "\n",
         "with open(conda_env_file_name, 'w') as cefw:\n",
-        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-train-automl']))\n",
+        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-sdk']))\n",
         "\n",
         "# Substitute the actual model id in the script file.\n",
         "\n",

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

@@ -2,8 +2,6 @@ name: auto-ml-classification-credit-card-fraud
 dependencies:
 - pip:
   - azureml-sdk
-  - azureml-defaults
-  - azureml-explain-model
   - azureml-train-automl
   - azureml-widgets
   - matplotlib

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

@@ -297,7 +297,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "for p in ['azureml-train-automl', 'azureml-core']:\n",
+        "for p in ['azureml-train-automl', 'azureml-sdk', 'azureml-core']:\n",
         "    print('{}\\t{}'.format(p, dependencies[p]))"
       ]
     },
@@ -310,7 +310,7 @@
         "from azureml.core.conda_dependencies import CondaDependencies\n",
         "\n",
         "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn','py-xgboost<=0.80'],\n",
-        "                                 pip_packages=['azureml-train-automl'])\n",
+        "                                 pip_packages=['azureml-sdk[automl]'])\n",
         "\n",
         "conda_env_file_name = 'myenv.yml'\n",
         "myenv.save_to_file('.', conda_env_file_name)"
@@ -330,7 +330,7 @@
         "    content = cefr.read()\n",
         "\n",
         "with open(conda_env_file_name, 'w') as cefw:\n",
-        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-train-automl']))\n",
+        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-sdk']))\n",
         "\n",
         "# Substitute the actual model id in the script file.\n",
         "\n",

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

@@ -29,6 +29,7 @@
         "1. [Data](#Data)\n",
         "1. [Train](#Train)\n",
         "1. [Results](#Results)\n",
+        "1. [Test](#Test)\n",
         "\n"
       ]
     },
@@ -38,7 +39,7 @@
       "source": [
         "## Introduction\n",
         "\n",
-        "In this example we use the scikit-learn's [iris dataset](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html) to showcase how you can use AutoML for a simple classification problem.\n",
+        "In this example we use the scikit-learn's [digit dataset](http://scikit-learn.org/stable/datasets/index.html#optical-recognition-of-handwritten-digits-dataset) to showcase how you can use AutoML for a simple classification problem.\n",
         "\n",
         "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
         "\n",
@@ -48,8 +49,7 @@
         "1. Create an `Experiment` in an existing `Workspace`.\n",
         "2. Configure AutoML using `AutoMLConfig`.\n",
         "3. Train the model using local compute with ONNX compatible config on.\n",
-        "4. Explore the results and save the ONNX model.\n",
-        "5. Inference with the ONNX model."
+        "4. Explore the results and save the ONNX model."
       ]
     },
     {
@@ -156,11 +156,11 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Train\n",
+        "## Train with enable ONNX compatible models config on\n",
         "\n",
         "Instantiate an `AutoMLConfig` object to specify the settings and data used to run the experiment.\n",
         "\n",
-        "**Note:** Set the parameter enable_onnx_compatible_models=True, if you also want to generate the ONNX compatible models. Please note, the forecasting task and TensorFlow models are not ONNX compatible yet.\n",
+        "Set the parameter enable_onnx_compatible_models=True, if you also want to generate the ONNX compatible models. Please note, the forecasting task and TensorFlow models are not ONNX compatible yet.\n",
         "\n",
         "|Property|Description|\n",
         "|-|-|\n",

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

@@ -41,7 +41,7 @@
         "In this example we use the scikit-learn's [digit dataset](http://scikit-learn.org/stable/datasets/index.html#optical-recognition-of-handwritten-digits-dataset) to showcase how you can use AutoML for a simple classification problem.\n",
         "\n",
         "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
-        "This notebooks shows how can automl can be trained on a selected list of models, see the readme.md for the models.\n",
+        "This notebooks shows how can automl can be trained on a a selected list of models,see the readme.md for the models.\n",
         "This trains the model exclusively on tensorflow based models.\n",
         "\n",
         "In this notebook you will learn how to:\n",

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

@@ -258,11 +258,7 @@
     {
       "cell_type": "code",
       "execution_count": null,
-      "metadata": {
-        "tags": [
-          "widget-rundetails-sample"
-        ]
-      },
+      "metadata": {},
       "outputs": [],
       "source": [
         "from azureml.widgets import RunDetails\n",

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

@@ -128,7 +128,7 @@
         "# You can also use `read_csv` and `to_*` transformations to read (with overridable delimiter)\n",
         "# and convert column types manually.\n",
         "example_data = 'https://dprepdata.blob.core.windows.net/demo/crime0-random.csv'\n",
-        "dflow = dprep.read_csv(example_data, infer_column_types=True)\n",
+        "dflow = dprep.auto_read_file(example_data).skip(1)  # Remove the header row.\n",
         "dflow.get_profile()"
       ]
     },
@@ -241,7 +241,6 @@
       "source": [
         "from azureml.core.runconfig import RunConfiguration\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
         "\n",
         "# create a new RunConfig object\n",
         "conda_run_config = RunConfiguration(framework=\"python\")\n",
@@ -251,9 +250,7 @@
         "conda_run_config.environment.docker.enabled = True\n",
         "conda_run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE\n",
         "\n",
-        "dprep_dependency = 'azureml-dataprep==' + pkg_resources.get_distribution(\"azureml-dataprep\").version\n",
-        "\n",
-        "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]', dprep_dependency], conda_packages=['numpy','py-xgboost<=0.80'])\n",
+        "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'], conda_packages=['numpy','py-xgboost<=0.80'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },

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

@@ -1,12 +1,5 @@
 {
   "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/automated-machine-learning/dataprep/auto-ml-dataprep.png)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -16,6 +9,13 @@
         "Licensed under the MIT License."
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/automated-machine-learning/dataprep/auto-ml-dataprep.png)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},

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

@@ -1,509 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/automated-machine-learning/dataprep-remote-execution/auto-ml-dataprep-remote-execution.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Automated Machine Learning\n",
-        "_**Load Data using `TabularDataset` for Remote Execution (AmlCompute)**_\n",
-        "\n",
-        "## Contents\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Data](#Data)\n",
-        "1. [Train](#Train)\n",
-        "1. [Results](#Results)\n",
-        "1. [Test](#Test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "In this example we showcase how you can use AzureML Dataset to load data for AutoML.\n",
-        "\n",
-        "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
-        "\n",
-        "In this notebook you will learn how to:\n",
-        "1. Create a `TabularDataset` pointing to the training data.\n",
-        "2. Pass the `TabularDataset` to AutoML for a remote run."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Setup"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "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 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.core.dataset import Dataset\n",
-        "from azureml.train.automl import AutoMLConfig"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ws = Workspace.from_config()\n",
-        "\n",
-        "# choose a name for experiment\n",
-        "experiment_name = 'automl-dataset-remote-bai'\n",
-        "# project folder\n",
-        "project_folder = './sample_projects/automl-dataprep-remote-bai'\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",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
-        "outputDf.T"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# The data referenced here was a 1MB simple random sample of the Chicago Crime data into a local temporary directory.\n",
-        "example_data = 'https://dprepdata.blob.core.windows.net/demo/crime0-random.csv'\n",
-        "dataset = Dataset.Tabular.from_delimited_files(example_data)\n",
-        "dataset.take(5).to_pandas_dataframe()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Review the data\n",
-        "\n",
-        "You can peek the result of a `TabularDataset` at any range using `skip(i)` and `take(j).to_pandas_dataframe()`. Doing so evaluates only `j` records, which makes it fast even against large datasets.\n",
-        "\n",
-        "`TabularDataset` objects are immutable and are composed of a list of subsetting transformations (optional)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "X = dataset.drop_columns(columns=['Primary Type', 'FBI Code'])\n",
-        "y = dataset.keep_columns(columns=['Primary Type'], validate=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Train\n",
-        "\n",
-        "This creates a general AutoML settings object applicable for both local and remote runs."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "automl_settings = {\n",
-        "    \"iteration_timeout_minutes\" : 10,\n",
-        "    \"iterations\" : 2,\n",
-        "    \"primary_metric\" : 'AUC_weighted',\n",
-        "    \"preprocess\" : True,\n",
-        "    \"verbosity\" : logging.INFO\n",
-        "}"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Create or Attach an AmlCompute cluster"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.compute import AmlCompute\n",
-        "from azureml.core.compute import ComputeTarget\n",
-        "\n",
-        "# Choose a name for your cluster.\n",
-        "amlcompute_cluster_name = \"automlc2\"\n",
-        "\n",
-        "found = False\n",
-        "\n",
-        "# Check if this compute target already exists in the workspace.\n",
-        "\n",
-        "cts = ws.compute_targets\n",
-        "if amlcompute_cluster_name in cts and cts[amlcompute_cluster_name].type == 'AmlCompute':\n",
-        "    found = True\n",
-        "    print('Found existing compute target.')\n",
-        "    compute_target = cts[amlcompute_cluster_name]\n",
-        "\n",
-        "if not found:\n",
-        "    print('Creating a new compute target...')\n",
-        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_D2_V2\", # for GPU, use \"STANDARD_NC6\"\n",
-        "                                                                #vm_priority = 'lowpriority', # optional\n",
-        "                                                                max_nodes = 6)\n",
-        "\n",
-        "    # Create the cluster.\\n\",\n",
-        "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
-        "\n",
-        "print('Checking cluster status...')\n",
-        "# Can poll for a minimum number of nodes and for a specific timeout.\n",
-        "# If no min_node_count is provided, it will use the scale settings for the cluster.\n",
-        "compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
-        "\n",
-        "# For a more detailed view of current AmlCompute status, use get_status()."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.runconfig import RunConfiguration\n",
-        "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
-        "\n",
-        "# create a new RunConfig object\n",
-        "conda_run_config = RunConfiguration(framework=\"python\")\n",
-        "\n",
-        "# Set compute target to AmlCompute\n",
-        "conda_run_config.target = compute_target\n",
-        "conda_run_config.environment.docker.enabled = True\n",
-        "\n",
-        "cd = CondaDependencies.create(conda_packages=['numpy','py-xgboost<=0.80'])\n",
-        "conda_run_config.environment.python.conda_dependencies = cd"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Pass Data with `TabularDataset` Objects\n",
-        "\n",
-        "The `TabularDataset` objects captured above can also be passed to the `submit` method for a remote run. AutoML will serialize the `TabularDataset` object and send it to the remote compute target. The `TabularDataset` will not be evaluated locally."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "automl_config = AutoMLConfig(task = 'classification',\n",
-        "                             debug_log = 'automl_errors.log',\n",
-        "                             path = project_folder,\n",
-        "                             run_configuration=conda_run_config,\n",
-        "                             X = X,\n",
-        "                             y = y,\n",
-        "                             **automl_settings)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "remote_run = experiment.submit(automl_config, show_output = True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "remote_run"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Pre-process cache cleanup\n",
-        "The preprocess data gets cache at user default file store. When the run is completed the cache can be cleaned by running below cell"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "remote_run.clean_preprocessor_cache()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Cancelling Runs\n",
-        "You can cancel ongoing remote runs using the `cancel` and `cancel_iteration` functions."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Cancel the ongoing experiment and stop scheduling new iterations.\n",
-        "# remote_run.cancel()\n",
-        "\n",
-        "# Cancel iteration 1 and move onto iteration 2.\n",
-        "# remote_run.cancel_iteration(1)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Results"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Widget for Monitoring Runs\n",
-        "\n",
-        "The widget will first report a \"loading\" status while running the first iteration. After completing the first iteration, an auto-updating graph and table will be shown. The widget will refresh once per minute, so you should see the graph update as child runs complete.\n",
-        "\n",
-        "**Note:** The widget displays a link at the bottom. Use this link to open a web interface to explore the individual run details."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.widgets import RunDetails\n",
-        "RunDetails(remote_run).show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Retrieve All Child Runs\n",
-        "You can also use SDK methods to fetch all the child runs and see individual metrics that we log."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "children = list(remote_run.get_children())\n",
-        "metricslist = {}\n",
-        "for run in children:\n",
-        "    properties = run.get_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",
-        "rundata = pd.DataFrame(metricslist).sort_index(1)\n",
-        "rundata"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Retrieve the Best Model\n",
-        "\n",
-        "Below we select the best pipeline from our iterations. The `get_output` method returns the best run and the fitted model. Overloads on `get_output` allow you to retrieve the best run and fitted model for *any* logged metric or for a particular *iteration*."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "best_run, fitted_model = remote_run.get_output()\n",
-        "print(best_run)\n",
-        "print(fitted_model)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Best Model Based on Any Other Metric\n",
-        "Show the run and the model that has the smallest `log_loss` value:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "lookup_metric = \"log_loss\"\n",
-        "best_run, fitted_model = remote_run.get_output(metric = lookup_metric)\n",
-        "print(best_run)\n",
-        "print(fitted_model)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Model from a Specific Iteration\n",
-        "Show the run and the model from the first iteration:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "iteration = 0\n",
-        "best_run, fitted_model = remote_run.get_output(iteration = iteration)\n",
-        "print(best_run)\n",
-        "print(fitted_model)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Test\n",
-        "\n",
-        "#### Load Test Data\n",
-        "For the test data, it should have the same preparation step as the train data. Otherwise it might get failed at the preprocessing step."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "dataset_test = Dataset.Tabular.from_delimited_files(path='https://dprepdata.blob.core.windows.net/demo/crime0-test.csv')\n",
-        "\n",
-        "df_test = dataset_test.to_pandas_dataframe()\n",
-        "df_test = df_test[pd.notnull(df_test['Primary Type'])]\n",
-        "\n",
-        "y_test = df_test[['Primary Type']]\n",
-        "X_test = df_test.drop(['Primary Type', 'FBI Code'], axis=1)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Testing Our Best Fitted Model\n",
-        "We will use confusion matrix to see how our model works."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from pandas_ml import ConfusionMatrix\n",
-        "\n",
-        "ypred = fitted_model.predict(X_test)\n",
-        "\n",
-        "cm = ConfusionMatrix(y_test['Primary Type'], ypred)\n",
-        "\n",
-        "print(cm)\n",
-        "\n",
-        "cm.plot()"
-      ]
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "savitam"
-      }
-    ],
-    "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/automated-machine-learning/dataset/auto-ml-dataset.ipynb

@@ -1,402 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/automated-machine-learning/dataprep/auto-ml-dataprep.png)"
-      ]
-    },
-    {
-      "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",
-        "_**Load Data using `TabularDataset` for Local Execution**_\n",
-        "\n",
-        "## Contents\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Data](#Data)\n",
-        "1. [Train](#Train)\n",
-        "1. [Results](#Results)\n",
-        "1. [Test](#Test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "In this example we showcase how you can use AzureML Dataset to load data for AutoML.\n",
-        "\n",
-        "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
-        "\n",
-        "In this notebook you will learn how to:\n",
-        "1. Create a `TabularDataset` pointing to the training data.\n",
-        "2. Pass the `TabularDataset` to AutoML for a local run."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Setup"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "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 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.core.dataset import Dataset\n",
-        "from azureml.train.automl import AutoMLConfig"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ws = Workspace.from_config()\n",
-        " \n",
-        "# choose a name for experiment\n",
-        "experiment_name = 'automl-dataset-local'\n",
-        "# project folder\n",
-        "project_folder = './sample_projects/automl-dataset-local'\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",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
-        "outputDf.T"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# The data referenced here was a 1MB simple random sample of the Chicago Crime data into a local temporary directory.\n",
-        "example_data = 'https://dprepdata.blob.core.windows.net/demo/crime0-random.csv'\n",
-        "dataset = Dataset.Tabular.from_delimited_files(example_data)\n",
-        "dataset.take(5).to_pandas_dataframe()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Review the data\n",
-        "\n",
-        "You can peek the result of a `TabularDataset` at any range using `skip(i)` and `take(j).to_pandas_dataframe()`. Doing so evaluates only `j` records, which makes it fast even against large datasets.\n",
-        "\n",
-        "`TabularDataset` objects are immutable and are composed of a list of subsetting transformations (optional)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "X = dataset.drop_columns(columns=['Primary Type', 'FBI Code'])\n",
-        "y = dataset.keep_columns(columns=['Primary Type'], validate=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Train\n",
-        "\n",
-        "This creates a general AutoML settings object applicable for both local and remote runs."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "automl_settings = {\n",
-        "    \"iteration_timeout_minutes\" : 10,\n",
-        "    \"iterations\" : 2,\n",
-        "    \"primary_metric\" : 'AUC_weighted',\n",
-        "    \"preprocess\" : True,\n",
-        "    \"verbosity\" : logging.INFO\n",
-        "}"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Pass Data with `TabularDataset` Objects\n",
-        "\n",
-        "The `TabularDataset` objects captured above can be passed to the `submit` method for a local run. AutoML will retrieve the results from the `TabularDataset` for model training."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "automl_config = AutoMLConfig(task = 'classification',\n",
-        "                             debug_log = 'automl_errors.log',\n",
-        "                             X = X,\n",
-        "                             y = y,\n",
-        "                             **automl_settings)"
-      ]
-    },
-    {
-      "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": [
-        "local_run"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Results"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Widget for Monitoring Runs\n",
-        "\n",
-        "The widget will first report a \"loading\" status while running the first iteration. After completing the first iteration, an auto-updating graph and table will be shown. The widget will refresh once per minute, so you should see the graph update as child runs complete.\n",
-        "\n",
-        "**Note:** The widget displays a link at the bottom. Use this link to open a web interface to explore the individual run details."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.widgets import RunDetails\n",
-        "RunDetails(local_run).show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Retrieve All Child Runs\n",
-        "You can also use SDK methods to fetch all the child runs and see individual metrics that we log."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "children = list(local_run.get_children())\n",
-        "metricslist = {}\n",
-        "for run in children:\n",
-        "    properties = run.get_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",
-        "rundata = pd.DataFrame(metricslist).sort_index(1)\n",
-        "rundata"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Retrieve the Best Model\n",
-        "\n",
-        "Below we select the best pipeline from our iterations. The `get_output` method returns the best run and the fitted model. Overloads on `get_output` allow you to retrieve the best run and fitted model for *any* logged metric or for a particular *iteration*."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "best_run, fitted_model = local_run.get_output()\n",
-        "print(best_run)\n",
-        "print(fitted_model)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Best Model Based on Any Other Metric\n",
-        "Show the run and the model that has the smallest `log_loss` value:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "lookup_metric = \"log_loss\"\n",
-        "best_run, fitted_model = local_run.get_output(metric = lookup_metric)\n",
-        "print(best_run)\n",
-        "print(fitted_model)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Model from a Specific Iteration\n",
-        "Show the run and the model from the first iteration:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "iteration = 0\n",
-        "best_run, fitted_model = local_run.get_output(iteration = iteration)\n",
-        "print(best_run)\n",
-        "print(fitted_model)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Test\n",
-        "\n",
-        "#### Load Test Data\n",
-        "For the test data, it should have the same preparation step as the train data. Otherwise it might get failed at the preprocessing step."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "dataset_test = Dataset.Tabular.from_delimited_files(path='https://dprepdata.blob.core.windows.net/demo/crime0-test.csv')\n",
-        "\n",
-        "df_test = dataset_test.to_pandas_dataframe()\n",
-        "df_test = df_test[pd.notnull(df_test['Primary Type'])]\n",
-        "\n",
-        "y_test = df_test[['Primary Type']]\n",
-        "X_test = df_test.drop(['Primary Type', 'FBI Code'], axis=1)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Testing Our Best Fitted Model\n",
-        "We will use confusion matrix to see how our model works."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from pandas_ml import ConfusionMatrix\n",
-        "\n",
-        "ypred = fitted_model.predict(X_test)\n",
-        "\n",
-        "cm = ConfusionMatrix(y_test['Primary Type'], ypred)\n",
-        "\n",
-        "print(cm)\n",
-        "\n",
-        "cm.plot()"
-      ]
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "savitam"
-      }
-    ],
-    "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/automated-machine-learning/dataset/auto-ml-dataset.yml

@@ -1,8 +0,0 @@
-name: auto-ml-dataset
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-train-automl
-  - azureml-widgets
-  - matplotlib
-  - pandas_ml

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

@@ -197,12 +197,12 @@
         "display(HTML('<h3>Iterations</h3>'))\n",
         "RunDetails(ml_run).show() \n",
         "\n",
-        "all_metrics = ml_run.get_metrics(recursive=True)\n",
+        "children = list(ml_run.get_children())\n",
         "metricslist = {}\n",
-        "for run_id, metrics in all_metrics.items():\n",
-        "    iteration = int(run_id.split('_')[-1])\n",
-        "    float_metrics = {k: v for k, v in metrics.items() if isinstance(v, float)}\n",
-        "    metricslist[iteration] = float_metrics\n",
+        "for run in children:\n",
+        "    properties = run.get_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",
         "rundata = pd.DataFrame(metricslist).sort_index(1)\n",
         "display(HTML('<h3>Metrics</h3>'))\n",

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

@@ -345,10 +345,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Get the featurization summary as a list of JSON\n",
-        "featurization_summary = fitted_model.named_steps['timeseriestransformer'].get_featurization_summary()\n",
-        "# View the featurization summary as a pandas dataframe\n",
-        "pd.DataFrame.from_records(featurization_summary)"
+        "fitted_model.named_steps['timeseriestransformer'].get_featurization_summary()"
       ]
     },
     {
@@ -525,7 +522,7 @@
         "print('MAPE: %.2f' % MAPE(df_all[target_column_name], df_all['predicted']))\n",
         "\n",
         "# Plot outputs\n",
-        "%matplotlib inline\n",
+        "%matplotlib notebook\n",
         "test_pred = plt.scatter(df_all[target_column_name], df_all['predicted'], color='b')\n",
         "test_test = plt.scatter(y_test, y_test, color='g')\n",
         "plt.legend((test_pred, test_test), ('prediction', 'truth'), loc='upper left', fontsize=8)\n",
@@ -567,7 +564,7 @@
         "df_all_APE = df_all.assign(APE=APE(df_all[target_column_name], df_all['predicted']))\n",
         "APEs = [df_all_APE[df_all['horizon_origin'] == h].APE.values for h in range(1, max_horizon + 1)]\n",
         "\n",
-        "%matplotlib inline\n",
+        "%matplotlib notebook\n",
         "plt.boxplot(APEs)\n",
         "plt.yscale('log')\n",
         "plt.xlabel('horizon')\n",
@@ -581,7 +578,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "erwright"
+        "name": "xiaga@microsoft.com, tosingli@microsoft.com, erwright@microsoft.com"
       }
     ],
     "kernelspec": {

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

@@ -231,7 +231,6 @@
         "automl_config = AutoMLConfig(task='forecasting',\n",
         "                             debug_log='automl_nyc_energy_errors.log',\n",
         "                             primary_metric='normalized_root_mean_squared_error',\n",
-        "                             blacklist_models = ['ExtremeRandomTrees'],\n",
         "                             iterations=10,\n",
         "                             iteration_timeout_minutes=5,\n",
         "                             X=X_train,\n",
@@ -433,7 +432,7 @@
         "print('MAPE: %.2f' % MAPE(df_all[target_column_name], df_all['predicted']))\n",
         "\n",
         "# Plot outputs\n",
-        "%matplotlib inline\n",
+        "%matplotlib notebook\n",
         "pred, = plt.plot(df_all[time_column_name], df_all['predicted'], color='b')\n",
         "actual, = plt.plot(df_all[time_column_name], df_all[target_column_name], color='g')\n",
         "plt.xticks(fontsize=8)\n",
@@ -482,7 +481,7 @@
         "automl_config_lags = AutoMLConfig(task='forecasting',\n",
         "                                  debug_log='automl_nyc_energy_errors.log',\n",
         "                                  primary_metric='normalized_root_mean_squared_error',\n",
-        "                                  blacklist_models=['ElasticNet','ExtremeRandomTrees','GradientBoosting'],\n",
+        "                                  blacklist_models=['ElasticNet'],\n",
         "                                  iterations=10,\n",
         "                                  iteration_timeout_minutes=10,\n",
         "                                  X=X_train,\n",
@@ -544,7 +543,7 @@
         "print('MAPE: %.2f' % MAPE(df_lags[target_column_name], df_lags['predicted']))\n",
         "\n",
         "# Plot outputs\n",
-        "%matplotlib inline\n",
+        "%matplotlib notebook\n",
         "pred, = plt.plot(df_lags[time_column_name], df_lags['predicted'], color='b')\n",
         "actual, = plt.plot(df_lags[time_column_name], df_lags[target_column_name], color='g')\n",
         "plt.xticks(fontsize=8)\n",
@@ -588,7 +587,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "erwright"
+        "name": "xiaga, tosingli, erwright"
       }
     ],
     "kernelspec": {

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

@@ -244,8 +244,7 @@
         "|**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_voting_ensemble**|Allow AutoML to create a Voting ensemble of the best performing models\n",
-        "|**enable_stack_ensemble**|Allow AutoML to create a Stack ensemble of the best performing models\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.|\n",
         "|**time_column_name**|Name of the datetime column in the input data|\n",
@@ -274,8 +273,7 @@
         "                             X=X_train,\n",
         "                             y=y_train,\n",
         "                             n_cross_validations=3,\n",
-        "                             enable_voting_ensemble=False,\n",
-        "                             enable_stack_ensemble=False,\n",
+        "                             enable_ensembling=False,\n",
         "                             path=project_folder,\n",
         "                             verbosity=logging.INFO,\n",
         "                             **time_series_settings)"
@@ -465,7 +463,7 @@
         "# Plot outputs\n",
         "import matplotlib.pyplot as plt\n",
         "\n",
-        "%matplotlib inline\n",
+        "%matplotlib notebook\n",
         "test_pred = plt.scatter(df_all[target_column_name], df_all['predicted'], color='b')\n",
         "test_test = plt.scatter(y_test, y_test, color='g')\n",
         "plt.legend((test_pred, test_test), ('prediction', 'truth'), loc='upper left', fontsize=8)\n",
@@ -665,10 +663,10 @@
         "conda_env_file_name = 'fcast_env.yml'\n",
         "\n",
         "dependencies = ml_run.get_run_sdk_dependencies(iteration = best_iteration)\n",
-        "for p in ['azureml-train-automl', 'azureml-core']:\n",
+        "for p in ['azureml-train-automl', 'azureml-sdk', 'azureml-core']:\n",
         "    print('{}\\t{}'.format(p, dependencies[p]))\n",
         "\n",
-        "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn'], pip_packages=['azureml-train-automl'])\n",
+        "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn'], pip_packages=['azureml-sdk[automl]'])\n",
         "\n",
         "myenv.save_to_file('.', conda_env_file_name)"
       ]
@@ -690,7 +688,7 @@
         "    content = cefr.read()\n",
         "\n",
         "with open(conda_env_file_name, 'w') as cefw:\n",
-        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-train-automl']))\n",
+        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-sdk']))\n",
         "\n",
         "# Substitute the actual model id in the script file.\n",
         "\n",
@@ -831,7 +829,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "erwright"
+        "name": "erwright, tosingli"
       }
     ],
     "kernelspec": {

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

@@ -360,10 +360,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Get the featurization summary as a list of JSON\n",
-        "featurization_summary = fitted_model.named_steps['datatransformer'].get_featurization_summary()\n",
-        "# View the featurization summary as a pandas dataframe\n",
-        "pd.DataFrame.from_records(featurization_summary)"
+        "fitted_model.named_steps['datatransformer'].get_featurization_summary()"
       ]
     },
     {

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

@@ -70,12 +70,13 @@
         "import numpy as np\n",
         "import pandas as pd\n",
         "import os\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import azureml.dataprep as dprep\n",
         " \n",
         "\n",
         "import azureml.core\n",
         "from azureml.core.experiment import Experiment\n",
         "from azureml.core.workspace import Workspace\n",
-        "from azureml.core.dataset import Dataset\n",
         "from azureml.train.automl import AutoMLConfig"
       ]
     },
@@ -146,12 +147,11 @@
         "    # Create the cluster.\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
         "    \n",
-        "print('Checking cluster status...')\n",
-        "# Can poll for a minimum number of nodes and for a specific timeout.\n",
-        "# If no min_node_count is provided, it will use the scale settings for the cluster.\n",
-        "compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
+        "    # Can poll for a minimum number of nodes and for a specific timeout.\n",
+        "    # If no min_node_count is provided, it will use the scale settings for the cluster.\n",
+        "    compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
         "    \n",
-        "# For a more detailed view of current AmlCompute status, use get_status()."
+        "     # For a more detailed view of current AmlCompute status, use get_status()."
       ]
     },
     {
@@ -184,7 +184,6 @@
       "source": [
         "from azureml.core.runconfig import RunConfiguration\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
         "\n",
         "# create a new RunConfig object\n",
         "conda_run_config = RunConfiguration(framework=\"python\")\n",
@@ -192,8 +191,10 @@
         "# Set compute target to AmlCompute\n",
         "conda_run_config.target = compute_target\n",
         "conda_run_config.environment.docker.enabled = True\n",
+        "conda_run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE\n",
         "\n",
-        "cd = CondaDependencies.create(conda_packages=['numpy', 'py-xgboost<=0.80'])\n",
+        "\n",
+        "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'], conda_packages=['numpy'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },
@@ -203,7 +204,7 @@
       "source": [
         "### Load Data\n",
         "\n",
-        "Here create the script to be run in azure compute for loading the data, load the concrete strength dataset into the X and y  variables. Next, split the data using random_split and return X_train and y_train for training the model. Finally, return X_train and y_train for training the model."
+        "Here create the script to be run in azure compute for loading the data, load the concrete strength dataset into the X and y  variables. Next, split the data  using train_test_split and return X_train and y_train for training the model. Finally, return X_train and y_train for training the model."
       ]
     },
     {
@@ -213,12 +214,13 @@
       "outputs": [],
       "source": [
         "data = \"https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/compresive_strength_concrete.csv\"\n",
-        "dataset = Dataset.Tabular.from_delimited_files(data)\n",
-        "X = dataset.drop_columns(columns=['CONCRETE'])\n",
-        "y = dataset.keep_columns(columns=['CONCRETE'], validate=True)\n",
+        "dflow = dprep.auto_read_file(data)\n",
+        "dflow.get_profile()\n",
+        "X = dflow.drop_columns(columns=['CONCRETE'])\n",
+        "y = dflow.keep_columns(columns=['CONCRETE'], validate_column_exists=True)\n",
         "X_train, X_test = X.random_split(percentage=0.8, seed=223)\n",
         "y_train, y_test = y.random_split(percentage=0.8, seed=223) \n",
-        "dataset.take(5).to_pandas_dataframe()"
+        "dflow.head()"
       ]
     },
     {
@@ -480,7 +482,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "for p in ['azureml-train-automl', 'azureml-core']:\n",
+        "for p in ['azureml-train-automl', 'azureml-sdk', 'azureml-core']:\n",
         "    print('{}\\t{}'.format(p, dependencies[p]))"
       ]
     },
@@ -490,7 +492,9 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn','py-xgboost==0.80'], pip_packages=['azureml-train-automl'])\n",
+        "from azureml.core.conda_dependencies import CondaDependencies\n",
+        "\n",
+        "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn'], pip_packages=['azureml-sdk[automl]'])\n",
         "\n",
         "conda_env_file_name = 'myenv.yml'\n",
         "myenv.save_to_file('.', conda_env_file_name)"
@@ -510,7 +514,7 @@
         "    content = cefr.read()\n",
         "\n",
         "with open(conda_env_file_name, 'w') as cefw:\n",
-        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-train-automl']))\n",
+        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-sdk']))\n",
         "\n",
         "# Substitute the actual model id in the script file.\n",
         "\n",

how-to-use-azureml/automated-machine-learning/regression-concrete-strength/auto-ml-regression-concrete-strength.yml

@@ -2,8 +2,6 @@ name: auto-ml-regression-concrete-strength
 dependencies:
 - pip:
   - azureml-sdk
-  - azureml-defaults
-  - azureml-explain-model
   - azureml-train-automl
   - azureml-widgets
   - matplotlib

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

@@ -70,12 +70,13 @@
         "import numpy as np\n",
         "import pandas as pd\n",
         "import os\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import azureml.dataprep as dprep\n",
         " \n",
         "\n",
         "import azureml.core\n",
         "from azureml.core.experiment import Experiment\n",
         "from azureml.core.workspace import Workspace\n",
-        "from azureml.core.dataset import Dataset\n",
         "from azureml.train.automl import AutoMLConfig"
       ]
     },
@@ -146,12 +147,11 @@
         "    # Create the cluster.\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
         "    \n",
-        "print('Checking cluster status...')\n",
-        "# Can poll for a minimum number of nodes and for a specific timeout.\n",
-        "# If no min_node_count is provided, it will use the scale settings for the cluster.\n",
-        "compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
+        "    # Can poll for a minimum number of nodes and for a specific timeout.\n",
+        "    # If no min_node_count is provided, it will use the scale settings for the cluster.\n",
+        "    compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
         "    \n",
-        "# For a more detailed view of current AmlCompute status, use get_status()."
+        "     # For a more detailed view of current AmlCompute status, use get_status()."
       ]
     },
     {
@@ -184,7 +184,6 @@
       "source": [
         "from azureml.core.runconfig import RunConfiguration\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
         "\n",
         "# create a new RunConfig object\n",
         "conda_run_config = RunConfiguration(framework=\"python\")\n",
@@ -192,8 +191,10 @@
         "# Set compute target to AmlCompute\n",
         "conda_run_config.target = compute_target\n",
         "conda_run_config.environment.docker.enabled = True\n",
+        "conda_run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE\n",
         "\n",
-        "cd = CondaDependencies.create(conda_packages=['numpy', 'py-xgboost<=0.80'])\n",
+        "\n",
+        "cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'], conda_packages=['numpy'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },
@@ -203,7 +204,7 @@
       "source": [
         "### Load Data\n",
         "\n",
-        "Here create the script to be run in azure compute for loading the data, load the hardware dataset into the X and y variables. Next split the data using random_split and return X_train and y_train for training the model."
+        "Here create the script to be run in azure compute for loading the data, load the hardware dataset into the X and y variables. Next split the data  using train_test_split and return X_train and y_train for training the model."
       ]
     },
     {
@@ -213,12 +214,13 @@
       "outputs": [],
       "source": [
         "data = \"https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/machineData.csv\"\n",
-        "dataset = Dataset.Tabular.from_delimited_files(data)\n",
-        "X = dataset.drop_columns(columns=['ERP'])\n",
-        "y = dataset.keep_columns(columns=['ERP'], validate=True)\n",
+        "dflow = dprep.auto_read_file(data)\n",
+        "dflow.get_profile()\n",
+        "X = dflow.drop_columns(columns=['ERP'])\n",
+        "y = dflow.keep_columns(columns=['ERP'], validate_column_exists=True)\n",
         "X_train, X_test = X.random_split(percentage=0.8, seed=223)\n",
-        "y_train, y_test = y.random_split(percentage=0.8, seed=223)\n",
-        "dataset.take(5).to_pandas_dataframe()"
+        "y_train, y_test = y.random_split(percentage=0.8, seed=223) \n",
+        "dflow.head()"
       ]
     },
     {
@@ -498,7 +500,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "for p in ['azureml-train-automl', 'azureml-core']:\n",
+        "for p in ['azureml-train-automl', 'azureml-sdk', 'azureml-core']:\n",
         "    print('{}\\t{}'.format(p, dependencies[p]))"
       ]
     },
@@ -508,7 +510,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn','py-xgboost==0.80'], pip_packages=['azureml-train-automl'])\n",
+        "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn'], pip_packages=['azureml-sdk[automl]'])\n",
         "\n",
         "conda_env_file_name = 'myenv.yml'\n",
         "myenv.save_to_file('.', conda_env_file_name)"
@@ -528,7 +530,7 @@
         "    content = cefr.read()\n",
         "\n",
         "with open(conda_env_file_name, 'w') as cefw:\n",
-        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-train-automl']))\n",
+        "    cefw.write(content.replace(azureml.core.VERSION, dependencies['azureml-sdk']))\n",
         "\n",
         "# Substitute the actual model id in the script file.\n",
         "\n",

how-to-use-azureml/automated-machine-learning/regression-hardware-performance/auto-ml-regression-hardware-performance.yml

@@ -2,8 +2,6 @@ name: auto-ml-regression-hardware-performance
 dependencies:
 - pip:
   - azureml-sdk
-  - azureml-defaults
-  - azureml-explain-model
   - azureml-train-automl
   - azureml-widgets
   - matplotlib

how-to-use-azureml/automated-machine-learning/remote-amlcompute-with-onnx/auto-ml-remote-amlcompute-with-onnx.ipynb

@@ -1,548 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/automated-machine-learning/remote-amlcompute/auto-ml-remote-amlcompute.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Automated Machine Learning\n",
-        "_**Remote Execution using AmlCompute**_\n",
-        "\n",
-        "## Contents\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Data](#Data)\n",
-        "1. [Train](#Train)\n",
-        "1. [Results](#Results)\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "In this example we use the scikit-learn's [iris dataset](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html) to showcase how you can use AutoML for a simple classification problem.\n",
-        "\n",
-        "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
-        "\n",
-        "In this notebook you would see\n",
-        "1. Create an `Experiment` in an existing `Workspace`.\n",
-        "2. Create or Attach existing AmlCompute to a workspace.\n",
-        "3. Configure AutoML using `AutoMLConfig`.\n",
-        "4. Train the model using AmlCompute with ONNX compatible config on.\n",
-        "5. Explore the results and save the ONNX model.\n",
-        "6. Inference with the ONNX model.\n",
-        "\n",
-        "In addition this notebook showcases the following features\n",
-        "- **Parallel** executions for iterations\n",
-        "- **Asynchronous** tracking of progress\n",
-        "- **Cancellation** of individual iterations or the entire run\n",
-        "- Retrieving models for any iteration or logged metric\n",
-        "- Specifying AutoML settings as `**kwargs`"
-      ]
-    },
-    {
-      "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",
-        "import os\n",
-        "\n",
-        "import pandas as pd\n",
-        "from sklearn import datasets\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "\n",
-        "import azureml.core\n",
-        "from azureml.core.experiment import Experiment\n",
-        "from azureml.core.workspace import Workspace\n",
-        "from azureml.core.dataset import Dataset\n",
-        "from azureml.train.automl import AutoMLConfig"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ws = Workspace.from_config()\n",
-        "\n",
-        "# Choose a name for the run history container in the workspace.\n",
-        "experiment_name = 'automl-remote-amlcompute-with-onnx'\n",
-        "project_folder = './project'\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",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
-        "outputDf.T"
-      ]
-    },
-    {
-      "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 your AutoML run. In this tutorial, you create `AmlCompute` as your 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 AmlCompute\n",
-        "from azureml.core.compute import ComputeTarget\n",
-        "\n",
-        "# Choose a name for your cluster.\n",
-        "amlcompute_cluster_name = \"automlc2\"\n",
-        "\n",
-        "found = False\n",
-        "# Check if this compute target already exists in the workspace.\n",
-        "cts = ws.compute_targets\n",
-        "if amlcompute_cluster_name in cts and cts[amlcompute_cluster_name].type == 'AmlCompute':\n",
-        "    found = True\n",
-        "    print('Found existing compute target.')\n",
-        "    compute_target = cts[amlcompute_cluster_name]\n",
-        "\n",
-        "if not found:\n",
-        "    print('Creating a new compute target...')\n",
-        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_D2_V2\", # for GPU, use \"STANDARD_NC6\"\n",
-        "                                                                #vm_priority = 'lowpriority', # optional\n",
-        "                                                                max_nodes = 6)\n",
-        "\n",
-        "    # Create the cluster.\\n\",\n",
-        "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
-        "\n",
-        "print('Checking cluster status...')\n",
-        "# Can poll for a minimum number of nodes and for a specific timeout.\n",
-        "# If no min_node_count is provided, it will use the scale settings for the cluster.\n",
-        "compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
-        "\n",
-        "# For a more detailed view of current AmlCompute status, use get_status()."
-      ]
-    },
-    {
-      "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_iris](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html) data."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "iris = datasets.load_iris()\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",
-        "X_train, X_test, y_train, y_test = train_test_split(iris.data, \n",
-        "                                                    iris.target, \n",
-        "                                                    test_size=0.2, \n",
-        "                                                    random_state=0)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Ensure the x_train and x_test are pandas DataFrame."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Convert the X_train and X_test to pandas DataFrame and set column names,\n",
-        "# This is needed for initializing the input variable names of ONNX model, \n",
-        "# and the prediction with the ONNX model using the inference helper.\n",
-        "X_train = pd.DataFrame(X_train, columns=['c1', 'c2', 'c3', 'c4'])\n",
-        "X_test = pd.DataFrame(X_test, columns=['c1', 'c2', 'c3', 'c4'])\n",
-        "y_train = pd.DataFrame(y_train, columns=['label'])\n",
-        "\n",
-        "X_train.to_csv(\"data/X_train.csv\", index=False)\n",
-        "y_train.to_csv(\"data/y_train.csv\", index=False)\n",
-        "\n",
-        "ds = ws.get_default_datastore()\n",
-        "ds.upload(src_dir='./data', target_path='irisdata', overwrite=True, show_progress=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.runconfig import RunConfiguration\n",
-        "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
-        "\n",
-        "# create a new RunConfig object\n",
-        "conda_run_config = RunConfiguration(framework=\"python\")\n",
-        "\n",
-        "# Set compute target to AmlCompute\n",
-        "conda_run_config.target = compute_target\n",
-        "conda_run_config.environment.docker.enabled = True\n",
-        "\n",
-        "cd = CondaDependencies.create(conda_packages=['numpy','py-xgboost<=0.80'])\n",
-        "conda_run_config.environment.python.conda_dependencies = cd"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "###  Creating a TabularDataset\n",
-        "\n",
-        "Defined X and y as `TabularDataset`s, which are passed to automated machine learning in the AutoMLConfig."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "X = Dataset.Tabular.from_delimited_files(path=ds.path('irisdata/X_train.csv'))\n",
-        "y = Dataset.Tabular.from_delimited_files(path=ds.path('irisdata/y_train.csv'))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Train\n",
-        "\n",
-        "You can specify `automl_settings` as `**kwargs` as well. Also note that you can use a `get_data()` function for local excutions too.\n",
-        "\n",
-        "**Note:** Set the parameter enable_onnx_compatible_models=True, if you also want to generate the ONNX compatible models. Please note, the forecasting task and TensorFlow models are not ONNX compatible yet.\n",
-        "\n",
-        "**Note:** When using AmlCompute, you can't pass Numpy arrays directly to the fit method.\n",
-        "\n",
-        "|Property|Description|\n",
-        "|-|-|\n",
-        "|**primary_metric**|This is the metric that you want to optimize. Classification supports the following primary metrics: <br><i>accuracy</i><br><i>AUC_weighted</i><br><i>average_precision_score_weighted</i><br><i>norm_macro_recall</i><br><i>precision_score_weighted</i>|\n",
-        "|**iteration_timeout_minutes**|Time limit in minutes for each iteration.|\n",
-        "|**iterations**|Number of iterations. In each iteration AutoML trains a specific pipeline with the data.|\n",
-        "|**n_cross_validations**|Number of cross validation splits.|\n",
-        "|**max_concurrent_iterations**|Maximum number of iterations that would be executed in parallel. This should be less than the number of cores on the DSVM.|\n",
-        "|**enable_onnx_compatible_models**|Enable the ONNX compatible models in the experiment.|"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Set the preprocess=True,  currently the InferenceHelper only supports this mode."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "automl_settings = {\n",
-        "    \"iteration_timeout_minutes\": 10,\n",
-        "    \"iterations\": 10,\n",
-        "    \"n_cross_validations\": 5,\n",
-        "    \"primary_metric\": 'AUC_weighted',\n",
-        "    \"preprocess\": True,\n",
-        "    \"max_concurrent_iterations\": 5,\n",
-        "    \"verbosity\": logging.INFO\n",
-        "}\n",
-        "\n",
-        "automl_config = AutoMLConfig(task = 'classification',\n",
-        "                             debug_log = 'automl_errors.log',\n",
-        "                             path = project_folder,\n",
-        "                             run_configuration=conda_run_config,\n",
-        "                             X = X,\n",
-        "                             y = y,\n",
-        "                             enable_onnx_compatible_models=True, # This will generate ONNX compatible models.\n",
-        "                             **automl_settings\n",
-        "                            )"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Call the `submit` method on the experiment object and pass the run configuration. For remote runs the execution is asynchronous, so you will see the iterations get populated as they complete. You can interact with the widgets and models even when the experiment is running to retrieve the best model up to that point. Once you are satisfied with the model, you can cancel a particular iteration or the whole run.\n",
-        "In this example, we specify `show_output = False` to suppress console output while the run is in progress."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "remote_run = experiment.submit(automl_config, show_output = False)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "remote_run"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Results\n",
-        "\n",
-        "#### Loading executed runs\n",
-        "In case you need to load a previously executed run, enable the cell below and replace the `run_id` value."
-      ]
-    },
-    {
-      "cell_type": "raw",
-      "metadata": {},
-      "source": [
-        "remote_run = AutoMLRun(experiment = experiment, run_id = 'AutoML_5db13491-c92a-4f1d-b622-8ab8d973a058')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Widget for Monitoring Runs\n",
-        "\n",
-        "The widget will first report a \"loading\" status while running the first iteration. After completing the first iteration, an auto-updating graph and table will be shown. The widget will refresh once per minute, so you should see the graph update as child runs complete.\n",
-        "\n",
-        "You can click on a pipeline to see run properties and output logs.  Logs are also available on the DSVM under `/tmp/azureml_run/{iterationid}/azureml-logs`\n",
-        "\n",
-        "**Note:** The widget displays a link at the bottom. Use this link to open a web interface to explore the individual run details."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "remote_run"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.widgets import RunDetails\n",
-        "RunDetails(remote_run).show() "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Wait until the run finishes.\n",
-        "remote_run.wait_for_completion(show_output = True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Cancelling Runs\n",
-        "\n",
-        "You can cancel ongoing remote runs using the `cancel` and `cancel_iteration` functions."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Cancel the ongoing experiment and stop scheduling new iterations.\n",
-        "# remote_run.cancel()\n",
-        "\n",
-        "# Cancel iteration 1 and move onto iteration 2.\n",
-        "# remote_run.cancel_iteration(1)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Retrieve the Best ONNX Model\n",
-        "\n",
-        "Below we select the best pipeline from our iterations. The `get_output` method returns the best run and the fitted model. The Model includes the pipeline and any pre-processing.  Overloads on `get_output` allow you to retrieve the best run and fitted model for *any* logged metric or for a particular *iteration*.\n",
-        "\n",
-        "Set the parameter return_onnx_model=True to retrieve the best ONNX model, instead of the Python model."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "best_run, onnx_mdl = remote_run.get_output(return_onnx_model=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Save the best ONNX model"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.automl.core.onnx_convert import OnnxConverter\n",
-        "onnx_fl_path = \"./best_model.onnx\"\n",
-        "OnnxConverter.save_onnx_model(onnx_mdl, onnx_fl_path)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Predict with the ONNX model, using onnxruntime package"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import sys\n",
-        "import json\n",
-        "from azureml.automl.core.onnx_convert import OnnxConvertConstants\n",
-        "from azureml.train.automl import constants\n",
-        "\n",
-        "if sys.version_info < OnnxConvertConstants.OnnxIncompatiblePythonVersion:\n",
-        "    python_version_compatible = True\n",
-        "else:\n",
-        "    python_version_compatible = False\n",
-        "\n",
-        "try:\n",
-        "    import onnxruntime\n",
-        "    from azureml.automl.core.onnx_convert import OnnxInferenceHelper    \n",
-        "    onnxrt_present = True\n",
-        "except ImportError:\n",
-        "    onnxrt_present = False\n",
-        "\n",
-        "def get_onnx_res(run):\n",
-        "    res_path = 'onnx_resource.json'\n",
-        "    run.download_file(name=constants.MODEL_RESOURCE_PATH_ONNX, output_file_path=res_path)\n",
-        "    with open(res_path) as f:\n",
-        "        return json.load(f)\n",
-        "\n",
-        "if onnxrt_present and python_version_compatible:    \n",
-        "    mdl_bytes = onnx_mdl.SerializeToString()\n",
-        "    onnx_res = get_onnx_res(best_run)\n",
-        "\n",
-        "    onnxrt_helper = OnnxInferenceHelper(mdl_bytes, onnx_res)\n",
-        "    pred_onnx, pred_prob_onnx = onnxrt_helper.predict(X_test)\n",
-        "\n",
-        "    print(pred_onnx)\n",
-        "    print(pred_prob_onnx)\n",
-        "else:\n",
-        "    if not python_version_compatible:\n",
-        "        print('Please use Python version 3.6 or 3.7 to run the inference helper.')    \n",
-        "    if not onnxrt_present:\n",
-        "        print('Please install the onnxruntime package to do the prediction with ONNX model.')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "savitam"
-      }
-    ],
-    "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/automated-machine-learning/remote-amlcompute-with-onnx/auto-ml-remote-amlcompute-with-onnx.yml

@@ -1,11 +0,0 @@
-name: auto-ml-remote-amlcompute-with-onnx
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-defaults
-  - azureml-explain-model
-  - azureml-train-automl
-  - azureml-widgets
-  - matplotlib
-  - pandas_ml
-  - onnxruntime

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

@@ -74,6 +74,7 @@
       "source": [
         "import logging\n",
         "import os\n",
+        "import csv\n",
         "\n",
         "from matplotlib import pyplot as plt\n",
         "import numpy as np\n",
@@ -83,7 +84,6 @@
         "import azureml.core\n",
         "from azureml.core.experiment import Experiment\n",
         "from azureml.core.workspace import Workspace\n",
-        "from azureml.core.dataset import Dataset\n",
         "from azureml.train.automl import AutoMLConfig"
       ]
     },
@@ -136,7 +136,7 @@
         "from azureml.core.compute import ComputeTarget\n",
         "\n",
         "# Choose a name for your cluster.\n",
-        "amlcompute_cluster_name = \"automlc2\"\n",
+        "amlcompute_cluster_name = \"cpu-cluster\"\n",
         "\n",
         "found = False\n",
         "# Check if this compute target already exists in the workspace.\n",
@@ -155,12 +155,11 @@
         "    # Create the cluster.\\n\",\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
         "\n",
-        "print('Checking cluster status...')\n",
-        "# Can poll for a minimum number of nodes and for a specific timeout.\n",
-        "# If no min_node_count is provided, it will use the scale settings for the cluster.\n",
-        "compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
+        "    # Can poll for a minimum number of nodes and for a specific timeout.\n",
+        "    # If no min_node_count is provided, it will use the scale settings for the cluster.\n",
+        "    compute_target.wait_for_completion(show_output = True, min_node_count = None, timeout_in_minutes = 20)\n",
         "\n",
-        "# For a more detailed view of current AmlCompute status, use get_status()."
+        "     # For a more detailed view of current AmlCompute status, use get_status()."
       ]
     },
     {
@@ -187,11 +186,18 @@
         "if not os.path.exists(project_folder):\n",
         "    os.makedirs(project_folder)\n",
         "    \n",
-        "pd.DataFrame(data_train.data[100:,:]).to_csv(\"data/X_train.csv\", index=False)\n",
-        "pd.DataFrame(data_train.target[100:]).to_csv(\"data/y_train.csv\", index=False)\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='digitsdata', overwrite=True, show_progress=True)"
+        "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)"
       ]
     },
     {
@@ -202,7 +208,6 @@
       "source": [
         "from azureml.core.runconfig import RunConfiguration\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "import pkg_resources\n",
         "\n",
         "# create a new RunConfig object\n",
         "conda_run_config = RunConfiguration(framework=\"python\")\n",
@@ -210,28 +215,30 @@
         "# Set compute target to AmlCompute\n",
         "conda_run_config.target = compute_target\n",
         "conda_run_config.environment.docker.enabled = True\n",
+        "conda_run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE\n",
         "\n",
-        "cd = CondaDependencies.create(conda_packages=['numpy','py-xgboost<=0.80'])\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','py-xgboost<=0.80'])\n",
         "conda_run_config.environment.python.conda_dependencies = cd"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "###  Creating TabularDataset\n",
-        "\n",
-        "Defined X and y as `TabularDataset`s, which are passed to Automated ML in the AutoMLConfig. `from_delimited_files` by default sets the `infer_column_types` to true, which will infer the columns type automatically. If you do wish to manually set the column types, you can set the `set_column_types` argument to manually set the type of each columns."
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
       "metadata": {},
       "outputs": [],
       "source": [
-        "X = Dataset.Tabular.from_delimited_files(path=ds.path('digitsdata/X_train.csv'))\n",
-        "y = Dataset.Tabular.from_delimited_files(path=ds.path('digitsdata/y_train.csv'))"
+        "%%writefile $project_folder/get_data.py\n",
+        "\n",
+        "import pandas as pd\n",
+        "\n",
+        "def get_data():\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.values, \"y\" : y_train[0].values }\n"
       ]
     },
     {
@@ -273,8 +280,7 @@
         "                             debug_log = 'automl_errors.log',\n",
         "                             path = project_folder,\n",
         "                             run_configuration=conda_run_config,\n",
-        "                             X = X,\n",
-        "                             y = y,\n",
+        "                             data_script = project_folder + \"/get_data.py\",\n",
         "                             **automl_settings\n",
         "                            )\n"
       ]

how-to-use-azureml/automated-machine-learning/remote-amlcompute/auto-ml-remote-amlcompute.yml

@@ -2,8 +2,6 @@ name: auto-ml-remote-amlcompute
 dependencies:
 - pip:
   - azureml-sdk
-  - azureml-defaults
-  - azureml-explain-model
   - azureml-train-automl
   - azureml-widgets
   - matplotlib

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

@@ -1,113 +0,0 @@
-# Table of Contents
-1. [Introduction](#introduction)
-1. [Setup using Azure Data Studio](#azuredatastudiosetup)
-1. [Energy demand example using Azure Data Studio](#azuredatastudioenergydemand)
-1. [Set using SQL Server Management Studio for SQL Server 2017 on Windows](#ssms2017)
-1. [Set using SQL Server Management Studio for SQL Server 2019 on Linux](#ssms2019)
-1. [Energy demand example using SQL Server Management Studio](#ssmsenergydemand)
-
-
-<a name="introduction"></a>
-# Introduction
-SQL Server 2017 or 2019 can call Azure ML automated machine learning to create models trained on data from SQL Server.
-This uses the sp_execute_external_script stored procedure, which can call Python scripts.
-SQL Server 2017 and SQL Server 2019 can both run on Windows or Linux.
-However, this integration is not available for SQL Server 2017 on Linux. 
-
-This folder shows how to setup the integration and has a sample that uses the integration to train and predict based on an energy demand dataset.
-
-This integration is part of SQL Server and so can be used from any SQL client. 
-These instructions show using it from Azure Data Studio or SQL Server Managment Studio.
-
-<a name="azuredatastudiosetup"></a>
-## Setup using Azure Data Studio
-
-These step show setting up the integration using Azure Data Studio.
-
-1. If you don't already have SQL Server, you can install it from [https://www.microsoft.com/en-us/sql-server/sql-server-downloads](https://www.microsoft.com/en-us/sql-server/sql-server-downloads)
-1. Install Azure Data Studio from [https://docs.microsoft.com/en-us/sql/azure-data-studio/download?view=sql-server-2017](https://docs.microsoft.com/en-us/sql/azure-data-studio/download?view=sql-server-2017)
-1. Start Azure Data Studio and connect to SQL Server. [https://docs.microsoft.com/en-us/sql/azure-data-studio/sql-notebooks?view=sql-server-2017](https://docs.microsoft.com/en-us/sql/azure-data-studio/sql-notebooks?view=sql-server-2017)
-1. Create a database named "automl".
-1. Open the notebook how-to-use-azureml\automated-machine-learning\sql-server\setup\auto-ml-sql-setup.ipynb and follow the instructions in it.
-
- <a name="azuredatastudioenergydemand"></a>
-## Energy demand example using Azure Data Studio
-
-Once you have completed the setup, you can try the energy demand sample in the notebook energy-demand\auto-ml-sql-energy-demand.ipynb.
-This has cells to train a model, predict based on the model and show metrics for each pipeline run in training the model.
-
-<a name="ssms2017"></a>
-## Setup using SQL Server Management Studio for SQL Server 2017 on Windows
-
-These instruction setup the integration for SQL Server 2017 on Windows.
-
-1. If you don't already have SQL Server, you can install it from [https://www.microsoft.com/en-us/sql-server/sql-server-downloads](https://www.microsoft.com/en-us/sql-server/sql-server-downloads)
-2. Enable external scripts with the following commands: 
-```sh
-   sp_configure 'external scripts enabled',1 
-   reconfigure with override
-```
-3. Stop SQL Server. 
-4. Install the automated machine learning libraries using the following commands from Administrator command prompt (If you are using a non-default SQL Server instance name, replace MSSQLSERVER in the second command with the instance name)
-```sh
-   cd "C:\Program Files\Microsoft SQL Server"
-   cd "MSSQL14.MSSQLSERVER\PYTHON_SERVICES"
-   python.exe -m pip install azureml-sdk[automl]
-   python.exe -m pip install --upgrade numpy
-   python.exe -m pip install --upgrade sklearn
-```
-5. Start SQL Server and the service "SQL Server Launchpad service". 
-6. In Windows Firewall, click on advanced settings and in Outbound Rules, disable "Block network access for R local user accounts in SQL Server instance xxxx". 
-7. Execute the files in the setup folder in SQL Server Management Studio: aml_model.sql, aml_connection.sql, AutoMLGetMetrics.sql, AutoMLPredict.sql and AutoMLTrain.sql 
-8. Create an Azure Machine Learning Workspace.  You can use the instructions at: [https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-workspace ](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-workspace)
-9. Create a config.json file file using the subscription id, resource group name and workspace name that you used to create the workspace.  The file is described at: [https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-environment#workspace](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-environment#workspace)
-10. Create an Azure service principal.  You can do this with the commands: 
-```sh
-   az login 
-   az account set --subscription subscriptionid 
-   az ad sp create-for-rbac --name principlename --password password 
-```
-11. Insert the values \<tenant\>, \<AppId\> and \<password\> returned by create-for-rbac above into the aml_connection table.  Set \<path\> as the absolute path to your config.json file. Set the name to “Default”. 
- 
-<a name="ssms2019"></a>
-## Setup using SQL Server Management Studio for SQL Server 2019 on Linux
-1. Install SQL Server 2019 from: [https://www.microsoft.com/en-us/sql-server/sql-server-downloads](https://www.microsoft.com/en-us/sql-server/sql-server-downloads)
-2. Install machine learning support from: [https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-machine-learning?view=sqlallproducts-allversions#ubuntu](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-machine-learning?view=sqlallproducts-allversions#ubuntu)
-3. Then install SQL Server management Studio from [https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-2017](https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-2017)
-4. Enable external scripts with the following commands: 
-```sh
-   sp_configure 'external scripts enabled',1 
-   reconfigure with override 
-```
-5. Stop SQL Server. 
-6. Install the automated machine learning libraries using the following commands from Administrator command (If you are using a non-default SQL Server instance name, replace MSSQLSERVER in the second command with the instance name): 
-```sh
-   sudo /opt/mssql/mlservices/bin/python/python -m pip install azureml-sdk[automl] 
-   sudo /opt/mssql/mlservices/bin/python/python -m pip install --upgrade numpy 
-   sudo /opt/mssql/mlservices/bin/python/python -m pip install --upgrade sklearn
-```
-7. Start SQL Server. 
-8. Execute the files aml_model.sql, aml_connection.sql, AutoMLGetMetrics.sql, AutoMLPredict.sql, AutoMLForecast.sql and AutoMLTrain.sql in SQL Server Management Studio. 
-9. Create an Azure Machine Learning Workspace.  You can use the instructions at: [https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-workspace](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-workspace)
-10. Create a config.json file file using the subscription id, resource group name and workspace name that you use to create the workspace.  The file is described at: [https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-environment#workspace](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-environment#workspace)
-11. Create an Azure service principal.  You can do this with the commands: 
-```sh
-   az login 
-   az account set --subscription subscriptionid 
-   az ad sp create-for-rbac --name principlename --password password 
-``` 
-12. Insert the values \<tenant\>, \<AppId\> and \<password\> returned by create-for-rbac above into the aml_connection table.  Set \<path\> as the absolute path to your config.json file. Set the name to “Default”. 
- 
-<a name="ssmsenergydemand"></a>
-## Energy demand example using SQL Server Management Studio
-
-Once you have completed the setup, you can try the energy demand sample queries.
-First you need to load the sample data in the database.
-1. In SQL Server Management Studio, you can right-click the database, select Tasks, then Import Flat file. 
-1. Select the file MachineLearningNotebooks\notebooks\how-to-use-azureml\automated-machine-learning\forecasting-energy-demand\nyc_energy.csv. 
-1. When you get to the column definition page, allow nulls for all columns. 
-
-You can then run the queries in the energy-demand folder:
-* TrainEnergyDemand.sql runs AutoML, trains multiple models on data and selects the best model.
-* ForecastEnergyDemand.sql forecasts based on the most recent training run.
-* GetMetrics.sql returns all the metrics for each model in the most recent training run.

how-to-use-azureml/automated-machine-learning/sql-server/energy-demand/ForecastEnergyDemand.sql

@@ -1,23 +0,0 @@
--- This shows using the AutoMLForecast stored procedure to predict using a forecasting model for the nyc_energy dataset.
-
-DECLARE @Model NVARCHAR(MAX) = (SELECT TOP 1 Model FROM dbo.aml_model
-                                WHERE ExperimentName = 'automl-sql-forecast'
-								ORDER BY CreatedDate DESC)
-
-DECLARE @max_horizon INT = 48
-DECLARE @split_time NVARCHAR(22) = (SELECT DATEADD(hour, -@max_horizon, MAX(timeStamp)) FROM nyc_energy WHERE demand IS NOT NULL)
-
-DECLARE @TestDataQuery NVARCHAR(MAX) = '
-SELECT CAST(timeStamp AS NVARCHAR(30)) AS timeStamp,
-       demand,
-	   precip,
-	   temp
-FROM nyc_energy
-WHERE demand IS NOT NULL AND precip IS NOT NULL AND temp IS NOT NULL
-AND timeStamp > ''' + @split_time + ''''
-
-EXEC dbo.AutoMLForecast @input_query=@TestDataQuery,
-@label_column='demand',
-@time_column_name='timeStamp',
-@model=@model
-WITH RESULT SETS ((timeStamp DATETIME, grain NVARCHAR(255), predicted_demand FLOAT, precip FLOAT, temp FLOAT, actual_demand FLOAT))

how-to-use-azureml/automated-machine-learning/sql-server/energy-demand/GetMetrics.sql

@@ -1,10 +0,0 @@
--- This lists all the metrics for all iterations for the most recent run.
-
-DECLARE @RunId NVARCHAR(43)
-DECLARE @ExperimentName NVARCHAR(255)
-
-SELECT TOP 1 @ExperimentName=ExperimentName, @RunId=SUBSTRING(RunId, 1, 43)
-FROM aml_model
-ORDER BY CreatedDate DESC
-
-EXEC dbo.AutoMLGetMetrics @RunId, @ExperimentName

how-to-use-azureml/automated-machine-learning/sql-server/energy-demand/PredictEnergyDemand.sql

@@ -1,17 +0,0 @@
--- This shows using the AutoMLPredict stored procedure to predict using a forecasting model for the nyc_energy dataset.
-
-DECLARE @Model NVARCHAR(MAX) = (SELECT TOP 1 Model FROM dbo.aml_model
-                                WHERE ExperimentName = 'automl-sql-forecast'
-								ORDER BY CreatedDate DESC)
-
-EXEC dbo.AutoMLPredict @input_query='
-SELECT CAST(timeStamp AS NVARCHAR(30)) AS timeStamp,
-       demand,
-	   precip,
-	   temp
-FROM nyc_energy
-WHERE demand IS NOT NULL AND precip IS NOT NULL AND temp IS NOT NULL
-AND timeStamp >= ''2017-02-01''',
-@label_column='demand',
-@model=@model
-WITH RESULT SETS ((timeStamp NVARCHAR(30), actual_demand FLOAT, precip FLOAT, temp FLOAT, predicted_demand FLOAT))

how-to-use-azureml/automated-machine-learning/sql-server/energy-demand/TrainEnergyDemand.sql

@@ -1,25 +0,0 @@
--- This shows using the AutoMLTrain stored procedure to create a forecasting model for the nyc_energy dataset.
-
-DECLARE @max_horizon INT = 48
-DECLARE @split_time NVARCHAR(22) = (SELECT DATEADD(hour, -@max_horizon, MAX(timeStamp)) FROM nyc_energy WHERE demand IS NOT NULL)
-
-DECLARE @TrainDataQuery NVARCHAR(MAX) = '
-SELECT CAST(timeStamp as NVARCHAR(30)) as timeStamp,
-       demand,
-	   precip,
-	   temp
-FROM nyc_energy
-WHERE demand IS NOT NULL AND precip IS NOT NULL AND temp IS NOT NULL
-and timeStamp < ''' + @split_time + ''''
-
-INSERT INTO dbo.aml_model(RunId, ExperimentName, Model, LogFileText, WorkspaceName)
-EXEC dbo.AutoMLTrain @input_query= @TrainDataQuery,
-@label_column='demand',
-@task='forecasting',
-@iterations=10,
-@iteration_timeout_minutes=5,
-@time_column_name='timeStamp',
-@max_horizon=@max_horizon,
-@experiment_name='automl-sql-forecast',
-@primary_metric='normalized_root_mean_squared_error'
-

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

@@ -1,141 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Train a model and use it for prediction\r\n",
-        "\r\n",
-        "Before running this notebook, run the auto-ml-sql-setup.ipynb notebook."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/automated-machine-learning/sql-server/energy-demand/auto-ml-sql-energy-demand.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Set the default database"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "USE [automl]\r\n",
-        "GO"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Use the AutoMLTrain stored procedure to create a forecasting model for the nyc_energy dataset."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "INSERT INTO dbo.aml_model(RunId, ExperimentName, Model, LogFileText, WorkspaceName)\r\n",
-        "EXEC dbo.AutoMLTrain @input_query='\r\n",
-        "SELECT CAST(timeStamp as NVARCHAR(30)) as timeStamp,\r\n",
-        "       demand,\r\n",
-        "\t   precip,\r\n",
-        "\t   temp,\r\n",
-        "\t   CASE WHEN timeStamp < ''2017-01-01'' THEN 0 ELSE 1 END AS is_validate_column\r\n",
-        "FROM nyc_energy\r\n",
-        "WHERE demand IS NOT NULL AND precip IS NOT NULL AND temp IS NOT NULL\r\n",
-        "and timeStamp < ''2017-02-01''',\r\n",
-        "@label_column='demand',\r\n",
-        "@task='forecasting',\r\n",
-        "@iterations=10,\r\n",
-        "@iteration_timeout_minutes=5,\r\n",
-        "@time_column_name='timeStamp',\r\n",
-        "@is_validate_column='is_validate_column',\r\n",
-        "@experiment_name='automl-sql-forecast',\r\n",
-        "@primary_metric='normalized_root_mean_squared_error'"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Use the AutoMLPredict stored procedure to predict using the forecasting model for the nyc_energy dataset."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "DECLARE @Model NVARCHAR(MAX) = (SELECT TOP 1 Model FROM dbo.aml_model\r\n",
-        "                                WHERE ExperimentName = 'automl-sql-forecast'\r\n",
-        "\t\t\t\t\t\t\t\tORDER BY CreatedDate DESC)\r\n",
-        "\r\n",
-        "EXEC dbo.AutoMLPredict @input_query='\r\n",
-        "SELECT CAST(timeStamp AS NVARCHAR(30)) AS timeStamp,\r\n",
-        "       demand,\r\n",
-        "\t   precip,\r\n",
-        "\t   temp\r\n",
-        "FROM nyc_energy\r\n",
-        "WHERE demand IS NOT NULL AND precip IS NOT NULL AND temp IS NOT NULL\r\n",
-        "AND timeStamp >= ''2017-02-01''',\r\n",
-        "@label_column='demand',\r\n",
-        "@model=@model\r\n",
-        "WITH RESULT SETS ((timeStamp NVARCHAR(30), actual_demand FLOAT, precip FLOAT, temp FLOAT, predicted_demand FLOAT))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## List all the metrics for all iterations for the most recent training run."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "DECLARE @RunId NVARCHAR(43)\r\n",
-        "DECLARE @ExperimentName NVARCHAR(255)\r\n",
-        "\r\n",
-        "SELECT TOP 1 @ExperimentName=ExperimentName, @RunId=SUBSTRING(RunId, 1, 43)\r\n",
-        "FROM aml_model\r\n",
-        "ORDER BY CreatedDate DESC\r\n",
-        "\r\n",
-        "EXEC dbo.AutoMLGetMetrics @RunId, @ExperimentName"
-      ]
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "jeffshep"
-      }
-    ],
-    "kernelspec": {
-      "display_name": "Python 3.6",
-      "language": "sql",
-      "name": "python36"
-    },
-    "language_info": {
-      "name": "sql",
-      "version": ""
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

how-to-use-azureml/automated-machine-learning/sql-server/setup/AutoMLForecast.sql

@@ -1,92 +0,0 @@
--- This procedure forecast values based on a forecasting model returned by AutoMLTrain.
--- It returns a dataset with the forecasted values.
-SET ANSI_NULLS ON
-GO
-SET QUOTED_IDENTIFIER ON
-GO
-CREATE OR ALTER PROCEDURE [dbo].[AutoMLForecast]
- (
-   @input_query NVARCHAR(MAX),          -- A SQL query returning data to predict on.
-   @model NVARCHAR(MAX),                -- A model returned from AutoMLTrain.
-   @time_column_name  NVARCHAR(255)='', -- The name of the timestamp column for forecasting.
-   @label_column  NVARCHAR(255)='',     -- Optional name of the column from input_query, which should be ignored when predicting
-   @y_query_column NVARCHAR(255)='',    -- Optional value column that can be used for predicting.
-                                        -- If specified, this can contain values for past times (after the model was trained)
-									    -- and contain Nan for future times.
-   @forecast_column_name NVARCHAR(255) = 'predicted'
-                                        -- The name of the output column containing the forecast value.
- ) AS 
-BEGIN 
-  
-    EXEC sp_execute_external_script @language = N'Python', @script = N'import pandas as pd 
-import azureml.core  
-import numpy as np 
-from azureml.train.automl import AutoMLConfig  
-import pickle 
-import codecs 
-  
-model_obj = pickle.loads(codecs.decode(model.encode(), "base64")) 
-  
-test_data = input_data.copy() 
-
-if label_column != "" and label_column is not None:
-    y_test = test_data.pop(label_column).values
-else:
-    y_test = None 
-
-if y_query_column != "" and y_query_column is not None:
-    y_query = test_data.pop(y_query_column).values
-else:
-    y_query = np.repeat(np.nan, len(test_data))
-
-X_test = test_data 
-
-if time_column_name != "" and time_column_name is not None:
-    X_test[time_column_name] = pd.to_datetime(X_test[time_column_name])
-
-y_fcst, X_trans = model_obj.forecast(X_test, y_query) 
-
-def align_outputs(y_forecast, X_trans, X_test, y_test, forecast_column_name):
-    # Demonstrates how to get the output aligned to the inputs
-    # using pandas indexes. Helps understand what happened if
-    # the output shape differs from the input shape, or if
-    # the data got re-sorted by time and grain during forecasting.
-    
-    # Typical causes of misalignment are:
-    # * we predicted some periods that were missing in actuals -> drop from eval
-    # * model was asked to predict past max_horizon -> increase max horizon
-    # * data at start of X_test was needed for lags -> provide previous periods
-
-    df_fcst = pd.DataFrame({forecast_column_name : y_forecast})
-    # y and X outputs are aligned by forecast() function contract
-    df_fcst.index = X_trans.index
-    
-    # align original X_test to y_test    
-    X_test_full = X_test.copy()
-    if y_test is not None:
-        X_test_full[label_column] = y_test
-
-    # X_test_full does not include origin, so reset for merge
-    df_fcst.reset_index(inplace=True)
-    X_test_full = X_test_full.reset_index().drop(columns=''index'')
-    together = df_fcst.merge(X_test_full, how=''right'')
-    
-    # drop rows where prediction or actuals are nan 
-    # happens because of missing actuals 
-    # or at edges of time due to lags/rolling windows
-    clean = together[together[[label_column, forecast_column_name]].notnull().all(axis=1)]
-    return(clean)
-
-combined_output = align_outputs(y_fcst, X_trans, X_test, y_test, forecast_column_name)
-  
-' 
-    , @input_data_1 = @input_query 
-    , @input_data_1_name = N'input_data' 
-    , @output_data_1_name = N'combined_output' 
-    , @params = N'@model NVARCHAR(MAX), @time_column_name  NVARCHAR(255), @label_column NVARCHAR(255), @y_query_column NVARCHAR(255), @forecast_column_name NVARCHAR(255)' 
-    , @model = @model 
-	, @time_column_name = @time_column_name
-	, @label_column = @label_column
-	, @y_query_column = @y_query_column
-	, @forecast_column_name = @forecast_column_name
-END

how-to-use-azureml/automated-machine-learning/sql-server/setup/AutoMLGetMetrics.sql

@@ -1,70 +0,0 @@
--- This procedure returns a list of metrics for each iteration of a run.
-SET ANSI_NULLS ON
-GO
-SET QUOTED_IDENTIFIER ON
-GO
-CREATE OR ALTER PROCEDURE [dbo].[AutoMLGetMetrics]
- (
-	@run_id NVARCHAR(250),                           -- The RunId
-    @experiment_name NVARCHAR(32)='automl-sql-test', -- This can be used to find the experiment in the Azure Portal.
-    @connection_name NVARCHAR(255)='default'         -- The AML connection to use.
- ) AS
-BEGIN
-    DECLARE @tenantid NVARCHAR(255)
-    DECLARE @appid NVARCHAR(255)
-    DECLARE @password NVARCHAR(255)
-    DECLARE @config_file NVARCHAR(255)
-
-	SELECT @tenantid=TenantId, @appid=AppId, @password=Password, @config_file=ConfigFile
-	FROM aml_connection
-	WHERE ConnectionName = @connection_name;
-
-    EXEC sp_execute_external_script @language = N'Python', @script = N'import pandas as pd
-import logging 
-import azureml.core 
-import numpy as np
-from azureml.core.experiment import Experiment 
-from azureml.train.automl.run import AutoMLRun
-from azureml.core.authentication import ServicePrincipalAuthentication 
-from azureml.core.workspace import Workspace 
-
-auth = ServicePrincipalAuthentication(tenantid, appid, password) 
- 
-ws = Workspace.from_config(path=config_file, auth=auth) 
- 
-experiment = Experiment(ws, experiment_name) 
-
-ml_run = AutoMLRun(experiment = experiment, run_id = run_id)
-
-children = list(ml_run.get_children())
-iterationlist = []
-metricnamelist = []
-metricvaluelist = []
-
-for run in children:
-    properties = run.get_properties()
-    if "iteration" in properties:
-        iteration = int(properties["iteration"])
-        for metric_name, metric_value in run.get_metrics().items():
-            if isinstance(metric_value, float):
-                iterationlist.append(iteration)
-                metricnamelist.append(metric_name)
-                metricvaluelist.append(metric_value)
-             
-metrics = pd.DataFrame({"iteration": iterationlist, "metric_name": metricnamelist, "metric_value": metricvaluelist})
-'
-    , @output_data_1_name = N'metrics'
-	, @params = N'@run_id NVARCHAR(250), 
-				  @experiment_name NVARCHAR(32),
-  				  @tenantid NVARCHAR(255),
-				  @appid NVARCHAR(255),
-				  @password NVARCHAR(255),
-				  @config_file NVARCHAR(255)'
-    , @run_id = @run_id
-	, @experiment_name = @experiment_name
-	, @tenantid = @tenantid
-	, @appid = @appid
-	, @password = @password
-	, @config_file = @config_file
-WITH RESULT SETS ((iteration INT, metric_name NVARCHAR(100), metric_value FLOAT))
-END

how-to-use-azureml/automated-machine-learning/sql-server/setup/AutoMLPredict.sql

@@ -1,41 +0,0 @@
--- This procedure predicts values based on a model returned by AutoMLTrain and a dataset.
--- It returns the dataset with a new column added, which is the predicted value.
-SET ANSI_NULLS ON
-GO
-SET QUOTED_IDENTIFIER ON
-GO
-CREATE OR ALTER PROCEDURE [dbo].[AutoMLPredict]
- (
-   @input_query NVARCHAR(MAX),      -- A SQL query returning data to predict on.
-   @model NVARCHAR(MAX),            -- A model returned from AutoMLTrain.
-   @label_column  NVARCHAR(255)=''  -- Optional name of the column from input_query, which should be ignored when predicting
- ) AS 
-BEGIN 
-  
-    EXEC sp_execute_external_script @language = N'Python', @script = N'import pandas as pd 
-import azureml.core  
-import numpy as np 
-from azureml.train.automl import AutoMLConfig  
-import pickle 
-import codecs 
-  
-model_obj = pickle.loads(codecs.decode(model.encode(), "base64")) 
-  
-test_data = input_data.copy() 
-
-if label_column != "" and label_column is not None:
-    y_test = test_data.pop(label_column).values 
-X_test = test_data 
-  
-predicted = model_obj.predict(X_test) 
-  
-combined_output = input_data.assign(predicted=predicted)
-  
-' 
-    , @input_data_1 = @input_query 
-    , @input_data_1_name = N'input_data' 
-    , @output_data_1_name = N'combined_output' 
-    , @params = N'@model NVARCHAR(MAX), @label_column  NVARCHAR(255)' 
-    , @model = @model 
-	, @label_column = @label_column
-END

how-to-use-azureml/automated-machine-learning/sql-server/setup/AutoMLTrain.sql

@@ -1,240 +0,0 @@
--- This stored procedure uses automated machine learning to train several models
--- and returns the best model.
---
--- The result set has several columns:
---   best_run - iteration ID for the best model
---   experiment_name - experiment name pass in with the @experiment_name parameter
---   fitted_model - best model found
---   log_file_text - AutoML debug_log contents
---   workspace - name of the Azure ML workspace where run history is stored
---
--- An example call for a classification problem is:
---    insert into dbo.aml_model(RunId, ExperimentName, Model, LogFileText, WorkspaceName)
---    exec dbo.AutoMLTrain @input_query='
---    SELECT top 100000 
---          CAST([pickup_datetime] AS NVARCHAR(30)) AS pickup_datetime
---          ,CAST([dropoff_datetime] AS NVARCHAR(30)) AS dropoff_datetime
---          ,[passenger_count]
---          ,[trip_time_in_secs]
---          ,[trip_distance]
---          ,[payment_type]
---          ,[tip_class]
---      FROM [dbo].[nyctaxi_sample] order by [hack_license] ',
---      @label_column = 'tip_class',
---      @iterations=10
--- 
--- An example call for forecasting is:
---      insert into dbo.aml_model(RunId, ExperimentName, Model, LogFileText, WorkspaceName)
---      exec dbo.AutoMLTrain @input_query='
---      select cast(timeStamp as nvarchar(30)) as timeStamp,
---             demand,
---      	   precip,
---      	   temp,
---             case when timeStamp < ''2017-01-01'' then 0 else 1 end as is_validate_column
---      from nyc_energy
---      where demand is not null and precip is not null and temp is not null
---      and timeStamp < ''2017-02-01''',
---      @label_column='demand',
---      @task='forecasting',
---      @iterations=10,
---      @iteration_timeout_minutes=5,
---      @time_column_name='timeStamp',
---      @is_validate_column='is_validate_column',
---      @experiment_name='automl-sql-forecast',
---      @primary_metric='normalized_root_mean_squared_error'
-
-SET ANSI_NULLS ON
-GO
-SET QUOTED_IDENTIFIER ON
-GO
-CREATE OR ALTER PROCEDURE [dbo].[AutoMLTrain]
- (
-    @input_query NVARCHAR(MAX),                      -- The SQL Query that will return the data to train and validate the model.
-    @label_column NVARCHAR(255)='Label',             -- The name of the column in the result of @input_query that is the label.
-    @primary_metric NVARCHAR(40)='AUC_weighted',     -- The metric to optimize.
-    @iterations INT=100,                             -- The maximum number of pipelines to train.
-    @task NVARCHAR(40)='classification',             -- The type of task.  Can be classification, regression or forecasting.
-    @experiment_name NVARCHAR(32)='automl-sql-test', -- This can be used to find the experiment in the Azure Portal.
-    @iteration_timeout_minutes INT = 15,             -- The maximum time in minutes for training a single pipeline. 
-    @experiment_timeout_minutes INT = 60,            -- The maximum time in minutes for training all pipelines.
-    @n_cross_validations INT = 3,                    -- The number of cross validations.
-    @blacklist_models NVARCHAR(MAX) = '',            -- A comma separated list of algos that will not be used.
-                                                     -- The list of possible models can be found at:
-                                                     -- https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-auto-train#configure-your-experiment-settings
-    @whitelist_models NVARCHAR(MAX) = '',            -- A comma separated list of algos that can be used.
-                                                     -- The list of possible models can be found at:
-                                                     -- https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-auto-train#configure-your-experiment-settings
-    @experiment_exit_score FLOAT = 0,                -- Stop the experiment if this score is acheived.
-    @sample_weight_column NVARCHAR(255)='',          -- The name of the column in the result of  @input_query that gives a sample weight.
-    @is_validate_column NVARCHAR(255)='',            -- The name of the column in the result of  @input_query that indicates if the row is for training or validation.
-	                                                 -- In the values of the column, 0 means for training and 1 means for validation.
-    @time_column_name  NVARCHAR(255)='',             -- The name of the timestamp column for forecasting.
-    @connection_name NVARCHAR(255)='default',        -- The AML connection to use.
-    @max_horizon INT = 0                             -- A forecast horizon is a time span into the future (or just beyond the latest date in the training data)
-                                                     -- where forecasts of the target quantity are needed.
-                                                     -- For example, if data is recorded daily and max_horizon is 5, we will predict 5 days ahead.
- ) AS
-BEGIN
-
-    DECLARE @tenantid NVARCHAR(255)
-    DECLARE @appid NVARCHAR(255)
-    DECLARE @password NVARCHAR(255)
-    DECLARE @config_file NVARCHAR(255)
-
-	SELECT @tenantid=TenantId, @appid=AppId, @password=Password, @config_file=ConfigFile
-	FROM aml_connection
-	WHERE ConnectionName = @connection_name;
-
-	EXEC sp_execute_external_script @language = N'Python', @script = N'import pandas as pd
-import logging 
-import azureml.core 
-import pandas as pd
-import numpy as np
-from azureml.core.experiment import Experiment 
-from azureml.train.automl import AutoMLConfig 
-from sklearn import datasets 
-import pickle
-import codecs
-from azureml.core.authentication import ServicePrincipalAuthentication 
-from azureml.core.workspace import Workspace 
-
-if __name__.startswith("sqlindb"):
-    auth = ServicePrincipalAuthentication(tenantid, appid, password) 
- 
-    ws = Workspace.from_config(path=config_file, auth=auth) 
- 
-    project_folder = "./sample_projects/" + experiment_name
- 
-    experiment = Experiment(ws, experiment_name) 
-
-    data_train = input_data
-    X_valid = None
-    y_valid = None
-    sample_weight_valid = None
-
-    if is_validate_column != "" and is_validate_column is not None:
-        data_train = input_data[input_data[is_validate_column] <= 0]
-        data_valid = input_data[input_data[is_validate_column] > 0]
-        data_train.pop(is_validate_column)
-        data_valid.pop(is_validate_column)
-        y_valid = data_valid.pop(label_column).values
-        if sample_weight_column != "" and sample_weight_column is not None:
-            sample_weight_valid = data_valid.pop(sample_weight_column).values
-        X_valid = data_valid
-        n_cross_validations = None
-
-    y_train = data_train.pop(label_column).values
-
-    sample_weight = None
-    if sample_weight_column != "" and sample_weight_column is not None:
-        sample_weight = data_train.pop(sample_weight_column).values
-
-    X_train = data_train
-
-    if experiment_timeout_minutes == 0:
-        experiment_timeout_minutes = None
-
-    if experiment_exit_score == 0:
-        experiment_exit_score = None
-
-    if blacklist_models == "":
-        blacklist_models = None
-
-    if blacklist_models is not None:
-        blacklist_models = blacklist_models.replace(" ", "").split(",")
-
-    if whitelist_models == "":
-        whitelist_models = None
-
-    if whitelist_models is not None:
-        whitelist_models = whitelist_models.replace(" ", "").split(",")
-
-    automl_settings = {}
-    preprocess = True
-    if time_column_name != "" and time_column_name is not None:
-        automl_settings = { "time_column_name": time_column_name }
-        preprocess = False
-        if max_horizon > 0:
-            automl_settings["max_horizon"] = max_horizon
-
-    log_file_name = "automl_sqlindb_errors.log"
-	 
-    automl_config = AutoMLConfig(task = task, 
-                                 debug_log = log_file_name, 
-                                 primary_metric = primary_metric, 
-                                 iteration_timeout_minutes = iteration_timeout_minutes, 
-                                 experiment_timeout_minutes = experiment_timeout_minutes,
-                                 iterations = iterations, 
-                                 n_cross_validations = n_cross_validations, 
-                                 preprocess = preprocess,
-                                 verbosity = logging.INFO, 
-                                 X = X_train,  
-                                 y = y_train, 
-                                 path = project_folder,
-                                 blacklist_models = blacklist_models,
-                                 whitelist_models = whitelist_models,
-                                 experiment_exit_score = experiment_exit_score,
-                                 sample_weight = sample_weight,
-                                 X_valid = X_valid,
-                                 y_valid = y_valid,
-                                 sample_weight_valid = sample_weight_valid,
-                                 **automl_settings) 
- 
-    local_run = experiment.submit(automl_config, show_output = True) 
-
-    best_run, fitted_model = local_run.get_output()
-
-    pickled_model = codecs.encode(pickle.dumps(fitted_model), "base64").decode()
-
-    log_file_text = ""
-
-    try:
-        with open(log_file_name, "r") as log_file:
-            log_file_text = log_file.read()
-    except:
-        log_file_text = "Log file not found"
-
-    returned_model = pd.DataFrame({"best_run": [best_run.id], "experiment_name": [experiment_name], "fitted_model": [pickled_model], "log_file_text": [log_file_text], "workspace": [ws.name]}, dtype=np.dtype(np.str))
-'
-	, @input_data_1 = @input_query
-	, @input_data_1_name = N'input_data'
-	, @output_data_1_name = N'returned_model'
-	, @params = N'@label_column NVARCHAR(255), 
-	              @primary_metric NVARCHAR(40),
-				  @iterations INT, @task NVARCHAR(40),
-				  @experiment_name NVARCHAR(32),
-				  @iteration_timeout_minutes INT,
-				  @experiment_timeout_minutes INT,
-				  @n_cross_validations INT,
-				  @blacklist_models NVARCHAR(MAX),
-				  @whitelist_models NVARCHAR(MAX),
-				  @experiment_exit_score FLOAT,
-				  @sample_weight_column NVARCHAR(255),
-				  @is_validate_column NVARCHAR(255),
-				  @time_column_name  NVARCHAR(255),
-				  @tenantid NVARCHAR(255),
-				  @appid NVARCHAR(255),
-				  @password NVARCHAR(255),
-				  @config_file NVARCHAR(255),
-				  @max_horizon INT'
-	, @label_column = @label_column
-	, @primary_metric = @primary_metric
-	, @iterations = @iterations
-	, @task = @task
-	, @experiment_name = @experiment_name
-	, @iteration_timeout_minutes = @iteration_timeout_minutes
-	, @experiment_timeout_minutes = @experiment_timeout_minutes
-	, @n_cross_validations = @n_cross_validations
-	, @blacklist_models = @blacklist_models
-	, @whitelist_models = @whitelist_models
-	, @experiment_exit_score = @experiment_exit_score
-	, @sample_weight_column = @sample_weight_column
-	, @is_validate_column = @is_validate_column
-	, @time_column_name = @time_column_name
-	, @tenantid = @tenantid
-	, @appid = @appid
-	, @password = @password
-	, @config_file = @config_file
-	, @max_horizon = @max_horizon
-WITH RESULT SETS ((best_run NVARCHAR(250), experiment_name NVARCHAR(100), fitted_model VARCHAR(MAX), log_file_text NVARCHAR(MAX), workspace NVARCHAR(100)))
-END

how-to-use-azureml/automated-machine-learning/sql-server/setup/aml_connection.sql

@@ -1,18 +0,0 @@
--- This is a table to store the Azure ML connection information.
-SET ANSI_NULLS ON
-GO
-
-SET QUOTED_IDENTIFIER ON
-GO
-
-CREATE TABLE [dbo].[aml_connection](
-    [Id] [int] IDENTITY(1,1) NOT NULL PRIMARY KEY,
-	[ConnectionName] [nvarchar](255) NULL,
-	[TenantId] [nvarchar](255) NULL,
-	[AppId] [nvarchar](255) NULL,
-	[Password] [nvarchar](255) NULL,
-	[ConfigFile] [nvarchar](255) NULL
-) ON [PRIMARY]
-GO
-
-

how-to-use-azureml/automated-machine-learning/sql-server/setup/aml_model.sql

@@ -1,22 +0,0 @@
--- This is a table to hold the results from the AutoMLTrain procedure.
-SET ANSI_NULLS ON
-GO
-
-SET QUOTED_IDENTIFIER ON
-GO
-
-CREATE TABLE [dbo].[aml_model](
-    [Id] [int] IDENTITY(1,1) NOT NULL PRIMARY KEY,
-    [Model] [varchar](max) NOT NULL,        -- The model, which can be passed to AutoMLPredict for testing or prediction.
-    [RunId] [nvarchar](250) NULL,           -- The RunId, which can be used to view the model in the Azure Portal.
-    [CreatedDate] [datetime] NULL,
-    [ExperimentName] [nvarchar](100) NULL,  -- Azure ML Experiment Name
-    [WorkspaceName] [nvarchar](100) NULL,   -- Azure ML Workspace Name
-	[LogFileText] [nvarchar](max) NULL
-) 
-GO
-
-ALTER TABLE [dbo].[aml_model] ADD  DEFAULT (getutcdate()) FOR [CreatedDate]
-GO
-
-

how-to-use-azureml/automated-machine-learning/sql-server/setup/auto-ml-sql-setup.ipynb

@@ -1,561 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Set up Azure ML Automated Machine Learning on SQL Server 2019 CTP 2.4 big data cluster\r\n",
-        "\r\n",
-        "\\# Prerequisites:  \r\n",
-        "\\# - An Azure subscription and resource group  \r\n",
-        "\\# - An Azure Machine Learning workspace  \r\n",
-        "\\# - A SQL Server 2019 CTP 2.4 big data cluster with Internet access and a database named 'automl'  \r\n",
-        "\\# - Azure CLI  \r\n",
-        "\\# - kubectl command  \r\n",
-        "\\# - The https://github.com/Azure/MachineLearningNotebooks repository downloaded (cloned) to your local machine\r\n",
-        "\r\n",
-        "\\# In the 'automl' database, create a table named 'dbo.nyc_energy' as follows:  \r\n",
-        "\\# - In SQL Server Management Studio, right-click the 'automl' database, select Tasks, then Import Flat File.  \r\n",
-        "\\# - Select the file AzureMlCli\\notebooks\\how-to-use-azureml\\automated-machine-learning\\forecasting-energy-demand\\nyc_energy.csv.  \r\n",
-        "\\# - Using the \"Modify Columns\" page, allow nulls for all columns. \r\n",
-        "\r\n",
-        "\\# Create an Azure Machine Learning Workspace using the instructions at https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-manage-workspace \r\n",
-        "\r\n",
-        "\\# Create an Azure service principal.  You can do this with the following commands: \r\n",
-        "\r\n",
-        "az login  \r\n",
-        "az account set --subscription *subscriptionid*  \r\n",
-        "\r\n",
-        "\\# The following command prints out the **appId** and **tenant**,  \r\n",
-        "\\# which you insert into the indicated cell later in this notebook  \r\n",
-        "\\# to allow AutoML to authenticate with Azure:  \r\n",
-        "\r\n",
-        "az ad sp create-for-rbac --name *principlename* --password *password*\r\n",
-        "\r\n",
-        "\\# Log into the master instance of SQL Server 2019 CTP 2.4:  \r\n",
-        "kubectl exec -it mssql-master-pool-0 -n *clustername* -c mssql-server -- /bin/bash\r\n",
-        "\r\n",
-        "mkdir /tmp/aml\r\n",
-        "\r\n",
-        "cd /tmp/aml\r\n",
-        "\r\n",
-        "\\# **Modify** the following with your subscription_id, resource_group, and workspace_name:  \r\n",
-        "cat > config.json << EOF  \r\n",
-        "{  \r\n",
-        "    \"subscription_id\": \"123456ab-78cd-0123-45ef-abcd12345678\",  \r\n",
-        "    \"resource_group\": \"myrg1\",  \r\n",
-        "    \"workspace_name\": \"myws1\"  \r\n",
-        "}  \r\n",
-        "EOF\r\n",
-        "\r\n",
-        "\\# The directory referenced below is appropriate for the master instance of SQL Server 2019 CTP 2.4.\r\n",
-        "\r\n",
-        "cd /opt/mssql/mlservices/runtime/python/bin\r\n",
-        "\r\n",
-        "./python -m pip install azureml-sdk[automl]\r\n",
-        "\r\n",
-        "./python -m pip install --upgrade numpy \r\n",
-        "\r\n",
-        "./python -m pip install --upgrade sklearn\r\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/automated-machine-learning/sql-server/setup/auto-ml-sql-setup.png)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- Enable external scripts to allow invoking Python\r\n",
-        "sp_configure 'external scripts enabled',1 \r\n",
-        "reconfigure with override \r\n",
-        "GO\r\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- Use database 'automl'\r\n",
-        "USE [automl]\r\n",
-        "GO"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- This is a table to hold the Azure ML connection information.\r\n",
-        "SET ANSI_NULLS ON\r\n",
-        "GO\r\n",
-        "\r\n",
-        "SET QUOTED_IDENTIFIER ON\r\n",
-        "GO\r\n",
-        "\r\n",
-        "CREATE TABLE [dbo].[aml_connection](\r\n",
-        "    [Id] [int] IDENTITY(1,1) NOT NULL PRIMARY KEY,\r\n",
-        "\t[ConnectionName] [nvarchar](255) NULL,\r\n",
-        "\t[TenantId] [nvarchar](255) NULL,\r\n",
-        "\t[AppId] [nvarchar](255) NULL,\r\n",
-        "\t[Password] [nvarchar](255) NULL,\r\n",
-        "\t[ConfigFile] [nvarchar](255) NULL\r\n",
-        ") ON [PRIMARY]\r\n",
-        "GO"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Copy the values from create-for-rbac above into the cell below"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- Use the following values:\r\n",
-        "-- Leave the name as 'Default'\r\n",
-        "-- Insert <tenant> returned by create-for-rbac above\r\n",
-        "-- Insert <AppId> returned by create-for-rbac above\r\n",
-        "-- Insert <password> used in create-for-rbac above\r\n",
-        "-- Leave <path> as '/tmp/aml/config.json'\r\n",
-        "INSERT INTO [dbo].[aml_connection]  \r\n",
-        "VALUES (\r\n",
-        "    N'Default', -- Name\r\n",
-        "    N'11111111-2222-3333-4444-555555555555', -- Tenant\r\n",
-        "    N'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', -- AppId\r\n",
-        "    N'insertpasswordhere', -- Password\r\n",
-        "    N'/tmp/aml/config.json' -- Path\r\n",
-        "    );\r\n",
-        "GO"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- This is a table to hold the results from the AutoMLTrain procedure.\r\n",
-        "SET ANSI_NULLS ON\r\n",
-        "GO\r\n",
-        "\r\n",
-        "SET QUOTED_IDENTIFIER ON\r\n",
-        "GO\r\n",
-        "\r\n",
-        "CREATE TABLE [dbo].[aml_model](\r\n",
-        "    [Id] [int] IDENTITY(1,1) NOT NULL PRIMARY KEY,\r\n",
-        "    [Model] [varchar](max) NOT NULL,        -- The model, which can be passed to AutoMLPredict for testing or prediction.\r\n",
-        "    [RunId] [nvarchar](250) NULL,           -- The RunId, which can be used to view the model in the Azure Portal.\r\n",
-        "    [CreatedDate] [datetime] NULL,\r\n",
-        "    [ExperimentName] [nvarchar](100) NULL,  -- Azure ML Experiment Name\r\n",
-        "    [WorkspaceName] [nvarchar](100) NULL,   -- Azure ML Workspace Name\r\n",
-        "\t[LogFileText] [nvarchar](max) NULL\r\n",
-        ") \r\n",
-        "GO\r\n",
-        "\r\n",
-        "ALTER TABLE [dbo].[aml_model] ADD  DEFAULT (getutcdate()) FOR [CreatedDate]\r\n",
-        "GO\r\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- This stored procedure uses automated machine learning to train several models\r\n",
-        "-- and return the best model.\r\n",
-        "--\r\n",
-        "-- The result set has several columns:\r\n",
-        "--   best_run - ID of the best model found\r\n",
-        "--   experiment_name - training run name\r\n",
-        "--   fitted_model - best model found\r\n",
-        "--   log_file_text - console output\r\n",
-        "--   workspace - name of the Azure ML workspace where run history is stored\r\n",
-        "--\r\n",
-        "-- An example call for a classification problem is:\r\n",
-        "--    insert into dbo.aml_model(RunId, ExperimentName, Model, LogFileText, WorkspaceName)\r\n",
-        "--    exec dbo.AutoMLTrain @input_query='\r\n",
-        "--    SELECT top 100000 \r\n",
-        "--          CAST([pickup_datetime] AS NVARCHAR(30)) AS pickup_datetime\r\n",
-        "--          ,CAST([dropoff_datetime] AS NVARCHAR(30)) AS dropoff_datetime\r\n",
-        "--          ,[passenger_count]\r\n",
-        "--          ,[trip_time_in_secs]\r\n",
-        "--          ,[trip_distance]\r\n",
-        "--          ,[payment_type]\r\n",
-        "--          ,[tip_class]\r\n",
-        "--      FROM [dbo].[nyctaxi_sample] order by [hack_license] ',\r\n",
-        "--      @label_column = 'tip_class',\r\n",
-        "--      @iterations=10\r\n",
-        "-- \r\n",
-        "-- An example call for forecasting is:\r\n",
-        "--      insert into dbo.aml_model(RunId, ExperimentName, Model, LogFileText, WorkspaceName)\r\n",
-        "--      exec dbo.AutoMLTrain @input_query='\r\n",
-        "--      select cast(timeStamp as nvarchar(30)) as timeStamp,\r\n",
-        "--             demand,\r\n",
-        "--      \t   precip,\r\n",
-        "--      \t   temp,\r\n",
-        "--             case when timeStamp < ''2017-01-01'' then 0 else 1 end as is_validate_column\r\n",
-        "--      from nyc_energy\r\n",
-        "--      where demand is not null and precip is not null and temp is not null\r\n",
-        "--      and timeStamp < ''2017-02-01''',\r\n",
-        "--      @label_column='demand',\r\n",
-        "--      @task='forecasting',\r\n",
-        "--      @iterations=10,\r\n",
-        "--      @iteration_timeout_minutes=5,\r\n",
-        "--      @time_column_name='timeStamp',\r\n",
-        "--      @is_validate_column='is_validate_column',\r\n",
-        "--      @experiment_name='automl-sql-forecast',\r\n",
-        "--      @primary_metric='normalized_root_mean_squared_error'\r\n",
-        "\r\n",
-        "SET ANSI_NULLS ON\r\n",
-        "GO\r\n",
-        "SET QUOTED_IDENTIFIER ON\r\n",
-        "GO\r\n",
-        "CREATE OR ALTER PROCEDURE [dbo].[AutoMLTrain]\r\n",
-        " (\r\n",
-        "    @input_query NVARCHAR(MAX),                      -- The SQL Query that will return the data to train and validate the model.\r\n",
-        "    @label_column NVARCHAR(255)='Label',             -- The name of the column in the result of @input_query that is the label.\r\n",
-        "    @primary_metric NVARCHAR(40)='AUC_weighted',     -- The metric to optimize.\r\n",
-        "    @iterations INT=100,                             -- The maximum number of pipelines to train.\r\n",
-        "    @task NVARCHAR(40)='classification',             -- The type of task.  Can be classification, regression or forecasting.\r\n",
-        "    @experiment_name NVARCHAR(32)='automl-sql-test', -- This can be used to find the experiment in the Azure Portal.\r\n",
-        "    @iteration_timeout_minutes INT = 15,             -- The maximum time in minutes for training a single pipeline. \r\n",
-        "    @experiment_timeout_minutes INT = 60,            -- The maximum time in minutes for training all pipelines.\r\n",
-        "    @n_cross_validations INT = 3,                    -- The number of cross validations.\r\n",
-        "    @blacklist_models NVARCHAR(MAX) = '',            -- A comma separated list of algos that will not be used.\r\n",
-        "                                                     -- The list of possible models can be found at:\r\n",
-        "                                                     -- https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-auto-train#configure-your-experiment-settings\r\n",
-        "    @whitelist_models NVARCHAR(MAX) = '',            -- A comma separated list of algos that can be used.\r\n",
-        "                                                     -- The list of possible models can be found at:\r\n",
-        "                                                     -- https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-configure-auto-train#configure-your-experiment-settings\r\n",
-        "    @experiment_exit_score FLOAT = 0,                -- Stop the experiment if this score is acheived.\r\n",
-        "    @sample_weight_column NVARCHAR(255)='',          -- The name of the column in the result of  @input_query that gives a sample weight.\r\n",
-        "    @is_validate_column NVARCHAR(255)='',            -- The name of the column in the result of  @input_query that indicates if the row is for training or validation.\r\n",
-        "\t                                                 -- In the values of the column, 0 means for training and 1 means for validation.\r\n",
-        "    @time_column_name  NVARCHAR(255)='',             -- The name of the timestamp column for forecasting.\r\n",
-        "\t@connection_name NVARCHAR(255)='default'         -- The AML connection to use.\r\n",
-        " ) AS\r\n",
-        "BEGIN\r\n",
-        "\r\n",
-        "    DECLARE @tenantid NVARCHAR(255)\r\n",
-        "    DECLARE @appid NVARCHAR(255)\r\n",
-        "    DECLARE @password NVARCHAR(255)\r\n",
-        "    DECLARE @config_file NVARCHAR(255)\r\n",
-        "\r\n",
-        "\tSELECT @tenantid=TenantId, @appid=AppId, @password=Password, @config_file=ConfigFile\r\n",
-        "\tFROM aml_connection\r\n",
-        "\tWHERE ConnectionName = @connection_name;\r\n",
-        "\r\n",
-        "\tEXEC sp_execute_external_script @language = N'Python', @script = N'import pandas as pd\r\n",
-        "import logging \r\n",
-        "import azureml.core \r\n",
-        "import pandas as pd\r\n",
-        "import numpy as np\r\n",
-        "from azureml.core.experiment import Experiment \r\n",
-        "from azureml.train.automl import AutoMLConfig \r\n",
-        "from sklearn import datasets \r\n",
-        "import pickle\r\n",
-        "import codecs\r\n",
-        "from azureml.core.authentication import ServicePrincipalAuthentication \r\n",
-        "from azureml.core.workspace import Workspace \r\n",
-        "\r\n",
-        "if __name__.startswith(\"sqlindb\"):\r\n",
-        "    auth = ServicePrincipalAuthentication(tenantid, appid, password) \r\n",
-        " \r\n",
-        "    ws = Workspace.from_config(path=config_file, auth=auth) \r\n",
-        " \r\n",
-        "    project_folder = \"./sample_projects/\" + experiment_name\r\n",
-        " \r\n",
-        "    experiment = Experiment(ws, experiment_name) \r\n",
-        "\r\n",
-        "    data_train = input_data\r\n",
-        "    X_valid = None\r\n",
-        "    y_valid = None\r\n",
-        "    sample_weight_valid = None\r\n",
-        "\r\n",
-        "    if is_validate_column != \"\" and is_validate_column is not None:\r\n",
-        "        data_train = input_data[input_data[is_validate_column] <= 0]\r\n",
-        "        data_valid = input_data[input_data[is_validate_column] > 0]\r\n",
-        "        data_train.pop(is_validate_column)\r\n",
-        "        data_valid.pop(is_validate_column)\r\n",
-        "        y_valid = data_valid.pop(label_column).values\r\n",
-        "        if sample_weight_column != \"\" and sample_weight_column is not None:\r\n",
-        "            sample_weight_valid = data_valid.pop(sample_weight_column).values\r\n",
-        "        X_valid = data_valid\r\n",
-        "        n_cross_validations = None\r\n",
-        "\r\n",
-        "    y_train = data_train.pop(label_column).values\r\n",
-        "\r\n",
-        "    sample_weight = None\r\n",
-        "    if sample_weight_column != \"\" and sample_weight_column is not None:\r\n",
-        "        sample_weight = data_train.pop(sample_weight_column).values\r\n",
-        "\r\n",
-        "    X_train = data_train\r\n",
-        "\r\n",
-        "    if experiment_timeout_minutes == 0:\r\n",
-        "        experiment_timeout_minutes = None\r\n",
-        "\r\n",
-        "    if experiment_exit_score == 0:\r\n",
-        "        experiment_exit_score = None\r\n",
-        "\r\n",
-        "    if blacklist_models == \"\":\r\n",
-        "        blacklist_models = None\r\n",
-        "\r\n",
-        "    if blacklist_models is not None:\r\n",
-        "        blacklist_models = blacklist_models.replace(\" \", \"\").split(\",\")\r\n",
-        "\r\n",
-        "    if whitelist_models == \"\":\r\n",
-        "        whitelist_models = None\r\n",
-        "\r\n",
-        "    if whitelist_models is not None:\r\n",
-        "        whitelist_models = whitelist_models.replace(\" \", \"\").split(\",\")\r\n",
-        "\r\n",
-        "    automl_settings = {}\r\n",
-        "    preprocess = True\r\n",
-        "    if time_column_name != \"\" and time_column_name is not None:\r\n",
-        "        automl_settings = { \"time_column_name\": time_column_name }\r\n",
-        "        preprocess = False\r\n",
-        "\r\n",
-        "    log_file_name = \"automl_errors.log\"\r\n",
-        "\t \r\n",
-        "    automl_config = AutoMLConfig(task = task, \r\n",
-        "                                 debug_log = log_file_name, \r\n",
-        "                                 primary_metric = primary_metric, \r\n",
-        "                                 iteration_timeout_minutes = iteration_timeout_minutes, \r\n",
-        "                                 experiment_timeout_minutes = experiment_timeout_minutes,\r\n",
-        "                                 iterations = iterations, \r\n",
-        "                                 n_cross_validations = n_cross_validations, \r\n",
-        "                                 preprocess = preprocess,\r\n",
-        "                                 verbosity = logging.INFO, \r\n",
-        "                                 X = X_train,  \r\n",
-        "                                 y = y_train, \r\n",
-        "                                 path = project_folder,\r\n",
-        "                                 blacklist_models = blacklist_models,\r\n",
-        "                                 whitelist_models = whitelist_models,\r\n",
-        "                                 experiment_exit_score = experiment_exit_score,\r\n",
-        "                                 sample_weight = sample_weight,\r\n",
-        "                                 X_valid = X_valid,\r\n",
-        "                                 y_valid = y_valid,\r\n",
-        "                                 sample_weight_valid = sample_weight_valid,\r\n",
-        "                                 **automl_settings) \r\n",
-        " \r\n",
-        "    local_run = experiment.submit(automl_config, show_output = True) \r\n",
-        "\r\n",
-        "    best_run, fitted_model = local_run.get_output()\r\n",
-        "\r\n",
-        "    pickled_model = codecs.encode(pickle.dumps(fitted_model), \"base64\").decode()\r\n",
-        "\r\n",
-        "    log_file_text = \"\"\r\n",
-        "\r\n",
-        "    try:\r\n",
-        "        with open(log_file_name, \"r\") as log_file:\r\n",
-        "            log_file_text = log_file.read()\r\n",
-        "    except:\r\n",
-        "        log_file_text = \"Log file not found\"\r\n",
-        "\r\n",
-        "    returned_model = pd.DataFrame({\"best_run\": [best_run.id], \"experiment_name\": [experiment_name], \"fitted_model\": [pickled_model], \"log_file_text\": [log_file_text], \"workspace\": [ws.name]}, dtype=np.dtype(np.str))\r\n",
-        "'\r\n",
-        "\t, @input_data_1 = @input_query\r\n",
-        "\t, @input_data_1_name = N'input_data'\r\n",
-        "\t, @output_data_1_name = N'returned_model'\r\n",
-        "\t, @params = N'@label_column NVARCHAR(255), \r\n",
-        "\t              @primary_metric NVARCHAR(40),\r\n",
-        "\t\t\t\t  @iterations INT, @task NVARCHAR(40),\r\n",
-        "\t\t\t\t  @experiment_name NVARCHAR(32),\r\n",
-        "\t\t\t\t  @iteration_timeout_minutes INT,\r\n",
-        "\t\t\t\t  @experiment_timeout_minutes INT,\r\n",
-        "\t\t\t\t  @n_cross_validations INT,\r\n",
-        "\t\t\t\t  @blacklist_models NVARCHAR(MAX),\r\n",
-        "\t\t\t\t  @whitelist_models NVARCHAR(MAX),\r\n",
-        "\t\t\t\t  @experiment_exit_score FLOAT,\r\n",
-        "\t\t\t\t  @sample_weight_column NVARCHAR(255),\r\n",
-        "\t\t\t\t  @is_validate_column NVARCHAR(255),\r\n",
-        "\t\t\t\t  @time_column_name  NVARCHAR(255),\r\n",
-        "\t\t\t\t  @tenantid NVARCHAR(255),\r\n",
-        "\t\t\t\t  @appid NVARCHAR(255),\r\n",
-        "\t\t\t\t  @password NVARCHAR(255),\r\n",
-        "\t\t\t\t  @config_file NVARCHAR(255)'\r\n",
-        "\t, @label_column = @label_column\r\n",
-        "\t, @primary_metric = @primary_metric\r\n",
-        "\t, @iterations = @iterations\r\n",
-        "\t, @task = @task\r\n",
-        "\t, @experiment_name = @experiment_name\r\n",
-        "\t, @iteration_timeout_minutes = @iteration_timeout_minutes\r\n",
-        "\t, @experiment_timeout_minutes = @experiment_timeout_minutes\r\n",
-        "\t, @n_cross_validations = @n_cross_validations\r\n",
-        "\t, @blacklist_models = @blacklist_models\r\n",
-        "\t, @whitelist_models = @whitelist_models\r\n",
-        "\t, @experiment_exit_score = @experiment_exit_score\r\n",
-        "\t, @sample_weight_column = @sample_weight_column\r\n",
-        "\t, @is_validate_column = @is_validate_column\r\n",
-        "\t, @time_column_name = @time_column_name\r\n",
-        "\t, @tenantid = @tenantid\r\n",
-        "\t, @appid = @appid\r\n",
-        "\t, @password = @password\r\n",
-        "\t, @config_file = @config_file\r\n",
-        "WITH RESULT SETS ((best_run NVARCHAR(250), experiment_name NVARCHAR(100), fitted_model VARCHAR(MAX), log_file_text NVARCHAR(MAX), workspace NVARCHAR(100)))\r\n",
-        "END"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- This procedure returns a list of metrics for each iteration of a training run.\r\n",
-        "SET ANSI_NULLS ON\r\n",
-        "GO\r\n",
-        "SET QUOTED_IDENTIFIER ON\r\n",
-        "GO\r\n",
-        "CREATE OR ALTER PROCEDURE [dbo].[AutoMLGetMetrics]\r\n",
-        " (\r\n",
-        "\t@run_id NVARCHAR(250),                           -- The RunId\r\n",
-        "    @experiment_name NVARCHAR(32)='automl-sql-test', -- This can be used to find the experiment in the Azure Portal.\r\n",
-        "    @connection_name NVARCHAR(255)='default'         -- The AML connection to use.\r\n",
-        " ) AS\r\n",
-        "BEGIN\r\n",
-        "    DECLARE @tenantid NVARCHAR(255)\r\n",
-        "    DECLARE @appid NVARCHAR(255)\r\n",
-        "    DECLARE @password NVARCHAR(255)\r\n",
-        "    DECLARE @config_file NVARCHAR(255)\r\n",
-        "\r\n",
-        "\tSELECT @tenantid=TenantId, @appid=AppId, @password=Password, @config_file=ConfigFile\r\n",
-        "\tFROM aml_connection\r\n",
-        "\tWHERE ConnectionName = @connection_name;\r\n",
-        "\r\n",
-        "    EXEC sp_execute_external_script @language = N'Python', @script = N'import pandas as pd\r\n",
-        "import logging \r\n",
-        "import azureml.core \r\n",
-        "import numpy as np\r\n",
-        "from azureml.core.experiment import Experiment \r\n",
-        "from azureml.train.automl.run import AutoMLRun\r\n",
-        "from azureml.core.authentication import ServicePrincipalAuthentication \r\n",
-        "from azureml.core.workspace import Workspace \r\n",
-        "\r\n",
-        "auth = ServicePrincipalAuthentication(tenantid, appid, password) \r\n",
-        " \r\n",
-        "ws = Workspace.from_config(path=config_file, auth=auth) \r\n",
-        " \r\n",
-        "experiment = Experiment(ws, experiment_name) \r\n",
-        "\r\n",
-        "ml_run = AutoMLRun(experiment = experiment, run_id = run_id)\r\n",
-        "\r\n",
-        "children = list(ml_run.get_children())\r\n",
-        "iterationlist = []\r\n",
-        "metricnamelist = []\r\n",
-        "metricvaluelist = []\r\n",
-        "\r\n",
-        "for run in children:\r\n",
-        "    properties = run.get_properties()\r\n",
-        "    if \"iteration\" in properties:\r\n",
-        "        iteration = int(properties[\"iteration\"])\r\n",
-        "        for metric_name, metric_value in run.get_metrics().items():\r\n",
-        "            if isinstance(metric_value, float):\r\n",
-        "                iterationlist.append(iteration)\r\n",
-        "                metricnamelist.append(metric_name)\r\n",
-        "                metricvaluelist.append(metric_value)\r\n",
-        "             \r\n",
-        "metrics = pd.DataFrame({\"iteration\": iterationlist, \"metric_name\": metricnamelist, \"metric_value\": metricvaluelist})\r\n",
-        "'\r\n",
-        "    , @output_data_1_name = N'metrics'\r\n",
-        "\t, @params = N'@run_id NVARCHAR(250), \r\n",
-        "\t\t\t\t  @experiment_name NVARCHAR(32),\r\n",
-        "  \t\t\t\t  @tenantid NVARCHAR(255),\r\n",
-        "\t\t\t\t  @appid NVARCHAR(255),\r\n",
-        "\t\t\t\t  @password NVARCHAR(255),\r\n",
-        "\t\t\t\t  @config_file NVARCHAR(255)'\r\n",
-        "    , @run_id = @run_id\r\n",
-        "\t, @experiment_name = @experiment_name\r\n",
-        "\t, @tenantid = @tenantid\r\n",
-        "\t, @appid = @appid\r\n",
-        "\t, @password = @password\r\n",
-        "\t, @config_file = @config_file\r\n",
-        "WITH RESULT SETS ((iteration INT, metric_name NVARCHAR(100), metric_value FLOAT))\r\n",
-        "END"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "-- This procedure predicts values based on a model returned by AutoMLTrain and a dataset.\r\n",
-        "-- It returns the dataset with a new column added, which is the predicted value.\r\n",
-        "SET ANSI_NULLS ON\r\n",
-        "GO\r\n",
-        "SET QUOTED_IDENTIFIER ON\r\n",
-        "GO\r\n",
-        "CREATE OR ALTER PROCEDURE [dbo].[AutoMLPredict]\r\n",
-        " (\r\n",
-        "   @input_query NVARCHAR(MAX),      -- A SQL query returning data to predict on.\r\n",
-        "   @model NVARCHAR(MAX),            -- A model returned from AutoMLTrain.\r\n",
-        "   @label_column  NVARCHAR(255)=''  -- Optional name of the column from input_query, which should be ignored when predicting\r\n",
-        " ) AS \r\n",
-        "BEGIN \r\n",
-        "  \r\n",
-        "    EXEC sp_execute_external_script @language = N'Python', @script = N'import pandas as pd \r\n",
-        "import azureml.core  \r\n",
-        "import numpy as np \r\n",
-        "from azureml.train.automl import AutoMLConfig  \r\n",
-        "import pickle \r\n",
-        "import codecs \r\n",
-        "  \r\n",
-        "model_obj = pickle.loads(codecs.decode(model.encode(), \"base64\")) \r\n",
-        "  \r\n",
-        "test_data = input_data.copy() \r\n",
-        "\r\n",
-        "if label_column != \"\" and label_column is not None:\r\n",
-        "    y_test = test_data.pop(label_column).values \r\n",
-        "X_test = test_data \r\n",
-        "  \r\n",
-        "predicted = model_obj.predict(X_test) \r\n",
-        "  \r\n",
-        "combined_output = input_data.assign(predicted=predicted)\r\n",
-        "  \r\n",
-        "' \r\n",
-        "    , @input_data_1 = @input_query \r\n",
-        "    , @input_data_1_name = N'input_data' \r\n",
-        "    , @output_data_1_name = N'combined_output' \r\n",
-        "    , @params = N'@model NVARCHAR(MAX), @label_column  NVARCHAR(255)' \r\n",
-        "    , @model = @model \r\n",
-        "\t, @label_column = @label_column\r\n",
-        "END"
-      ]
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "jeffshep"
-      }
-    ],
-    "kernelspec": {
-      "display_name": "Python 3.6",
-      "language": "sql",
-      "name": "python36"
-    },
-    "language_info": {
-      "name": "sql",
-      "version": ""
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

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

@@ -314,18 +314,25 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Load Training Data Using Dataset"
+        "## Load Training Data Using DataPrep"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Automated ML takes a `TabularDataset` as input.\n",
+        "Automated ML takes a Dataflow as input.\n",
         "\n",
-        "You are free to use the data preparation libraries/tools of your choice to do the require preparation and once you are done, you can write it to a datastore and create a TabularDataset from it.\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",
-        "You will get the datastore you registered previously and pass it to Dataset for reading. The data comes from the digits dataset: `sklearn.datasets.load_digits()`. `DataPath` points to a specific location within a datastore. "
+        "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. "
       ]
     },
     {
@@ -334,21 +341,21 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.dataset import Dataset\n",
+        "import azureml.dataprep as dprep\n",
         "from azureml.data.datapath import DataPath\n",
         "\n",
         "datastore = Datastore.get(workspace = ws, datastore_name = datastore_name)\n",
         "\n",
-        "X_train = Dataset.Tabular.from_delimited_files(datastore.path('X.csv'))\n",
-        "y_train = Dataset.Tabular.from_delimited_files(datastore.path('y.csv'))"
+        "X_train = dprep.read_csv(datastore.path('X.csv'))\n",
+        "y_train = dprep.read_csv(datastore.path('y.csv')).to_long(dprep.ColumnSelector(term='.*', use_regex = True))"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Review the TabularDataset\n",
-        "You can peek the result of a TabularDataset at any range using `skip(i)` and `take(j).to_pandas_dataframe()`. Doing so evaluates only j records for all the steps in the TabularDataset, which makes it fast even against large datasets."
+        "## 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."
       ]
     },
     {
@@ -357,7 +364,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "X_train.take(5).to_pandas_dataframe()"
+        "X_train.get_profile()"
       ]
     },
     {
@@ -366,7 +373,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "y_train.take(5).to_pandas_dataframe()"
+        "y_train.get_profile()"
       ]
     },
     {
@@ -586,10 +593,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Get the featurization summary as a list of JSON\n",
-        "featurization_summary = fitted_model.named_steps['datatransformer'].get_featurization_summary()\n",
-        "# View the featurization summary as a pandas dataframe\n",
-        "pd.DataFrame.from_records(featurization_summary)"
+        "fitted_model.named_steps['datatransformer'].get_featurization_summary()"
       ]
     },
     {

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

@@ -331,18 +331,25 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Load Training Data Using Dataset"
+        "## Load Training Data Using DataPrep"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Automated ML takes a `TabularDataset` as input.\n",
+        "Automated ML takes a Dataflow as input.\n",
         "\n",
-        "You are free to use the data preparation libraries/tools of your choice to do the require preparation and once you are done, you can write it to a datastore and create a TabularDataset from it.\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",
-        "You will get the datastore you registered previously and pass it to Dataset for reading. The data comes from the digits dataset: `sklearn.datasets.load_digits()`. `DataPath` points to a specific location within a datastore. "
+        "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. "
       ]
     },
     {
@@ -351,21 +358,21 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.dataset import Dataset\n",
+        "import azureml.dataprep as dprep\n",
         "from azureml.data.datapath import DataPath\n",
         "\n",
         "datastore = Datastore.get(workspace = ws, datastore_name = datastore_name)\n",
         "\n",
-        "X_train = Dataset.Tabular.from_delimited_files(datastore.path('X.csv'))\n",
-        "y_train = Dataset.Tabular.from_delimited_files(datastore.path('y.csv'))"
+        "X_train = dprep.read_csv(datastore.path('X.csv'))\n",
+        "y_train = dprep.read_csv(datastore.path('y.csv')).to_long(dprep.ColumnSelector(term='.*', use_regex = True))"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Review the TabularDataset\n",
-        "You can peek the result of a TabularDataset at any range using `skip(i)` and `take(j).to_pandas_dataframe()`. Doing so evaluates only j records for all the steps in the TabularDataset, which makes it fast even against large datasets."
+        "## 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."
       ]
     },
     {
@@ -374,7 +381,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "X_train.take(5).to_pandas_dataframe()"
+        "X_train.get_profile()"
       ]
     },
     {
@@ -383,7 +390,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "y_train.take(5).to_pandas_dataframe()"
+        "y_train.get_profile()"
       ]
     },
     {

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

@@ -13,7 +13,7 @@
       "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://aka.ms/pl-concept), 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",
+        "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",
@@ -675,7 +675,7 @@
       "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](https://aka.ms/pl-adla) demonstrates the use of AdlaStep in Azure Machine Learning Pipeline."
+        "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."
       ]
     },
     {

how-to-use-azureml/data-drift/azure-ml-datadrift.ipynb

@@ -17,7 +17,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/monitor-models/data-drift/azureml-datadrift.png)"
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/contrib/datadrift/azureml-datadrift.png)"
       ]
     },
     {
@@ -33,9 +33,10 @@
       "source": [
         "## Install the DataDrift package\n",
         "\n",
-        "Install the azureml-contrib-datadrift, azureml-opendatasets and lightgbm packages before running this notebook.\n",
+        "Install the azureml-contrib-datadrift, azureml-contrib-opendatasets and lightgbm packages before running this notebook.\n",
         "```\n",
         "pip install azureml-contrib-datadrift\n",
+        "pip install azureml-contrib-datasets\n",
         "pip install lightgbm\n",
         "```"
       ]
@@ -62,7 +63,7 @@
         "import pandas as pd\n",
         "import requests\n",
         "from azureml.contrib.datadrift import DataDriftDetector, AlertConfiguration\n",
-        "from azureml.opendatasets import NoaaIsdWeather\n",
+        "from azureml.contrib.opendatasets import NoaaIsdWeather\n",
         "from azureml.core import Dataset, Workspace, Run\n",
         "from azureml.core.compute import AksCompute, ComputeTarget\n",
         "from azureml.core.conda_dependencies import CondaDependencies\n",
@@ -258,7 +259,8 @@
         "trainingDataset = Dataset.auto_read_files(dpath, include_path=True)\n",
         "trainingDataset = trainingDataset.register(workspace=ws, name=dataset_name, description=\"dset\", exist_ok=True)\n",
         "\n",
-        "datasets = [(Dataset.Scenario.TRAINING, trainingDataset)]\n",
+        "trainingDataSnapshot = trainingDataset.create_snapshot(snapshot_name=snapshot_name, compute_target=None, create_data_snapshot=True)\n",
+        "datasets = [(Dataset.Scenario.TRAINING, trainingDataSnapshot)]\n",
         "print(\"dataset registration done.\\n\")\n",
         "datasets"
       ]
@@ -572,22 +574,6 @@
         "        time.sleep(3)"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "We need to wait up to 10 minutes for the Model Data Collector to dump the model input and inference data to storage in the Workspace, where it's used by the DataDriftDetector job."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "time.sleep(600)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -716,8 +702,7 @@
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
       "version": "3.6.6"
-    },
-    "notice": "Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT License."
+    }
   },
   "nbformat": 4,
   "nbformat_minor": 2

how-to-use-azureml/data-drift/readme.md

@@ -0,0 +1,3 @@
+## Using data drift APIs
+
+1. [Detect data drift for a model](azure-ml-datadrift.ipynb): Detect data drift for a deployed model.

how-to-use-azureml/deploy-to-cloud/model-register-and-deploy.ipynb

@@ -77,7 +77,7 @@
         "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')"
+        "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')"
       ]
     },
     {
@@ -108,41 +108,11 @@
       "source": [
         "from azureml.core.model import Model\n",
         "\n",
-        "model = Model.register(model_path=\"sklearn_regression_model.pkl\",\n",
-        "                       model_name=\"sklearn_regression_model.pkl\",\n",
-        "                       tags={'area': \"diabetes\", 'type': \"regression\"},\n",
-        "                       description=\"Ridge regression model to predict diabetes\",\n",
-        "                       workspace=ws)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Create Environment"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "You can now create and/or use an Environment object when deploying a Webservice. The Environment can have been previously registered with your Workspace, or it will be registered with it as a part of the Webservice deployment. Only Environments that were created using azureml-defaults version 1.0.48 or later will work with this new handling however.\n",
-        "\n",
-        "More information can be found in our [using environments notebook](../training/using-environments/using-environments.ipynb)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core import Environment\n",
-        "\n",
-        "env = Environment.from_conda_specification(name='deploytocloudenv', file_path='myenv.yml')\n",
-        "\n",
-        "# This is optional at this point\n",
-        "# env.register(workspace=ws)"
+        "model = Model.register(model_path = \"sklearn_regression_model.pkl\",\n",
+        "                       model_name = \"sklearn_regression_model.pkl\",\n",
+        "                       tags = {'area': \"diabetes\", 'type': \"regression\"},\n",
+        "                       description = \"Ridge regression model to predict diabetes\",\n",
+        "                       workspace = ws)"
       ]
     },
     {
@@ -183,7 +153,10 @@
       "source": [
         "from azureml.core.model import InferenceConfig\n",
         "\n",
-        "inference_config = InferenceConfig(entry_script=\"score.py\", environment=env)"
+        "inference_config = InferenceConfig(runtime= \"python\", \n",
+        "                                   entry_script=\"score.py\",\n",
+        "                                   conda_file=\"myenv.yml\", \n",
+        "                                   extra_docker_file_steps=\"helloworld.txt\")"
       ]
     },
     {
@@ -204,7 +177,7 @@
         "from azureml.core.webservice import AciWebservice, Webservice\n",
         "from azureml.exceptions import WebserviceException\n",
         "\n",
-        "deployment_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)\n",
+        "deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)\n",
         "aci_service_name = 'aciservice1'\n",
         "\n",
         "try:\n",
@@ -242,7 +215,7 @@
         "    [10,9,8,7,6,5,4,3,2,1]\n",
         "]})\n",
         "\n",
-        "test_sample_encoded = bytes(test_sample, encoding='utf8')\n",
+        "test_sample_encoded = bytes(test_sample,encoding = 'utf8')\n",
         "prediction = service.run(input_data=test_sample_encoded)\n",
         "print(prediction)"
       ]
@@ -274,38 +247,15 @@
       "source": [
         "### Model Profiling\n",
         "\n",
-        "You can also take advantage of the profiling feature to estimate CPU and memory requirements for models.\n",
+        "you can also take advantage of profiling feature for model\n",
         "\n",
         "```python\n",
-        "profile = Model.profile(ws, \"profilename\", [model], inference_config, test_sample)\n",
+        "\n",
+        "profile = model.profile(ws, \"profilename\", [model], inference_config, test_sample)\n",
         "profile.wait_for_profiling(True)\n",
         "profiling_results = profile.get_results()\n",
         "print(profiling_results)\n",
-        "```"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Model Packaging\n",
         "\n",
-        "If you want to build a Docker image that encapsulates your model and its dependencies, you can use the model packaging option. The output image will be pushed to your workspace's ACR.\n",
-        "\n",
-        "You must include an Environment object in your inference configuration to use `Model.package()`.\n",
-        "\n",
-        "```python\n",
-        "package = Model.package(ws, [model], inference_config)\n",
-        "package.wait_for_creation(show_output=True)  # Or show_output=False to hide the Docker build logs.\n",
-        "package.pull()\n",
-        "```\n",
-        "\n",
-        "Instead of a fully-built image, you can also generate a Dockerfile and download all the assets needed to build an image on top of your Environment.\n",
-        "\n",
-        "```python\n",
-        "package = Model.package(ws, [model], inference_config, generate_dockerfile=True)\n",
-        "package.wait_for_creation(show_output=True)\n",
-        "package.save(\"./local_context_dir\")\n",
         "```"
       ]
     }

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

@@ -72,7 +72,7 @@
         "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')"
+        "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')"
       ]
     },
     {
@@ -103,11 +103,11 @@
       "source": [
         "from azureml.core.model import Model\n",
         "\n",
-        "model = Model.register(model_path=\"sklearn_regression_model.pkl\",\n",
-        "                       model_name=\"sklearn_regression_model.pkl\",\n",
-        "                       tags={'area': \"diabetes\", 'type': \"regression\"},\n",
-        "                       description=\"Ridge regression model to predict diabetes\",\n",
-        "                       workspace=ws)"
+        "model = Model.register(model_path = \"sklearn_regression_model.pkl\",\n",
+        "                       model_name = \"sklearn_regression_model.pkl\",\n",
+        "                       tags = {'area': \"diabetes\", 'type': \"regression\"},\n",
+        "                       description = \"Ridge regression model to predict diabetes\",\n",
+        "                       workspace = ws)"
       ]
     },
     {
@@ -127,10 +127,10 @@
         "\n",
         "source_directory = \"C:/abc\"\n",
         "\n",
-        "os.makedirs(source_directory, exist_ok=True)\n",
-        "os.makedirs(\"C:/abc/x/y\", exist_ok=True)\n",
-        "os.makedirs(\"C:/abc/env\", exist_ok=True)\n",
-        "os.makedirs(\"C:/abc/dockerstep\", exist_ok=True)"
+        "os.makedirs(source_directory, exist_ok = True)\n",
+        "os.makedirs(\"C:/abc/x/y\", exist_ok = True)\n",
+        "os.makedirs(\"C:/abc/env\", exist_ok = True)\n",
+        "os.makedirs(\"C:/abc/dockerstep\", exist_ok = True)"
       ]
     },
     {
@@ -253,7 +253,7 @@
         "from azureml.core.model import InferenceConfig\n",
         "\n",
         "inference_config = InferenceConfig(source_directory=\"C:/abc\",\n",
-        "                                   runtime=\"python\", \n",
+        "                                   runtime= \"python\", \n",
         "                                   entry_script=\"x/y/score.py\",\n",
         "                                   conda_file=\"env/myenv.yml\", \n",
         "                                   extra_docker_file_steps=\"dockerstep/customDockerStep.txt\")"
@@ -271,10 +271,15 @@
         "\n",
         "NOTE:\n",
         "\n",
-        "The Docker image runs as a Linux container. If you are running Docker for Windows, you need to ensure the Linux Engine is running:\n",
+        "we require docker running with linux container. If you are running Docker for Windows, you need to ensure the Linux Engine is running\n",
         "\n",
-        "    # PowerShell command to switch to Linux engine\n",
-        "    & 'C:\\Program Files\\Docker\\Docker\\DockerCli.exe' -SwitchLinuxEngine"
+        "    powershell command to switch to linux engine\n",
+        "    & 'C:\\Program Files\\Docker\\Docker\\DockerCli.exe' -SwitchLinuxEngine\n",
+        "\n",
+        "and c drive is shared https://docs.docker.com/docker-for-windows/#shared-drives\n",
+        "sometimes you have to reshare c drive as docker \n",
+        "\n",
+        "<img src=\"./dockerSharedDrive.JPG\" align=\"left\"/>"
       ]
     },
     {
@@ -290,7 +295,7 @@
       "source": [
         "from azureml.core.webservice import LocalWebservice\n",
         "\n",
-        "# This is optional, if not provided Docker will choose a random unused port.\n",
+        "#this is optional, if not provided we choose random port\n",
         "deployment_config = LocalWebservice.deploy_configuration(port=6789)\n",
         "\n",
         "local_service = Model.deploy(ws, \"test\", [model], inference_config, deployment_config)\n",
@@ -422,8 +427,9 @@
         "local_service.reload()\n",
         "print(\"--------------------------------------------------------------\")\n",
         "\n",
-        "# After calling reload(), run() will return the updated message.\n",
-        "local_service.run(input_data=sample_input)"
+        "# after reload now if you call run this will return updated return message\n",
+        "\n",
+        "print(local_service.run(input_data=sample_input))"
       ]
     },
     {
@@ -436,9 +442,9 @@
         "\n",
         "```python\n",
         "\n",
-        "local_service.update(models=[SomeOtherModelObject],\n",
-        "                     deployment_config=local_config,\n",
-        "                     inference_config=inference_config)\n",
+        "local_service.update(models = [SomeOtherModelObject],\n",
+        "             deployment_config = local_config,\n",
+        "             inference_config = inference_config)\n",
         "```"
       ]
     },
@@ -462,7 +468,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "keriehm"
+        "name": "raymondl"
       }
     ],
     "kernelspec": {

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

@@ -68,7 +68,7 @@
         "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')"
+        "print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')"
       ]
     },
     {
@@ -99,31 +99,11 @@
       "source": [
         "from azureml.core.model import Model\n",
         "\n",
-        "model = Model.register(model_path=\"sklearn_regression_model.pkl\",\n",
-        "                       model_name=\"sklearn_regression_model.pkl\",\n",
-        "                       tags={'area': \"diabetes\", 'type': \"regression\"},\n",
-        "                       description=\"Ridge regression model to predict diabetes\",\n",
-        "                       workspace=ws)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Create Environment"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "from azureml.core.environment import Environment\n",
-        "\n",
-        "environment = Environment(\"LocalDeploy\")\n",
-        "environment.python.conda_dependencies = CondaDependencies(\"myenv.yml\")"
+        "model = Model.register(model_path = \"sklearn_regression_model.pkl\",\n",
+        "                       model_name = \"sklearn_regression_model.pkl\",\n",
+        "                       tags = {'area': \"diabetes\", 'type': \"regression\"},\n",
+        "                       description = \"Ridge regression model to predict diabetes\",\n",
+        "                       workspace = ws)"
       ]
     },
     {
@@ -141,8 +121,9 @@
       "source": [
         "from azureml.core.model import InferenceConfig\n",
         "\n",
-        "inference_config = InferenceConfig(entry_script=\"score.py\",\n",
-        "                                   environment=environment)"
+        "inference_config = InferenceConfig(runtime= \"python\", \n",
+        "                                   entry_script=\"score.py\",\n",
+        "                                   conda_file=\"myenv.yml\")"
       ]
     },
     {
@@ -157,10 +138,15 @@
         "\n",
         "NOTE:\n",
         "\n",
-        "The Docker image runs as a Linux container. If you are running Docker for Windows, you need to ensure the Linux Engine is running:\n",
+        "we require docker running with linux container. If you are running Docker for Windows, you need to ensure the Linux Engine is running\n",
         "\n",
-        "    # PowerShell command to switch to Linux engine\n",
-        "    & 'C:\\Program Files\\Docker\\Docker\\DockerCli.exe' -SwitchLinuxEngine"
+        "    powershell command to switch to linux engine\n",
+        "    & 'C:\\Program Files\\Docker\\Docker\\DockerCli.exe' -SwitchLinuxEngine\n",
+        "\n",
+        "and c drive is shared https://docs.docker.com/docker-for-windows/#shared-drives\n",
+        "sometimes you have to reshare c drive as docker \n",
+        "\n",
+        "<img src=\"./dockerSharedDrive.JPG\" align=\"left\"/>"
       ]
     },
     {
@@ -171,7 +157,7 @@
       "source": [
         "from azureml.core.webservice import LocalWebservice\n",
         "\n",
-        "# This is optional, if not provided Docker will choose a random unused port.\n",
+        "#this is optional, if not provided we choose random port\n",
         "deployment_config = LocalWebservice.deploy_configuration(port=6789)\n",
         "\n",
         "local_service = Model.deploy(ws, \"test\", [model], inference_config, deployment_config)\n",
@@ -235,7 +221,7 @@
         "\n",
         "sample_input = bytes(sample_input, encoding='utf-8')\n",
         "\n",
-        "local_service.run(input_data=sample_input)"
+        "print(local_service.run(input_data=sample_input))"
       ]
     },
     {
@@ -296,8 +282,9 @@
         "local_service.reload()\n",
         "print(\"--------------------------------------------------------------\")\n",
         "\n",
-        "# After calling reload(), run() will return the updated message.\n",
-        "local_service.run(input_data=sample_input)"
+        "# after reload now if you call run this will return updated return message\n",
+        "\n",
+        "print(local_service.run(input_data=sample_input))"
       ]
     },
     {
@@ -309,9 +296,10 @@
         "If you want to change your model(s), Conda dependencies, or deployment configuration, call `update()` to rebuild the Docker image.\n",
         "\n",
         "```python\n",
-        "local_service.update(models=[SomeOtherModelObject],\n",
-        "                     inference_config=inference_config,\n",
-        "                     deployment_config=local_config)\n",
+        "\n",
+        "local_service.update(models = [SomeOtherModelObject],\n",
+        "             deployment_config = local_config,\n",
+        "             inference_config = inference_config)\n",
         "```"
       ]
     },
@@ -335,7 +323,7 @@
   "metadata": {
     "authors": [
       {
-        "name": "keriehm"
+        "name": "raymondl"
       }
     ],
     "kernelspec": {

how-to-use-azureml/deployment/accelerated-models/README.md

@@ -12,7 +12,7 @@ Easily create and train a model using various deep neural networks (DNNs) as a f
 To learn more about the azureml-accel-model classes, see the section [Model Classes](#model-classes) below or the [Azure ML Accel Models SDK documentation](https://docs.microsoft.com/en-us/python/api/azureml-accel-models/azureml.accel?view=azure-ml-py).
 
 ### Step 1: Create an Azure ML workspace
-Follow [these instructions](https://docs.microsoft.com/en-us/azure/machine-learning/service/setup-create-workspace) to install the Azure ML SDK on your local machine, create an Azure ML workspace, and set up your notebook environment, which is required for the next step.
+Follow [these instructions](https://docs.microsoft.com/en-us/azure/machine-learning/service/quickstart-create-workspace-with-python) to install the Azure ML SDK on your local machine, create an Azure ML workspace, and set up your notebook environment, which is required for the next step.
 
 ### Step 2: Check your FPGA quota
 Use the Azure CLI to check whether you have quota.

how-to-use-azureml/deployment/accelerated-models/accelerated-models-object-detection.ipynb

@@ -1,12 +1,5 @@
 {
   "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/deployment/accelerated-models/accelerated-models-object-detection.png)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -237,14 +230,11 @@
         "\n",
         "# Convert model\n",
         "convert_request = AccelOnnxConverter.convert_tf_model(ws, registered_model, input_tensors, output_tensors_str)\n",
-        "if convert_request.wait_for_completion(show_output = False):\n",
-        "    # If the above call succeeded, get the converted model\n",
-        "    converted_model = convert_request.result\n",
-        "    print(\"\\nSuccessfully converted: \", converted_model.name, converted_model.url, converted_model.version, \n",
-        "          converted_model.id, converted_model.created_time, '\\n')\n",
-        "else:\n",
-        "    print(\"Model conversion failed. Showing output.\")\n",
-        "    convert_request.wait_for_completion(show_output = True)\n",
+        "# If it fails, you can run wait_for_completion again with show_output=True.\n",
+        "convert_request.wait_for_completion(show_output=False)\n",
+        "converted_model = convert_request.result\n",
+        "print(\"\\nSuccessfully converted: \", converted_model.name, converted_model.url, converted_model.version, \n",
+        "      converted_model.id, converted_model.created_time, '\\n')\n",
         "\n",
         "# Package into AccelContainerImage\n",
         "image_config = AccelContainerImage.image_configuration()\n",
@@ -308,7 +298,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%time\n",
         "aks_target.wait_for_completion(show_output = True)\n",
         "print(aks_target.provisioning_state)\n",
         "print(aks_target.provisioning_errors)"
@@ -327,7 +316,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%time\n",
         "from azureml.core.webservice import Webservice, AksWebservice\n",
         "\n",
         "# Set the web service configuration (for creating a test service, we don't want autoscale enabled)\n",
@@ -336,7 +324,7 @@
         "                                                num_replicas=1,\n",
         "                                                auth_enabled = False)\n",
         "\n",
-        "aks_service_name ='my-aks-service-3'\n",
+        "aks_service_name ='my-aks-service'\n",
         "\n",
         "aks_service = Webservice.deploy_from_image(workspace = ws,\n",
         "                                           name = aks_service_name,\n",
@@ -354,9 +342,10 @@
         "## 5. Test the service\n",
         "<a id=\"create-client\"></a>\n",
         "### 5.a. Create Client\n",
-        "The image supports gRPC and the TensorFlow Serving \"predict\" API. We will create a PredictionClient from the Webservice object that can call into the docker image to get predictions. If you do not have the Webservice object, you can also create [PredictionClient](https://docs.microsoft.com/en-us/python/api/azureml-accel-models/azureml.accel.predictionclient?view=azure-ml-py) directly.\n",
+        "The image supports gRPC and the TensorFlow Serving \"predict\" API. We have a client that can call into the docker image to get predictions. \n",
+        "\n",
+        "**Note:** If you chose to use auth_enabled=True when creating your AksWebservice.deploy_configuration(), see documentation [here](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.webservice(class)?view=azure-ml-py#get-keys--) on how to retrieve your keys and use either key as an argument to PredictionClient(...,access_token=key).",
         "\n",
-        "**Note:** If you chose to use auth_enabled=True when creating your AksWebservice.deploy_configuration(), see documentation [here](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.webservice(class)?view=azure-ml-py#get-keys--) on how to retrieve your keys and use either key as an argument to PredictionClient(...,access_token=key).\n",
         "**WARNING:** If you are running on Azure Notebooks free compute, you will not be able to make outgoing calls to your service. Try locating your client on a different machine to consume it."
       ]
     },
@@ -367,10 +356,18 @@
       "outputs": [],
       "source": [
         "# Using the grpc client in AzureML Accelerated Models SDK\n",
-        "from azureml.accel import client_from_service\n",
+        "from azureml.accel.client import PredictionClient\n",
+        "\n",
+        "address = aks_service.scoring_uri\n",
+        "ssl_enabled = address.startswith(\"https\")\n",
+        "address = address[address.find('/')+2:].strip('/')\n",
+        "port = 443 if ssl_enabled else 80\n",
         "\n",
         "# Initialize AzureML Accelerated Models client\n",
-        "client = client_from_service(aks_service)"
+        "client = PredictionClient(address=address,\n",
+        "                          port=port,\n",
+        "                          use_ssl=ssl_enabled,\n",
+        "                          service_name=aks_service.name)"
       ]
     },
     {
@@ -489,7 +486,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.5.6"
+      "version": "3.6.0"
     }
   },
   "nbformat": 4,

how-to-use-azureml/deployment/accelerated-models/accelerated-models-object-detection.yml

@@ -1,8 +0,0 @@
-name: accelerated-models-object-detection
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-accel-models
-  - tensorflow
-  - opencv-python
-  - matplotlib

how-to-use-azureml/deployment/accelerated-models/accelerated-models-quickstart.ipynb

@@ -1,12 +1,5 @@
 {
   "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/deployment/accelerated-models/accelerated-models-quickstart.png)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -277,15 +270,12 @@
         "from azureml.accel import AccelOnnxConverter\n",
         "\n",
         "convert_request = AccelOnnxConverter.convert_tf_model(ws, registered_model, input_tensors, output_tensors)\n",
-        "\n",
-        "if convert_request.wait_for_completion(show_output = False):\n",
-        "    # If the above call succeeded, get the converted model\n",
-        "    converted_model = convert_request.result\n",
-        "    print(\"\\nSuccessfully converted: \", converted_model.name, converted_model.url, converted_model.version, \n",
-        "          converted_model.id, converted_model.created_time, '\\n')\n",
-        "else:\n",
-        "    print(\"Model conversion failed. Showing output.\")\n",
-        "    convert_request.wait_for_completion(show_output = True)"
+        "# If it fails, you can run wait_for_completion again with show_output=True.\n",
+        "convert_request.wait_for_completion(show_output = False)\n",
+        "# If the above call succeeded, get the converted model\n",
+        "converted_model = convert_request.result\n",
+        "print(\"\\nSuccessfully converted: \", converted_model.name, converted_model.url, converted_model.version, \n",
+        "      converted_model.id, converted_model.created_time, '\\n')"
       ]
     },
     {
@@ -376,7 +366,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%time\n",
         "aks_target.wait_for_completion(show_output = True)\n",
         "print(aks_target.provisioning_state)\n",
         "print(aks_target.provisioning_errors)"
@@ -395,16 +384,15 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%time\n",
         "from azureml.core.webservice import Webservice, AksWebservice\n",
         "\n",
-        "# Set the web service configuration (for creating a test service, we don't want autoscale enabled)\n",
+        "#Set the web service configuration (for creating a test service, we don't want autoscale enabled)\n",
         "# Authentication is enabled by default, but for testing we specify False\n",
         "aks_config = AksWebservice.deploy_configuration(autoscale_enabled=False,\n",
         "                                                num_replicas=1,\n",
         "                                                auth_enabled = False)\n",
         "\n",
-        "aks_service_name ='my-aks-service-1'\n",
+        "aks_service_name ='my-aks-service'\n",
         "\n",
         "aks_service = Webservice.deploy_from_image(workspace = ws,\n",
         "                                           name = aks_service_name,\n",
@@ -427,9 +415,10 @@
       "metadata": {},
       "source": [
         "### 7.a. Create Client\n",
-        "The image supports gRPC and the TensorFlow Serving \"predict\" API. We will create a PredictionClient from the Webservice object that can call into the docker image to get predictions. If you do not have the Webservice object, you can also create [PredictionClient](https://docs.microsoft.com/en-us/python/api/azureml-accel-models/azureml.accel.predictionclient?view=azure-ml-py) directly.\n",
+        "The image supports gRPC and the TensorFlow Serving \"predict\" API. We have a client that can call into the docker image to get predictions.\n",
+        "\n",
+        "**Note:** If you chose to use auth_enabled=True when creating your AksWebservice, see documentation [here](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.webservice(class)?view=azure-ml-py#get-keys--) on how to retrieve your keys and use either key as an argument to PredictionClient(...,access_token=key).",
         "\n",
-        "**Note:** If you chose to use auth_enabled=True when creating your AksWebservice, see documentation [here](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.webservice(class)?view=azure-ml-py#get-keys--) on how to retrieve your keys and use either key as an argument to PredictionClient(...,access_token=key).\n",
         "**WARNING:** If you are running on Azure Notebooks free compute, you will not be able to make outgoing calls to your service. Try locating your client on a different machine to consume it."
       ]
     },
@@ -440,10 +429,18 @@
       "outputs": [],
       "source": [
         "# Using the grpc client in AzureML Accelerated Models SDK\n",
-        "from azureml.accel import client_from_service\n",
+        "from azureml.accel.client import PredictionClient\n",
+        "\n",
+        "address = aks_service.scoring_uri\n",
+        "ssl_enabled = address.startswith(\"https\")\n",
+        "address = address[address.find('/')+2:].strip('/')\n",
+        "port = 443 if ssl_enabled else 80\n",
         "\n",
         "# Initialize AzureML Accelerated Models client\n",
-        "client = client_from_service(aks_service)"
+        "client = PredictionClient(address=address,\n",
+        "                          port=port,\n",
+        "                          use_ssl=ssl_enabled,\n",
+        "                          service_name=aks_service.name)"
       ]
     },
     {
@@ -543,7 +540,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.5.6"
+      "version": "3.6.0"
     }
   },
   "nbformat": 4,

how-to-use-azureml/deployment/accelerated-models/accelerated-models-quickstart.yml

@@ -1,6 +0,0 @@
-name: accelerated-models-quickstart
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-accel-models
-  - tensorflow

how-to-use-azureml/deployment/accelerated-models/accelerated-models-training.ipynb

@@ -1,12 +1,5 @@
 {
   "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/deployment/accelerated-models/accelerated-models-training.png)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -417,7 +410,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%time\n",
         "# Launch the training\n",
         "tf.reset_default_graph()\n",
         "sess = tf.Session(graph=tf.get_default_graph())\n",
@@ -590,14 +582,11 @@
         "\n",
         "# Convert model\n",
         "convert_request = AccelOnnxConverter.convert_tf_model(ws, registered_model, input_tensors, output_tensors)\n",
-        "if convert_request.wait_for_completion(show_output = False):\n",
-        "    # If the above call succeeded, get the converted model\n",
-        "    converted_model = convert_request.result\n",
-        "    print(\"\\nSuccessfully converted: \", converted_model.name, converted_model.url, converted_model.version, \n",
-        "          converted_model.id, converted_model.created_time, '\\n')\n",
-        "else:\n",
-        "    print(\"Model conversion failed. Showing output.\")\n",
-        "    convert_request.wait_for_completion(show_output = True)\n",
+        "# If it fails, you can run wait_for_completion again with show_output=True.\n",
+        "convert_request.wait_for_completion(show_output=False)\n",
+        "converted_model = convert_request.result\n",
+        "print(\"\\nSuccessfully converted: \", converted_model.name, converted_model.url, converted_model.version, \n",
+        "      converted_model.id, converted_model.created_time, '\\n')\n",
         "\n",
         "# Package into AccelContainerImage\n",
         "image_config = AccelContainerImage.image_configuration()\n",
@@ -666,7 +655,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%time\n",
         "aks_target.wait_for_completion(show_output = True)\n",
         "print(aks_target.provisioning_state)\n",
         "print(aks_target.provisioning_errors)"
@@ -685,7 +673,6 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "%%time\n",
         "from azureml.core.webservice import Webservice, AksWebservice\n",
         "\n",
         "# Set the web service configuration (for creating a test service, we don't want autoscale enabled)\n",
@@ -694,7 +681,7 @@
         "                                                num_replicas=1,\n",
         "                                                auth_enabled = False)\n",
         "\n",
-        "aks_service_name ='my-aks-service-2'\n",
+        "aks_service_name ='my-aks-service'\n",
         "\n",
         "aks_service = Webservice.deploy_from_image(workspace = ws,\n",
         "                                           name = aks_service_name,\n",
@@ -713,9 +700,10 @@
         "\n",
         "<a id=\"create-client\"></a>\n",
         "### 9.a. Create Client\n",
-        "The image supports gRPC and the TensorFlow Serving \"predict\" API. We will create a PredictionClient from the Webservice object that can call into the docker image to get predictions. If you do not have the Webservice object, you can also create [PredictionClient](https://docs.microsoft.com/en-us/python/api/azureml-accel-models/azureml.accel.predictionclient?view=azure-ml-py) directly.\n",
+        "The image supports gRPC and the TensorFlow Serving \"predict\" API. We have a client that can call into the docker image to get predictions. \n",
+        "\n",
+        "**Note:** If you chose to use auth_enabled=True when creating your AksWebservice.deploy_configuration(), see documentation [here](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.webservice(class)?view=azure-ml-py#get-keys--) on how to retrieve your keys and use either key as an argument to PredictionClient(...,access_token=key).",
         "\n",
-        "**Note:** If you chose to use auth_enabled=True when creating your AksWebservice.deploy_configuration(), see documentation [here](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.webservice(class)?view=azure-ml-py#get-keys--) on how to retrieve your keys and use either key as an argument to PredictionClient(...,access_token=key).\n",
         "**WARNING:** If you are running on Azure Notebooks free compute, you will not be able to make outgoing calls to your service. Try locating your client on a different machine to consume it."
       ]
     },
@@ -726,10 +714,18 @@
       "outputs": [],
       "source": [
         "# Using the grpc client in AzureML Accelerated Models SDK\n",
-        "from azureml.accel import client_from_service\n",
+        "from azureml.accel.client import PredictionClient\n",
+        "\n",
+        "address = aks_service.scoring_uri\n",
+        "ssl_enabled = address.startswith(\"https\")\n",
+        "address = address[address.find('/')+2:].strip('/')\n",
+        "port = 443 if ssl_enabled else 80\n",
         "\n",
         "# Initialize AzureML Accelerated Models client\n",
-        "client = client_from_service(aks_service)"
+        "client = PredictionClient(address=address,\n",
+        "                          port=port,\n",
+        "                          use_ssl=ssl_enabled,\n",
+        "                          service_name=aks_service.name)"
       ]
     },
     {
@@ -858,7 +854,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.5.6"
+      "version": "3.6.0"
     }
   },
   "nbformat": 4,

how-to-use-azureml/deployment/accelerated-models/accelerated-models-training.yml

@@ -1,9 +0,0 @@
-name: accelerated-models-training
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-accel-models
-  - tensorflow
-  - keras
-  - tqdm 
-  - sklearn

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

@@ -22,7 +22,7 @@
         "If you want to log custom traces, you will follow the standard deplyment process for AKS and you will:\n",
         "1. Update scoring file.\n",
         "2. Update aks configuration.\n",
-        "3. Deploy the model with this new configuration. "
+        "3. Build new image and deploy it. "
       ]
     },
     {
@@ -178,7 +178,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## 6. Create Inference Configuration"
+        "## 6. Create your new Image"
       ]
     },
     {
@@ -187,11 +187,22 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.model import InferenceConfig\n",
+        "from azureml.core.image import ContainerImage\n",
         "\n",
-        "inference_config = InferenceConfig(runtime= \"python\", \n",
-        "                                   entry_script=\"score.py\",\n",
-        "                                   conda_file=\"myenv.yml\")"
+        "image_config = ContainerImage.image_configuration(execution_script = \"score.py\",\n",
+        "                                                  runtime = \"python\",\n",
+        "                                                  conda_file = \"myenv.yml\",\n",
+        "                                                  description = \"Image with ridge regression model\",\n",
+        "                                                  tags = {'area': \"diabetes\", 'type': \"regression\"}\n",
+        "                                                 )\n",
+        "\n",
+        "image = ContainerImage.create(name = \"myimage1\",\n",
+        "                              # this is the model object\n",
+        "                              models = [model],\n",
+        "                              image_config = image_config,\n",
+        "                              workspace = ws)\n",
+        "\n",
+        "image.wait_for_creation(show_output = True)"
       ]
     },
     {
@@ -209,7 +220,7 @@
       "source": [
         "from azureml.core.webservice import AciWebservice\n",
         "\n",
-        "aci_deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, \n",
+        "aciconfig = AciWebservice.deploy_configuration(cpu_cores = 1, \n",
         "                                               memory_gb = 1, \n",
         "                                               tags = {'area': \"diabetes\", 'type': \"regression\"}, \n",
         "                                               description = 'Predict diabetes using regression model',\n",
@@ -225,7 +236,11 @@
         "from azureml.core.webservice import Webservice\n",
         "\n",
         "aci_service_name = 'my-aci-service-4'\n",
-        "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aci_deployment_config)\n",
+        "print(aci_service_name)\n",
+        "aci_service = Webservice.deploy_from_image(deployment_config = aciconfig,\n",
+        "                                           image = image,\n",
+        "                                           name = aci_service_name,\n",
+        "                                           workspace = ws)\n",
         "aci_service.wait_for_deployment(True)\n",
         "print(aci_service.state)"
       ]
@@ -346,7 +361,7 @@
       "outputs": [],
       "source": [
         "#Set the web service configuration\n",
-        "aks_deployment_config = AksWebservice.deploy_configuration(enable_app_insights=True)"
+        "aks_config = AksWebservice.deploy_configuration(enable_app_insights=True)"
       ]
     },
     {
@@ -364,12 +379,12 @@
       "source": [
         "if aks_target.provisioning_state== \"Succeeded\": \n",
         "    aks_service_name ='aks-w-dc5'\n",
-        "    aks_service = Model.deploy(ws,\n",
-        "                               aks_service_name, \n",
-        "                               [model], \n",
-        "                               inference_config, \n",
-        "                               aks_deployment_config, \n",
-        "                               deployment_target = aks_target)    \n",
+        "    aks_service = Webservice.deploy_from_image(workspace = ws, \n",
+        "                                               name = aks_service_name,\n",
+        "                                               image = image,\n",
+        "                                               deployment_config = aks_config,\n",
+        "                                               deployment_target = aks_target\n",
+        "                                               )\n",
         "    aks_service.wait_for_deployment(show_output = True)\n",
         "    print(aks_service.state)\n",
         "else:\n",
@@ -449,6 +464,7 @@
         "%%time\n",
         "aks_service.delete()\n",
         "aci_service.delete()\n",
+        "image.delete()\n",
         "model.delete()"
       ]
     }

how-to-use-azureml/deployment/onnx/onnx-convert-aml-deploy-tinyyolo.ipynb

@@ -243,7 +243,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Setting up inference configuration\n",
+        "### Create container image\n",
         "First we create a YAML file that specifies which dependencies we would like to see in our container."
       ]
     },
@@ -265,7 +265,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Then we create the inference configuration."
+        "Then we have Azure ML create the container. This step will likely take a few minutes."
       ]
     },
     {
@@ -274,19 +274,48 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.model import InferenceConfig\n",
+        "from azureml.core.image import ContainerImage\n",
         "\n",
-        "inference_config = InferenceConfig(runtime= \"python\", \n",
-        "                                   entry_script=\"score.py\",\n",
-        "                                   conda_file=\"myenv.yml\",\n",
-        "                                   extra_docker_file_steps = \"Dockerfile\")"
+        "image_config = ContainerImage.image_configuration(execution_script = \"score.py\",\n",
+        "                                                  runtime = \"python\",\n",
+        "                                                  conda_file = \"myenv.yml\",\n",
+        "                                                  docker_file = \"Dockerfile\",\n",
+        "                                                  description = \"TinyYOLO ONNX Demo\",\n",
+        "                                                  tags = {\"demo\": \"onnx\"}\n",
+        "                                                 )\n",
+        "\n",
+        "\n",
+        "image = ContainerImage.create(name = \"onnxyolo\",\n",
+        "                              models = [model],\n",
+        "                              image_config = image_config,\n",
+        "                              workspace = ws)\n",
+        "\n",
+        "image.wait_for_creation(show_output = True)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Deploy the model"
+        "In case you need to debug your code, the next line of code accesses the log file."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(image.image_build_log_uri)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We're all set! Let's get our model chugging.\n",
+        "\n",
+        "### Deploy the container image"
       ]
     },
     {
@@ -307,7 +336,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "The following cell will take a few minutes to run as the model gets packaged up and deployed to ACI."
+        "The following cell will likely take a few minutes to run as well."
       ]
     },
     {
@@ -319,9 +348,14 @@
         "from azureml.core.webservice import Webservice\n",
         "from random import randint\n",
         "\n",
-        "aci_service_name = 'my-aci-service-15ad'\n",
+        "aci_service_name = 'onnx-tinyyolo'+str(randint(0,100))\n",
         "print(\"Service\", aci_service_name)\n",
-        "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig)\n",
+        "\n",
+        "aci_service = Webservice.deploy_from_image(deployment_config = aciconfig,\n",
+        "                                           image = image,\n",
+        "                                           name = aci_service_name,\n",
+        "                                           workspace = ws)\n",
+        "\n",
         "aci_service.wait_for_deployment(True)\n",
         "print(aci_service.state)"
       ]

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

@@ -54,7 +54,7 @@
         "\n",
         "### 3. Download sample data and pre-trained ONNX model from ONNX Model Zoo.\n",
         "\n",
-        "In the following lines of code, we download [the trained ONNX Emotion FER+ model and corresponding test data](https://github.com/onnx/models/tree/master/vision/body_analysis/emotion_ferplus) and place them in the same folder as this tutorial notebook. For more information about the FER+ dataset, please visit Microsoft Researcher Emad Barsoum's [FER+ source data repository](https://github.com/ebarsoum/FERPlus)."
+        "In the following lines of code, we download [the trained ONNX Emotion FER+ model and corresponding test data](https://github.com/onnx/models/tree/master/emotion_ferplus) and place them in the same folder as this tutorial notebook. For more information about the FER+ dataset, please visit Microsoft Researcher Emad Barsoum's [FER+ source data repository](https://github.com/ebarsoum/FERPlus)."
       ]
     },
     {
@@ -176,7 +176,7 @@
       "source": [
         "### ONNX FER+ Model Methodology\n",
         "\n",
-        "The image classification model we are using is pre-trained using Microsoft's deep learning cognitive toolkit, [CNTK](https://github.com/Microsoft/CNTK), from the [ONNX model zoo](http://github.com/onnx/models). The model zoo has many other models that can be deployed on cloud providers like AzureML without any additional training. To ensure that our cloud deployed model works, we use testing data from the well-known FER+ data set, provided as part of the [trained Emotion Recognition model](https://github.com/onnx/models/tree/master/vision/body_analysis/emotion_ferplus) in the ONNX model zoo.\n",
+        "The image classification model we are using is pre-trained using Microsoft's deep learning cognitive toolkit, [CNTK](https://github.com/Microsoft/CNTK), from the [ONNX model zoo](http://github.com/onnx/models). The model zoo has many other models that can be deployed on cloud providers like AzureML without any additional training. To ensure that our cloud deployed model works, we use testing data from the well-known FER+ data set, provided as part of the [trained Emotion Recognition model](https://github.com/onnx/models/tree/master/emotion_ferplus) in the ONNX model zoo.\n",
         "\n",
         "The original Facial Emotion Recognition (FER) Dataset was released in 2013 by Pierre-Luc Carrier and Aaron Courville as part of a [Kaggle Competition](https://www.kaggle.com/c/challenges-in-representation-learning-facial-expression-recognition-challenge/data), but some of the labels are not entirely appropriate for the expression. In the FER+ Dataset, each photo was evaluated by at least 10 croud sourced reviewers, creating a more accurate basis for ground truth. \n",
         "\n",
@@ -341,7 +341,9 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Setup inference configuration"
+        "### Create the Container Image\n",
+        "\n",
+        "This step will likely take a few minutes."
       ]
     },
     {
@@ -350,19 +352,48 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.model import InferenceConfig\n",
+        "from azureml.core.image import ContainerImage\n",
         "\n",
-        "inference_config = InferenceConfig(runtime= \"python\", \n",
-        "                                   entry_script=\"score.py\",\n",
-        "                                   conda_file=\"myenv.yml\",\n",
-        "                                   extra_docker_file_steps = \"Dockerfile\")"
+        "image_config = ContainerImage.image_configuration(execution_script = \"score.py\",\n",
+        "                                                  runtime = \"python\",\n",
+        "                                                  conda_file = \"myenv.yml\",\n",
+        "                                                  docker_file = \"Dockerfile\",\n",
+        "                                                  description = \"Emotion ONNX Runtime container\",\n",
+        "                                                  tags = {\"demo\": \"onnx\"})\n",
+        "\n",
+        "\n",
+        "image = ContainerImage.create(name = \"onnximage\",\n",
+        "                              # this is the model object\n",
+        "                              models = [model],\n",
+        "                              image_config = image_config,\n",
+        "                              workspace = ws)\n",
+        "\n",
+        "image.wait_for_creation(show_output = True)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Deploy the model"
+        "In case you need to debug your code, the next line of code accesses the log file."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(image.image_build_log_uri)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We're all done specifying what we want our virtual machine to do. Let's configure and deploy our container image.\n",
+        "\n",
+        "### Deploy the container image"
       ]
     },
     {
@@ -379,13 +410,6 @@
         "                                               description = 'ONNX for emotion recognition model')"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "The following cell will likely take a few minutes to run as well."
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -396,11 +420,23 @@
         "\n",
         "aci_service_name = 'onnx-demo-emotion'\n",
         "print(\"Service\", aci_service_name)\n",
-        "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig)\n",
+        "\n",
+        "aci_service = Webservice.deploy_from_image(deployment_config = aciconfig,\n",
+        "                                           image = image,\n",
+        "                                           name = aci_service_name,\n",
+        "                                           workspace = ws)\n",
+        "\n",
         "aci_service.wait_for_deployment(True)\n",
         "print(aci_service.state)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The following cell will likely take a few minutes to run as well."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -434,7 +470,7 @@
         "\n",
         "### Useful Helper Functions\n",
         "\n",
-        "We preprocess and postprocess our data (see score.py file) using the helper functions specified in the [ONNX FER+ Model page in the Model Zoo repository](https://github.com/onnx/models/tree/master/vision/body_analysis/emotion_ferplus)."
+        "We preprocess and postprocess our data (see score.py file) using the helper functions specified in the [ONNX FER+ Model page in the Model Zoo repository](https://github.com/onnx/models/tree/master/emotion_ferplus)."
       ]
     },
     {

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

@@ -54,7 +54,7 @@
         "\n",
         "### 3. Download sample data and pre-trained ONNX model from ONNX Model Zoo.\n",
         "\n",
-        "In the following lines of code, we download [the trained ONNX MNIST model and corresponding test data](https://github.com/onnx/models/tree/master/vision/classification/mnist) and place them in the same folder as this tutorial notebook. For more information about the MNIST dataset, please visit [Yan LeCun's website](http://yann.lecun.com/exdb/mnist/)."
+        "In the following lines of code, we download [the trained ONNX MNIST model and corresponding test data](https://github.com/onnx/models/tree/master/mnist) and place them in the same folder as this tutorial notebook. For more information about the MNIST dataset, please visit [Yan LeCun's website](http://yann.lecun.com/exdb/mnist/)."
       ]
     },
     {
@@ -187,7 +187,7 @@
       "source": [
         "### ONNX MNIST Model Methodology\n",
         "\n",
-        "The image classification model we are using is pre-trained using Microsoft's deep learning cognitive toolkit, [CNTK](https://github.com/Microsoft/CNTK), from the [ONNX model zoo](http://github.com/onnx/models). The model zoo has many other models that can be deployed on cloud providers like AzureML without any additional training. To ensure that our cloud deployed model works, we use testing data from the famous MNIST data set, provided as part of the [trained MNIST model](https://github.com/onnx/models/tree/master/vision/classification/mnist) in the ONNX model zoo.\n",
+        "The image classification model we are using is pre-trained using Microsoft's deep learning cognitive toolkit, [CNTK](https://github.com/Microsoft/CNTK), from the [ONNX model zoo](http://github.com/onnx/models). The model zoo has many other models that can be deployed on cloud providers like AzureML without any additional training. To ensure that our cloud deployed model works, we use testing data from the famous MNIST data set, provided as part of the [trained MNIST model](https://github.com/onnx/models/tree/master/mnist) in the ONNX model zoo.\n",
         "\n",
         "***Input: Handwritten Images from MNIST Dataset***\n",
         "\n",
@@ -325,7 +325,8 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Create Inference Configuration"
+        "### Create the Container Image\n",
+        "This step will likely take a few minutes."
       ]
     },
     {
@@ -334,19 +335,48 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.model import InferenceConfig\n",
+        "from azureml.core.image import ContainerImage\n",
         "\n",
-        "inference_config = InferenceConfig(runtime= \"python\", \n",
-        "                                   entry_script=\"score.py\",\n",
-        "                                   extra_docker_file_steps = \"Dockerfile\",\n",
-        "                                   conda_file=\"myenv.yml\")"
+        "image_config = ContainerImage.image_configuration(execution_script = \"score.py\",\n",
+        "                                                  runtime = \"python\",\n",
+        "                                                  conda_file = \"myenv.yml\",\n",
+        "                                                  docker_file = \"Dockerfile\",\n",
+        "                                                  description = \"MNIST ONNX Runtime container\",\n",
+        "                                                  tags = {\"demo\": \"onnx\"}) \n",
+        "\n",
+        "\n",
+        "image = ContainerImage.create(name = \"onnximage\",\n",
+        "                              # this is the model object\n",
+        "                              models = [model],\n",
+        "                              image_config = image_config,\n",
+        "                              workspace = ws)\n",
+        "\n",
+        "image.wait_for_creation(show_output = True)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Deploy the model"
+        "In case you need to debug your code, the next line of code accesses the log file."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(image.image_build_log_uri)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We're all done specifying what we want our virtual machine to do. Let's configure and deploy our container image.\n",
+        "\n",
+        "### Deploy the container image"
       ]
     },
     {
@@ -367,7 +397,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "The following cell will likely take a few minutes to run."
+        "The following cell will likely take a few minutes to run as well."
       ]
     },
     {
@@ -380,7 +410,12 @@
         "\n",
         "aci_service_name = 'onnx-demo-mnist'\n",
         "print(\"Service\", aci_service_name)\n",
-        "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig)\n",
+        "\n",
+        "aci_service = Webservice.deploy_from_image(deployment_config = aciconfig,\n",
+        "                                           image = image,\n",
+        "                                           name = aci_service_name,\n",
+        "                                           workspace = ws)\n",
+        "\n",
         "aci_service.wait_for_deployment(True)\n",
         "print(aci_service.state)"
       ]

how-to-use-azureml/deployment/onnx/onnx-modelzoo-aml-deploy-resnet50.ipynb

@@ -28,7 +28,7 @@
         "ONNX is an open format for representing machine learning and deep learning models. ONNX enables open and interoperable AI by enabling data scientists and developers to use the tools of their choice without worrying about lock-in and flexibility to deploy to a variety of platforms. ONNX is developed and supported by a community of partners including Microsoft, Facebook, and Amazon. For more information, explore the [ONNX website](http://onnx.ai).\n",
         "\n",
         "## ResNet50 Details\n",
-        "ResNet classifies the major object in an input image into a set of 1000 pre-defined classes. For more information about the ResNet50 model and how it was created can be found on the [ONNX Model Zoo github](https://github.com/onnx/models/tree/master/vision/classification/resnet). "
+        "ResNet classifies the major object in an input image into a set of 1000 pre-defined classes. For more information about the ResNet50 model and how it was created can be found on the [ONNX Model Zoo github](https://github.com/onnx/models/tree/master/models/image_classification/resnet). "
       ]
     },
     {
@@ -221,7 +221,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Create inference configuration"
+        "### Create container image"
       ]
     },
     {
@@ -249,7 +249,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Create the inference configuration object"
+        "Then we have Azure ML create the container. This step will likely take a few minutes."
       ]
     },
     {
@@ -258,19 +258,48 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.model import InferenceConfig\n",
+        "from azureml.core.image import ContainerImage\n",
         "\n",
-        "inference_config = InferenceConfig(runtime= \"python\", \n",
-        "                                   entry_script=\"score.py\",\n",
-        "                                   conda_file=\"myenv.yml\",\n",
-        "                                   extra_docker_file_steps = \"Dockerfile\")"
+        "image_config = ContainerImage.image_configuration(execution_script = \"score.py\",\n",
+        "                                                  runtime = \"python\",\n",
+        "                                                  conda_file = \"myenv.yml\",\n",
+        "                                                  docker_file = \"Dockerfile\",\n",
+        "                                                  description = \"ONNX ResNet50 Demo\",\n",
+        "                                                  tags = {\"demo\": \"onnx\"}\n",
+        "                                                 )\n",
+        "\n",
+        "\n",
+        "image = ContainerImage.create(name = \"onnxresnet50v2\",\n",
+        "                              models = [model],\n",
+        "                              image_config = image_config,\n",
+        "                              workspace = ws)\n",
+        "\n",
+        "image.wait_for_creation(show_output = True)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Deploy the model"
+        "In case you need to debug your code, the next line of code accesses the log file."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(image.image_build_log_uri)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We're all set! Let's get our model chugging.\n",
+        "\n",
+        "### Deploy the container image"
       ]
     },
     {
@@ -305,7 +334,12 @@
         "\n",
         "aci_service_name = 'onnx-demo-resnet50'+str(randint(0,100))\n",
         "print(\"Service\", aci_service_name)\n",
-        "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig)\n",
+        "\n",
+        "aci_service = Webservice.deploy_from_image(deployment_config = aciconfig,\n",
+        "                                           image = image,\n",
+        "                                           name = aci_service_name,\n",
+        "                                           workspace = ws)\n",
+        "\n",
         "aci_service.wait_for_deployment(True)\n",
         "print(aci_service.state)"
       ]

how-to-use-azureml/deployment/onnx/onnx-train-pytorch-aml-deploy-mnist.ipynb

@@ -28,7 +28,7 @@
         "ONNX is an open format for representing machine learning and deep learning models. ONNX enables open and interoperable AI by enabling data scientists and developers to use the tools of their choice without worrying about lock-in and flexibility to deploy to a variety of platforms. ONNX is developed and supported by a community of partners including Microsoft, Facebook, and Amazon. For more information, explore the [ONNX website](http://onnx.ai).\n",
         "\n",
         "## MNIST Details\n",
-        "The Modified National Institute of Standards and Technology (MNIST) dataset consists of 70,000 grayscale images. Each image is a handwritten digit of 28x28 pixels, representing numbers from 0 to 9. For more information about the MNIST dataset, please visit [Yan LeCun's website](http://yann.lecun.com/exdb/mnist/). For more information about the MNIST model and how it was created can be found on the [ONNX Model Zoo github](https://github.com/onnx/models/tree/master/vision/classification/mnist). "
+        "The Modified National Institute of Standards and Technology (MNIST) dataset consists of 70,000 grayscale images. Each image is a handwritten digit of 28x28 pixels, representing numbers from 0 to 9. For more information about the MNIST dataset, please visit [Yan LeCun's website](http://yann.lecun.com/exdb/mnist/). For more information about the MNIST model and how it was created can be found on the [ONNX Model Zoo github](https://github.com/onnx/models/tree/master/mnist). "
       ]
     },
     {
@@ -401,7 +401,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Create inference configuration\n",
+        "### Create container image\n",
         "First we create a YAML file that specifies which dependencies we would like to see in our container."
       ]
     },
@@ -423,7 +423,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Then we setup the inference configuration "
+        "Then we have Azure ML create the container. This step will likely take a few minutes."
       ]
     },
     {
@@ -432,19 +432,48 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.model import InferenceConfig\n",
+        "from azureml.core.image import ContainerImage\n",
         "\n",
-        "inference_config = InferenceConfig(runtime= \"python\", \n",
-        "                                   entry_script=\"score.py\",\n",
-        "                                   conda_file=\"myenv.yml\",\n",
-        "                                   extra_docker_file_steps = \"Dockerfile\")"
+        "image_config = ContainerImage.image_configuration(execution_script = \"score.py\",\n",
+        "                                                  runtime = \"python\",\n",
+        "                                                  conda_file = \"myenv.yml\",\n",
+        "                                                  docker_file = \"Dockerfile\",\n",
+        "                                                  description = \"MNIST ONNX Demo\",\n",
+        "                                                  tags = {\"demo\": \"onnx\"}\n",
+        "                                                 )\n",
+        "\n",
+        "\n",
+        "image = ContainerImage.create(name = \"onnxmnistdemo\",\n",
+        "                              models = [model],\n",
+        "                              image_config = image_config,\n",
+        "                              workspace = ws)\n",
+        "\n",
+        "image.wait_for_creation(show_output = True)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Deploy the model"
+        "In case you need to debug your code, the next line of code accesses the log file."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(image.image_build_log_uri)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We're all set! Let's get our model chugging.\n",
+        "\n",
+        "### Deploy the container image"
       ]
     },
     {
@@ -475,12 +504,16 @@
       "outputs": [],
       "source": [
         "from azureml.core.webservice import Webservice\n",
-        "from azureml.core.model import Model\n",
         "from random import randint\n",
         "\n",
         "aci_service_name = 'onnx-demo-mnist'+str(randint(0,100))\n",
         "print(\"Service\", aci_service_name)\n",
-        "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig)\n",
+        "\n",
+        "aci_service = Webservice.deploy_from_image(deployment_config = aciconfig,\n",
+        "                                           image = image,\n",
+        "                                           name = aci_service_name,\n",
+        "                                           workspace = ws)\n",
+        "\n",
         "aci_service.wait_for_deployment(True)\n",
         "print(aci_service.state)"
       ]

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

@@ -34,6 +34,7 @@
         "from azureml.core import Workspace\n",
         "from azureml.core.compute import AksCompute, ComputeTarget\n",
         "from azureml.core.webservice import Webservice, AksWebservice\n",
+        "from azureml.core.image import Image\n",
         "from azureml.core.model import Model"
       ]
     },
@@ -96,51 +97,8 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# Create the Environment\n",
-        "Create an environment that the model will be deployed with"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core import Environment\n",
-        "from azureml.core.conda_dependencies import CondaDependencies \n",
-        "\n",
-        "conda_deps = CondaDependencies.create(conda_packages=['numpy','scikit-learn'], pip_packages=['azureml-defaults'])\n",
-        "myenv = Environment(name='myenv')\n",
-        "myenv.python.conda_dependencies = conda_deps"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "#### Use a custom Docker image\n",
-        "\n",
-        "You can also specify a custom Docker image to be used as base image if you don't want to use the default base image provided by Azure ML. Please make sure the custom Docker image has Ubuntu >= 16.04, Conda >= 4.5.\\* and Python(3.5.\\* or 3.6.\\*).\n",
-        "\n",
-        "Only supported with `python` runtime.\n",
-        "```python\n",
-        "# use an image available in public Container Registry without authentication\n",
-        "myenv.docker.base_image = \"mcr.microsoft.com/azureml/o16n-sample-user-base/ubuntu-miniconda\"\n",
-        "\n",
-        "# or, use an image available in a private Container Registry\n",
-        "myenv.docker.base_image = \"myregistry.azurecr.io/mycustomimage:1.0\"\n",
-        "myenv.docker.base_image_registry.address = \"myregistry.azurecr.io\"\n",
-        "myenv.docker.base_image_registry.username = \"username\"\n",
-        "myenv.docker.base_image_registry.password = \"password\"\n",
-        "```"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Write the Entry Script\n",
-        "Write the script that will be used to predict on your model"
+        "# Create an image\n",
+        "Create an image using the registered model the script that will load and run the model."
       ]
     },
     {
@@ -179,11 +137,17 @@
       ]
     },
     {
-      "cell_type": "markdown",
+      "cell_type": "code",
+      "execution_count": null,
       "metadata": {},
+      "outputs": [],
       "source": [
-        "# Create the InferenceConfig\n",
-        "Create the inference config that will be used when deploying the model"
+        "from azureml.core.conda_dependencies import CondaDependencies \n",
+        "\n",
+        "myenv = CondaDependencies.create(conda_packages=['numpy','scikit-learn'])\n",
+        "\n",
+        "with open(\"myenv.yml\",\"w\") as f:\n",
+        "    f.write(myenv.serialize_to_string())"
       ]
     },
     {
@@ -192,9 +156,47 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from azureml.core.model import InferenceConfig\n",
+        "from azureml.core.image import ContainerImage\n",
         "\n",
-        "inf_config = InferenceConfig(entry_script='score.py', environment=myenv)"
+        "image_config = ContainerImage.image_configuration(execution_script = \"score.py\",\n",
+        "                                                  runtime = \"python\",\n",
+        "                                                  conda_file = \"myenv.yml\",\n",
+        "                                                  description = \"Image with ridge regression model\",\n",
+        "                                                  tags = {'area': \"diabetes\", 'type': \"regression\"}\n",
+        "                                                 )\n",
+        "\n",
+        "image = ContainerImage.create(name = \"myimage1\",\n",
+        "                              # this is the model object\n",
+        "                              models = [model],\n",
+        "                              image_config = image_config,\n",
+        "                              workspace = ws)\n",
+        "\n",
+        "image.wait_for_creation(show_output = True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Use a custom Docker image\n",
+        "\n",
+        "You can also specify a custom Docker image to be used as base image if you don't want to use the default base image provided by Azure ML. Please make sure the custom Docker image has Ubuntu >= 16.04, Conda >= 4.5.\\* and Python(3.5.\\* or 3.6.\\*).\n",
+        "\n",
+        "Only Supported for `ContainerImage`(from azureml.core.image) with `python` runtime.\n",
+        "```python\n",
+        "# use an image available in public Container Registry without authentication\n",
+        "image_config.base_image = \"mcr.microsoft.com/azureml/o16n-sample-user-base/ubuntu-miniconda\"\n",
+        "\n",
+        "# or, use an image available in a private Container Registry\n",
+        "image_config.base_image = \"myregistry.azurecr.io/mycustomimage:1.0\"\n",
+        "image_config.base_image_registry.address = \"myregistry.azurecr.io\"\n",
+        "image_config.base_image_registry.username = \"username\"\n",
+        "image_config.base_image_registry.password = \"password\"\n",
+        "\n",
+        "# or, use an image built during training.\n",
+        "image_config.base_image = run.properties[\"AzureML.DerivedImageName\"]\n",
+        "```\n",
+        "You can get the address of training image from the properties of a Run object. Only new runs submitted with azureml-sdk>=1.0.22 to AMLCompute targets will have the 'AzureML.DerivedImageName' property. Instructions on how to get a Run can be found in [manage-runs](../../training/manage-runs/manage-runs.ipynb). \n"
       ]
     },
     {
@@ -235,21 +237,23 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# from azureml.core.compute import ComputeTarget, AksCompute\n",
+        "'''\n",
+        "from azureml.core.compute import ComputeTarget, AksCompute\n",
         "\n",
-        "# # Create the compute configuration and set virtual network information\n",
-        "# config = AksCompute.provisioning_configuration(location=\"eastus2\")\n",
-        "# config.vnet_resourcegroup_name = \"mygroup\"\n",
-        "# config.vnet_name = \"mynetwork\"\n",
-        "# config.subnet_name = \"default\"\n",
-        "# config.service_cidr = \"10.0.0.0/16\"\n",
-        "# config.dns_service_ip = \"10.0.0.10\"\n",
-        "# config.docker_bridge_cidr = \"172.17.0.1/16\"\n",
+        "# Create the compute configuration and set virtual network information\n",
+        "config = AksCompute.provisioning_configuration(location=\"eastus2\")\n",
+        "config.vnet_resourcegroup_name = \"mygroup\"\n",
+        "config.vnet_name = \"mynetwork\"\n",
+        "config.subnet_name = \"default\"\n",
+        "config.service_cidr = \"10.0.0.0/16\"\n",
+        "config.dns_service_ip = \"10.0.0.10\"\n",
+        "config.docker_bridge_cidr = \"172.17.0.1/16\"\n",
         "\n",
-        "# # Create the compute target\n",
-        "# aks_target = ComputeTarget.create(workspace = ws,\n",
-        "#                                   name = \"myaks\",\n",
-        "#                                   provisioning_configuration = config)"
+        "# Create the compute target\n",
+        "aks_target = ComputeTarget.create(workspace = ws,\n",
+        "                                  name = \"myaks\",\n",
+        "                                  provisioning_configuration = config)\n",
+        "'''"
       ]
     },
     {
@@ -296,15 +300,17 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# # Use the default configuration (can also provide parameters to customize)\n",
-        "# resource_id = '/subscriptions/92c76a2f-0e1c-4216-b65e-abf7a3f34c1e/resourcegroups/raymondsdk0604/providers/Microsoft.ContainerService/managedClusters/my-aks-0605d37425356b7d01'\n",
+        "'''\n",
+        "# Use the default configuration (can also provide parameters to customize)\n",
+        "resource_id = '/subscriptions/92c76a2f-0e1c-4216-b65e-abf7a3f34c1e/resourcegroups/raymondsdk0604/providers/Microsoft.ContainerService/managedClusters/my-aks-0605d37425356b7d01'\n",
         "\n",
-        "# create_name='my-existing-aks' \n",
-        "# # Create the cluster\n",
-        "# attach_config = AksCompute.attach_configuration(resource_id=resource_id)\n",
-        "# aks_target = ComputeTarget.attach(workspace=ws, name=create_name, attach_configuration=attach_config)\n",
-        "# # Wait for the operation to complete\n",
-        "# aks_target.wait_for_completion(True)"
+        "create_name='my-existing-aks' \n",
+        "# Create the cluster\n",
+        "attach_config = AksCompute.attach_configuration(resource_id=resource_id)\n",
+        "aks_target = ComputeTarget.attach(workspace=ws, name=create_name, attach_configuration=attach_config)\n",
+        "# Wait for the operation to complete\n",
+        "aks_target.wait_for_completion(True)\n",
+        "'''"
       ]
     },
     {
@@ -320,11 +326,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Set the web service configuration (using default here)\n",
-        "aks_config = AksWebservice.deploy_configuration()\n",
-        "\n",
-        "# # Enable token auth and disable (key) auth on the webservice\n",
-        "# aks_config = AksWebservice.deploy_configuration(token_auth_enabled=True, auth_enabled=False)\n"
+        "#Set the web service configuration (using default here)\n",
+        "aks_config = AksWebservice.deploy_configuration()"
       ]
     },
     {
@@ -336,13 +339,11 @@
         "%%time\n",
         "aks_service_name ='aks-service-1'\n",
         "\n",
-        "aks_service = Model.deploy(workspace=ws,\n",
-        "                           name=aks_service_name,\n",
-        "                           models=[model],\n",
-        "                           inference_config=inf_config,\n",
-        "                           deployment_config=aks_config,\n",
-        "                           deployment_target=aks_target)\n",
-        "\n",
+        "aks_service = Webservice.deploy_from_image(workspace = ws, \n",
+        "                                           name = aks_service_name,\n",
+        "                                           image = image,\n",
+        "                                           deployment_config = aks_config,\n",
+        "                                           deployment_target = aks_target)\n",
         "aks_service.wait_for_deployment(show_output = True)\n",
         "print(aks_service.state)"
       ]
@@ -389,12 +390,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# # if (key) auth is enabled, retrieve the API keys. AML generates two keys.\n",
-        "# key1, Key2 = aks_service.get_keys()\n",
-        "# print(key1)\n",
-        "\n",
-        "# # if token auth is enabled, retrieve the token.\n",
-        "# access_token, refresh_after = aks_service.get_token()"
+        "# retreive the API keys. AML generates two keys.\n",
+        "'''\n",
+        "key1, Key2 = aks_service.get_keys()\n",
+        "print(key1)\n",
+        "'''"
       ]
     },
     {
@@ -404,28 +404,27 @@
       "outputs": [],
       "source": [
         "# construct raw HTTP request and send to the service\n",
-        "# %%time\n",
+        "'''\n",
+        "%%time\n",
         "\n",
-        "# import requests\n",
+        "import requests\n",
         "\n",
-        "# import json\n",
+        "import json\n",
         "\n",
-        "# test_sample = json.dumps({'data': [\n",
-        "#     [1,2,3,4,5,6,7,8,9,10], \n",
-        "#     [10,9,8,7,6,5,4,3,2,1]\n",
-        "# ]})\n",
-        "# test_sample = bytes(test_sample,encoding = 'utf8')\n",
+        "test_sample = json.dumps({'data': [\n",
+        "    [1,2,3,4,5,6,7,8,9,10], \n",
+        "    [10,9,8,7,6,5,4,3,2,1]\n",
+        "]})\n",
+        "test_sample = bytes(test_sample,encoding = 'utf8')\n",
         "\n",
-        "# # If (key) auth is enabled, don't forget to add key to the HTTP header.\n",
-        "# headers = {'Content-Type':'application/json', 'Authorization': 'Bearer ' + key1}\n",
+        "# Don't forget to add key to the HTTP header.\n",
+        "headers = {'Content-Type':'application/json', 'Authorization': 'Bearer ' + key1}\n",
         "\n",
-        "# # If token auth is enabled, don't forget to add token to the HTTP header.\n",
-        "# headers = {'Content-Type':'application/json', 'Authorization': 'Bearer ' + access_token}\n",
-        "\n",
-        "# resp = requests.post(aks_service.scoring_uri, test_sample, headers=headers)\n",
+        "resp = requests.post(aks_service.scoring_uri, test_sample, headers=headers)\n",
         "\n",
         "\n",
-        "# print(\"prediction:\", resp.text)"
+        "print(\"prediction:\", resp.text)\n",
+        "'''"
       ]
     },
     {
@@ -444,6 +443,7 @@
       "source": [
         "%%time\n",
         "aks_service.delete()\n",
+        "image.delete()\n",
         "model.delete()"
       ]
     }

how-to-use-azureml/explain-model/README.md

@@ -1,11 +1,8 @@
 ## Using explain model APIs
 
-<a name="samples"></a>
-# Explain Model SDK Sample Notebooks
-
 Follow these sample notebooks to learn:
 
-1. [Explain tabular data locally](tabular-data): Basic examples of explaining model trained on tabular data.
-2. [Explain on remote AMLCompute](azure-integration/remote-explanation): Explain a model on a remote AMLCompute target.
-3. [Explain tabular data with Run History](azure-integration/run-history): Explain a model with Run History.
-4. [Operationalize model explanation](azure-integration/scoring-time): Operationalize model explanation as a web service.
+1. [Explain tabular data locally](explain-tabular-data-local): Basic example of explaining model trained on tabular data.
+4. [Explain on remote AMLCompute](explain-on-amlcompute): Explain a model on a remote AMLCompute target.
+5. [Explain tabular data with Run History](explain-tabular-data-run-history): Explain a model with Run History.
+7. [Explain raw features](explain-tabular-data-raw-features): Explain the raw features of a trained model.

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

@@ -1,8 +0,0 @@
-name: explain-model-on-amlcompute
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-explain-model
-  - azureml-contrib-explain-model
-  - sklearn-pandas
-  - azureml-dataprep

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

@@ -1,645 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/azure-integration/run-history/save-retrieve-explanations-run-history.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Save and retrieve explanations via Azure Machine Learning Run History\n",
-        "\n",
-        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to save and retrieve classification model explanations to/from Azure Machine Learning Run History.**_\n",
-        "\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Run model explainer locally at training time](#Explain)\n",
-        "    1. Apply feature transformations\n",
-        "    1. Train a binary classification model\n",
-        "    1. Explain the model on raw features\n",
-        "        1. Generate global explanations\n",
-        "        1. Generate local explanations\n",
-        "1. [Upload model explanations to Azure Machine Learning Run History](#Upload)\n",
-        "1. [Download model explanations from Azure Machine Learning Run History](#Download)\n",
-        "1. [Visualize explanations](#Visualize)\n",
-        "1. [Next steps](#Next)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "\n",
-        "This notebook showcases how to explain a classification model predictions locally at training time, upload explanations to the Azure Machine Learning's run history, and download previously-uploaded explanations from the Run History.\n",
-        "It demonstrates the API calls that you need to make to upload/download the global and local explanations and a visualization dashboard that provides an interactive way of discovering patterns in data and downloaded explanations.\n",
-        "\n",
-        "We will showcase three tabular data explainers: TabularExplainer (SHAP), MimicExplainer (global surrogate), and PFIExplainer.\n",
-        "\n",
-        "\n",
-        "\n",
-        "Problem: IBM employee attrition classification with scikit-learn (run model explainer locally and upload explanation to the Azure Machine Learning Run History)\n",
-        "\n",
-        "1. Train a SVM classification model using Scikit-learn\n",
-        "2. Run 'explain_model' with AML Run History, which leverages run history service to store and manage the explanation data\n",
-        "---\n",
-        "\n",
-        "## Setup\n",
-        "\n",
-        "You will need to have extensions enabled prior to jupyter kernel starting to see the visualization dashboard.\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "(myenv) $ jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "```\n",
-        "Or\n",
-        "\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install azureml.contrib.explain.model.visualize --user --py\n",
-        "(myenv) $ jupyter nbextension enable azureml.contrib.explain.model.visualize --user --py\n",
-        "```\n",
-        "\n",
-        "If you are using Jupyter Labs run the following commands instead:\n",
-        "```\n",
-        "(myenv) $ jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
-        "(myenv) $ jupyter labextension install microsoft-mli-widget\n",
-        "```"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Explain\n",
-        "\n",
-        "### Run model explainer locally at training time"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.pipeline import Pipeline\n",
-        "from sklearn.impute import SimpleImputer\n",
-        "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
-        "from sklearn.svm import SVC\n",
-        "import pandas as pd\n",
-        "import numpy as np\n",
-        "\n",
-        "# Explainers:\n",
-        "# 1. SHAP Tabular Explainer\n",
-        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 2. Mimic Explainer\n",
-        "from azureml.explain.model.mimic.mimic_explainer import MimicExplainer\n",
-        "# You can use one of the following four interpretable models as a global surrogate to the black box model\n",
-        "from azureml.explain.model.mimic.models.lightgbm_model import LGBMExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import LinearExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import SGDExplainableModel\n",
-        "from azureml.explain.model.mimic.models.tree_model import DecisionTreeExplainableModel\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 3. PFI Explainer\n",
-        "from azureml.explain.model.permutation.permutation_importance import PFIExplainer "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Load the IBM employee attrition data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# get the IBM employee attrition dataset\n",
-        "outdirname = 'dataset.6.21.19'\n",
-        "try:\n",
-        "    from urllib import urlretrieve\n",
-        "except ImportError:\n",
-        "    from urllib.request import urlretrieve\n",
-        "import zipfile\n",
-        "zipfilename = outdirname + '.zip'\n",
-        "urlretrieve('https://publictestdatasets.blob.core.windows.net/data/' + zipfilename, zipfilename)\n",
-        "with zipfile.ZipFile(zipfilename, 'r') as unzip:\n",
-        "    unzip.extractall('.')\n",
-        "attritionData = pd.read_csv('./WA_Fn-UseC_-HR-Employee-Attrition.csv')\n",
-        "\n",
-        "# Dropping Employee count as all values are 1 and hence attrition is independent of this feature\n",
-        "attritionData = attritionData.drop(['EmployeeCount'], axis=1)\n",
-        "# Dropping Employee Number since it is merely an identifier\n",
-        "attritionData = attritionData.drop(['EmployeeNumber'], axis=1)\n",
-        "\n",
-        "attritionData = attritionData.drop(['Over18'], axis=1)\n",
-        "\n",
-        "# Since all values are 80\n",
-        "attritionData = attritionData.drop(['StandardHours'], axis=1)\n",
-        "\n",
-        "# Converting target variables from string to numerical values\n",
-        "target_map = {'Yes': 1, 'No': 0}\n",
-        "attritionData[\"Attrition_numerical\"] = attritionData[\"Attrition\"].apply(lambda x: target_map[x])\n",
-        "target = attritionData[\"Attrition_numerical\"]\n",
-        "\n",
-        "attritionXData = attritionData.drop(['Attrition_numerical', 'Attrition'], axis=1)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Split data into train and test\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "x_train, x_test, y_train, y_test = train_test_split(attritionXData, \n",
-        "                                                    target, \n",
-        "                                                    test_size = 0.2,\n",
-        "                                                    random_state=0,\n",
-        "                                                    stratify=target)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Creating dummy columns for each categorical feature\n",
-        "categorical = []\n",
-        "for col, value in attritionXData.iteritems():\n",
-        "    if value.dtype == 'object':\n",
-        "        categorical.append(col)\n",
-        "        \n",
-        "# Store the numerical columns in a list numerical\n",
-        "numerical = attritionXData.columns.difference(categorical)        "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Transform raw features"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "We can explain raw features by either using a `sklearn.compose.ColumnTransformer` or a list of fitted transformer tuples. The cell below uses `sklearn.compose.ColumnTransformer`. In case you want to run the example with the list of fitted transformer tuples, comment the cell below and uncomment the cell that follows after. "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.compose import ColumnTransformer\n",
-        "\n",
-        "# We create the preprocessing pipelines for both numeric and categorical data.\n",
-        "numeric_transformer = Pipeline(steps=[\n",
-        "    ('imputer', SimpleImputer(strategy='median')),\n",
-        "    ('scaler', StandardScaler())])\n",
-        "\n",
-        "categorical_transformer = Pipeline(steps=[\n",
-        "    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),\n",
-        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))])\n",
-        "\n",
-        "transformations = ColumnTransformer(\n",
-        "    transformers=[\n",
-        "        ('num', numeric_transformer, numerical),\n",
-        "        ('cat', categorical_transformer, categorical)])\n",
-        "\n",
-        "# Append classifier to preprocessing pipeline.\n",
-        "# Now we have a full prediction pipeline.\n",
-        "clf = Pipeline(steps=[('preprocessor', transformations),\n",
-        "                      ('classifier', SVC(kernel='linear', C = 1.0, probability=True))])"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "'''\n",
-        "# Uncomment below if sklearn-pandas is not installed\n",
-        "#!pip install sklearn-pandas\n",
-        "from sklearn_pandas import DataFrameMapper\n",
-        "\n",
-        "# Impute, standardize the numeric features and one-hot encode the categorical features.    \n",
-        "\n",
-        "\n",
-        "numeric_transformations = [([f], Pipeline(steps=[('imputer', SimpleImputer(strategy='median')), ('scaler', StandardScaler())])) for f in numerical]\n",
-        "\n",
-        "categorical_transformations = [([f], OneHotEncoder(handle_unknown='ignore', sparse=False)) for f in categorical]\n",
-        "\n",
-        "transformations = numeric_transformations + categorical_transformations\n",
-        "\n",
-        "# Append classifier to preprocessing pipeline.\n",
-        "# Now we have a full prediction pipeline.\n",
-        "clf = Pipeline(steps=[('preprocessor', transformations),\n",
-        "                      ('classifier', SVC(kernel='linear', C = 1.0, probability=True))]) \n",
-        "\n",
-        "\n",
-        "\n",
-        "'''"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Train a SVM classification model, which you want to explain"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "model = clf.fit(x_train, y_train)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain predictions on your local machine"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# 1. Using SHAP TabularExplainer\n",
-        "# clf.steps[-1][1] returns the trained classification model\n",
-        "explainer = TabularExplainer(clf.steps[-1][1], \n",
-        "                             initialization_examples=x_train, \n",
-        "                             features=attritionXData.columns, \n",
-        "                             classes=[\"Not leaving\", \"leaving\"], \n",
-        "                             transformations=transformations)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 2. Using MimicExplainer\n",
-        "# augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns. \n",
-        "# max_num_of_augmentations is optional and defines max number of times we can increase the input data size.\n",
-        "# LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel\n",
-        "# explainer = MimicExplainer(clf.steps[-1][1], \n",
-        "#                            x_train, \n",
-        "#                            LGBMExplainableModel, \n",
-        "#                            augment_data=True, \n",
-        "#                            max_num_of_augmentations=10, \n",
-        "#                            features=attritionXData.columns, \n",
-        "#                            classes=[\"Not leaving\", \"leaving\"], \n",
-        "#                            transformations=transformations)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 3. Using PFIExplainer\n",
-        "\n",
-        "# Use the parameter \"metric\" to pass a metric name or function to evaluate the permutation. \n",
-        "# Note that if a metric function is provided a higher value must be better.\n",
-        "# Otherwise, take the negative of the function or set the parameter \"is_error_metric\" to True.\n",
-        "# Default metrics: \n",
-        "# F1 Score for binary classification, F1 Score with micro average for multiclass classification and\n",
-        "# Mean absolute error for regression\n",
-        "\n",
-        "# explainer = PFIExplainer(clf.steps[-1][1], \n",
-        "#                          features=x_train.columns, \n",
-        "#                          transformations=transformations,\n",
-        "#                          classes=[\"Not leaving\", \"leaving\"])"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate global explanations\n",
-        "Explain overall model predictions (global explanation)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
-        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
-        "global_explanation = explainer.explain_global(x_test)\n",
-        "\n",
-        "# Note: if you used the PFIExplainer in the previous step, use the next line of code instead\n",
-        "# global_explanation = explainer.explain_global(x_test, true_labels=y_test)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Sorted SHAP values\n",
-        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
-        "# Corresponding feature names\n",
-        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
-        "# Feature ranks (based on original order of features)\n",
-        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))\n",
-        "\n",
-        "# Note: PFIExplainer does not support per class explanations\n",
-        "# Per class feature names\n",
-        "print('ranked per class feature names: {}'.format(global_explanation.get_ranked_per_class_names()))\n",
-        "# Per class feature importance values\n",
-        "print('ranked per class feature values: {}'.format(global_explanation.get_ranked_per_class_values()))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Print out a dictionary that holds the sorted feature importance names and values\n",
-        "print('global importance rank: {}'.format(global_explanation.get_feature_importance_dict()))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain overall model predictions as a collection of local (instance-level) explanations"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# feature shap values for all features and all data points in the training data\n",
-        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate local explanations\n",
-        "Explain local data points (individual instances)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Note: PFIExplainer does not support local explanations\n",
-        "# You can pass a specific data point or a group of data points to the explain_local function\n",
-        "\n",
-        "# E.g., Explain the first data point in the test set\n",
-        "instance_num = 1\n",
-        "local_explanation = explainer.explain_local(x_test[:instance_num])"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Get the prediction for the first member of the test set and explain why model made that prediction\n",
-        "prediction_value = clf.predict(x_test)[instance_num]\n",
-        "\n",
-        "sorted_local_importance_values = local_explanation.get_ranked_local_values()[prediction_value]\n",
-        "sorted_local_importance_names = local_explanation.get_ranked_local_names()[prediction_value]\n",
-        "\n",
-        "print('local importance values: {}'.format(sorted_local_importance_values))\n",
-        "print('local importance names: {}'.format(sorted_local_importance_names))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Upload\n",
-        "Upload explanations to Azure Machine Learning Run History"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import azureml.core\n",
-        "from azureml.core import Workspace, Experiment, Run\n",
-        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
-        "from azureml.contrib.explain.model.explanation.explanation_client import ExplanationClient\n",
-        "# Check core SDK version number\n",
-        "print(\"SDK version:\", azureml.core.VERSION)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "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": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "experiment_name = 'explain_model'\n",
-        "experiment = Experiment(ws, experiment_name)\n",
-        "run = experiment.start_logging()\n",
-        "client = ExplanationClient.from_run(run)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Uploading model explanation data for storage or visualization in webUX\n",
-        "# The explanation can then be downloaded on any compute\n",
-        "# Multiple explanations can be uploaded\n",
-        "client.upload_model_explanation(global_explanation, comment='global explanation: all features')\n",
-        "# Or you can only upload the explanation object with the top k feature info\n",
-        "#client.upload_model_explanation(global_explanation, top_k=2, comment='global explanation: Only top 2 features')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Uploading model explanation data for storage or visualization in webUX\n",
-        "# The explanation can then be downloaded on any compute\n",
-        "# Multiple explanations can be uploaded\n",
-        "client.upload_model_explanation(local_explanation, comment='local explanation for test point 1: all features')\n",
-        "\n",
-        "# Alterntively, you can only upload the local explanation object with the top k feature info\n",
-        "#client.upload_model_explanation(local_explanation, top_k=2, comment='local explanation: top 2 features')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Download\n",
-        "Download explanations from Azure Machine Learning Run History"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# List uploaded explanations\n",
-        "client.list_model_explanations()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "for explanation in client.list_model_explanations():\n",
-        "    \n",
-        "    if explanation['comment'] == 'local explanation for test point 1: all features':\n",
-        "        downloaded_local_explanation = client.download_model_explanation(explanation_id=explanation['id'])\n",
-        "        # You can pass a k value to only download the top k feature importance values\n",
-        "        downloaded_local_explanation_top2 = client.download_model_explanation(top_k=2, explanation_id=explanation['id'])\n",
-        "    \n",
-        "    \n",
-        "    elif explanation['comment'] == 'global explanation: all features':\n",
-        "        downloaded_global_explanation = client.download_model_explanation(explanation_id=explanation['id'])\n",
-        "        # You can pass a k value to only download the top k feature importance values\n",
-        "        downloaded_global_explanation_top2 = client.download_model_explanation(top_k=2, explanation_id=explanation['id'])\n",
-        "    "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Load the visualization dashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(downloaded_global_explanation, model, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "1. [Training time: regression problem](../../tabular-data/explain-binary-classification-local.ipynb)       \n",
-        "1. [Training time: binary classification problem](../../tabular-data/explain-binary-classification-local.ipynb)\n",
-        "1. [Training time: multiclass classification problem](../../tabular-data/explain-multiclass-classification-local.ipynb)\n",
-        "1. Explain models with engineered features:\n",
-        "    1. [Simple feature transformations](../../tabular-data/simple-feature-transformations-explain-local.ipynb)\n",
-        "    1. [Advanced feature transformations](../../tabular-data/advanced-feature-transformations-explain-local.ipynb)\n",
-        "1. [Run explainers remotely on Azure Machine Learning Compute (AMLCompute)](../remote-explanation/explain-model-on-amlcompute.ipynb)\n",
-        "1. Inferencing time: deploy a classification model and explainer:\n",
-        "    1. [Deploy a locally-trained model and explainer](../scoring-time/train-explain-model-locally-and-deploy.ipynb)\n",
-        "    1. [Deploy a remotely-trained model and explainer](../scoring-time/train-explain-model-on-amlcompute-and-deploy.ipynb)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "mesameki"
-      }
-    ],
-    "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.8"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

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

@@ -1,33 +0,0 @@
-import json
-import numpy as np
-import pandas as pd
-import os
-import pickle
-from sklearn.externals import joblib
-from sklearn.linear_model import LogisticRegression
-from azureml.core.model import Model
-
-
-def init():
-
-    global original_model
-    global scoring_explainer
-
-    # Retrieve the path to the model file using the model name
-    # Assume original model is named original_prediction_model
-    original_model_path = Model.get_model_path('original_model')
-    scoring_explainer_path = Model.get_model_path('IBM_attrition_explainer')
-
-    original_model = joblib.load(original_model_path)
-    scoring_explainer = joblib.load(scoring_explainer_path)
-
-
-def run(raw_data):
-    # Get predictions and explanations for each data point
-    data = pd.read_json(raw_data)
-    # Make prediction
-    predictions = original_model.predict(data)
-    # Retrieve model explanations
-    local_importance_values = scoring_explainer.explain(data)
-    # You can return any data type as long as it is JSON-serializable
-    return {'predictions': predictions.tolist(), 'local_importance_values': local_importance_values}

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

@@ -1,513 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/azure-integration/scoring-time/train-explain-model-locally-and-deploy.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Train and explain models locally and deploy model and scoring explainer\n",
-        "\n",
-        "\n",
-        "_**This notebook illustrates how to use the Azure Machine Learning Interpretability SDK to deploy a locally-trained model and its corresponding scoring explainer to Azure Container Instances (ACI) as a web service.**_\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "Problem: IBM employee attrition classification with scikit-learn (train and explain a model locally and use Azure Container Instances (ACI) for deploying your model and its corresponding scoring explainer as a web service.)\n",
-        "\n",
-        "---\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Run model explainer locally at training time](#Explain)\n",
-        "    1. Apply feature transformations\n",
-        "    1. Train a binary classification model\n",
-        "    1. Explain the model on raw features\n",
-        "        1. Generate global explanations\n",
-        "        1. Generate local explanations\n",
-        "1. [Visualize explanations](#Visualize)\n",
-        "1. [Deploy model and scoring explainer](#Deploy)\n",
-        "1. [Next steps](#Next)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "\n",
-        "\n",
-        "This notebook showcases how to train and explain a classification model locally, and deploy the trained model and its corresponding explainer to Azure Container Instances (ACI).\n",
-        "It demonstrates the API calls that you need to make to submit a run for training and explaining a model to AMLCompute, download the compute explanations remotely, and visualizing the global and local explanations via a visualization dashboard that provides an interactive way of discovering patterns in model predictions and downloaded explanations. It also demonstrates how to use Azure Machine Learning MLOps capabilities to deploy your model and its corresponding explainer.\n",
-        "\n",
-        "We will showcase one of the tabular data explainers: TabularExplainer (SHAP) and follow these steps:\n",
-        "1.\tDevelop a machine learning script in Python which involves the training script and the explanation script.\n",
-        "2.\tRun the script locally.\n",
-        "3.\tUse the interpretability toolkit\u00e2\u20ac\u2122s visualization dashboard to visualize predictions and their explanation. If the metrics and explanations don't indicate a desired outcome, loop back to step 1 and iterate on your scripts.\n",
-        "5.\tAfter a satisfactory run is found, create a scoring explainer and register the persisted model and its corresponding explainer in the model registry.\n",
-        "6.\tDevelop a scoring script.\n",
-        "7.\tCreate an image and register it in the image registry.\n",
-        "8.\tDeploy the image as a web service in Azure.\n",
-        "\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Setup\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 a Workspace\n",
-        "\n",
-        "Initialize a workspace object from persisted configuration"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "tags": [
-          "create workspace"
-        ]
-      },
-      "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": [
-        "## Explain\n",
-        "Create An Experiment: **Experiment** is a logical container in an Azure ML Workspace. It hosts run records which can include run metrics and output artifacts from your experiments."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core import Experiment\n",
-        "experiment_name = 'explain_model_at_scoring_time'\n",
-        "experiment = Experiment(workspace=ws, name=experiment_name)\n",
-        "run = experiment.start_logging()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# get IBM attrition data\n",
-        "import os\n",
-        "import pandas as pd\n",
-        "\n",
-        "outdirname = 'dataset.6.21.19'\n",
-        "try:\n",
-        "    from urllib import urlretrieve\n",
-        "except ImportError:\n",
-        "    from urllib.request import urlretrieve\n",
-        "import zipfile\n",
-        "zipfilename = outdirname + '.zip'\n",
-        "urlretrieve('https://publictestdatasets.blob.core.windows.net/data/' + zipfilename, zipfilename)\n",
-        "with zipfile.ZipFile(zipfilename, 'r') as unzip:\n",
-        "    unzip.extractall('.')\n",
-        "attritionData = pd.read_csv('./WA_Fn-UseC_-HR-Employee-Attrition.csv')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.model_selection import train_test_split\n",
-        "from sklearn.externals import joblib\n",
-        "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
-        "from sklearn.impute import SimpleImputer\n",
-        "from sklearn.pipeline import Pipeline\n",
-        "from sklearn.linear_model import LogisticRegression\n",
-        "from sklearn.ensemble import RandomForestClassifier\n",
-        "from sklearn_pandas import DataFrameMapper\n",
-        "\n",
-        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
-        "\n",
-        "os.makedirs('./outputs', exist_ok=True)\n",
-        "\n",
-        "# Dropping Employee count as all values are 1 and hence attrition is independent of this feature\n",
-        "attritionData = attritionData.drop(['EmployeeCount'], axis=1)\n",
-        "# Dropping Employee Number since it is merely an identifier\n",
-        "attritionData = attritionData.drop(['EmployeeNumber'], axis=1)\n",
-        "attritionData = attritionData.drop(['Over18'], axis=1)\n",
-        "# Since all values are 80\n",
-        "attritionData = attritionData.drop(['StandardHours'], axis=1)\n",
-        "\n",
-        "# Converting target variables from string to numerical values\n",
-        "target_map = {'Yes': 1, 'No': 0}\n",
-        "attritionData[\"Attrition_numerical\"] = attritionData[\"Attrition\"].apply(lambda x: target_map[x])\n",
-        "target = attritionData[\"Attrition_numerical\"]\n",
-        "\n",
-        "attritionXData = attritionData.drop(['Attrition_numerical', 'Attrition'], axis=1)\n",
-        "\n",
-        "# Creating dummy columns for each categorical feature\n",
-        "categorical = []\n",
-        "for col, value in attritionXData.iteritems():\n",
-        "    if value.dtype == 'object':\n",
-        "        categorical.append(col)\n",
-        "\n",
-        "# Store the numerical columns in a list numerical\n",
-        "numerical = attritionXData.columns.difference(categorical)\n",
-        "\n",
-        "numeric_transformations = [([f], Pipeline(steps=[\n",
-        "    ('imputer', SimpleImputer(strategy='median')),\n",
-        "    ('scaler', StandardScaler())])) for f in numerical]\n",
-        "\n",
-        "categorical_transformations = [([f], OneHotEncoder(handle_unknown='ignore', sparse=False)) for f in categorical]\n",
-        "\n",
-        "transformations = numeric_transformations + categorical_transformations\n",
-        "\n",
-        "# Append classifier to preprocessing pipeline.\n",
-        "# Now we have a full prediction pipeline.\n",
-        "clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),\n",
-        "                      ('classifier', RandomForestClassifier())])\n",
-        "\n",
-        "# Split data into train and test\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "x_train, x_test, y_train, y_test = train_test_split(attritionXData,\n",
-        "                                                    target,\n",
-        "                                                    test_size = 0.2,\n",
-        "                                                    random_state=0,\n",
-        "                                                    stratify=target)\n",
-        "\n",
-        "# preprocess the data and fit the classification model\n",
-        "clf.fit(x_train, y_train)\n",
-        "model = clf.steps[-1][1]\n",
-        "\n",
-        "model_file_name = 'log_reg.pkl'\n",
-        "\n",
-        "# save model in the outputs folder so it automatically get uploaded\n",
-        "with open(model_file_name, 'wb') as file:\n",
-        "    joblib.dump(value=clf, filename=os.path.join('./outputs/',\n",
-        "                                                 model_file_name))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Explain predictions on your local machine\n",
-        "tabular_explainer = TabularExplainer(model, \n",
-        "                                     initialization_examples=x_train, \n",
-        "                                     features=attritionXData.columns, \n",
-        "                                     classes=[\"Not leaving\", \"leaving\"], \n",
-        "                                     transformations=transformations)\n",
-        "\n",
-        "# Explain overall model predictions (global explanation)\n",
-        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
-        "# x_train can be passed as well, but with more examples explanations it will\n",
-        "# take longer although they may be more accurate\n",
-        "global_explanation = tabular_explainer.explain_global(x_test)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.explain.model.scoring.scoring_explainer import TreeScoringExplainer, save\n",
-        "# ScoringExplainer\n",
-        "scoring_explainer = TreeScoringExplainer(tabular_explainer)\n",
-        "# Pickle scoring explainer locally\n",
-        "save(scoring_explainer, exist_ok=True)\n",
-        "\n",
-        "# Register original model\n",
-        "run.upload_file('original_model.pkl', os.path.join('./outputs/', model_file_name))\n",
-        "original_model = run.register_model(model_name='original_model', model_path='original_model.pkl')\n",
-        "\n",
-        "# Register scoring explainer\n",
-        "run.upload_file('IBM_attrition_explainer.pkl', 'scoring_explainer.pkl')\n",
-        "scoring_explainer_model = run.register_model(model_name='IBM_attrition_explainer', model_path='IBM_attrition_explainer.pkl')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Visualize the explanations"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(global_explanation, clf, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Deploy \n",
-        "\n",
-        "Deploy Model and ScoringExplainer"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.webservice import AciWebservice\n",
-        "\n",
-        "aciconfig = AciWebservice.deploy_configuration(cpu_cores=1, \n",
-        "                                               memory_gb=1, \n",
-        "                                               tags={\"data\": \"IBM_Attrition\",  \n",
-        "                                                     \"method\" : \"local_explanation\"}, \n",
-        "                                               description='Get local explanations for IBM Employee Attrition data')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.conda_dependencies import CondaDependencies \n",
-        "\n",
-        "# WARNING: to install this, g++ needs to be available on the Docker image and is not by default (look at the next cell)\n",
-        "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-explain-model', 'azureml-core', 'azureml-telemetry',\n",
-        "    'azureml-explain-model'\n",
-        "]\n",
-        " \n",
-        "\n",
-        "# specify CondaDependencies obj\n",
-        "myenv = CondaDependencies.create(conda_packages=['scikit-learn', 'pandas'],\n",
-        "                                 pip_packages=['sklearn-pandas', 'pyyaml'] + azureml_pip_packages,\n",
-        "                                 pin_sdk_version=False)\n",
-        "\n",
-        "with open(\"myenv.yml\",\"w\") as f:\n",
-        "    f.write(myenv.serialize_to_string())\n",
-        "\n",
-        "with open(\"myenv.yml\",\"r\") as f:\n",
-        "    print(f.read())"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%writefile dockerfile\n",
-        "RUN apt-get update && apt-get install -y g++ "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.model import Model\n",
-        "# retrieve scoring explainer for deployment\n",
-        "scoring_explainer_model = Model(ws, 'IBM_attrition_explainer')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.webservice import Webservice\n",
-        "from azureml.core.image import ContainerImage\n",
-        "\n",
-        "# Use the custom scoring, docker, and conda files we created above\n",
-        "image_config = ContainerImage.image_configuration(execution_script=\"score.py\",\n",
-        "                                                  docker_file=\"dockerfile\", \n",
-        "                                                  runtime=\"python\", \n",
-        "                                                  conda_file=\"myenv.yml\")\n",
-        "\n",
-        "# Use configs and models generated above\n",
-        "service = Webservice.deploy_from_model(workspace=ws,\n",
-        "                                       name='model-scoring',\n",
-        "                                       deployment_config=aciconfig,\n",
-        "                                       models=[scoring_explainer_model, original_model],\n",
-        "                                       image_config=image_config)\n",
-        "\n",
-        "service.wait_for_deployment(show_output=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import requests\n",
-        "import json\n",
-        "\n",
-        "\n",
-        "# Create data to test service with\n",
-        "sample_data = '{\"Age\":{\"899\":49},\"BusinessTravel\":{\"899\":\"Travel_Rarely\"},\"DailyRate\":{\"899\":1098},\"Department\":{\"899\":\"Research & Development\"},\"DistanceFromHome\":{\"899\":4},\"Education\":{\"899\":2},\"EducationField\":{\"899\":\"Medical\"},\"EnvironmentSatisfaction\":{\"899\":1},\"Gender\":{\"899\":\"Male\"},\"HourlyRate\":{\"899\":85},\"JobInvolvement\":{\"899\":2},\"JobLevel\":{\"899\":5},\"JobRole\":{\"899\":\"Manager\"},\"JobSatisfaction\":{\"899\":3},\"MaritalStatus\":{\"899\":\"Married\"},\"MonthlyIncome\":{\"899\":18711},\"MonthlyRate\":{\"899\":12124},\"NumCompaniesWorked\":{\"899\":2},\"OverTime\":{\"899\":\"No\"},\"PercentSalaryHike\":{\"899\":13},\"PerformanceRating\":{\"899\":3},\"RelationshipSatisfaction\":{\"899\":3},\"StockOptionLevel\":{\"899\":1},\"TotalWorkingYears\":{\"899\":23},\"TrainingTimesLastYear\":{\"899\":2},\"WorkLifeBalance\":{\"899\":4},\"YearsAtCompany\":{\"899\":1},\"YearsInCurrentRole\":{\"899\":0},\"YearsSinceLastPromotion\":{\"899\":0},\"YearsWithCurrManager\":{\"899\":0}}'\n",
-        "\n",
-        "\n",
-        "\n",
-        "headers = {'Content-Type':'application/json'}\n",
-        "\n",
-        "# send request to service\n",
-        "resp = requests.post(service.scoring_uri, sample_data, headers=headers)\n",
-        "\n",
-        "print(\"POST to url\", service.scoring_uri)\n",
-        "# can covert back to Python objects from json string if desired\n",
-        "print(\"prediction:\", resp.text)\n",
-        "result = json.loads(resp.text)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "#plot the feature importance for the prediction\n",
-        "import numpy as np\n",
-        "import matplotlib.pyplot as plt; plt.rcdefaults()\n",
-        "\n",
-        "labels = json.loads(sample_data)\n",
-        "labels = labels.keys()\n",
-        "objects = labels\n",
-        "y_pos = np.arange(len(objects))\n",
-        "performance = result[\"local_importance_values\"][0][0]\n",
-        "\n",
-        "plt.bar(y_pos, performance, align='center', alpha=0.5)\n",
-        "plt.xticks(y_pos, objects)\n",
-        "locs, labels = plt.xticks()\n",
-        "plt.setp(labels, rotation=90)\n",
-        "plt.ylabel('Feature impact - leaving vs not leaving')\n",
-        "plt.title('Local feature importance for prediction')\n",
-        "\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "service.delete()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "1. [Training time: regression problem](../../tabular-data/explain-binary-classification-local.ipynb)       \n",
-        "1. [Training time: binary classification problem](../../tabular-data/explain-binary-classification-local.ipynb)\n",
-        "1. [Training time: multiclass classification problem](../../tabular-data/explain-multiclass-classification-local.ipynb)\n",
-        "1. Explain models with engineered features:\n",
-        "    1. [Simple feature transformations](../../tabular-data/simple-feature-transformations-explain-local.ipynb)\n",
-        "    1. [Advanced feature transformations](../../tabular-data/advanced-feature-transformations-explain-local.ipynb)\n",
-        "1. [Save model explanations via Azure Machine Learning Run History](../run-history/save-retrieve-explanations-run-history.ipynb)\n",
-        "1. [Run explainers remotely on Azure Machine Learning Compute (AMLCompute)](../remote-explanation/explain-model-on-amlcompute.ipynb)\n",
-        "1. [Inferencing time: deploy a remotely-trained model and explainer](./train-explain-model-on-amlcompute-and-deploy.ipynb)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "mesameki"
-      }
-    ],
-    "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.8"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

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

@@ -1,548 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/azure-integration/scoring-time/train-explain-model-on-amlcompute-and-deploy.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Train and explain models remotely via Azure Machine Learning Compute and deploy model and scoring explainer\n",
-        "\n",
-        "\n",
-        "_**This notebook illustrates how to use the Azure Machine Learning Interpretability SDK to train and explain a classification model remotely on an Azure Machine Leanrning Compute Target (AMLCompute), and use Azure Container Instances (ACI) for deploying your model and its corresponding scoring explainer as a web service.**_\n",
-        "\n",
-        "Problem: IBM employee attrition classification with scikit-learn (train a model and run an explainer remotely via AMLCompute, and deploy model and its corresponding explainer.)\n",
-        "\n",
-        "---\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Run model explainer locally at training time](#Explain)\n",
-        "    1. Apply feature transformations\n",
-        "    1. Train a binary classification model\n",
-        "    1. Explain the model on raw features\n",
-        "        1. Generate global explanations\n",
-        "        1. Generate local explanations\n",
-        "1. [Visualize results](#Visualize)\n",
-        "1. [Deploy model and scoring explainer](#Deploy)\n",
-        "1. [Next steps](#Next)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "\n",
-        "This notebook showcases how to train and explain a classification model remotely via Azure Machine Learning Compute (AMLCompute), download the calculated explanations locally for visualization and inspection, and deploy the final model and its corresponding explainer to Azure Container Instances (ACI).\n",
-        "It demonstrates the API calls that you need to make to submit a run for training and explaining a model to AMLCompute, download the compute explanations remotely, and visualizing the global and local explanations via a visualization dashboard that provides an interactive way of discovering patterns in model predictions and downloaded explanations, and using Azure Machine Learning MLOps capabilities to deploy your model and its corresponding explainer.\n",
-        "\n",
-        "We will showcase one of the tabular data explainers: TabularExplainer (SHAP) and follow these steps:\n",
-        "1.\tDevelop a machine learning script in Python which involves the training script and the explanation script.\n",
-        "2.\tCreate and configure a compute target.\n",
-        "3.\tSubmit the scripts to the configured compute target to run in that environment. During training, the scripts can read from or write to datastore. And the records of execution (e.g., model, metrics, prediction explanations) are saved as runs in the workspace and grouped under experiments.\n",
-        "4.\tQuery the experiment for logged metrics and explanations from the current and past runs. Use the interpretability toolkit\u00e2\u20ac\u2122s visualization dashboard to visualize predictions and their explanation. If the metrics and explanations don't indicate a desired outcome, loop back to step 1 and iterate on your scripts.\n",
-        "5.\tAfter a satisfactory run is found, create a scoring explainer and register the persisted model and its corresponding explainer in the model registry.\n",
-        "6.\tDevelop a scoring script.\n",
-        "7.\tCreate an image and register it in the image registry.\n",
-        "8.\tDeploy the image as a web service in Azure.\n",
-        "\n",
-        "| ![azure-machine-learning-cycle](./img/azure-machine-learning-cycle.PNG) |\n",
-        "|:--:|"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Setup\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 a Workspace\n",
-        "\n",
-        "Initialize a workspace object from persisted configuration"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "tags": [
-          "create workspace"
-        ]
-      },
-      "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": [
-        "## Explain\n",
-        "\n",
-        "Create An Experiment: **Experiment** is a logical container in an Azure ML Workspace. It hosts run records which can include run metrics and output artifacts from your experiments."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core import Experiment\n",
-        "experiment_name = 'explainer-remote-run-on-amlcompute'\n",
-        "experiment = Experiment(workspace=ws, name=experiment_name)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction to AmlCompute\n",
-        "\n",
-        "Azure Machine Learning Compute is managed compute infrastructure that allows the user to easily create single to multi-node compute of the appropriate VM Family. It is created **within your workspace region** and is a resource that can be used by other users in your workspace. It autoscales by default to the max_nodes, when a job is submitted, and executes in a containerized environment packaging the dependencies as specified by the user. \n",
-        "\n",
-        "Since it is managed compute, job scheduling and cluster management are handled internally by Azure Machine Learning service. \n",
-        "\n",
-        "For more information on Azure Machine Learning Compute, please read [this article](https://docs.microsoft.com/azure/machine-learning/service/how-to-set-up-training-targets#amlcompute)\n",
-        "\n",
-        "If you are an existing BatchAI customer who is migrating to Azure Machine Learning, please read [this article](https://aka.ms/batchai-retirement)\n",
-        "\n",
-        "**Note**: As with other Azure services, there are limits on certain resources (for eg. AmlCompute quota) associated with the Azure Machine Learning service. Please read [this article](https://docs.microsoft.com/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota.\n",
-        "\n",
-        "\n",
-        "The training script `run_explainer.py` is already created for you. Let's have a look."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Submit an AmlCompute run in a few different ways\n",
-        "\n",
-        "First lets check which VM families are available in your region. Azure is a regional service and some specialized SKUs (especially GPUs) are only available in certain regions. Since AmlCompute is created in the region of your workspace, we will use the supported_vms () function to see if the VM family we want to use ('STANDARD_D2_V2') is supported.\n",
-        "\n",
-        "You can also pass a different region to check availability and then re-create your workspace in that region through the [configuration notebook](../../../configuration.ipynb)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.compute import ComputeTarget, AmlCompute\n",
-        "\n",
-        "AmlCompute.supported_vmsizes(workspace=ws)\n",
-        "# AmlCompute.supported_vmsizes(workspace=ws, location='southcentralus')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Create project directory\n",
-        "\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",
-        "import shutil\n",
-        "\n",
-        "project_folder = './explainer-remote-run-on-amlcompute'\n",
-        "os.makedirs(project_folder, exist_ok=True)\n",
-        "shutil.copy('train_explain.py', project_folder)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Provision as a run based compute target\n",
-        "\n",
-        "You can provision AmlCompute as a compute target at run-time. In this case, the compute is auto-created for your run, scales up to max_nodes that you specify, and then **deleted automatically** after the run completes."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.runconfig import RunConfiguration\n",
-        "from azureml.core.conda_dependencies import CondaDependencies\n",
-        "from azureml.core.runconfig import DEFAULT_CPU_IMAGE\n",
-        "\n",
-        "# create a new runconfig object\n",
-        "run_config = RunConfiguration()\n",
-        "\n",
-        "# signal that you want to use AmlCompute to execute script.\n",
-        "run_config.target = \"amlcompute\"\n",
-        "\n",
-        "# AmlCompute will be created in the same region as workspace\n",
-        "# Set vm size for AmlCompute\n",
-        "run_config.amlcompute.vm_size = 'STANDARD_D2_V2'\n",
-        "\n",
-        "# enable Docker \n",
-        "run_config.environment.docker.enabled = True\n",
-        "\n",
-        "# set Docker base image to the default CPU-based image\n",
-        "run_config.environment.docker.base_image = DEFAULT_CPU_IMAGE\n",
-        "\n",
-        "# use conda_dependencies.yml to create a conda environment in the Docker image for execution\n",
-        "run_config.environment.python.user_managed_dependencies = False\n",
-        "\n",
-        "# auto-prepare the Docker image when used for execution (if it is not already prepared)\n",
-        "run_config.auto_prepare_environment = True\n",
-        "\n",
-        "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-explain-model', 'azureml-core', 'azureml-telemetry',\n",
-        "    'azureml-explain-model'\n",
-        "]\n",
-        " \n",
-        "\n",
-        "\n",
-        "# specify CondaDependencies obj\n",
-        "run_config.environment.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'],\n",
-        "                                pip_packages=['sklearn_pandas', 'pyyaml'] + azureml_pip_packages,\n",
-        "                                pin_sdk_version=False)\n",
-        "# Now submit a run on AmlCompute\n",
-        "from azureml.core.script_run_config import ScriptRunConfig\n",
-        "\n",
-        "script_run_config = ScriptRunConfig(source_directory=project_folder,\n",
-        "                                    script='train_explain.py',\n",
-        "                                    run_config=run_config)\n",
-        "\n",
-        "run = experiment.submit(script_run_config)\n",
-        "\n",
-        "# Show run details\n",
-        "run"
-      ]
-    },
-    {
-      "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": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%time\n",
-        "# Shows output of the run on stdout.\n",
-        "run.wait_for_completion(show_output=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Delete () is used to deprovision and delete the AmlCompute target. Useful if you want to re-use the compute name \n",
-        "# 'cpucluster' in this case but use a different VM family for instance.\n",
-        "\n",
-        "# cpu_cluster.delete()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Download Model Explanation, Model, and Data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# retrieve model for visualization and deployment\n",
-        "from azureml.core.model import Model\n",
-        "from sklearn.externals import joblib\n",
-        "original_model = Model(ws, 'original_model')\n",
-        "model_path = original_model.download(exist_ok=True)\n",
-        "original_svm_model = joblib.load(model_path)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# retrieve global explanation for visualization\n",
-        "from azureml.contrib.explain.model.explanation.explanation_client import ExplanationClient\n",
-        "\n",
-        "# get model explanation data\n",
-        "client = ExplanationClient.from_run(run)\n",
-        "global_explanation = client.download_model_explanation()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# retrieve x_test for visualization\n",
-        "from sklearn.externals import joblib\n",
-        "x_test_path = './x_test.pkl'\n",
-        "run.download_file('x_test_ibm.pkl', output_file_path=x_test_path)\n",
-        "x_test = joblib.load(x_test_path)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Visualize the explanations"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(global_explanation, original_svm_model, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Deploy\n",
-        "Deploy Model and ScoringExplainer"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.webservice import AciWebservice\n",
-        "\n",
-        "aciconfig = AciWebservice.deploy_configuration(cpu_cores=1, \n",
-        "                                               memory_gb=1, \n",
-        "                                               tags={\"data\": \"IBM_Attrition\",  \n",
-        "                                                     \"method\" : \"local_explanation\"}, \n",
-        "                                               description='Get local explanations for IBM Employee Attrition data')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.conda_dependencies import CondaDependencies \n",
-        "\n",
-        "# WARNING: to install this, g++ needs to be available on the Docker image and is not by default (look at the next cell)\n",
-        "azureml_pip_packages = [\n",
-        "    'azureml-defaults', 'azureml-contrib-explain-model', 'azureml-core', 'azureml-telemetry',\n",
-        "    'azureml-explain-model'\n",
-        "]\n",
-        " \n",
-        "\n",
-        "# specify CondaDependencies obj\n",
-        "myenv = CondaDependencies.create(conda_packages=['scikit-learn', 'pandas'],\n",
-        "                                 pip_packages=['sklearn-pandas', 'pyyaml'] + azureml_pip_packages,\n",
-        "                                 pin_sdk_version=False)\n",
-        "\n",
-        "with open(\"myenv.yml\",\"w\") as f:\n",
-        "    f.write(myenv.serialize_to_string())\n",
-        "\n",
-        "with open(\"myenv.yml\",\"r\") as f:\n",
-        "    print(f.read())"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%writefile dockerfile\n",
-        "RUN apt-get update && apt-get install -y g++ "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# retrieve scoring explainer for deployment\n",
-        "scoring_explainer_model = Model(ws, 'IBM_attrition_explainer')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.core.webservice import Webservice\n",
-        "from azureml.core.image import ContainerImage\n",
-        "\n",
-        "# Use the custom scoring, docker, and conda files we created above\n",
-        "image_config = ContainerImage.image_configuration(execution_script=\"score.py\",\n",
-        "                                                  docker_file=\"dockerfile\", \n",
-        "                                                  runtime=\"python\", \n",
-        "                                                  conda_file=\"myenv.yml\")\n",
-        "\n",
-        "# Use configs and models generated above\n",
-        "service = Webservice.deploy_from_model(workspace=ws,\n",
-        "                                       name='model-scoring-service',\n",
-        "                                       deployment_config=aciconfig,\n",
-        "                                       models=[scoring_explainer_model, original_model],\n",
-        "                                       image_config=image_config)\n",
-        "\n",
-        "service.wait_for_deployment(show_output=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import requests\n",
-        "\n",
-        "# create data to test service with\n",
-        "examples = x_test[:4]\n",
-        "input_data = examples.to_json()\n",
-        "\n",
-        "headers = {'Content-Type':'application/json'}\n",
-        "\n",
-        "# send request to service\n",
-        "resp = requests.post(service.scoring_uri, input_data, headers=headers)\n",
-        "\n",
-        "print(\"POST to url\", service.scoring_uri)\n",
-        "# can covert back to Python objects from json string if desired\n",
-        "print(\"prediction:\", resp.text)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "service.delete()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "1. [Training time: regression problem](../../tabular-data/explain-binary-classification-local.ipynb)       \n",
-        "1. [Training time: binary classification problem](../../tabular-data/explain-binary-classification-local.ipynb)\n",
-        "1. [Training time: multiclass classification problem](../../tabular-data/explain-multiclass-classification-local.ipynb)\n",
-        "1. Explain models with engineered features:\n",
-        "    1. [Simple feature transformations](../../tabular-data/simple-feature-transformations-explain-local.ipynb)\n",
-        "    1. [Advanced feature transformations](../../tabular-data/advanced-feature-transformations-explain-local.ipynb)\n",
-        "1. [Save model explanations via Azure Machine Learning Run History](../run-history/save-retrieve-explanations-run-history.ipynb)\n",
-        "1. [Run explainers remotely on Azure Machine Learning Compute (AMLCompute)](../remote-explanation/explain-model-on-amlcompute.ipynb)\n",
-        "1. [Inferencing time: deploy a locally-trained model and explainer](./train-explain-model-locally-and-deploy.ipynb)\n",
-        "   "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "mesameki"
-      }
-    ],
-    "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.8"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

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

@@ -1,8 +0,0 @@
-name: train-explain-model-on-amlcompute-and-deploy
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-explain-model
-  - azureml-contrib-explain-model
-  - sklearn-pandas
-  - azureml-dataprep

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

@@ -1,128 +0,0 @@
-# ---------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# ---------------------------------------------------------
-
-import os
-import pandas as pd
-import zipfile
-from sklearn.model_selection import train_test_split
-from sklearn.externals import joblib
-from sklearn.preprocessing import StandardScaler, OneHotEncoder
-from sklearn.impute import SimpleImputer
-from sklearn.pipeline import Pipeline
-from sklearn.linear_model import LogisticRegression
-from sklearn_pandas import DataFrameMapper
-
-from azureml.core.run import Run
-from azureml.explain.model.tabular_explainer import TabularExplainer
-from azureml.contrib.explain.model.explanation.explanation_client import ExplanationClient
-from azureml.explain.model.scoring.scoring_explainer import LinearScoringExplainer, save
-
-OUTPUT_DIR = './outputs/'
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-# get the IBM employee attrition dataset
-outdirname = 'dataset.6.21.19'
-try:
-    from urllib import urlretrieve
-except ImportError:
-    from urllib.request import urlretrieve
-zipfilename = outdirname + '.zip'
-urlretrieve('https://publictestdatasets.blob.core.windows.net/data/' + zipfilename, zipfilename)
-with zipfile.ZipFile(zipfilename, 'r') as unzip:
-    unzip.extractall('.')
-attritionData = pd.read_csv('./WA_Fn-UseC_-HR-Employee-Attrition.csv')
-
-# dropping Employee count as all values are 1 and hence attrition is independent of this feature
-attritionData = attritionData.drop(['EmployeeCount'], axis=1)
-# dropping Employee Number since it is merely an identifier
-attritionData = attritionData.drop(['EmployeeNumber'], axis=1)
-attritionData = attritionData.drop(['Over18'], axis=1)
-# since all values are 80
-attritionData = attritionData.drop(['StandardHours'], axis=1)
-
-# converting target variables from string to numerical values
-target_map = {'Yes': 1, 'No': 0}
-attritionData["Attrition_numerical"] = attritionData["Attrition"].apply(lambda x: target_map[x])
-target = attritionData["Attrition_numerical"]
-
-attritionXData = attritionData.drop(['Attrition_numerical', 'Attrition'], axis=1)
-
-# creating dummy columns for each categorical feature
-categorical = []
-for col, value in attritionXData.iteritems():
-    if value.dtype == 'object':
-        categorical.append(col)
-
-# store the numerical columns
-numerical = attritionXData.columns.difference(categorical)
-
-numeric_transformations = [([f], Pipeline(steps=[
-    ('imputer', SimpleImputer(strategy='median')),
-    ('scaler', StandardScaler())])) for f in numerical]
-
-categorical_transformations = [([f], OneHotEncoder(handle_unknown='ignore', sparse=False)) for f in categorical]
-
-transformations = numeric_transformations + categorical_transformations
-
-# append classifier to preprocessing pipeline
-clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),
-                      ('classifier', LogisticRegression(solver='lbfgs'))])
-
-# get the run this was submitted from to interact with run history
-run = Run.get_context()
-
-# create an explanation client to store the explanation (contrib API)
-client = ExplanationClient.from_run(run)
-
-# Split data into train and test
-x_train, x_test, y_train, y_test = train_test_split(attritionXData,
-                                                    target,
-                                                    test_size=0.2,
-                                                    random_state=0,
-                                                    stratify=target)
-
-# write x_test out as a pickle file for later visualization
-x_test_pkl = 'x_test.pkl'
-with open(x_test_pkl, 'wb') as file:
-    joblib.dump(value=x_test, filename=os.path.join(OUTPUT_DIR, x_test_pkl))
-run.upload_file('x_test_ibm.pkl', os.path.join(OUTPUT_DIR, x_test_pkl))
-
-# preprocess the data and fit the classification model
-clf.fit(x_train, y_train)
-model = clf.steps[-1][1]
-
-# save model for use outside the script
-model_file_name = 'log_reg.pkl'
-with open(model_file_name, 'wb') as file:
-    joblib.dump(value=clf, filename=os.path.join(OUTPUT_DIR, model_file_name))
-
-# register the model with the model management service for later use
-run.upload_file('original_model.pkl', os.path.join(OUTPUT_DIR, model_file_name))
-original_model = run.register_model(model_name='original_model', model_path='original_model.pkl')
-
-# create an explainer to validate or debug the model
-tabular_explainer = TabularExplainer(model,
-                                     initialization_examples=x_train,
-                                     features=attritionXData.columns,
-                                     classes=["Not leaving", "leaving"],
-                                     transformations=transformations)
-
-# explain overall model predictions (global explanation)
-# passing in test dataset for evaluation examples - note it must be a representative sample of the original data
-# more data (e.g. x_train) will likely lead to higher accuracy, but at a time cost
-global_explanation = tabular_explainer.explain_global(x_test)
-
-# uploading model explanation data for storage or visualization
-comment = 'Global explanation on classification model trained on IBM employee attrition dataset'
-client.upload_model_explanation(global_explanation, comment=comment)
-
-# also create a lightweight explainer for scoring time
-scoring_explainer = LinearScoringExplainer(tabular_explainer)
-# pickle scoring explainer locally
-save(scoring_explainer, directory=OUTPUT_DIR, exist_ok=True)
-
-# register scoring explainer
-run.upload_file('IBM_attrition_explainer.pkl', os.path.join(OUTPUT_DIR, 'scoring_explainer.pkl'))
-scoring_explainer_model = run.register_model(model_name='IBM_attrition_explainer',
-                                             model_path='IBM_attrition_explainer.pkl')

how-to-use-azureml/explain-model/explain-on-amlcompute/regression-sklearn-on-amlcompute.ipynb

@@ -13,80 +13,33 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/azure-integration/remote-explanation/explain-model-on-amlcompute.png)"
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/explain-on-amlcompute/regression-sklearn-on-amlcompute.png)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# Train and explain models remotely via Azure Machine Learning Compute\n",
+        "# Train using Azure Machine Learning Compute\n",
         "\n",
-        "\n",
-        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to train and explain a regression model remotely on an Azure Machine Leanrning Compute Target (AMLCompute).**_\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "    1. Initialize a Workspace\n",
-        "    1. Create an Experiment\n",
-        "    1. Introduction to AmlCompute\n",
-        "    1. Submit an AmlCompute run in a few different ways\n",
-        "        1. Option 1: Provision as a run based compute target \n",
-        "        1. Option 2: Provision as a persistent compute target (Basic)\n",
-        "        1. Option 3: Provision as a persistent compute target (Advanced)\n",
-        "1. Additional operations to perform on AmlCompute\n",
-        "1. [Download model explanations from Azure Machine Learning Run History](#Download)\n",
-        "1. [Visualize explanations](#Visualize)\n",
-        "1. [Next steps](#Next)"
+        "* Initialize a Workspace\n",
+        "* Create an Experiment\n",
+        "* Introduction to AmlCompute\n",
+        "* Submit an AmlCompute run in a few different ways\n",
+        "    - Provision as a run based compute target \n",
+        "    - Provision as a persistent compute target (Basic)\n",
+        "    - Provision as a persistent compute target (Advanced)\n",
+        "* Additional operations to perform on AmlCompute\n",
+        "* Download model explanation data from the Run History Portal\n",
+        "* Print the explanation data"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Introduction\n",
-        "\n",
-        "This notebook showcases how to train and explain a regression model remotely via Azure Machine Learning Compute (AMLCompute), and download the calculated explanations locally for visualization.\n",
-        "It demonstrates the API calls that you need to make to submit a run for training and explaining a model to AMLCompute, download the compute explanations remotely, and visualizing the global and local explanations via a visualization dashboard that provides an interactive way of discovering patterns in model predictions and downloaded explanations.\n",
-        "\n",
-        "We will showcase one of the tabular data explainers: TabularExplainer (SHAP).\n",
-        "\n",
-        "Problem: Boston Housing Price Prediction with scikit-learn (train a model and run an explainer remotely via AMLCompute, and download and visualize the remotely-calculated explanations.)\n",
-        "\n",
-        "| ![explanations-run-history](./img/explanations-run-history.PNG) |\n",
-        "|:--:|\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Setup\n",
-        "If you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, make sure you go through the [configuration notebook](../../../configuration.ipynb) first if you haven't.\n",
-        "\n",
-        "\n",
-        "You will need to have extensions enabled prior to jupyter kernel starting to see the visualization dashboard.\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "(myenv) $ jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "```\n",
-        "Or\n",
-        "\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install azureml.contrib.explain.model.visualize --user --py\n",
-        "(myenv) $ jupyter nbextension enable azureml.contrib.explain.model.visualize --user --py\n",
-        "```\n",
-        "\n",
-        "If you are using Jupyter Labs run the following commands instead:\n",
-        "```\n",
-        "(myenv) $ jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
-        "(myenv) $ jupyter labextension install microsoft-mli-widget\n",
-        "```"
+        "## Prerequisites\n",
+        "If you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, make sure you go through the [configuration notebook](../../../configuration.ipynb) first if you haven't."
       ]
     },
     {
@@ -163,7 +116,7 @@
         "**Note**: As with other Azure services, there are limits on certain resources (for eg. AmlCompute quota) associated with the Azure Machine Learning service. Please read [this article](https://docs.microsoft.com/azure/machine-learning/service/how-to-manage-quotas) on the default limits and how to request more quota.\n",
         "\n",
         "\n",
-        "The training script `train_explain.py` is already created for you. Let's have a look."
+        "The training script `run_explainer.py` is already created for you. Let's have a look."
       ]
     },
     {
@@ -209,14 +162,14 @@
         "\n",
         "project_folder = './explainer-remote-run-on-amlcompute'\n",
         "os.makedirs(project_folder, exist_ok=True)\n",
-        "shutil.copy('train_explain.py', project_folder)"
+        "shutil.copy('run_explainer.py', project_folder)"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Option 1: Provision as a run based compute target\n",
+        "### Provision as a run based compute target\n",
         "\n",
         "You can provision AmlCompute as a compute target at run-time. In this case, the compute is auto-created for your run, scales up to max_nodes that you specify, and then **deleted automatically** after the run completes."
       ]
@@ -252,7 +205,7 @@
         "\n",
         "azureml_pip_packages = [\n",
         "    'azureml-defaults', 'azureml-contrib-explain-model', 'azureml-core', 'azureml-telemetry',\n",
-        "    'azureml-explain-model', 'sklearn-pandas', 'azureml-dataprep'\n",
+        "    'azureml-explain-model'\n",
         "]\n",
         "\n",
         "# specify CondaDependencies obj\n",
@@ -263,7 +216,7 @@
         "from azureml.core.script_run_config import ScriptRunConfig\n",
         "\n",
         "script_run_config = ScriptRunConfig(source_directory=project_folder,\n",
-        "                                    script='train_explain.py',\n",
+        "                                    script='run_explainer.py',\n",
         "                                    run_config=run_config)\n",
         "\n",
         "run = experiment.submit(script_run_config)\n",
@@ -294,7 +247,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Option 2: Provision as a persistent compute target (Basic)\n",
+        "### Provision as a persistent compute target (Basic)\n",
         "\n",
         "You can provision a persistent AmlCompute resource by simply defining two parameters thanks to smart defaults. By default it autoscales from 0 nodes and provisions dedicated VMs to run your job in a container. This is useful when you want to continously re-use the same target, debug it between jobs or simply share the resource with other users of your workspace.\n",
         "\n",
@@ -353,7 +306,7 @@
         "\n",
         "azureml_pip_packages = [\n",
         "    'azureml-defaults', 'azureml-contrib-explain-model', 'azureml-core', 'azureml-telemetry',\n",
-        "    'azureml-explain-model', 'azureml-dataprep'\n",
+        "    'azureml-explain-model'\n",
         "]\n",
         "\n",
         "# specify CondaDependencies obj\n",
@@ -364,7 +317,7 @@
         "from azureml.core import ScriptRunConfig\n",
         "\n",
         "src = ScriptRunConfig(source_directory=project_folder, \n",
-        "                      script='train_explain.py', \n",
+        "                      script='run_explainer.py', \n",
         "                      run_config=run_config) \n",
         "run = experiment.submit(config=src)\n",
         "run"
@@ -394,7 +347,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Option 3: Provision as a persistent compute target (Advanced)\n",
+        "### Provision as a persistent compute target (Advanced)\n",
         "\n",
         "You can also specify additional properties or change defaults while provisioning AmlCompute using a more advanced configuration. This is useful when you want a dedicated cluster of 4 nodes (for example you can set the min_nodes and max_nodes to 4), or want the compute to be within an existing VNet in your subscription.\n",
         "\n",
@@ -464,11 +417,9 @@
         "\n",
         "azureml_pip_packages = [\n",
         "    'azureml-defaults', 'azureml-contrib-explain-model', 'azureml-core', 'azureml-telemetry',\n",
-        "    'azureml-explain-model', 'azureml-dataprep'\n",
+        "    'azureml-explain-model'\n",
         "]\n",
         "\n",
-        "\n",
-        "\n",
         "# specify CondaDependencies obj\n",
         "run_config.environment.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'],\n",
         "                                                                            pip_packages=azureml_pip_packages)\n",
@@ -477,7 +428,7 @@
         "from azureml.core import ScriptRunConfig\n",
         "\n",
         "src = ScriptRunConfig(source_directory=project_folder, \n",
-        "                      script='train_explain.py', \n",
+        "                      script='run_explainer.py', \n",
         "                      run_config=run_config) \n",
         "run = experiment.submit(config=src)\n",
         "run"
@@ -564,8 +515,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Download \n",
-        "1. Download model explanation data."
+        "## Download Model Explanation Data"
       ]
     },
     {
@@ -578,9 +528,9 @@
         "\n",
         "# Get model explanation data\n",
         "client = ExplanationClient.from_run(run)\n",
-        "global_explanation = client.download_model_explanation()\n",
-        "local_importance_values = global_explanation.local_importance_values\n",
-        "expected_values = global_explanation.expected_values\n"
+        "explanation = client.download_model_explanation()\n",
+        "local_importance_values = explanation.local_importance_values\n",
+        "expected_values = explanation.expected_values\n"
       ]
     },
     {
@@ -591,9 +541,9 @@
       "source": [
         "# Or you can use the saved run.id to retrive the feature importance values\n",
         "client = ExplanationClient.from_run_id(ws, experiment_name, run.id)\n",
-        "global_explanation = client.download_model_explanation()\n",
-        "local_importance_values = global_explanation.local_importance_values\n",
-        "expected_values = global_explanation.expected_values"
+        "explanation = client.download_model_explanation()\n",
+        "local_importance_values = explanation.local_importance_values\n",
+        "expected_values = explanation.expected_values"
       ]
     },
     {
@@ -603,9 +553,9 @@
       "outputs": [],
       "source": [
         "# Get the top k (e.g., 4) most important features with their importance values\n",
-        "global_explanation_topk = client.download_model_explanation(top_k=4)\n",
-        "global_importance_values = global_explanation_topk.get_ranked_global_values()\n",
-        "global_importance_names = global_explanation_topk.get_ranked_global_names()"
+        "explanation = client.download_model_explanation(top_k=4)\n",
+        "global_importance_values = explanation.get_ranked_global_values()\n",
+        "global_importance_names = explanation.get_ranked_global_names()"
       ]
     },
     {
@@ -622,101 +572,9 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "2. Download model file."
+        "## Success!\n",
+        "Great, you are ready to move on to the remaining notebooks."
       ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# retrieve model for visualization and deployment\n",
-        "from azureml.core.model import Model\n",
-        "from sklearn.externals import joblib\n",
-        "original_model = Model(ws, 'original_model')\n",
-        "model_path = original_model.download(exist_ok=True)\n",
-        "original_model = joblib.load(model_path)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "3. Download test dataset."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# retrieve x_test for visualization\n",
-        "from sklearn.externals import joblib\n",
-        "x_test_path = './x_test_boston_housing.pkl'\n",
-        "run.download_file('x_test_boston_housing.pkl', output_file_path=x_test_path)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "x_test = joblib.load('x_test_boston_housing.pkl')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Load the visualization dashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(global_explanation, original_model, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "1. [Training time: regression problem](../../tabular-data/explain-binary-classification-local.ipynb)       \n",
-        "1. [Training time: binary classification problem](../../tabular-data/explain-binary-classification-local.ipynb)\n",
-        "1. [Training time: multiclass classification problem](../../tabular-data/explain-multiclass-classification-local.ipynb)\n",
-        "1. Explain models with engineered features:\n",
-        "    1. [Simple feature transformations](../../tabular-data/simple-feature-transformations-explain-local.ipynb)\n",
-        "    1. [Advanced feature transformations](../../tabular-data/advanced-feature-transformations-explain-local.ipynb)\n",
-        "1. [Save model explanations via Azure Machine Learning Run History](../run-history/save-retrieve-explanations-run-history.ipynb)\n",
-        "1. Inferencing time: deploy a classification model and explainer:\n",
-        "    1. [Deploy a locally-trained model and explainer](../scoring-time/train-explain-model-locally-and-deploy.ipynb)\n",
-        "    1. [Deploy a remotely-trained model and explainer](../scoring-time/train-explain-model-on-amlcompute-and-deploy.ipynb)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
     }
   ],
   "metadata": {

how-to-use-azureml/explain-model/explain-on-amlcompute/regression-sklearn-on-amlcompute.yml

@@ -1,4 +1,4 @@
-name: explain-regression-local
+name: regression-sklearn-on-amlcompute
 dependencies:
 - pip:
   - azureml-sdk

how-to-use-azureml/explain-model/explain-on-amlcompute/run_explainer.py

@@ -11,8 +11,7 @@ from sklearn.externals import joblib
 import os
 import numpy as np
 
-OUTPUT_DIR = './outputs/'
-os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs('./outputs', exist_ok=True)
 
 boston_data = datasets.load_boston()
 
@@ -23,12 +22,6 @@ X_train, X_test, y_train, y_test = train_test_split(boston_data.data,
                                                     boston_data.target,
                                                     test_size=0.2,
                                                     random_state=0)
-# write x_test out as a pickle file for later visualization
-x_test_pkl = 'x_test.pkl'
-with open(x_test_pkl, 'wb') as file:
-    joblib.dump(value=X_test, filename=os.path.join(OUTPUT_DIR, x_test_pkl))
-run.upload_file('x_test_boston_housing.pkl', os.path.join(OUTPUT_DIR, x_test_pkl))
-
 
 alpha = 0.5
 # Use Ridge algorithm to create a regression model
@@ -41,13 +34,9 @@ run.log('alpha', alpha)
 model_file_name = 'ridge_{0:.2f}.pkl'.format(alpha)
 # save model in the outputs folder so it automatically get uploaded
 with open(model_file_name, 'wb') as file:
-    joblib.dump(value=reg, filename=os.path.join(OUTPUT_DIR,
+    joblib.dump(value=reg, filename=os.path.join('./outputs/',
                                                  model_file_name))
 
-# register the model
-run.upload_file('original_model.pkl', os.path.join('./outputs/', model_file_name))
-original_model = run.register_model(model_name='original_model', model_path='original_model.pkl')
-
 # Explain predictions on your local machine
 tabular_explainer = TabularExplainer(model, X_train, features=boston_data.feature_names)
 

how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-binary-classification.ipynb

@@ -0,0 +1,279 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Breast cancer diagnosis classification with scikit-learn (run model explainer locally)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-binary-classification.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Explain a model with the AML explain-model package\n",
+        "\n",
+        "1. Train a SVM classification model using Scikit-learn\n",
+        "2. Run 'explain_model' with full data in local mode, which doesn't contact any Azure services\n",
+        "3. Run 'explain_model' with summarized data in local mode, which doesn't contact any Azure services\n",
+        "4. Visualize the global and local explanations with the visualization dashboard."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn.datasets import load_breast_cancer\n",
+        "from sklearn import svm\n",
+        "from azureml.explain.model.tabular_explainer import TabularExplainer"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 1. Run model explainer locally with full data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the breast cancer diagnosis data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "breast_cancer_data = load_breast_cancer()\n",
+        "classes = breast_cancer_data.target_names.tolist()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Split data into train and test\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "x_train, x_test, y_train, y_test = train_test_split(breast_cancer_data.data, breast_cancer_data.target, test_size=0.2, random_state=0)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train a SVM classification model, which you want to explain"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "clf = svm.SVC(gamma=0.001, C=100., probability=True)\n",
+        "model = clf.fit(x_train, y_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain predictions on your local machine"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "tabular_explainer = TabularExplainer(model, x_train, features=breast_cancer_data.feature_names, classes=classes)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions (global explanation)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
+        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
+        "global_explanation = tabular_explainer.explain_global(x_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Sorted SHAP values\n",
+        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
+        "# Corresponding feature names\n",
+        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
+        "# feature ranks (based on original order of features)\n",
+        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))\n",
+        "# per class feature names\n",
+        "print('ranked per class feature names: {}'.format(global_explanation.get_ranked_per_class_names()))\n",
+        "# per class feature importance values\n",
+        "print('ranked per class feature values: {}'.format(global_explanation.get_ranked_per_class_values()))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "dict(zip(global_explanation.get_ranked_global_names(), global_explanation.get_ranked_global_values()))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions as a collection of local (instance-level) explanations"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# feature shap values for all features and all data points in the training data\n",
+        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain local data points (individual instances)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# explain the first member of the test set\n",
+        "instance_num = 0\n",
+        "local_explanation = tabular_explainer.explain_local(x_test[instance_num,:])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# get the prediction for the first member of the test set and explain why model made that prediction\n",
+        "prediction_value = clf.predict(x_test)[instance_num]\n",
+        "\n",
+        "sorted_local_importance_values = local_explanation.get_ranked_local_values()[prediction_value]\n",
+        "sorted_local_importance_names = local_explanation.get_ranked_local_names()[prediction_value]\n",
+        "\n",
+        "\n",
+        "dict(zip(sorted_local_importance_names, sorted_local_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 2. Load visualization dashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Note you will need to have extensions enabled prior to jupyter kernel starting\n",
+        "!jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "!jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "# Or, in Jupyter Labs, uncomment below\n",
+        "# jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
+        "# jupyter labextension install microsoft-mli-widget"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ExplanationDashboard(global_explanation, model, x_test)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "mesameki"
+      }
+    ],
+    "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.8"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-binary-classification.yml

@@ -0,0 +1,6 @@
+name: explain-local-sklearn-binary-classification
+dependencies:
+- pip:
+  - azureml-sdk
+  - azureml-explain-model
+  - azureml-contrib-explain-model

how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-multiclass-classification.ipynb

@@ -0,0 +1,280 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Iris flower classification with scikit-learn (run model explainer locally)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-multiclass-classification.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Explain a model with the AML explain-model package\n",
+        "\n",
+        "1. Train a SVM classification model using Scikit-learn\n",
+        "2. Run 'explain_model' with full data in local mode, which doesn't contact any Azure services\n",
+        "3. Run 'explain_model' with summarized data in local mode, which doesn't contact any Azure services\n",
+        "4. Visualize the global and local explanations with the visualization dashboard."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn.datasets import load_iris\n",
+        "from sklearn import svm\n",
+        "from azureml.explain.model.tabular_explainer import TabularExplainer"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 1. Run model explainer locally with full data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the breast cancer diagnosis data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "iris = load_iris()\n",
+        "X = iris['data']\n",
+        "y = iris['target']\n",
+        "classes = iris['target_names']\n",
+        "feature_names = iris['feature_names']"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Split data into train and test\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train a SVM classification model, which you want to explain"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "clf = svm.SVC(gamma=0.001, C=100., probability=True)\n",
+        "model = clf.fit(x_train, y_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain predictions on your local machine"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "tabular_explainer = TabularExplainer(model, x_train, features = feature_names, classes=classes)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions (global explanation)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "global_explanation = tabular_explainer.explain_global(x_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Sorted SHAP values\n",
+        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
+        "# Corresponding feature names\n",
+        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
+        "# feature ranks (based on original order of features)\n",
+        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))\n",
+        "# per class feature names\n",
+        "print('ranked per class feature names: {}'.format(global_explanation.get_ranked_per_class_names()))\n",
+        "# per class feature importance values\n",
+        "print('ranked per class feature values: {}'.format(global_explanation.get_ranked_per_class_values()))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "dict(zip(global_explanation.get_ranked_global_names(), global_explanation.get_ranked_global_values()))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions as a collection of local (instance-level) explanations"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# feature shap values for all features and all data points in the training data\n",
+        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain local data points (individual instances)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# explain the first member of the test set\n",
+        "instance_num = 0\n",
+        "local_explanation = tabular_explainer.explain_local(x_test[instance_num,:])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# get the prediction for the first member of the test set and explain why model made that prediction\n",
+        "prediction_value = clf.predict(x_test)[instance_num]\n",
+        "\n",
+        "sorted_local_importance_values = local_explanation.get_ranked_local_values()[prediction_value]\n",
+        "sorted_local_importance_names = local_explanation.get_ranked_local_names()[prediction_value]\n",
+        "\n",
+        "\n",
+        "dict(zip(sorted_local_importance_names, sorted_local_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load visualization dashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Note you will need to have extensions enabled prior to jupyter kernel starting\n",
+        "!jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "!jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "# Or, in Jupyter Labs, uncomment below\n",
+        "# jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
+        "# jupyter labextension install microsoft-mli-widget"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ExplanationDashboard(global_explanation, model, x_test)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "mesameki"
+      }
+    ],
+    "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.8"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-multiclass-classification.yml

@@ -0,0 +1,6 @@
+name: explain-local-sklearn-multiclass-classification
+dependencies:
+- pip:
+  - azureml-sdk
+  - azureml-explain-model
+  - azureml-contrib-explain-model

how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-regression.ipynb

@@ -0,0 +1,272 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Boston Housing Price Prediction with scikit-learn (run model explainer locally)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-regression.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Explain a model with the AML explain-model package\n",
+        "\n",
+        "1. Train a GradientBoosting regression model using Scikit-learn\n",
+        "2. Run 'explain_model' with full dataset in local mode, which doesn't contact any Azure services.\n",
+        "3. Run 'explain_model' with summarized dataset in local mode, which doesn't contact any Azure services.\n",
+        "4. Visualize the global and local explanations with the visualization dashboard."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn import datasets\n",
+        "from sklearn.ensemble import GradientBoostingRegressor\n",
+        "from azureml.explain.model.tabular_explainer import TabularExplainer"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 1. Run model explainer locally with full data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the Boston house price data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "boston_data = datasets.load_boston()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Split data into train and test\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "x_train, x_test, y_train, y_test = train_test_split(boston_data.data, boston_data.target, test_size=0.2, random_state=0)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train a GradientBoosting Regression model, which you want to explain"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "reg = GradientBoostingRegressor(n_estimators=100, max_depth=4,\n",
+        "                                learning_rate=0.1, loss='huber',\n",
+        "                                random_state=1)\n",
+        "model = reg.fit(x_train, y_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain predictions on your local machine"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "tabular_explainer = TabularExplainer(model, x_train, features = boston_data.feature_names)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions (global explanation)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
+        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
+        "global_explanation = tabular_explainer.explain_global(x_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Sorted SHAP values \n",
+        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
+        "# Corresponding feature names\n",
+        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
+        "# feature ranks (based on original order of features)\n",
+        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "dict(zip(global_explanation.get_ranked_global_names(), global_explanation.get_ranked_global_values()))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions as a collection of local (instance-level) explanations"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# feature shap values for all features and all data points in the training data\n",
+        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain local data points (individual instances)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "local_explanation = tabular_explainer.explain_local(x_test[0,:])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# sorted local feature importance information; reflects the original feature order\n",
+        "sorted_local_importance_names = local_explanation.get_ranked_local_names()\n",
+        "sorted_local_importance_values = local_explanation.get_ranked_local_values()\n",
+        "\n",
+        "print('sorted local importance names: {}'.format(sorted_local_importance_names))\n",
+        "print('sorted local importance values: {}'.format(sorted_local_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load visualization dashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Note you will need to have extensions enabled prior to jupyter kernel starting\n",
+        "!jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "!jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "# Or, in Jupyter Labs, uncomment below\n",
+        "# jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
+        "# jupyter labextension install microsoft-mli-widget"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ExplanationDashboard(global_explanation, model, x_test)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "mesameki"
+      }
+    ],
+    "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.8"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/explain-model/explain-tabular-data-local/explain-local-sklearn-regression.yml

@@ -1,4 +1,4 @@
-name: explain-binary-classification-local
+name: explain-local-sklearn-regression
 dependencies:
 - pip:
   - azureml-sdk

how-to-use-azureml/explain-model/explain-tabular-data-raw-features/explain-sklearn-raw-features.ipynb

@@ -0,0 +1,337 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Summary\n",
+        "From raw data that is a mixture of categoricals and numeric, featurize the categoricals using one hot encoding. Use tabular explainer to get explain object and then get raw feature importances"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/explain-tabular-data-raw-features/explain-sklearn-raw-features.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Explain a model with the AML explain-model package on raw features\n",
+        "\n",
+        "1. Train a Logistic Regression model using Scikit-learn\n",
+        "2. Run 'explain_model' with full dataset in local mode, which doesn't contact any Azure services.\n",
+        "3. Run 'explain_model' with summarized dataset in local mode, which doesn't contact any Azure services.\n",
+        "4. Visualize the global and local explanations with the visualization dashboard."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn.pipeline import Pipeline\n",
+        "from sklearn.impute import SimpleImputer\n",
+        "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
+        "from sklearn.linear_model import LogisticRegression\n",
+        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
+        "import pandas as pd\n",
+        "import numpy as np"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "titanic_url = ('https://raw.githubusercontent.com/amueller/'\n",
+        "               'scipy-2017-sklearn/091d371/notebooks/datasets/titanic3.csv')\n",
+        "data = pd.read_csv(titanic_url)\n",
+        "# fill missing values\n",
+        "data = data.fillna(method=\"ffill\")\n",
+        "data = data.fillna(method=\"bfill\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 1. Run model explainer locally with full data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Similar to example [here](https://scikit-learn.org/stable/auto_examples/compose/plot_column_transformer_mixed_types.html#sphx-glr-auto-examples-compose-plot-column-transformer-mixed-types-py), use a subset of columns"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "numeric_features = ['age', 'fare']\n",
+        "categorical_features = ['embarked', 'sex', 'pclass']\n",
+        "\n",
+        "y = data['survived'].values\n",
+        "X = data[categorical_features + numeric_features]\n",
+        "\n",
+        "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "sklearn imports"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn.pipeline import Pipeline\n",
+        "from sklearn.impute import SimpleImputer\n",
+        "from sklearn.preprocessing import StandardScaler, OneHotEncoder"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We can explain raw features by either using a `sklearn.compose.ColumnTransformer` or a list of fitted transformer tuples. The cell below uses `sklearn.compose.ColumnTransformer`. In case you want to run the example with the list of fitted transformer tuples, comment the cell below and uncomment the cell that follows after. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn.compose import ColumnTransformer\n",
+        "\n",
+        "transformations = ColumnTransformer([\n",
+        "    (\"age_fare\", Pipeline(steps=[\n",
+        "        ('imputer', SimpleImputer(strategy='median')),\n",
+        "        ('scaler', StandardScaler())\n",
+        "    ]), [\"age\", \"fare\"]),\n",
+        "    (\"embarked\", Pipeline(steps=[\n",
+        "        (\"imputer\", SimpleImputer(strategy='constant', fill_value='missing')), \n",
+        "        (\"encoder\", OneHotEncoder(sparse=False))]), [\"embarked\"]),\n",
+        "    (\"sex_pclass\", OneHotEncoder(sparse=False), [\"sex\", \"pclass\"])    \n",
+        "])\n",
+        "\n",
+        "\n",
+        "# Append classifier to preprocessing pipeline.\n",
+        "# Now we have a full prediction pipeline.\n",
+        "clf = Pipeline(steps=[('preprocessor', transformations),\n",
+        "                      ('classifier', LogisticRegression(solver='lbfgs'))])\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "'''\n",
+        "# Uncomment below if sklearn-pandas is not installed\n",
+        "#!pip install sklearn-pandas\n",
+        "from sklearn_pandas import DataFrameMapper\n",
+        "\n",
+        "# Impute, standardize the numeric features and one-hot encode the categorical features.    \n",
+        "\n",
+        "transformations = [\n",
+        "    ([\"age\", \"fare\"], Pipeline(steps=[\n",
+        "        ('imputer', SimpleImputer(strategy='median')),\n",
+        "        ('scaler', StandardScaler())\n",
+        "    ])),\n",
+        "    ([\"embarked\"], Pipeline(steps=[\n",
+        "        (\"imputer\", SimpleImputer(strategy='constant', fill_value='missing')), \n",
+        "        (\"encoder\", OneHotEncoder(sparse=False))])),\n",
+        "    ([\"sex\", \"pclass\"], OneHotEncoder(sparse=False))    \n",
+        "]\n",
+        "\n",
+        "\n",
+        "# Append classifier to preprocessing pipeline.\n",
+        "# Now we have a full prediction pipeline.\n",
+        "clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),\n",
+        "                      ('classifier', LogisticRegression(solver='lbfgs'))])\n",
+        "'''"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train a Logistic Regression model, which you want to explain"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "model = clf.fit(x_train, y_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain predictions on your local machine"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "tabular_explainer = TabularExplainer(clf.steps[-1][1], initialization_examples=x_train, features=x_train.columns, transformations=transformations)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
+        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
+        "global_explanation = tabular_explainer.explain_global(x_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "sorted_global_importance_values = global_explanation.get_ranked_global_values()\n",
+        "sorted_global_importance_names = global_explanation.get_ranked_global_names()\n",
+        "dict(zip(sorted_global_importance_names, sorted_global_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions as a collection of local (instance-level) explanations"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# explain the first member of the test set\n",
+        "local_explanation = tabular_explainer.explain_local(x_test[:1])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# get the prediction for the first member of the test set and explain why model made that prediction\n",
+        "prediction_value = clf.predict(x_test)[0]\n",
+        "\n",
+        "sorted_local_importance_values = local_explanation.get_ranked_local_values()[prediction_value]\n",
+        "sorted_local_importance_names = local_explanation.get_ranked_local_names()[prediction_value]\n",
+        "\n",
+        "# Sorted local SHAP values\n",
+        "print('ranked local importance values: {}'.format(sorted_local_importance_values))\n",
+        "# Corresponding feature names\n",
+        "print('ranked local importance names: {}'.format(sorted_local_importance_names))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 2. Load visualization dashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Note you will need to have extensions enabled prior to jupyter kernel starting\n",
+        "!jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "!jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
+        "# Or, in Jupyter Labs, uncomment below\n",
+        "# jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
+        "# jupyter labextension install microsoft-mli-widget"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ExplanationDashboard(global_explanation, model, x_test)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "mesameki"
+      }
+    ],
+    "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.8"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/explain-model/explain-tabular-data-raw-features/explain-sklearn-raw-features.yml

@@ -1,4 +1,4 @@
-name: train-explain-model-locally-and-deploy
+name: explain-sklearn-raw-features
 dependencies:
 - pip:
   - azureml-sdk

how-to-use-azureml/explain-model/explain-tabular-data-run-history/explain-run-history-sklearn-classification.ipynb

@@ -0,0 +1,262 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Breast cancer diagnosis classification with scikit-learn (save model explanations via AML Run History)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/explain-tabular-data-run-history/explain-run-history-sklearn-classification.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Explain a model with the AML explain-model package\n",
+        "\n",
+        "1. Train a SVM classification model using Scikit-learn\n",
+        "2. Run 'explain_model' with AML Run History, which leverages run history service to store and manage the explanation data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sklearn.datasets import load_breast_cancer\n",
+        "from sklearn import svm\n",
+        "from azureml.explain.model.tabular_explainer import TabularExplainer"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 1. Run model explainer locally with full data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the breast cancer diagnosis data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "breast_cancer_data = load_breast_cancer()\n",
+        "classes = breast_cancer_data.target_names.tolist()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Split data into train and test\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "x_train, x_test, y_train, y_test = train_test_split(breast_cancer_data.data, breast_cancer_data.target, test_size=0.2, random_state=0)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train a SVM classification model, which you want to explain"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "clf = svm.SVC(gamma=0.001, C=100., probability=True)\n",
+        "model = clf.fit(x_train, y_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain predictions on your local machine"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "tabular_explainer = TabularExplainer(model, x_train, features=breast_cancer_data.feature_names, classes=classes)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions (global explanation)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
+        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
+        "global_explanation = tabular_explainer.explain_global(x_test)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 2. Save Model Explanation With AML Run History"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "from azureml.core import Workspace, Experiment, Run\n",
+        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
+        "from azureml.contrib.explain.model.explanation.explanation_client import ExplanationClient\n",
+        "# Check core SDK version number\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "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": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "experiment_name = 'explain_model'\n",
+        "experiment = Experiment(ws, experiment_name)\n",
+        "run = experiment.start_logging()\n",
+        "client = ExplanationClient.from_run(run)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Uploading model explanation data for storage or visualization in webUX\n",
+        "# The explanation can then be downloaded on any compute\n",
+        "client.upload_model_explanation(global_explanation)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Get model explanation data\n",
+        "explanation = client.download_model_explanation()\n",
+        "local_importance_values = explanation.local_importance_values\n",
+        "expected_values = explanation.expected_values"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Get the top k (e.g., 4) most important features with their importance values\n",
+        "explanation = client.download_model_explanation(top_k=4)\n",
+        "global_importance_values = explanation.get_ranked_global_values()\n",
+        "global_importance_names = explanation.get_ranked_global_names()\n",
+        "per_class_names = explanation.get_ranked_per_class_names()[0]\n",
+        "per_class_values = explanation.get_ranked_per_class_values()[0]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print('per class feature importance values: {}'.format(per_class_values))\n",
+        "print('per class feature importance names: {}'.format(per_class_names))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "dict(zip(per_class_names, per_class_values))"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "mesameki"
+      }
+    ],
+    "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.8"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/explain-model/explain-tabular-data-run-history/explain-run-history-sklearn-classification.yml

@@ -1,4 +1,4 @@
-name: explain-multiclass-classification-local
+name: explain-run-history-sklearn-classification
 dependencies:
 - pip:
   - azureml-sdk

how-to-use-azureml/explain-model/explain-tabular-data-run-history/explain-run-history-sklearn-regression.ipynb

@@ -0,0 +1,276 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Boston Housing Price Prediction with scikit-learn (save model explanations via AML Run History)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/explain-tabular-data-run-history/explain-run-history-sklearn-regression.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
+        "\n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Explain a model with the AML explain-model package\n",
+        "\n",
+        "1. Train a GradientBoosting regression model using Scikit-learn\n",
+        "2. Run 'explain_model' with AML Run History, which leverages run history service to store and manage the explanation data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Save Model Explanation With AML Run History"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#Import Iris dataset\n",
+        "from sklearn import datasets\n",
+        "from sklearn.ensemble import GradientBoostingRegressor\n",
+        "\n",
+        "import azureml.core\n",
+        "from azureml.core import Workspace, Experiment, Run\n",
+        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
+        "from azureml.contrib.explain.model.explanation.explanation_client import ExplanationClient\n",
+        "# Check core SDK version number\n",
+        "print(\"SDK version:\", azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "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": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "experiment_name = 'explain_model'\n",
+        "experiment = Experiment(ws, experiment_name)\n",
+        "run = experiment.start_logging()\n",
+        "client = ExplanationClient.from_run(run)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the Boston house price data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "boston_data = datasets.load_boston()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Split data into train and test\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "x_train, x_test, y_train, y_test = train_test_split(boston_data.data, boston_data.target, test_size=0.2, random_state=0)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Train a GradientBoosting Regression model, which you want to explain"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "clf = GradientBoostingRegressor(n_estimators=100, max_depth=4,\n",
+        "                                learning_rate=0.1, loss='huber',\n",
+        "                                random_state=1)\n",
+        "model = clf.fit(x_train, y_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain predictions on your local machine"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "tabular_explainer = TabularExplainer(model, x_train, features=boston_data.feature_names)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain overall model predictions (global explanation)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
+        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
+        "global_explanation = tabular_explainer.explain_global(x_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Uploading model explanation data for storage or visualization in webUX\n",
+        "# The explanation can then be downloaded on any compute\n",
+        "client.upload_model_explanation(global_explanation)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Get model explanation data\n",
+        "explanation = client.download_model_explanation()\n",
+        "local_importance_values = explanation.local_importance_values\n",
+        "expected_values = explanation.expected_values"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Print the values\n",
+        "print('expected values: {}'.format(expected_values))\n",
+        "print('local importance values: {}'.format(local_importance_values))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Get the top k (e.g., 4) most important features with their importance values\n",
+        "explanation = client.download_model_explanation(top_k=4)\n",
+        "global_importance_values = explanation.get_ranked_global_values()\n",
+        "global_importance_names = explanation.get_ranked_global_names()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print('global importance values: {}'.format(global_importance_values))\n",
+        "print('global importance names: {}'.format(global_importance_names))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Explain individual instance predictions (local explanation) ##### needs to get updated with the new build"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "local_explanation = tabular_explainer.explain_local(x_test[0,:])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# local feature importance information\n",
+        "local_importance_values = local_explanation.local_importance_values\n",
+        "print('local importance values: {}'.format(local_importance_values))"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "mesameki"
+      }
+    ],
+    "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.8"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

how-to-use-azureml/explain-model/explain-tabular-data-run-history/explain-run-history-sklearn-regression.yml

@@ -1,4 +1,4 @@
-name: save-retrieve-explanations-run-history
+name: explain-run-history-sklearn-regression
 dependencies:
 - pip:
   - azureml-sdk

how-to-use-azureml/explain-model/tabular-data/advanced-feature-transformations-explain-local.ipynb

@@ -1,523 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/tabular-data/advanced-feature-transformations-explain-local.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Explain binary classification model predictions with raw feature transformations\n",
-        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to explain and visualize a binary classification model that uses advanced many to one or many to many feature transformations.**_\n",
-        "\n",
-        "\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Run model explainer locally at training time](#Explain)\n",
-        "    1. Apply feature transformations\n",
-        "    1. Train a binary classification model\n",
-        "    1. Explain the model on raw features\n",
-        "        1. Generate global explanations\n",
-        "        1. Generate local explanations\n",
-        "1. [Visualize results](#Visualize)\n",
-        "1. [Next steps](#Next)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "\n",
-        "This notebook illustrates creating explanations for a binary classification model, Titanic passenger data classification, that uses many to one and many to many feature transformations from raw data to engineered features. For the many to one transformation, we sum 2 features `age` and `fare`. For many to many transformations two features are computed: one that is product of `age` and `fare` and another that is square of this product. Our tabular data explainer is then used to get the explanation object with the flag `allow_all_transformations` passed. The object is then used to get raw feature importances.\n",
-        "\n",
-        "\n",
-        "We will showcase raw feature transformations with three tabular data explainers: TabularExplainer (SHAP), MimicExplainer (global surrogate), and PFIExplainer.\n",
-        "\n",
-        "| ![Interpretability Toolkit Architecture](./img/interpretability-architecture.PNG) |\n",
-        "|:--:|\n",
-        "| *Interpretability Toolkit Architecture* |\n",
-        "\n",
-        "Problem: Titanic passenger data classification with scikit-learn (run model explainer locally)\n",
-        "\n",
-        "1. Transform raw features to engineered features\n",
-        "2. Train a Logistic Regression model using Scikit-learn\n",
-        "3. Run 'explain_model' globally and locally with full dataset in local mode, which doesn't contact any Azure services.\n",
-        "4. Visualize the global and local explanations with the visualization dashboard.\n",
-        "---\n",
-        "\n",
-        "## Setup\n",
-        "\n",
-        "You will need to have extensions enabled prior to jupyter kernel starting to see the visualization dashboard.\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "(myenv) $ jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "```\n",
-        "Or\n",
-        "\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install azureml.contrib.explain.model.visualize --user --py\n",
-        "(myenv) $ jupyter nbextension enable azureml.contrib.explain.model.visualize --user --py\n",
-        "```\n",
-        "\n",
-        "If you are using Jupyter Labs run the following commands instead:\n",
-        "```\n",
-        "(myenv) $ jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
-        "(myenv) $ jupyter labextension install microsoft-mli-widget\n",
-        "```\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Explain\n",
-        "\n",
-        "### Run model explainer locally at training time"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.pipeline import Pipeline\n",
-        "from sklearn.impute import SimpleImputer\n",
-        "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
-        "from sklearn.linear_model import LogisticRegression\n",
-        "import pandas as pd\n",
-        "import numpy as np\n",
-        "\n",
-        "# Explainers:\n",
-        "# 1. SHAP Tabular Explainer\n",
-        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 2. Mimic Explainer\n",
-        "from azureml.explain.model.mimic.mimic_explainer import MimicExplainer\n",
-        "# You can use one of the following four interpretable models as a global surrogate to the black box model\n",
-        "from azureml.explain.model.mimic.models.lightgbm_model import LGBMExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import LinearExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import SGDExplainableModel\n",
-        "from azureml.explain.model.mimic.models.tree_model import DecisionTreeExplainableModel\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 3. PFI Explainer\n",
-        "from azureml.explain.model.permutation.permutation_importance import PFIExplainer "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Load the Titanic passenger data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "titanic_url = ('https://raw.githubusercontent.com/amueller/'\n",
-        "               'scipy-2017-sklearn/091d371/notebooks/datasets/titanic3.csv')\n",
-        "data = pd.read_csv(titanic_url)\n",
-        "# fill missing values\n",
-        "data = data.fillna(method=\"ffill\")\n",
-        "data = data.fillna(method=\"bfill\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Similar to example [here](https://scikit-learn.org/stable/auto_examples/compose/plot_column_transformer_mixed_types.html#sphx-glr-auto-examples-compose-plot-column-transformer-mixed-types-py), use a subset of columns"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.model_selection import train_test_split\n",
-        "\n",
-        "numeric_features = ['age', 'fare']\n",
-        "categorical_features = ['embarked', 'sex', 'pclass']\n",
-        "\n",
-        "y = data['survived'].values\n",
-        "X = data[categorical_features + numeric_features]\n",
-        "\n",
-        "# Split data into train and test\n",
-        "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Transform raw features"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "We can explain raw features by either using a `sklearn.compose.ColumnTransformer` or a list of fitted transformer tuples. The cell below uses `sklearn.compose.ColumnTransformer`. In case you want to run the example with the list of fitted transformer tuples, comment the cell below and uncomment the cell that follows after. "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# We add many to one and many to many transformations for illustration purposes.\n",
-        "# The support for raw feature explanations with many to one and many to many transformations are only supported \n",
-        "# When allow_all_transformations is set to True on explainer creation\n",
-        "from sklearn.preprocessing import FunctionTransformer\n",
-        "many_to_one_transformer = FunctionTransformer(lambda x: x.sum(axis=1).reshape(-1, 1))\n",
-        "many_to_many_transformer = FunctionTransformer(lambda x: np.hstack(\n",
-        "    (np.prod(x, axis=1).reshape(-1, 1), (np.prod(x, axis=1)**2).reshape(-1, 1))\n",
-        "))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.compose import ColumnTransformer\n",
-        "\n",
-        "transformations = ColumnTransformer([\n",
-        "    (\"age_fare_1\", Pipeline(steps=[\n",
-        "        ('imputer', SimpleImputer(strategy='median')),\n",
-        "        ('scaler', StandardScaler())\n",
-        "    ]), [\"age\", \"fare\"]),\n",
-        "    (\"age_fare_2\", many_to_one_transformer, [\"age\", \"fare\"]),\n",
-        "    (\"age_fare_3\", many_to_many_transformer, [\"age\", \"fare\"]),\n",
-        "    (\"embarked\", Pipeline(steps=[\n",
-        "        (\"imputer\", SimpleImputer(strategy='constant', fill_value='missing')), \n",
-        "        (\"encoder\", OneHotEncoder(sparse=False))]), [\"embarked\"]),\n",
-        "    (\"sex_pclass\", OneHotEncoder(sparse=False), [\"sex\", \"pclass\"])    \n",
-        "])\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "'''\n",
-        "# Uncomment below if sklearn-pandas is not installed\n",
-        "#!pip install sklearn-pandas\n",
-        "from sklearn_pandas import DataFrameMapper\n",
-        "\n",
-        "# Impute, standardize the numeric features and one-hot encode the categorical features.    \n",
-        "\n",
-        "transformations = [\n",
-        "    ([\"age\", \"fare\"], Pipeline(steps=[\n",
-        "        ('imputer', SimpleImputer(strategy='median')),\n",
-        "        ('scaler', StandardScaler())\n",
-        "    ])),\n",
-        "    ([\"age\", \"fare\"], many_to_one_transformer),\n",
-        "    ([\"age\", \"fare\"], many_to_many_transformer),\n",
-        "    ([\"embarked\"], Pipeline(steps=[\n",
-        "        (\"imputer\", SimpleImputer(strategy='constant', fill_value='missing')), \n",
-        "        (\"encoder\", OneHotEncoder(sparse=False))])),\n",
-        "    ([\"sex\", \"pclass\"], OneHotEncoder(sparse=False))    \n",
-        "]\n",
-        "\n",
-        "\n",
-        "# Append classifier to preprocessing pipeline.\n",
-        "# Now we have a full prediction pipeline.\n",
-        "clf = Pipeline(steps=[('preprocessor', DataFrameMapper(transformations)),\n",
-        "                      ('classifier', LogisticRegression(solver='lbfgs'))])\n",
-        "'''"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Train a Logistic Regression model, which you want to explain"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Append classifier to preprocessing pipeline.\n",
-        "# Now we have a full prediction pipeline.\n",
-        "clf = Pipeline(steps=[('preprocessor', transformations),\n",
-        "                      ('classifier', LogisticRegression(solver='lbfgs'))])\n",
-        "model = clf.fit(x_train, y_train)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain predictions on your local machine"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# 1. Using SHAP TabularExplainer\n",
-        "# When the last parameter allow_all_transformations is passed, we handle many to one and many to many transformations to \n",
-        "# generate approximations to raw feature importances. When this flag is passed, for transformations not recognized as one to \n",
-        "# many, we distribute feature importances evenly to raw features generating them.\n",
-        "# clf.steps[-1][1] returns the trained classification model\n",
-        "explainer = TabularExplainer(clf.steps[-1][1], \n",
-        "                             initialization_examples=x_train, \n",
-        "                             features=x_train.columns, \n",
-        "                             transformations=transformations, \n",
-        "                             allow_all_transformations=True)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 2. Using MimicExplainer\n",
-        "# augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns. \n",
-        "# max_num_of_augmentations is optional and defines max number of times we can increase the input data size.\n",
-        "# LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel\n",
-        "# explainer = MimicExplainer(clf.steps[-1][1], \n",
-        "#                            x_train, \n",
-        "#                            LGBMExplainableModel, \n",
-        "#                            augment_data=True, \n",
-        "#                            max_num_of_augmentations=10, \n",
-        "#                            features=x_train.columns, \n",
-        "#                            transformations=transformations, \n",
-        "#                            allow_all_transformations=True)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 3. Using PFIExplainer\n",
-        "\n",
-        "# Use the parameter \"metric\" to pass a metric name or function to evaluate the permutation. \n",
-        "# Note that if a metric function is provided a higher value must be better.\n",
-        "# Otherwise, take the negative of the function or set the parameter \"is_error_metric\" to True.\n",
-        "# Default metrics: \n",
-        "# F1 Score for binary classification, F1 Score with micro average for multiclass classification and\n",
-        "# Mean absolute error for regression\n",
-        "\n",
-        "\n",
-        "# explainer = PFIExplainer(clf.steps[-1][1], \n",
-        "#                          features=x_train.columns, \n",
-        "#                          transformations=transformations)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate global explanations\n",
-        "Explain overall model predictions (global explanation)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
-        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
-        "\n",
-        "global_explanation = explainer.explain_global(x_test)\n",
-        "\n",
-        "# Note: if you used the PFIExplainer in the previous step, use the next line of code instead\n",
-        "# global_explanation = explainer.explain_global(x_test, true_labels=y_test)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Sorted SHAP values\n",
-        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
-        "# Corresponding feature names\n",
-        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
-        "# Feature ranks (based on original order of features)\n",
-        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))\n",
-        "# Per class feature names\n",
-        "print('ranked per class feature names: {}'.format(global_explanation.get_ranked_per_class_names()))\n",
-        "# Per class feature importance values\n",
-        "print('ranked per class feature values: {}'.format(global_explanation.get_ranked_per_class_values()))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Print out a dictionary that holds the sorted feature importance names and values\n",
-        "print('global importance rank: {}'.format(global_explanation.get_feature_importance_dict()))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain overall model predictions as a collection of local (instance-level) explanations"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# feature shap values for all features and all data points in the training data\n",
-        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate local explanations\n",
-        "Explain local data points (individual instances)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Note: PFIExplainer does not support local explanations\n",
-        "# You can pass a specific data point or a group of data points to the explain_local function\n",
-        "\n",
-        "# E.g., Explain the first data point in the test set\n",
-        "instance_num = 1\n",
-        "local_explanation = explainer.explain_local(x_test[:instance_num])"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Get the prediction for the first member of the test set and explain why model made that prediction\n",
-        "prediction_value = clf.predict(x_test)[instance_num]\n",
-        "\n",
-        "sorted_local_importance_values = local_explanation.get_ranked_local_values()[prediction_value]\n",
-        "sorted_local_importance_names = local_explanation.get_ranked_local_names()[prediction_value]\n",
-        "\n",
-        "print('local importance values: {}'.format(sorted_local_importance_values))\n",
-        "print('local importance names: {}'.format(sorted_local_importance_names))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Load the visualization dashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(global_explanation, model, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "       \n",
-        "1. [Training time: regression problem](./explain-regression-local.ipynb)\n",
-        "1. [Training time: binary classification problem](./explain-binary-classification-local.ipynb)\n",
-        "1. [Training time: multiclass classification problem](./explain-multiclass-classification-local.ipynb)\n",
-        "1. [Explain models with simple feature transformations](./simple-feature-transformations-explain-local.ipynb)\n",
-        "1. [Save model explanations via Azure Machine Learning Run History](../azure-integration/run-history/save-retrieve-explanations-run-history.ipynb)\n",
-        "1. [Run explainers remotely on Azure Machine Learning Compute (AMLCompute)](../azure-integration/remote-explanation/explain-model-on-amlcompute.ipynb)\n",
-        "1. Inferencing time: deploy a classification model and explainer:\n",
-        "    1. [Deploy a locally-trained model and explainer](../azure-integration/scoring-time/train-explain-model-locally-and-deploy.ipynb)\n",
-        "    1. [Deploy a remotely-trained model and explainer](../azure-integration/scoring-time/train-explain-model-on-amlcompute-and-deploy.ipynb)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "mesameki"
-      }
-    ],
-    "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.8"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

how-to-use-azureml/explain-model/tabular-data/advanced-feature-transformations-explain-local.yml

@@ -1,7 +0,0 @@
-name: advanced-feature-transformations-explain-local
-dependencies:
-- pip:
-  - azureml-sdk
-  - azureml-explain-model
-  - azureml-contrib-explain-model
-  - sklearn-pandas

how-to-use-azureml/explain-model/tabular-data/explain-binary-classification-local.ipynb

@@ -1,404 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/tabular-data/explain-binary-classification-local.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Explain binary classification model predictions\n",
-        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to explain and visualize a binary classification model predictions.**_\n",
-        "\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Run model explainer locally at training time](#Explain)\n",
-        "    1. Train a binary classification model\n",
-        "    1. Explain the model\n",
-        "        1. Generate global explanations\n",
-        "        1. Generate local explanations\n",
-        "1. [Visualize results](#Visualize)\n",
-        "1. [Next steps](#Next)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "\n",
-        "This notebook illustrates how to explain a binary classification model predictions locally at training time without contacting any Azure services.\n",
-        "It demonstrates the API calls that you need to make to get the global and local explanations and a visualization dashboard that provides an interactive way of discovering patterns in data and explanations.\n",
-        "\n",
-        "We will showcase three tabular data explainers: TabularExplainer (SHAP), MimicExplainer (global surrogate), and PFIExplainer.\n",
-        "\n",
-        "| ![Interpretability Toolkit Architecture](./img/interpretability-architecture.PNG) |\n",
-        "|:--:|\n",
-        "| *Interpretability Toolkit Architecture* |\n",
-        "\n",
-        "Problem: Breast cancer diagnosis classification with scikit-learn (run model explainer locally)\n",
-        "\n",
-        "1. Train a SVM classification model using Scikit-learn\n",
-        "2. Run 'explain_model' globally and locally with full dataset in local mode, which doesn't contact any Azure services.\n",
-        "3. Visualize the global and local explanations with the visualization dashboard.\n",
-        "---\n",
-        "\n",
-        "## Setup\n",
-        "\n",
-        "You will need to have extensions enabled prior to jupyter kernel starting to see the visualization dashboard.\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "(myenv) $ jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "```\n",
-        "Or\n",
-        "\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install azureml.contrib.explain.model.visualize --user --py\n",
-        "(myenv) $ jupyter nbextension enable azureml.contrib.explain.model.visualize --user --py\n",
-        "```\n",
-        "\n",
-        "If you are using Jupyter Labs run the following commands instead:\n",
-        "```\n",
-        "(myenv) $ jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
-        "(myenv) $ jupyter labextension install microsoft-mli-widget\n",
-        "```\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Explain\n",
-        "\n",
-        "### Run model explainer locally at training time"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.datasets import load_breast_cancer\n",
-        "from sklearn import svm\n",
-        "\n",
-        "# Explainers:\n",
-        "# 1. SHAP Tabular Explainer\n",
-        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 2. Mimic Explainer\n",
-        "from azureml.explain.model.mimic.mimic_explainer import MimicExplainer\n",
-        "# You can use one of the following four interpretable models as a global surrogate to the black box model\n",
-        "from azureml.explain.model.mimic.models.lightgbm_model import LGBMExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import LinearExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import SGDExplainableModel\n",
-        "from azureml.explain.model.mimic.models.tree_model import DecisionTreeExplainableModel\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 3. PFI Explainer\n",
-        "from azureml.explain.model.permutation.permutation_importance import PFIExplainer "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Load the breast cancer diagnosis data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "breast_cancer_data = load_breast_cancer()\n",
-        "classes = breast_cancer_data.target_names.tolist()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Split data into train and test\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "x_train, x_test, y_train, y_test = train_test_split(breast_cancer_data.data, breast_cancer_data.target, test_size=0.2, random_state=0)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Train a SVM classification model, which you want to explain"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "clf = svm.SVC(gamma=0.001, C=100., probability=True)\n",
-        "model = clf.fit(x_train, y_train)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain predictions on your local machine"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# 1. Using SHAP TabularExplainer\n",
-        "explainer = TabularExplainer(model, \n",
-        "                             x_train, \n",
-        "                             features=breast_cancer_data.feature_names, \n",
-        "                             classes=classes)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 2. Using MimicExplainer\n",
-        "# augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns. \n",
-        "# max_num_of_augmentations is optional and defines max number of times we can increase the input data size.\n",
-        "# LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel\n",
-        "# explainer = MimicExplainer(model, \n",
-        "#                            x_train, \n",
-        "#                            LGBMExplainableModel, \n",
-        "#                            augment_data=True, \n",
-        "#                            max_num_of_augmentations=10, \n",
-        "#                            features=breast_cancer_data.feature_names, \n",
-        "#                            classes=classes)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 3. Using PFIExplainer\n",
-        "\n",
-        "# Use the parameter \"metric\" to pass a metric name or function to evaluate the permutation. \n",
-        "# Note that if a metric function is provided a higher value must be better.\n",
-        "# Otherwise, take the negative of the function or set the parameter \"is_error_metric\" to True.\n",
-        "# Default metrics: \n",
-        "# F1 Score for binary classification, F1 Score with micro average for multiclass classification and\n",
-        "# Mean absolute error for regression\n",
-        "\n",
-        "# explainer = PFIExplainer(model, \n",
-        "#                          features=breast_cancer_data.feature_names, \n",
-        "#                          classes=classes)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate global explanations\n",
-        "Explain overall model predictions (global explanation)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
-        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
-        "global_explanation = explainer.explain_global(x_test)\n",
-        "\n",
-        "# Note: if you used the PFIExplainer in the previous step, use the next line of code instead\n",
-        "# global_explanation = explainer.explain_global(x_test, true_labels=y_test)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Sorted SHAP values\n",
-        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
-        "# Corresponding feature names\n",
-        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
-        "# Feature ranks (based on original order of features)\n",
-        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))\n",
-        "\n",
-        "# Note: PFIExplainer does not support per class explanations\n",
-        "# Per class feature names\n",
-        "print('ranked per class feature names: {}'.format(global_explanation.get_ranked_per_class_names()))\n",
-        "# Per class feature importance values\n",
-        "print('ranked per class feature values: {}'.format(global_explanation.get_ranked_per_class_values()))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Print out a dictionary that holds the sorted feature importance names and values\n",
-        "print('global importance rank: {}'.format(global_explanation.get_feature_importance_dict()))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain overall model predictions as a collection of local (instance-level) explanations"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# feature shap values for all features and all data points in the training data\n",
-        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate local explanations\n",
-        "Explain local data points (individual instances)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Note: PFIExplainer does not support local explanations\n",
-        "# You can pass a specific data point or a group of data points to the explain_local function\n",
-        "\n",
-        "# E.g., Explain the first data point in the test set\n",
-        "instance_num = 0\n",
-        "local_explanation = explainer.explain_local(x_test[instance_num,:])"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Get the prediction for the first member of the test set and explain why model made that prediction\n",
-        "prediction_value = clf.predict(x_test)[instance_num]\n",
-        "\n",
-        "sorted_local_importance_values = local_explanation.get_ranked_local_values()[prediction_value]\n",
-        "sorted_local_importance_names = local_explanation.get_ranked_local_names()[prediction_value]\n",
-        "\n",
-        "print('local importance values: {}'.format(sorted_local_importance_values))\n",
-        "print('local importance names: {}'.format(sorted_local_importance_names))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Load the visualization dashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(global_explanation, model, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "       \n",
-        "1. [Training time: regression problem](./explain-regression-local.ipynb)\n",
-        "1. [Training time: multiclass classification problem](./explain-multiclass-classification-local.ipynb)\n",
-        "1. Explain models with engineered features:\n",
-        "    1. [Simple feature transformations](./simple-feature-transformations-explain-local.ipynb)\n",
-        "    1. [Advanced feature transformations](./advanced-feature-transformations-explain-local.ipynb)\n",
-        "1. [Save model explanations via Azure Machine Learning Run History](../azure-integration/run-history/save-retrieve-explanations-run-history.ipynb)\n",
-        "1. [Run explainers remotely on Azure Machine Learning Compute (AMLCompute)](../azure-integration/remote-explanation/explain-model-on-amlcompute.ipynb)\n",
-        "1. Inferencing time: deploy a classification model and explainer:\n",
-        "    1. [Deploy a locally-trained model and explainer](../azure-integration/scoring-time/train-explain-model-locally-and-deploy.ipynb)\n",
-        "    1. [Deploy a remotely-trained model and explainer](../azure-integration/scoring-time/train-explain-model-on-amlcompute-and-deploy.ipynb)\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "mesameki"
-      }
-    ],
-    "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.8"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

how-to-use-azureml/explain-model/tabular-data/explain-multiclass-classification-local.ipynb

@@ -1,402 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/tabular-data/explain-multiclass-classification-local.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Explain multiclass classification model's predictions\n",
-        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to explain and visualize a multiclass classification model predictions.**_\n",
-        "\n",
-        "\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Run model explainer locally at training time](#Explain)\n",
-        "    1. Train a multiclass classification model\n",
-        "    1. Explain the model\n",
-        "        1. Generate global explanations\n",
-        "        1. Generate local explanations\n",
-        "1. [Visualize results](#Visualize)\n",
-        "1. [Next steps](#Next)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "\n",
-        "This notebook illustrates how to explain a multiclass classification model predictions locally at training time without contacting any Azure services.\n",
-        "It demonstrates the API calls that you need to make to get the global and local explanations and a visualization dashboard that provides an interactive way of discovering patterns in data and explanations.\n",
-        "\n",
-        "We will showcase three tabular data explainers: TabularExplainer (SHAP), MimicExplainer (global surrogate), and PFIExplainer.\n",
-        "\n",
-        "| ![Interpretability Toolkit Architecture](./img/interpretability-architecture.PNG) |\n",
-        "|:--:|\n",
-        "| *Interpretability Toolkit Architecture* |\n",
-        "\n",
-        "Problem: Iris flower classification with scikit-learn (run model explainer locally)\n",
-        "\n",
-        "1. Train a SVM classification model using Scikit-learn\n",
-        "2. Run 'explain_model' globally and locally with full dataset in local mode, which doesn't contact any Azure services.\n",
-        "3. Visualize the global and local explanations with the visualization dashboard.\n",
-        "---\n",
-        "\n",
-        "## Setup\n",
-        "\n",
-        "You will need to have extensions enabled prior to jupyter kernel starting to see the visualization dashboard.\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "(myenv) $ jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "```\n",
-        "Or\n",
-        "\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install azureml.contrib.explain.model.visualize --user --py\n",
-        "(myenv) $ jupyter nbextension enable azureml.contrib.explain.model.visualize --user --py\n",
-        "```\n",
-        "\n",
-        "If you are using Jupyter Labs run the following commands instead:\n",
-        "```\n",
-        "(myenv) $ jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
-        "(myenv) $ jupyter labextension install microsoft-mli-widget\n",
-        "```\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Explain\n",
-        "\n",
-        "### Run model explainer locally at training time"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn.datasets import load_iris\n",
-        "from sklearn import svm\n",
-        "\n",
-        "# Explainers:\n",
-        "# 1. SHAP Tabular Explainer\n",
-        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 2. Mimic Explainer\n",
-        "from azureml.explain.model.mimic.mimic_explainer import MimicExplainer\n",
-        "# You can use one of the following four interpretable models as a global surrogate to the black box model\n",
-        "from azureml.explain.model.mimic.models.lightgbm_model import LGBMExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import LinearExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import SGDExplainableModel\n",
-        "from azureml.explain.model.mimic.models.tree_model import DecisionTreeExplainableModel\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 3. PFI Explainer\n",
-        "from azureml.explain.model.permutation.permutation_importance import PFIExplainer "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Load the Iris flower dataset"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "iris = load_iris()\n",
-        "X = iris['data']\n",
-        "y = iris['target']\n",
-        "classes = iris['target_names']\n",
-        "feature_names = iris['feature_names']"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Split data into train and test\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Train a SVM classification model, which you want to explain"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "clf = svm.SVC(gamma=0.001, C=100., probability=True)\n",
-        "model = clf.fit(x_train, y_train)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain predictions on your local machine"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# 1. Using SHAP TabularExplainer\n",
-        "explainer = TabularExplainer(model, \n",
-        "                             x_train, \n",
-        "                             features=feature_names, \n",
-        "                             classes=classes)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 2. Using MimicExplainer\n",
-        "# augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns. \n",
-        "# max_num_of_augmentations is optional and defines max number of times we can increase the input data size.\n",
-        "# LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel\n",
-        "# explainer = MimicExplainer(model, \n",
-        "#                            x_train, \n",
-        "#                            LGBMExplainableModel, \n",
-        "#                            augment_data=True, \n",
-        "#                            max_num_of_augmentations=10, \n",
-        "#                            features=feature_names, \n",
-        "#                            classes=classes)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 3. Using PFIExplainer\n",
-        "\n",
-        "# Use the parameter \"metric\" to pass a metric name or function to evaluate the permutation. \n",
-        "# Note that if a metric function is provided a higher value must be better.\n",
-        "# Otherwise, take the negative of the function or set the parameter \"is_error_metric\" to True.\n",
-        "# Default metrics: \n",
-        "# F1 Score for binary classification, F1 Score with micro average for multiclass classification and\n",
-        "# Mean absolute error for regression\n",
-        "\n",
-        "# explainer = PFIExplainer(model, \n",
-        "#                          features=feature_names, \n",
-        "#                          classes=classes)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate global explanations\n",
-        "Explain overall model predictions (global explanation)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
-        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
-        "global_explanation = explainer.explain_global(x_test)\n",
-        "\n",
-        "# Note: if you used the PFIExplainer in the previous step, use the next line of code instead\n",
-        "# global_explanation = explainer.explain_global(x_test, true_labels=y_test)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Sorted SHAP values\n",
-        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
-        "# Corresponding feature names\n",
-        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
-        "# Feature ranks (based on original order of features)\n",
-        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))\n",
-        "\n",
-        "# Note: PFIExplainer does not support per class explanations\n",
-        "# Per class feature names\n",
-        "print('ranked per class feature names: {}'.format(global_explanation.get_ranked_per_class_names()))\n",
-        "# Per class feature importance values\n",
-        "print('ranked per class feature values: {}'.format(global_explanation.get_ranked_per_class_values()))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Print out a dictionary that holds the sorted feature importance names and values\n",
-        "print('global importance rank: {}'.format(global_explanation.get_feature_importance_dict()))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain overall model predictions as a collection of local (instance-level) explanations"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# feature shap values for all features and all data points in the training data\n",
-        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate local explanations\n",
-        "Explain local data points (individual instances)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Note: PFIExplainer does not support local explanations\n",
-        "# You can pass a specific data point or a group of data points to the explain_local function\n",
-        "\n",
-        "# E.g., Explain the first data point in the test set\n",
-        "instance_num = 0\n",
-        "local_explanation = explainer.explain_local(x_test[instance_num,:])"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Get the prediction for the first member of the test set and explain why model made that prediction\n",
-        "prediction_value = clf.predict(x_test)[instance_num]\n",
-        "\n",
-        "sorted_local_importance_values = local_explanation.get_ranked_local_values()[prediction_value]\n",
-        "sorted_local_importance_names = local_explanation.get_ranked_local_names()[prediction_value]\n",
-        "\n",
-        "print('local importance values: {}'.format(sorted_local_importance_values))\n",
-        "print('local importance names: {}'.format(sorted_local_importance_names))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Load the visualization dashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(global_explanation, model, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "\n",
-        "1. [Training time: regression problem](./explain-regression-local.ipynb)       \n",
-        "1. [Training time: binary classification problem](./explain-binary-classification-local.ipynb)\n",
-        "1. Explain models with engineered features:\n",
-        "    1. [Simple feature transformations](./simple-feature-transformations-explain-local.ipynb)\n",
-        "    1. [Advanced feature transformations](./advanced-feature-transformations-explain-local.ipynb)\n",
-        "1. [Save model explanations via Azure Machine Learning Run History](../azure-integration/run-history/save-retrieve-explanations-run-history.ipynb)\n",
-        "1. [Run explainers remotely on Azure Machine Learning Compute (AMLCompute)](../azure-integration/remote-explanation/explain-model-on-amlcompute.ipynb)\n",
-        "1. Inferencing time: deploy a classification model and explainer:\n",
-        "    1. [Deploy a locally-trained model and explainer](../azure-integration/scoring-time/train-explain-model-locally-and-deploy.ipynb)\n",
-        "    1. [Deploy a remotely-trained model and explainer](../azure-integration/scoring-time/train-explain-model-on-amlcompute-and-deploy.ipynb)\n",
-        "\u00e2\u20ac\u2039\n"
-      ]
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "mesameki"
-      }
-    ],
-    "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.8"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

how-to-use-azureml/explain-model/tabular-data/explain-regression-local.ipynb

@@ -1,397 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Copyright (c) Microsoft Corporation. All rights reserved.\n",
-        "\n",
-        "Licensed under the MIT License."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/explain-model/tabular-data/explain-regression-local.png)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Explain regression model predictions\n",
-        "_**This notebook showcases how to use the Azure Machine Learning Interpretability SDK to explain and visualize a regression model predictions.**_\n",
-        "\n",
-        "\n",
-        "## Table of Contents\n",
-        "\n",
-        "1. [Introduction](#Introduction)\n",
-        "1. [Setup](#Setup)\n",
-        "1. [Run model explainer locally at training time](#Explain)\n",
-        "    1. Train a regressor model\n",
-        "    1. Explain the model\n",
-        "        1. Generate global explanations\n",
-        "        1. Generate local explanations\n",
-        "1. [Visualize results](#Visualize)\n",
-        "1. [Next steps](#Next)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Introduction\n",
-        "\n",
-        "This notebook illustrates how to explain regression model predictions locally at training time without contacting any Azure services.\n",
-        "It demonstrates the API calls that you need to make to get the global and local explanations and a visualization dashboard that provides an interactive way of discovering patterns in data and explanations.\n",
-        "\n",
-        "We will showcase three tabular data explainers: TabularExplainer (SHAP), MimicExplainer (global surrogate), and PFIExplainer.\n",
-        "\n",
-        "| ![Interpretability Toolkit Architecture](./img/interpretability-architecture.PNG) |\n",
-        "|:--:|\n",
-        "| *Interpretability Toolkit Architecture* |\n",
-        "\n",
-        "Problem: Boston Housing Price Prediction with scikit-learn (run model explainer locally)\n",
-        "\n",
-        "1. Train a GradientBoosting regression model using Scikit-learn\n",
-        "2. Run 'explain_model' globally and locally with full dataset in local mode, which doesn't contact any Azure services.\n",
-        "3. Visualize the global and local explanations with the visualization dashboard.\n",
-        "---\n",
-        "\n",
-        "## Setup\n",
-        "\n",
-        "You will need to have extensions enabled prior to jupyter kernel starting to see the visualization dashboard.\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "(myenv) $ jupyter nbextension enable --py --sys-prefix azureml.contrib.explain.model.visualize\n",
-        "```\n",
-        "Or\n",
-        "\n",
-        "```\n",
-        "(myenv) $ jupyter nbextension install azureml.contrib.explain.model.visualize --user --py\n",
-        "(myenv) $ jupyter nbextension enable azureml.contrib.explain.model.visualize --user --py\n",
-        "```\n",
-        "\n",
-        "If you are using Jupyter Labs run the following commands instead:\n",
-        "```\n",
-        "(myenv) $ jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
-        "(myenv) $ jupyter labextension install microsoft-mli-widget\n",
-        "```\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Explain\n",
-        "\n",
-        "### Run model explainer locally at training time"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from sklearn import datasets\n",
-        "from sklearn.ensemble import GradientBoostingRegressor\n",
-        "\n",
-        "# Explainers:\n",
-        "# 1. SHAP Tabular Explainer\n",
-        "from azureml.explain.model.tabular_explainer import TabularExplainer\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 2. Mimic Explainer\n",
-        "from azureml.explain.model.mimic.mimic_explainer import MimicExplainer\n",
-        "# You can use one of the following four interpretable models as a global surrogate to the black box model\n",
-        "from azureml.explain.model.mimic.models.lightgbm_model import LGBMExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import LinearExplainableModel\n",
-        "from azureml.explain.model.mimic.models.linear_model import SGDExplainableModel\n",
-        "from azureml.explain.model.mimic.models.tree_model import DecisionTreeExplainableModel\n",
-        "\n",
-        "# OR\n",
-        "\n",
-        "# 3. PFI Explainer\n",
-        "from azureml.explain.model.permutation.permutation_importance import PFIExplainer "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Load the Boston house price data"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "boston_data = datasets.load_boston()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Split data into train and test\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "x_train, x_test, y_train, y_test = train_test_split(boston_data.data, boston_data.target, test_size=0.2, random_state=0)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Train a GradientBoosting regression model, which you want to explain"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "reg = GradientBoostingRegressor(n_estimators=100, max_depth=4,\n",
-        "                                learning_rate=0.1, loss='huber',\n",
-        "                                random_state=1)\n",
-        "model = reg.fit(x_train, y_train)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain predictions on your local machine"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# 1. Using SHAP TabularExplainer\n",
-        "explainer = TabularExplainer(model, \n",
-        "                             x_train, \n",
-        "                             features = boston_data.feature_names)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 2. Using MimicExplainer\n",
-        "# augment_data is optional and if true, oversamples the initialization examples to improve surrogate model accuracy to fit original model.  Useful for high-dimensional data where the number of rows is less than the number of columns. \n",
-        "# max_num_of_augmentations is optional and defines max number of times we can increase the input data size.\n",
-        "# LGBMExplainableModel can be replaced with LinearExplainableModel, SGDExplainableModel, or DecisionTreeExplainableModel\n",
-        "# explainer = MimicExplainer(model, \n",
-        "#                            x_train, \n",
-        "#                            LGBMExplainableModel, \n",
-        "#                            augment_data=True, \n",
-        "#                            max_num_of_augmentations=10, \n",
-        "#                            features=boston_data.feature_names)\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "# 3. Using PFIExplainer\n",
-        "\n",
-        "# Use the parameter \"metric\" to pass a metric name or function to evaluate the permutation. \n",
-        "# Note that if a metric function is provided a higher value must be better.\n",
-        "# Otherwise, take the negative of the function or set the parameter \"is_error_metric\" to True.\n",
-        "# Default metrics: \n",
-        "# F1 Score for binary classification, F1 Score with micro average for multiclass classification and\n",
-        "# Mean absolute error for regression\n",
-        "\n",
-        "# explainer = PFIExplainer(model, \n",
-        "#                          features=boston_data.feature_names)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate global explanations\n",
-        "Explain overall model predictions (global explanation)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Passing in test dataset for evaluation examples - note it must be a representative sample of the original data\n",
-        "# x_train can be passed as well, but with more examples explanations will take longer although they may be more accurate\n",
-        "global_explanation = explainer.explain_global(x_test)\n",
-        "\n",
-        "# Note: if you used the PFIExplainer in the previous step, use the next line of code instead\n",
-        "# global_explanation = explainer.explain_global(x_test, true_labels=y_test)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Sorted SHAP values \n",
-        "print('ranked global importance values: {}'.format(global_explanation.get_ranked_global_values()))\n",
-        "# Corresponding feature names\n",
-        "print('ranked global importance names: {}'.format(global_explanation.get_ranked_global_names()))\n",
-        "# Feature ranks (based on original order of features)\n",
-        "print('global importance rank: {}'.format(global_explanation.global_importance_rank))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Print out a dictionary that holds the sorted feature importance names and values\n",
-        "print('global importance rank: {}'.format(global_explanation.get_feature_importance_dict()))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Explain overall model predictions as a collection of local (instance-level) explanations"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Note: PFIExplainer does not support local explanations\n",
-        "# feature shap values for all features and all data points in the training data\n",
-        "print('local importance values: {}'.format(global_explanation.local_importance_values))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Generate local explanations\n",
-        "Explain local data points (individual instances)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Note: PFIExplainer does not support local explanations\n",
-        "# You can pass a specific data point or a group of data points to the explain_local function\n",
-        "\n",
-        "# E.g., Explain the first data point in the test set\n",
-        "local_explanation = explainer.explain_local(x_test[0,:])\n",
-        "\n",
-        "# E.g., Explain the first five data points in the test set\n",
-        "# local_explanation_group = explainer.explain_local(x_test[0:4,:])"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Sorted local feature importance information; reflects the original feature order\n",
-        "sorted_local_importance_names = local_explanation.get_ranked_local_names()\n",
-        "sorted_local_importance_values = local_explanation.get_ranked_local_values()\n",
-        "\n",
-        "print('sorted local importance names: {}'.format(sorted_local_importance_names))\n",
-        "print('sorted local importance values: {}'.format(sorted_local_importance_values))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Visualize\n",
-        "Load the visualization dashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from azureml.contrib.explain.model.visualize import ExplanationDashboard"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "ExplanationDashboard(global_explanation, model, x_test)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Next\n",
-        "Learn about other use cases of the explain package on a:\n",
-        "       \n",
-        "1. [Training time: binary classification problem](./explain-binary-classification-local.ipynb)\n",
-        "1. [Training time: multiclass classification problem](./explain-multiclass-classification-local.ipynb)\n",
-        "1. Explain models with engineered features:\n",
-        "    1. [Simple feature transformations](./simple-feature-transformations-explain-local.ipynb)\n",
-        "    1. [Advanced feature transformations](./advanced-feature-transformations-explain-local.ipynb)\n",
-        "1. [Save model explanations via Azure Machine Learning Run History](../azure-integration/run-history/save-retrieve-explanations-run-history.ipynb)\n",
-        "1. [Run explainers remotely on Azure Machine Learning Compute (AMLCompute)](../azure-integration/remote-explanation/explain-model-on-amlcompute.ipynb)\n",
-        "1. Inferencing time: deploy a classification model and explainer:\n",
-        "    1. [Deploy a locally-trained model and explainer](../azure-integration/scoring-time/train-explain-model-locally-and-deploy.ipynb)\n",
-        "    1. [Deploy a remotely-trained model and explainer](../azure-integration/scoring-time/train-explain-model-on-amlcompute-and-deploy.ipynb)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "authors": [
-      {
-        "name": "mesameki"
-      }
-    ],
-    "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.8"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}