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

Update samples from Release-115 as a part of  SDK release

configuration.ipynb

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

contrib/fairness/fairlearn-azureml-mitigation.yml

@@ -6,4 +6,4 @@ dependencies:
   - fairlearn>=0.6.2
   - joblib
   - liac-arff
-  - raiwidgets~=0.7.0
+  - raiwidgets~=0.13.0

contrib/fairness/upload-fairness-dashboard.yml

@@ -6,4 +6,4 @@ dependencies:
   - fairlearn>=0.6.2
   - joblib
   - liac-arff
-  - raiwidgets~=0.7.0
+  - raiwidgets~=0.13.0

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

@@ -22,9 +22,9 @@ dependencies:
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-widgets~=1.34.0
+  - azureml-widgets~=1.36.0
   - pytorch-transformers==1.0.0
   - spacy==2.1.8
   - https://aka.ms/automl-resources/packages/en_core_web_sm-2.1.0.tar.gz
-  - -r https://automlresources-prod.azureedge.net/validated-requirements/1.34.0/validated_win32_requirements.txt [--no-deps]
+  - -r https://automlsdkdataresources.blob.core.windows.net/validated-requirements/1.36.0/validated_win32_requirements.txt [--no-deps]
   - arch==4.14

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

@@ -22,9 +22,9 @@ dependencies:
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-widgets~=1.34.0
+  - azureml-widgets~=1.36.0
   - pytorch-transformers==1.0.0
   - spacy==2.1.8
   - https://aka.ms/automl-resources/packages/en_core_web_sm-2.1.0.tar.gz
-  - -r https://automlresources-prod.azureedge.net/validated-requirements/1.34.0/validated_linux_requirements.txt [--no-deps]
+  - -r https://automlsdkdataresources.blob.core.windows.net/validated-requirements/1.36.0/validated_linux_requirements.txt [--no-deps]
   - arch==4.14

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

@@ -23,9 +23,9 @@ dependencies:
 
 - pip:
   # Required packages for AzureML execution, history, and data preparation.
-  - azureml-widgets~=1.34.0
+  - azureml-widgets~=1.36.0
   - pytorch-transformers==1.0.0
   - spacy==2.1.8
   - https://aka.ms/automl-resources/packages/en_core_web_sm-2.1.0.tar.gz
-  - -r https://automlresources-prod.azureedge.net/validated-requirements/1.34.0/validated_darwin_requirements.txt [--no-deps]
+  - -r https://automlsdkdataresources.blob.core.windows.net/validated-requirements/1.36.0/validated_darwin_requirements.txt [--no-deps]
   - arch==4.14

how-to-use-azureml/automated-machine-learning/check_conda_version.py

@@ -3,7 +3,7 @@ import platform
 
 try:
     import conda
-except:
+except Exception:
     print('Failed to import conda.')
     print('This setup is usually run from the base conda environment.')
     print('You can activate the base environment using the command "conda activate base"')

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

@@ -104,7 +104,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -703,7 +703,7 @@
         "from azureml.core.webservice import AciWebservice\n",
         "from azureml.core.model import Model\n",
         "\n",
-        "inference_config = InferenceConfig(entry_script=script_file_name)\n",
+        "inference_config = InferenceConfig(environment = best_run.get_environment(), entry_script=script_file_name)\n",
         "\n",
         "aciconfig = AciWebservice.deploy_configuration(cpu_cores = 2, \n",
         "                                               memory_gb = 2, \n",

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

@@ -93,7 +93,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

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

@@ -96,7 +96,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

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

@@ -81,7 +81,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

how-to-use-azureml/automated-machine-learning/continuous-retraining/check_data.py

@@ -31,7 +31,7 @@ try:
     model = Model(ws, args.model_name)
     last_train_time = model.created_time
     print("Model was last trained on {0}.".format(last_train_time))
-except Exception as e:
+except Exception:
     print("Could not get last model train time.")
     last_train_time = datetime.min.replace(tzinfo=pytz.UTC)
 

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

@@ -92,7 +92,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

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

@@ -91,7 +91,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

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

@@ -113,7 +113,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -139,18 +139,18 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for the run history container in the workspace\n",
-        "experiment_name = 'beer-remote-cpu'\n",
+        "experiment_name = \"beer-remote-cpu\"\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
         "output = {}\n",
-        "output['Subscription ID'] = ws.subscription_id\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
-        "output['Workspace'] = ws.name\n",
+        "output[\"Workspace\"] = ws.name\n",
-        "output['Resource Group'] = ws.resource_group\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
-        "output['Location'] = ws.location\n",
+        "output[\"Location\"] = ws.location\n",
-        "output['Run History Name'] = experiment_name\n",
+        "output[\"Run History Name\"] = experiment_name\n",
-        "pd.set_option('display.max_colwidth', -1)\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
         "outputDf.T"
       ]
     },
@@ -185,10 +185,11 @@
         "# Verify that cluster does not exist already\n",
         "try:\n",
         "    compute_target = ComputeTarget(workspace=ws, name=cpu_cluster_name)\n",
-        "    print('Found existing cluster, use it.')\n",
+        "    print(\"Found existing cluster, use it.\")\n",
         "except ComputeTargetException:\n",
-        "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS12_V2',\n",
+        "    compute_config = AmlCompute.provisioning_configuration(\n",
-        "                                                           max_nodes=4)\n",
+        "        vm_size=\"STANDARD_DS12_V2\", max_nodes=4\n",
+        "    )\n",
         "    compute_target = ComputeTarget.create(ws, cpu_cluster_name, compute_config)\n",
         "\n",
         "compute_target.wait_for_completion(show_output=True)"
@@ -245,13 +246,17 @@
         "plt.tight_layout()\n",
         "\n",
         "plt.subplot(2, 1, 1)\n",
-        "plt.title('Beer Production By Year')\n",
+        "plt.title(\"Beer Production By Year\")\n",
-        "df = pd.read_csv(\"Beer_no_valid_split_train.csv\", parse_dates=True, index_col= 'DATE').drop(columns='grain')\n",
+        "df = pd.read_csv(\n",
-        "test_df = pd.read_csv(\"Beer_no_valid_split_test.csv\", parse_dates=True, index_col= 'DATE').drop(columns='grain')\n",
+        "    \"Beer_no_valid_split_train.csv\", parse_dates=True, index_col=\"DATE\"\n",
+        ").drop(columns=\"grain\")\n",
+        "test_df = pd.read_csv(\n",
+        "    \"Beer_no_valid_split_test.csv\", parse_dates=True, index_col=\"DATE\"\n",
+        ").drop(columns=\"grain\")\n",
         "plt.plot(df)\n",
         "\n",
         "plt.subplot(2, 1, 2)\n",
-        "plt.title('Beer Production By Month')\n",
+        "plt.title(\"Beer Production By Month\")\n",
         "groups = df.groupby(df.index.month)\n",
         "months = concat([DataFrame(x[1].values) for x in groups], axis=1)\n",
         "months = DataFrame(months)\n",
@@ -270,10 +275,10 @@
       },
       "outputs": [],
       "source": [
-        "target_column_name = 'BeerProduction'\n",
+        "target_column_name = \"BeerProduction\"\n",
-        "time_column_name = 'DATE'\n",
+        "time_column_name = \"DATE\"\n",
         "time_series_id_column_names = []\n",
-        "freq = 'M' #Monthly data"
+        "freq = \"M\"  # Monthly data"
       ]
     },
     {
@@ -301,14 +306,36 @@
         "test_df.to_csv(\"test.csv\")\n",
         "\n",
         "datastore = ws.get_default_datastore()\n",
-        "datastore.upload_files(files = ['./train.csv'], target_path = 'beer-dataset/tabular/', overwrite = True,show_progress = True)\n",
+        "datastore.upload_files(\n",
-        "datastore.upload_files(files = ['./valid.csv'], target_path = 'beer-dataset/tabular/', overwrite = True,show_progress = True)\n",
+        "    files=[\"./train.csv\"],\n",
-        "datastore.upload_files(files = ['./test.csv'], target_path = 'beer-dataset/tabular/', overwrite = True,show_progress = True)\n",
+        "    target_path=\"beer-dataset/tabular/\",\n",
+        "    overwrite=True,\n",
+        "    show_progress=True,\n",
+        ")\n",
+        "datastore.upload_files(\n",
+        "    files=[\"./valid.csv\"],\n",
+        "    target_path=\"beer-dataset/tabular/\",\n",
+        "    overwrite=True,\n",
+        "    show_progress=True,\n",
+        ")\n",
+        "datastore.upload_files(\n",
+        "    files=[\"./test.csv\"],\n",
+        "    target_path=\"beer-dataset/tabular/\",\n",
+        "    overwrite=True,\n",
+        "    show_progress=True,\n",
+        ")\n",
         "\n",
         "from azureml.core import Dataset\n",
-        "train_dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'beer-dataset/tabular/train.csv')])\n",
+        "\n",
-        "valid_dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'beer-dataset/tabular/valid.csv')])\n",
+        "train_dataset = Dataset.Tabular.from_delimited_files(\n",
-        "test_dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'beer-dataset/tabular/test.csv')])"
+        "    path=[(datastore, \"beer-dataset/tabular/train.csv\")]\n",
+        ")\n",
+        "valid_dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=[(datastore, \"beer-dataset/tabular/valid.csv\")]\n",
+        ")\n",
+        "test_dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=[(datastore, \"beer-dataset/tabular/test.csv\")]\n",
+        ")"
       ]
     },
     {
@@ -366,15 +393,17 @@
       "outputs": [],
       "source": [
         "from azureml.automl.core.forecasting_parameters import ForecastingParameters\n",
+        "\n",
         "forecasting_parameters = ForecastingParameters(\n",
         "    time_column_name=time_column_name,\n",
         "    forecast_horizon=forecast_horizon,\n",
-        "    freq='MS' # Set the forecast frequency to be monthly (start of the month)\n",
+        "    freq=\"MS\",  # Set the forecast frequency to be monthly (start of the month)\n",
         ")\n",
         "\n",
         "# We will disable the enable_early_stopping flag to ensure the DNN model is recommended for demonstration purpose.\n",
-        "automl_config = AutoMLConfig(task='forecasting',\n",
+        "automl_config = AutoMLConfig(\n",
-        "                             primary_metric='normalized_root_mean_squared_error',\n",
+        "    task=\"forecasting\",\n",
+        "    primary_metric=\"normalized_root_mean_squared_error\",\n",
         "    experiment_timeout_hours=1,\n",
         "    training_data=train_dataset,\n",
         "    label_column_name=target_column_name,\n",
@@ -385,7 +414,8 @@
         "    max_cores_per_iteration=-1,\n",
         "    enable_dnn=True,\n",
         "    enable_early_stopping=False,\n",
-        "                             forecasting_parameters=forecasting_parameters)"
+        "    forecasting_parameters=forecasting_parameters,\n",
+        ")"
       ]
     },
     {
@@ -455,6 +485,7 @@
       "outputs": [],
       "source": [
         "from helper import get_result_df\n",
+        "\n",
         "summary_df = get_result_df(remote_run)\n",
         "summary_df"
       ]
@@ -470,11 +501,12 @@
       "source": [
         "from azureml.core.run import Run\n",
         "from azureml.widgets import RunDetails\n",
-        "forecast_model = 'TCNForecaster'\n",
-        "if not forecast_model in summary_df['run_id']:\n",
-        "    forecast_model = 'ForecastTCN'\n",
         "\n",
-        "best_dnn_run_id = summary_df['run_id'][forecast_model]\n",
+        "forecast_model = \"TCNForecaster\"\n",
+        "if not forecast_model in summary_df[\"run_id\"]:\n",
+        "    forecast_model = \"ForecastTCN\"\n",
+        "\n",
+        "best_dnn_run_id = summary_df[\"run_id\"][forecast_model]\n",
         "best_dnn_run = Run(experiment, best_dnn_run_id)"
       ]
     },
@@ -536,7 +568,10 @@
       "outputs": [],
       "source": [
         "from azureml.core import Dataset\n",
-        "test_dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'beer-dataset/tabular/test.csv')])\n",
+        "\n",
+        "test_dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=[(datastore, \"beer-dataset/tabular/test.csv\")]\n",
+        ")\n",
         "# preview the first 3 rows of the dataset\n",
         "test_dataset.take(5).to_pandas_dataframe()"
       ]
@@ -547,7 +582,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "compute_target = ws.compute_targets['beer-cluster']\n",
+        "compute_target = ws.compute_targets[\"beer-cluster\"]\n",
         "test_experiment = Experiment(ws, experiment_name + \"_test\")"
       ]
     },
@@ -563,9 +598,9 @@
         "import os\n",
         "import shutil\n",
         "\n",
-        "script_folder = os.path.join(os.getcwd(), 'inference')\n",
+        "script_folder = os.path.join(os.getcwd(), \"inference\")\n",
         "os.makedirs(script_folder, exist_ok=True)\n",
-        "shutil.copy('infer.py', script_folder)"
+        "shutil.copy(\"infer.py\", script_folder)"
       ]
     },
     {
@@ -576,8 +611,18 @@
       "source": [
         "from helper import run_inference\n",
         "\n",
-        "test_run = run_inference(test_experiment, compute_target, script_folder, best_dnn_run, test_dataset, valid_dataset, forecast_horizon,\n",
+        "test_run = run_inference(\n",
-        "                 target_column_name, time_column_name, freq)"
+        "    test_experiment,\n",
+        "    compute_target,\n",
+        "    script_folder,\n",
+        "    best_dnn_run,\n",
+        "    test_dataset,\n",
+        "    valid_dataset,\n",
+        "    forecast_horizon,\n",
+        "    target_column_name,\n",
+        "    time_column_name,\n",
+        "    freq,\n",
+        ")"
       ]
     },
     {
@@ -597,8 +642,19 @@
       "source": [
         "from helper import run_multiple_inferences\n",
         "\n",
-        "summary_df = run_multiple_inferences(summary_df, experiment, test_experiment, compute_target, script_folder, test_dataset, \n",
+        "summary_df = run_multiple_inferences(\n",
-        "                  valid_dataset, forecast_horizon, target_column_name, time_column_name, freq)"
+        "    summary_df,\n",
+        "    experiment,\n",
+        "    test_experiment,\n",
+        "    compute_target,\n",
+        "    script_folder,\n",
+        "    test_dataset,\n",
+        "    valid_dataset,\n",
+        "    forecast_horizon,\n",
+        "    target_column_name,\n",
+        "    time_column_name,\n",
+        "    freq,\n",
+        ")"
       ]
     },
     {
@@ -618,7 +674,7 @@
         "    test_run = Run(test_experiment, test_run_id)\n",
         "    test_run.wait_for_completion()\n",
         "    test_score = test_run.get_metrics()[run_summary.primary_metric]\n",
-        "    summary_df.loc[summary_df.run_id == run_id, 'Test Score'] = test_score\n",
+        "    summary_df.loc[summary_df.run_id == run_id, \"Test Score\"] = test_score\n",
         "    print(\"Test Score: \", test_score)"
       ]
     },

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

@@ -6,120 +6,158 @@ from azureml.core.run import Run
 from azureml.automl.core.shared import constants
 
 
-def split_fraction_by_grain(df, fraction, time_column_name,
+def split_fraction_by_grain(df, fraction, time_column_name, grain_column_names=None):
-                            grain_column_names=None):
     if not grain_column_names:
-        df['tmp_grain_column'] = 'grain'
+        df["tmp_grain_column"] = "grain"
-        grain_column_names = ['tmp_grain_column']
+        grain_column_names = ["tmp_grain_column"]
 
     """Group df by grain and split on last n rows for each group."""
-    df_grouped = (df.sort_values(time_column_name)
+    df_grouped = df.sort_values(time_column_name).groupby(
-                  .groupby(grain_column_names, group_keys=False))
+        grain_column_names, group_keys=False
+    )
 
-    df_head = df_grouped.apply(lambda dfg: dfg.iloc[:-int(len(dfg) *
+    df_head = df_grouped.apply(
-                                                          fraction)] if fraction > 0 else dfg)
+        lambda dfg: dfg.iloc[: -int(len(dfg) * fraction)] if fraction > 0 else dfg
+    )
 
-    df_tail = df_grouped.apply(lambda dfg: dfg.iloc[-int(len(dfg) *
+    df_tail = df_grouped.apply(
-                                                         fraction):] if fraction > 0 else dfg[:0])
+        lambda dfg: dfg.iloc[-int(len(dfg) * fraction) :] if fraction > 0 else dfg[:0]
+    )
 
-    if 'tmp_grain_column' in grain_column_names:
+    if "tmp_grain_column" in grain_column_names:
         for df2 in (df, df_head, df_tail):
-            df2.drop('tmp_grain_column', axis=1, inplace=True)
+            df2.drop("tmp_grain_column", axis=1, inplace=True)
 
-        grain_column_names.remove('tmp_grain_column')
+        grain_column_names.remove("tmp_grain_column")
 
     return df_head, df_tail
 
 
-def split_full_for_forecasting(df, time_column_name,
+def split_full_for_forecasting(
-                               grain_column_names=None, test_split=0.2):
+    df, time_column_name, grain_column_names=None, test_split=0.2
+):
     index_name = df.index.name
 
     # Assumes that there isn't already a column called tmpindex
 
-    df['tmpindex'] = df.index
+    df["tmpindex"] = df.index
 
     train_df, test_df = split_fraction_by_grain(
-        df, test_split, time_column_name, grain_column_names)
+        df, test_split, time_column_name, grain_column_names
+    )
 
-    train_df = train_df.set_index('tmpindex')
+    train_df = train_df.set_index("tmpindex")
     train_df.index.name = index_name
 
-    test_df = test_df.set_index('tmpindex')
+    test_df = test_df.set_index("tmpindex")
     test_df.index.name = index_name
 
-    df.drop('tmpindex', axis=1, inplace=True)
+    df.drop("tmpindex", axis=1, inplace=True)
 
     return train_df, test_df
 
 
 def get_result_df(remote_run):
     children = list(remote_run.get_children(recursive=True))
-    summary_df = pd.DataFrame(index=['run_id', 'run_algorithm',
+    summary_df = pd.DataFrame(
-                                     'primary_metric', 'Score'])
+        index=["run_id", "run_algorithm", "primary_metric", "Score"]
+    )
     goal_minimize = False
     for run in children:
-        if run.get_status().lower() == constants.RunState.COMPLETE_RUN \
+        if (
-                and 'run_algorithm' in run.properties and 'score' in run.properties:
+            run.get_status().lower() == constants.RunState.COMPLETE_RUN
+            and "run_algorithm" in run.properties
+            and "score" in run.properties
+        ):
             # We only count in the completed child runs.
-            summary_df[run.id] = [run.id, run.properties['run_algorithm'],
+            summary_df[run.id] = [
-                                  run.properties['primary_metric'],
+                run.id,
-                                  float(run.properties['score'])]
+                run.properties["run_algorithm"],
-            if ('goal' in run.properties):
+                run.properties["primary_metric"],
-                goal_minimize = run.properties['goal'].split('_')[-1] == 'min'
+                float(run.properties["score"]),
+            ]
+            if "goal" in run.properties:
+                goal_minimize = run.properties["goal"].split("_")[-1] == "min"
 
     summary_df = summary_df.T.sort_values(
-        'Score',
+        "Score", ascending=goal_minimize
-        ascending=goal_minimize).drop_duplicates(['run_algorithm'])
+    ).drop_duplicates(["run_algorithm"])
-    summary_df = summary_df.set_index('run_algorithm')
+    summary_df = summary_df.set_index("run_algorithm")
     return summary_df
 
 
-def run_inference(test_experiment, compute_target, script_folder, train_run,
+def run_inference(
-                  test_dataset, lookback_dataset, max_horizon,
+    test_experiment,
-                  target_column_name, time_column_name, freq):
+    compute_target,
-    model_base_name = 'model.pkl'
+    script_folder,
-    if 'model_data_location' in train_run.properties:
+    train_run,
-        model_location = train_run.properties['model_data_location']
+    test_dataset,
-        _, model_base_name = model_location.rsplit('/', 1)
+    lookback_dataset,
-    train_run.download_file('outputs/{}'.format(model_base_name), 'inference/{}'.format(model_base_name))
+    max_horizon,
-    train_run.download_file('outputs/conda_env_v_1_0_0.yml', 'inference/condafile.yml')
+    target_column_name,
+    time_column_name,
+    freq,
+):
+    model_base_name = "model.pkl"
+    if "model_data_location" in train_run.properties:
+        model_location = train_run.properties["model_data_location"]
+        _, model_base_name = model_location.rsplit("/", 1)
+    train_run.download_file(
+        "outputs/{}".format(model_base_name), "inference/{}".format(model_base_name)
+    )
+    train_run.download_file("outputs/conda_env_v_1_0_0.yml", "inference/condafile.yml")
 
     inference_env = Environment("myenv")
     inference_env.docker.enabled = True
     inference_env.python.conda_dependencies = CondaDependencies(
-        conda_dependencies_file_path='inference/condafile.yml')
+        conda_dependencies_file_path="inference/condafile.yml"
+    )
 
-    est = Estimator(source_directory=script_folder,
+    est = Estimator(
-                    entry_script='infer.py',
+        source_directory=script_folder,
+        entry_script="infer.py",
         script_params={
-                        '--max_horizon': max_horizon,
+            "--max_horizon": max_horizon,
-                        '--target_column_name': target_column_name,
+            "--target_column_name": target_column_name,
-                        '--time_column_name': time_column_name,
+            "--time_column_name": time_column_name,
-                        '--frequency': freq,
+            "--frequency": freq,
-                        '--model_path': model_base_name
+            "--model_path": model_base_name,
         },
-                    inputs=[test_dataset.as_named_input('test_data'),
+        inputs=[
-                            lookback_dataset.as_named_input('lookback_data')],
+            test_dataset.as_named_input("test_data"),
+            lookback_dataset.as_named_input("lookback_data"),
+        ],
         compute_target=compute_target,
-                    environment_definition=inference_env)
+        environment_definition=inference_env,
+    )
 
     run = test_experiment.submit(
-        est, tags={
+        est,
-            'training_run_id': train_run.id,
+        tags={
-            'run_algorithm': train_run.properties['run_algorithm'],
+            "training_run_id": train_run.id,
-            'valid_score': train_run.properties['score'],
+            "run_algorithm": train_run.properties["run_algorithm"],
-            'primary_metric': train_run.properties['primary_metric']
+            "valid_score": train_run.properties["score"],
-        })
+            "primary_metric": train_run.properties["primary_metric"],
+        },
+    )
 
-    run.log("run_algorithm", run.tags['run_algorithm'])
+    run.log("run_algorithm", run.tags["run_algorithm"])
     return run
 
 
-def run_multiple_inferences(summary_df, train_experiment, test_experiment,
+def run_multiple_inferences(
-                            compute_target, script_folder, test_dataset,
+    summary_df,
-                            lookback_dataset, max_horizon, target_column_name,
+    train_experiment,
-                            time_column_name, freq):
+    test_experiment,
+    compute_target,
+    script_folder,
+    test_dataset,
+    lookback_dataset,
+    max_horizon,
+    target_column_name,
+    time_column_name,
+    freq,
+):
     for run_name, run_summary in summary_df.iterrows():
         print(run_name)
         print(run_summary)
@@ -127,12 +165,19 @@ def run_multiple_inferences(summary_df, train_experiment, test_experiment,
         train_run = Run(train_experiment, run_id)
 
         test_run = run_inference(
-            test_experiment, compute_target, script_folder, train_run,
+            test_experiment,
-            test_dataset, lookback_dataset, max_horizon, target_column_name,
+            compute_target,
-            time_column_name, freq)
+            script_folder,
+            train_run,
+            test_dataset,
+            lookback_dataset,
+            max_horizon,
+            target_column_name,
+            time_column_name,
+            freq,
+        )
 
         print(test_run)
-        summary_df.loc[summary_df.run_id == run_id,
+        summary_df.loc[summary_df.run_id == run_id, "test_run_id"] = test_run.id
-                       'test_run_id'] = test_run.id
 
     return summary_df

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

@@ -19,9 +19,14 @@ except ImportError:
     _torch_present = False
 
 
-def align_outputs(y_predicted, X_trans, X_test, y_test,
+def align_outputs(
-                  predicted_column_name='predicted',
+    y_predicted,
-                  horizon_colname='horizon_origin'):
+    X_trans,
+    X_test,
+    y_test,
+    predicted_column_name="predicted",
+    horizon_colname="horizon_origin",
+):
     """
     Demonstrates how to get the output aligned to the inputs
     using pandas indexes. Helps understand what happened if
@@ -33,9 +38,13 @@ def align_outputs(y_predicted, X_trans, X_test, y_test,
     * model was asked to predict past max_horizon -> increase max horizon
     * data at start of X_test was needed for lags -> provide previous periods
     """
-    if (horizon_colname in X_trans):
+    if horizon_colname in X_trans:
-        df_fcst = pd.DataFrame({predicted_column_name: y_predicted,
+        df_fcst = pd.DataFrame(
-                                horizon_colname: X_trans[horizon_colname]})
+            {
+                predicted_column_name: y_predicted,
+                horizon_colname: X_trans[horizon_colname],
+            }
+        )
     else:
         df_fcst = pd.DataFrame({predicted_column_name: y_predicted})
 
@@ -48,20 +57,21 @@ def align_outputs(y_predicted, X_trans, X_test, y_test,
 
     # X_test_full's index 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')
+    X_test_full = X_test_full.reset_index().drop(columns="index")
-    together = df_fcst.merge(X_test_full, how='right')
+    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[[target_column_name,
+    clean = together[
-                               predicted_column_name]].notnull().all(axis=1)]
+        together[[target_column_name, predicted_column_name]].notnull().all(axis=1)
-    return (clean)
+    ]
+    return clean
 
 
-def do_rolling_forecast_with_lookback(fitted_model, X_test, y_test,
+def do_rolling_forecast_with_lookback(
-                                      max_horizon, X_lookback, y_lookback,
+    fitted_model, X_test, y_test, max_horizon, X_lookback, y_lookback, freq="D"
-                                      freq='D'):
+):
     """
     Produce forecasts on a rolling origin over the given test set.
 
@@ -83,22 +93,28 @@ def do_rolling_forecast_with_lookback(fitted_model, X_test, y_test,
         horizon_time = origin_time + max_horizon * to_offset(freq)
 
         # Extract test data from an expanding window up-to the horizon
-        expand_wind = (X[time_column_name] < horizon_time)
+        expand_wind = X[time_column_name] < horizon_time
         X_test_expand = X[expand_wind]
         y_query_expand = np.zeros(len(X_test_expand)).astype(np.float)
         y_query_expand.fill(np.NaN)
 
         if origin_time != X[time_column_name].min():
             # Set the context by including actuals up-to the origin time
-            test_context_expand_wind = (X[time_column_name] < origin_time)
+            test_context_expand_wind = X[time_column_name] < origin_time
-            context_expand_wind = (X_test_expand[time_column_name] < origin_time)
+            context_expand_wind = X_test_expand[time_column_name] < origin_time
             y_query_expand[context_expand_wind] = y[test_context_expand_wind]
 
         # Print some debug info
-        print("Horizon_time:", horizon_time,
+        print(
-              " origin_time: ", origin_time,
+            "Horizon_time:",
-              " max_horizon: ", max_horizon,
+            horizon_time,
-              " freq: ", freq)
+            " origin_time: ",
+            origin_time,
+            " max_horizon: ",
+            max_horizon,
+            " freq: ",
+            freq,
+        )
         print("expand_wind: ", expand_wind)
         print("y_query_expand")
         print(y_query_expand)
@@ -124,9 +140,14 @@ def do_rolling_forecast_with_lookback(fitted_model, X_test, y_test,
         trans_tindex = X_trans.index.get_level_values(time_column_name)
         trans_roll_wind = (trans_tindex >= origin_time) & (trans_tindex < horizon_time)
         test_roll_wind = expand_wind & (X[time_column_name] >= origin_time)
-        df_list.append(align_outputs(
+        df_list.append(
-            y_fcst[trans_roll_wind], X_trans[trans_roll_wind],
+            align_outputs(
-            X[test_roll_wind], y[test_roll_wind]))
+                y_fcst[trans_roll_wind],
+                X_trans[trans_roll_wind],
+                X[test_roll_wind],
+                y[test_roll_wind],
+            )
+        )
 
         # Advance the origin time
         origin_time = horizon_time
@@ -134,7 +155,7 @@ def do_rolling_forecast_with_lookback(fitted_model, X_test, y_test,
     return pd.concat(df_list, ignore_index=True)
 
 
-def do_rolling_forecast(fitted_model, X_test, y_test, max_horizon, freq='D'):
+def do_rolling_forecast(fitted_model, X_test, y_test, max_horizon, freq="D"):
     """
     Produce forecasts on a rolling origin over the given test set.
 
@@ -153,23 +174,28 @@ def do_rolling_forecast(fitted_model, X_test, y_test, max_horizon, freq='D'):
         horizon_time = origin_time + max_horizon * to_offset(freq)
 
         # Extract test data from an expanding window up-to the horizon
-        expand_wind = (X_test[time_column_name] < horizon_time)
+        expand_wind = X_test[time_column_name] < horizon_time
         X_test_expand = X_test[expand_wind]
         y_query_expand = np.zeros(len(X_test_expand)).astype(np.float)
         y_query_expand.fill(np.NaN)
 
         if origin_time != X_test[time_column_name].min():
             # Set the context by including actuals up-to the origin time
-            test_context_expand_wind = (X_test[time_column_name] < origin_time)
+            test_context_expand_wind = X_test[time_column_name] < origin_time
-            context_expand_wind = (X_test_expand[time_column_name] < origin_time)
+            context_expand_wind = X_test_expand[time_column_name] < origin_time
-            y_query_expand[context_expand_wind] = y_test[
+            y_query_expand[context_expand_wind] = y_test[test_context_expand_wind]
-                test_context_expand_wind]
 
         # Print some debug info
-        print("Horizon_time:", horizon_time,
+        print(
-              " origin_time: ", origin_time,
+            "Horizon_time:",
-              " max_horizon: ", max_horizon,
+            horizon_time,
-              " freq: ", freq)
+            " origin_time: ",
+            origin_time,
+            " max_horizon: ",
+            max_horizon,
+            " freq: ",
+            freq,
+        )
         print("expand_wind: ", expand_wind)
         print("y_query_expand")
         print(y_query_expand)
@@ -193,10 +219,14 @@ def do_rolling_forecast(fitted_model, X_test, y_test, max_horizon, freq='D'):
         trans_tindex = X_trans.index.get_level_values(time_column_name)
         trans_roll_wind = (trans_tindex >= origin_time) & (trans_tindex < horizon_time)
         test_roll_wind = expand_wind & (X_test[time_column_name] >= origin_time)
-        df_list.append(align_outputs(y_fcst[trans_roll_wind],
+        df_list.append(
+            align_outputs(
+                y_fcst[trans_roll_wind],
                 X_trans[trans_roll_wind],
                 X_test[test_roll_wind],
-                                     y_test[test_roll_wind]))
+                y_test[test_roll_wind],
+            )
+        )
 
         # Advance the origin time
         origin_time = horizon_time
@@ -230,20 +260,31 @@ def map_location_cuda(storage, loc):
 
 parser = argparse.ArgumentParser()
 parser.add_argument(
-    '--max_horizon', type=int, dest='max_horizon',
+    "--max_horizon",
-    default=10, help='Max Horizon for forecasting')
+    type=int,
+    dest="max_horizon",
+    default=10,
+    help="Max Horizon for forecasting",
+)
 parser.add_argument(
-    '--target_column_name', type=str, dest='target_column_name',
+    "--target_column_name",
-    help='Target Column Name')
+    type=str,
+    dest="target_column_name",
+    help="Target Column Name",
+)
 parser.add_argument(
-    '--time_column_name', type=str, dest='time_column_name',
+    "--time_column_name", type=str, dest="time_column_name", help="Time Column Name"
-    help='Time Column Name')
+)
 parser.add_argument(
-    '--frequency', type=str, dest='freq',
+    "--frequency", type=str, dest="freq", help="Frequency of prediction"
-    help='Frequency of prediction')
+)
 parser.add_argument(
-    '--model_path', type=str, dest='model_path',
+    "--model_path",
-    default='model.pkl', help='Filename of model to be loaded')
+    type=str,
+    dest="model_path",
+    default="model.pkl",
+    help="Filename of model to be loaded",
+)
 
 args = parser.parse_args()
 max_horizon = args.max_horizon
@@ -252,7 +293,7 @@ time_column_name = args.time_column_name
 freq = args.freq
 model_path = args.model_path
 
-print('args passed are: ')
+print("args passed are: ")
 print(max_horizon)
 print(target_column_name)
 print(time_column_name)
@@ -261,39 +302,41 @@ print(model_path)
 
 run = Run.get_context()
 # get input dataset by name
-test_dataset = run.input_datasets['test_data']
+test_dataset = run.input_datasets["test_data"]
-lookback_dataset = run.input_datasets['lookback_data']
+lookback_dataset = run.input_datasets["lookback_data"]
 
 grain_column_names = []
 
 df = test_dataset.to_pandas_dataframe()
 
-print('Read df')
+print("Read df")
 print(df)
 
 X_test_df = test_dataset.drop_columns(columns=[target_column_name])
-y_test_df = test_dataset.with_timestamp_columns(
+y_test_df = test_dataset.with_timestamp_columns(None).keep_columns(
-    None).keep_columns(columns=[target_column_name])
+    columns=[target_column_name]
+)
 
 X_lookback_df = lookback_dataset.drop_columns(columns=[target_column_name])
-y_lookback_df = lookback_dataset.with_timestamp_columns(
+y_lookback_df = lookback_dataset.with_timestamp_columns(None).keep_columns(
-    None).keep_columns(columns=[target_column_name])
+    columns=[target_column_name]
+)
 
 _, ext = os.path.splitext(model_path)
-if ext == '.pt':
+if ext == ".pt":
     # Load the fc-tcn torch model.
     assert _torch_present
     if torch.cuda.is_available():
         map_location = map_location_cuda
     else:
-        map_location = 'cpu'
+        map_location = "cpu"
-    with open(model_path, 'rb') as fh:
+    with open(model_path, "rb") as fh:
         fitted_model = torch.load(fh, map_location=map_location)
 else:
     # Load the sklearn pipeline.
     fitted_model = joblib.load(model_path)
 
-if hasattr(fitted_model, 'get_lookback'):
+if hasattr(fitted_model, "get_lookback"):
     lookback = fitted_model.get_lookback()
     df_all = do_rolling_forecast_with_lookback(
         fitted_model,
@@ -302,26 +345,28 @@ if hasattr(fitted_model, 'get_lookback'):
         max_horizon,
         X_lookback_df.to_pandas_dataframe()[-lookback:],
         y_lookback_df.to_pandas_dataframe().values.T[0][-lookback:],
-        freq)
+        freq,
+    )
 else:
     df_all = do_rolling_forecast(
         fitted_model,
         X_test_df.to_pandas_dataframe(),
         y_test_df.to_pandas_dataframe().values.T[0],
         max_horizon,
-        freq)
+        freq,
+    )
 
 print(df_all)
 
 print("target values:::")
 print(df_all[target_column_name])
 print("predicted values:::")
-print(df_all['predicted'])
+print(df_all["predicted"])
 
 # Use the AutoML scoring module
 regression_metrics = list(constants.REGRESSION_SCALAR_SET)
 y_test = np.array(df_all[target_column_name])
-y_pred = np.array(df_all['predicted'])
+y_pred = np.array(df_all["predicted"])
 scores = scoring.score_regression(y_test, y_pred, regression_metrics)
 
 print("scores:")
@@ -331,12 +376,11 @@ for key, value in scores.items():
     run.log(key, value)
 
 print("Simple forecasting model")
-rmse = np.sqrt(mean_squared_error(
+rmse = np.sqrt(mean_squared_error(df_all[target_column_name], df_all["predicted"]))
-    df_all[target_column_name], df_all['predicted']))
 print("[Test Data] \nRoot Mean squared error: %.2f" % rmse)
-mae = mean_absolute_error(df_all[target_column_name], df_all['predicted'])
+mae = mean_absolute_error(df_all[target_column_name], df_all["predicted"])
-print('mean_absolute_error score: %.2f' % mae)
+print("mean_absolute_error score: %.2f" % mae)
-print('MAPE: %.2f' % MAPE(df_all[target_column_name], df_all['predicted']))
+print("MAPE: %.2f" % MAPE(df_all[target_column_name], df_all["predicted"]))
 
-run.log('rmse', rmse)
+run.log("rmse", rmse)
-run.log('mae', mae)
+run.log("mae", mae)

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

@@ -88,7 +88,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -108,19 +108,19 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for the run history container in the workspace\n",
-        "experiment_name = 'automl-bikeshareforecasting'\n",
+        "experiment_name = \"automl-bikeshareforecasting\"\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
         "output = {}\n",
-        "output['Subscription ID'] = ws.subscription_id\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
-        "output['Workspace'] = ws.name\n",
+        "output[\"Workspace\"] = ws.name\n",
-        "output['SKU'] = ws.sku\n",
+        "output[\"SKU\"] = ws.sku\n",
-        "output['Resource Group'] = ws.resource_group\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
-        "output['Location'] = ws.location\n",
+        "output[\"Location\"] = ws.location\n",
-        "output['Run History Name'] = experiment_name\n",
+        "output[\"Run History Name\"] = experiment_name\n",
-        "pd.set_option('display.max_colwidth', -1)\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
         "outputDf.T"
       ]
     },
@@ -153,10 +153,11 @@
         "# Verify that cluster does not exist already\n",
         "try:\n",
         "    compute_target = ComputeTarget(workspace=ws, name=amlcompute_cluster_name)\n",
-        "    print('Found existing cluster, use it.')\n",
+        "    print(\"Found existing cluster, use it.\")\n",
         "except ComputeTargetException:\n",
-        "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS12_V2',\n",
+        "    compute_config = AmlCompute.provisioning_configuration(\n",
-        "                                                           max_nodes=4)\n",
+        "        vm_size=\"STANDARD_DS12_V2\", max_nodes=4\n",
+        "    )\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, compute_config)\n",
         "\n",
         "compute_target.wait_for_completion(show_output=True)"
@@ -178,7 +179,9 @@
       "outputs": [],
       "source": [
         "datastore = ws.get_default_datastore()\n",
-        "datastore.upload_files(files = ['./bike-no.csv'], target_path = 'dataset/', overwrite = True,show_progress = True)"
+        "datastore.upload_files(\n",
+        "    files=[\"./bike-no.csv\"], target_path=\"dataset/\", overwrite=True, show_progress=True\n",
+        ")"
       ]
     },
     {
@@ -198,8 +201,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "target_column_name = 'cnt'\n",
+        "target_column_name = \"cnt\"\n",
-        "time_column_name = 'date'"
+        "time_column_name = \"date\""
       ]
     },
     {
@@ -208,10 +211,12 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'dataset/bike-no.csv')]).with_timestamp_columns(fine_grain_timestamp=time_column_name) \n",
+        "dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=[(datastore, \"dataset/bike-no.csv\")]\n",
+        ").with_timestamp_columns(fine_grain_timestamp=time_column_name)\n",
         "\n",
         "# Drop the columns 'casual' and 'registered' as these columns are a breakdown of the total and therefore a leak.\n",
-        "dataset = dataset.drop_columns(columns=['casual', 'registered'])\n",
+        "dataset = dataset.drop_columns(columns=[\"casual\", \"registered\"])\n",
         "\n",
         "dataset.take(5).to_pandas_dataframe().reset_index(drop=True)"
       ]
@@ -320,7 +325,7 @@
       "source": [
         "featurization_config = FeaturizationConfig()\n",
         "# Force the target column, to be integer type.\n",
-        "featurization_config.add_prediction_transform_type('Integer')"
+        "featurization_config.add_prediction_transform_type(\"Integer\")"
       ]
     },
     {
@@ -337,18 +342,20 @@
       "outputs": [],
       "source": [
         "from azureml.automl.core.forecasting_parameters import ForecastingParameters\n",
+        "\n",
         "forecasting_parameters = ForecastingParameters(\n",
         "    time_column_name=time_column_name,\n",
         "    forecast_horizon=forecast_horizon,\n",
-        "    country_or_region_for_holidays='US', # set country_or_region will trigger holiday featurizer\n",
+        "    country_or_region_for_holidays=\"US\",  # set country_or_region will trigger holiday featurizer\n",
-        "    target_lags='auto', # use heuristic based lag setting\n",
+        "    target_lags=\"auto\",  # use heuristic based lag setting\n",
-        "    freq='D' # Set the forecast frequency to be daily\n",
+        "    freq=\"D\",  # Set the forecast frequency to be daily\n",
         ")\n",
         "\n",
-        "automl_config = AutoMLConfig(task='forecasting',                             \n",
+        "automl_config = AutoMLConfig(\n",
-        "                             primary_metric='normalized_root_mean_squared_error',\n",
+        "    task=\"forecasting\",\n",
+        "    primary_metric=\"normalized_root_mean_squared_error\",\n",
         "    featurization=featurization_config,\n",
-        "                             blocked_models = ['ExtremeRandomTrees'],                             \n",
+        "    blocked_models=[\"ExtremeRandomTrees\"],\n",
         "    experiment_timeout_hours=0.3,\n",
         "    training_data=train,\n",
         "    label_column_name=target_column_name,\n",
@@ -358,7 +365,8 @@
         "    max_concurrent_iterations=4,\n",
         "    max_cores_per_iteration=-1,\n",
         "    verbosity=logging.INFO,\n",
-        "                             forecasting_parameters=forecasting_parameters)"
+        "    forecasting_parameters=forecasting_parameters,\n",
+        ")"
       ]
     },
     {
@@ -419,7 +427,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "fitted_model.named_steps['timeseriestransformer'].get_engineered_feature_names()"
+        "fitted_model.named_steps[\"timeseriestransformer\"].get_engineered_feature_names()"
       ]
     },
     {
@@ -444,7 +452,9 @@
       "outputs": [],
       "source": [
         "# Get the featurization summary as a list of JSON\n",
-        "featurization_summary = fitted_model.named_steps['timeseriestransformer'].get_featurization_summary()\n",
+        "featurization_summary = fitted_model.named_steps[\n",
+        "    \"timeseriestransformer\"\n",
+        "].get_featurization_summary()\n",
         "# View the featurization summary as a pandas dataframe\n",
         "pd.DataFrame.from_records(featurization_summary)"
       ]
@@ -491,9 +501,9 @@
         "import os\n",
         "import shutil\n",
         "\n",
-        "script_folder = os.path.join(os.getcwd(), 'forecast')\n",
+        "script_folder = os.path.join(os.getcwd(), \"forecast\")\n",
         "os.makedirs(script_folder, exist_ok=True)\n",
-        "shutil.copy('forecasting_script.py', script_folder)"
+        "shutil.copy(\"forecasting_script.py\", script_folder)"
       ]
     },
     {
@@ -511,7 +521,9 @@
       "source": [
         "from run_forecast import run_rolling_forecast\n",
         "\n",
-        "remote_run = run_rolling_forecast(test_experiment, compute_target, best_run, test, target_column_name)\n",
+        "remote_run = run_rolling_forecast(\n",
+        "    test_experiment, compute_target, best_run, test, target_column_name\n",
+        ")\n",
         "remote_run"
       ]
     },
@@ -538,8 +550,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "remote_run.download_file('outputs/predictions.csv', 'predictions.csv')\n",
+        "remote_run.download_file(\"outputs/predictions.csv\", \"predictions.csv\")\n",
-        "df_all = pd.read_csv('predictions.csv')"
+        "df_all = pd.read_csv(\"predictions.csv\")"
       ]
     },
     {
@@ -556,18 +568,23 @@
         "# use automl metrics module\n",
         "scores = scoring.score_regression(\n",
         "    y_test=df_all[target_column_name],\n",
-        "    y_pred=df_all['predicted'],\n",
+        "    y_pred=df_all[\"predicted\"],\n",
-        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET))\n",
+        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET),\n",
+        ")\n",
         "\n",
         "print(\"[Test data scores]\\n\")\n",
         "for key, value in scores.items():\n",
-        "    print('{}:   {:.3f}'.format(key, value))\n",
+        "    print(\"{}:   {:.3f}\".format(key, value))\n",
         "\n",
         "# Plot outputs\n",
         "%matplotlib inline\n",
-        "test_pred = plt.scatter(df_all[target_column_name], df_all['predicted'], color='b')\n",
+        "test_pred = plt.scatter(df_all[target_column_name], df_all[\"predicted\"], color=\"b\")\n",
-        "test_test = plt.scatter(df_all[target_column_name], df_all[target_column_name], color='g')\n",
+        "test_test = plt.scatter(\n",
-        "plt.legend((test_pred, test_test), ('prediction', 'truth'), loc='upper left', fontsize=8)\n",
+        "    df_all[target_column_name], df_all[target_column_name], color=\"g\"\n",
+        ")\n",
+        "plt.legend(\n",
+        "    (test_pred, test_test), (\"prediction\", \"truth\"), loc=\"upper left\", fontsize=8\n",
+        ")\n",
         "plt.show()"
       ]
     },
@@ -588,10 +605,18 @@
       "outputs": [],
       "source": [
         "from metrics_helper import MAPE, APE\n",
-        "df_all.groupby('horizon_origin').apply(\n",
+        "\n",
-        "    lambda df: pd.Series({'MAPE': MAPE(df[target_column_name], df['predicted']),\n",
+        "df_all.groupby(\"horizon_origin\").apply(\n",
-        "                          'RMSE': np.sqrt(mean_squared_error(df[target_column_name], df['predicted'])),\n",
+        "    lambda df: pd.Series(\n",
-        "                          'MAE': mean_absolute_error(df[target_column_name], df['predicted'])}))"
+        "        {\n",
+        "            \"MAPE\": MAPE(df[target_column_name], df[\"predicted\"]),\n",
+        "            \"RMSE\": np.sqrt(\n",
+        "                mean_squared_error(df[target_column_name], df[\"predicted\"])\n",
+        "            ),\n",
+        "            \"MAE\": mean_absolute_error(df[target_column_name], df[\"predicted\"]),\n",
+        "        }\n",
+        "    )\n",
+        ")"
       ]
     },
     {
@@ -607,15 +632,18 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "df_all_APE = df_all.assign(APE=APE(df_all[target_column_name], df_all['predicted']))\n",
+        "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, forecast_horizon + 1)]\n",
+        "APEs = [\n",
+        "    df_all_APE[df_all[\"horizon_origin\"] == h].APE.values\n",
+        "    for h in range(1, forecast_horizon + 1)\n",
+        "]\n",
         "\n",
         "%matplotlib inline\n",
         "plt.boxplot(APEs)\n",
-        "plt.yscale('log')\n",
+        "plt.yscale(\"log\")\n",
-        "plt.xlabel('horizon')\n",
+        "plt.xlabel(\"horizon\")\n",
-        "plt.ylabel('APE (%)')\n",
+        "plt.ylabel(\"APE (%)\")\n",
-        "plt.title('Absolute Percentage Errors by Forecast Horizon')\n",
+        "plt.title(\"Absolute Percentage Errors by Forecast Horizon\")\n",
         "\n",
         "plt.show()"
       ]

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

@@ -4,11 +4,14 @@ from sklearn.externals import joblib
 
 parser = argparse.ArgumentParser()
 parser.add_argument(
-    '--target_column_name', type=str, dest='target_column_name',
+    "--target_column_name",
-    help='Target Column Name')
+    type=str,
+    dest="target_column_name",
+    help="Target Column Name",
+)
 parser.add_argument(
-    '--test_dataset', type=str, dest='test_dataset',
+    "--test_dataset", type=str, dest="test_dataset", help="Test Dataset"
-    help='Test Dataset')
+)
 
 args = parser.parse_args()
 target_column_name = args.target_column_name
@@ -20,19 +23,30 @@ ws = run.experiment.workspace
 # get the input dataset by id
 test_dataset = Dataset.get_by_id(ws, id=test_dataset_id)
 
-X_test_df = test_dataset.drop_columns(columns=[target_column_name]).to_pandas_dataframe().reset_index(drop=True)
+X_test_df = (
-y_test_df = test_dataset.with_timestamp_columns(None).keep_columns(columns=[target_column_name]).to_pandas_dataframe()
+    test_dataset.drop_columns(columns=[target_column_name])
+    .to_pandas_dataframe()
+    .reset_index(drop=True)
+)
+y_test_df = (
+    test_dataset.with_timestamp_columns(None)
+    .keep_columns(columns=[target_column_name])
+    .to_pandas_dataframe()
+)
 
-fitted_model = joblib.load('model.pkl')
+fitted_model = joblib.load("model.pkl")
 
 y_pred, X_trans = fitted_model.rolling_evaluation(X_test_df, y_test_df.values)
 
 # Add predictions, actuals, and horizon relative to rolling origin to the test feature data
-assign_dict = {'horizon_origin': X_trans['horizon_origin'].values, 'predicted': y_pred,
+assign_dict = {
-               target_column_name: y_test_df[target_column_name].values}
+    "horizon_origin": X_trans["horizon_origin"].values,
+    "predicted": y_pred,
+    target_column_name: y_test_df[target_column_name].values,
+}
 df_all = X_test_df.assign(**assign_dict)
 
-file_name = 'outputs/predictions.csv'
+file_name = "outputs/predictions.csv"
 export_csv = df_all.to_csv(file_name, header=True)
 
 # Upload the predictions into artifacts

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

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

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

@@ -99,7 +99,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -119,7 +119,7 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for the run history container in the workspace\n",
-        "experiment_name = 'automl-forecasting-energydemand'\n",
+        "experiment_name = \"automl-forecasting-energydemand\"\n",
         "\n",
         "# # project folder\n",
         "# project_folder = './sample_projects/automl-forecasting-energy-demand'\n",
@@ -127,13 +127,13 @@
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
         "output = {}\n",
-        "output['Subscription ID'] = ws.subscription_id\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
-        "output['Workspace'] = ws.name\n",
+        "output[\"Workspace\"] = ws.name\n",
-        "output['Resource Group'] = ws.resource_group\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
-        "output['Location'] = ws.location\n",
+        "output[\"Location\"] = ws.location\n",
-        "output['Run History Name'] = experiment_name\n",
+        "output[\"Run History Name\"] = experiment_name\n",
-        "pd.set_option('display.max_colwidth', -1)\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
         "outputDf.T"
       ]
     },
@@ -166,10 +166,11 @@
         "# Verify that cluster does not exist already\n",
         "try:\n",
         "    compute_target = ComputeTarget(workspace=ws, name=amlcompute_cluster_name)\n",
-        "    print('Found existing cluster, use it.')\n",
+        "    print(\"Found existing cluster, use it.\")\n",
         "except ComputeTargetException:\n",
-        "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS12_V2',\n",
+        "    compute_config = AmlCompute.provisioning_configuration(\n",
-        "                                                           max_nodes=6)\n",
+        "        vm_size=\"STANDARD_DS12_V2\", max_nodes=6\n",
+        "    )\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, compute_config)\n",
         "\n",
         "compute_target.wait_for_completion(show_output=True)"
@@ -204,8 +205,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "target_column_name = 'demand'\n",
+        "target_column_name = \"demand\"\n",
-        "time_column_name = 'timeStamp'"
+        "time_column_name = \"timeStamp\""
       ]
     },
     {
@@ -214,7 +215,9 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "dataset = Dataset.Tabular.from_delimited_files(path = \"https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/nyc_energy.csv\").with_timestamp_columns(fine_grain_timestamp=time_column_name) \n",
+        "dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=\"https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/nyc_energy.csv\"\n",
+        ").with_timestamp_columns(fine_grain_timestamp=time_column_name)\n",
         "dataset.take(5).to_pandas_dataframe().reset_index(drop=True)"
       ]
     },
@@ -343,15 +346,17 @@
       "outputs": [],
       "source": [
         "from azureml.automl.core.forecasting_parameters import ForecastingParameters\n",
+        "\n",
         "forecasting_parameters = ForecastingParameters(\n",
         "    time_column_name=time_column_name,\n",
         "    forecast_horizon=forecast_horizon,\n",
-        "    freq='H' # Set the forecast frequency to be hourly\n",
+        "    freq=\"H\",  # Set the forecast frequency to be hourly\n",
         ")\n",
         "\n",
-        "automl_config = AutoMLConfig(task='forecasting',                             \n",
+        "automl_config = AutoMLConfig(\n",
-        "                             primary_metric='normalized_root_mean_squared_error',\n",
+        "    task=\"forecasting\",\n",
-        "                             blocked_models = ['ExtremeRandomTrees', 'AutoArima', 'Prophet'],                             \n",
+        "    primary_metric=\"normalized_root_mean_squared_error\",\n",
+        "    blocked_models=[\"ExtremeRandomTrees\", \"AutoArima\", \"Prophet\"],\n",
         "    experiment_timeout_hours=0.3,\n",
         "    training_data=train,\n",
         "    label_column_name=target_column_name,\n",
@@ -359,7 +364,8 @@
         "    enable_early_stopping=True,\n",
         "    n_cross_validations=3,\n",
         "    verbosity=logging.INFO,\n",
-        "                             forecasting_parameters=forecasting_parameters)"
+        "    forecasting_parameters=forecasting_parameters,\n",
+        ")"
       ]
     },
     {
@@ -420,7 +426,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "fitted_model.named_steps['timeseriestransformer'].get_engineered_feature_names()"
+        "fitted_model.named_steps[\"timeseriestransformer\"].get_engineered_feature_names()"
       ]
     },
     {
@@ -444,7 +450,9 @@
       "outputs": [],
       "source": [
         "# Get the featurization summary as a list of JSON\n",
-        "featurization_summary = fitted_model.named_steps['timeseriestransformer'].get_featurization_summary()\n",
+        "featurization_summary = fitted_model.named_steps[\n",
+        "    \"timeseriestransformer\"\n",
+        "].get_featurization_summary()\n",
         "# View the featurization summary as a pandas dataframe\n",
         "pd.DataFrame.from_records(featurization_summary)"
       ]
@@ -484,15 +492,18 @@
       "outputs": [],
       "source": [
         "from run_forecast import run_remote_inference\n",
-        "remote_run_infer = run_remote_inference(test_experiment=test_experiment,\n",
+        "\n",
+        "remote_run_infer = run_remote_inference(\n",
+        "    test_experiment=test_experiment,\n",
         "    compute_target=compute_target,\n",
         "    train_run=best_run,\n",
         "    test_dataset=test,\n",
-        "                                        target_column_name=target_column_name)\n",
+        "    target_column_name=target_column_name,\n",
+        ")\n",
         "remote_run_infer.wait_for_completion(show_output=False)\n",
         "\n",
         "# download the inference output file to the local machine\n",
-        "remote_run_infer.download_file('outputs/predictions.csv', 'predictions.csv')"
+        "remote_run_infer.download_file(\"outputs/predictions.csv\", \"predictions.csv\")"
       ]
     },
     {
@@ -510,7 +521,7 @@
       "outputs": [],
       "source": [
         "# load forecast data frame\n",
-        "fcst_df = pd.read_csv('predictions.csv', parse_dates=[time_column_name])\n",
+        "fcst_df = pd.read_csv(\"predictions.csv\", parse_dates=[time_column_name])\n",
         "fcst_df.head()"
       ]
     },
@@ -527,18 +538,23 @@
         "# use automl metrics module\n",
         "scores = scoring.score_regression(\n",
         "    y_test=fcst_df[target_column_name],\n",
-        "    y_pred=fcst_df['predicted'],\n",
+        "    y_pred=fcst_df[\"predicted\"],\n",
-        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET))\n",
+        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET),\n",
+        ")\n",
         "\n",
         "print(\"[Test data scores]\\n\")\n",
         "for key, value in scores.items():\n",
-        "    print('{}:   {:.3f}'.format(key, value))\n",
+        "    print(\"{}:   {:.3f}\".format(key, value))\n",
         "\n",
         "# Plot outputs\n",
         "%matplotlib inline\n",
-        "test_pred = plt.scatter(fcst_df[target_column_name], fcst_df['predicted'], color='b')\n",
+        "test_pred = plt.scatter(fcst_df[target_column_name], fcst_df[\"predicted\"], color=\"b\")\n",
-        "test_test = plt.scatter(fcst_df[target_column_name], fcst_df[target_column_name], color='g')\n",
+        "test_test = plt.scatter(\n",
-        "plt.legend((test_pred, test_test), ('prediction', 'truth'), loc='upper left', fontsize=8)\n",
+        "    fcst_df[target_column_name], fcst_df[target_column_name], color=\"g\"\n",
+        ")\n",
+        "plt.legend(\n",
+        "    (test_pred, test_test), (\"prediction\", \"truth\"), loc=\"upper left\", fontsize=8\n",
+        ")\n",
         "plt.show()"
       ]
     },
@@ -567,13 +583,24 @@
       "outputs": [],
       "source": [
         "advanced_forecasting_parameters = ForecastingParameters(\n",
-        "    time_column_name=time_column_name, forecast_horizon=forecast_horizon,\n",
+        "    time_column_name=time_column_name,\n",
-        "    target_lags=12, target_rolling_window_size=4\n",
+        "    forecast_horizon=forecast_horizon,\n",
+        "    target_lags=12,\n",
+        "    target_rolling_window_size=4,\n",
         ")\n",
         "\n",
-        "automl_config = AutoMLConfig(task='forecasting',                             \n",
+        "automl_config = AutoMLConfig(\n",
-        "                             primary_metric='normalized_root_mean_squared_error',\n",
+        "    task=\"forecasting\",\n",
-        "                             blocked_models = ['ElasticNet','ExtremeRandomTrees','GradientBoosting','XGBoostRegressor','ExtremeRandomTrees', 'AutoArima', 'Prophet'], #These models are blocked for tutorial purposes, remove this for real use cases.                            \n",
+        "    primary_metric=\"normalized_root_mean_squared_error\",\n",
+        "    blocked_models=[\n",
+        "        \"ElasticNet\",\n",
+        "        \"ExtremeRandomTrees\",\n",
+        "        \"GradientBoosting\",\n",
+        "        \"XGBoostRegressor\",\n",
+        "        \"ExtremeRandomTrees\",\n",
+        "        \"AutoArima\",\n",
+        "        \"Prophet\",\n",
+        "    ],  # These models are blocked for tutorial purposes, remove this for real use cases.\n",
         "    experiment_timeout_hours=0.3,\n",
         "    training_data=train,\n",
         "    label_column_name=target_column_name,\n",
@@ -581,7 +608,8 @@
         "    enable_early_stopping=True,\n",
         "    n_cross_validations=3,\n",
         "    verbosity=logging.INFO,\n",
-        "                             forecasting_parameters=advanced_forecasting_parameters)"
+        "    forecasting_parameters=advanced_forecasting_parameters,\n",
+        ")"
       ]
     },
     {
@@ -640,16 +668,20 @@
       "outputs": [],
       "source": [
         "test_experiment_advanced = Experiment(ws, experiment_name + \"_inference_advanced\")\n",
-        "advanced_remote_run_infer = run_remote_inference(test_experiment=test_experiment_advanced,\n",
+        "advanced_remote_run_infer = run_remote_inference(\n",
+        "    test_experiment=test_experiment_advanced,\n",
         "    compute_target=compute_target,\n",
         "    train_run=best_run_lags,\n",
         "    test_dataset=test,\n",
         "    target_column_name=target_column_name,\n",
-        "                                                 inference_folder='./forecast_advanced')\n",
+        "    inference_folder=\"./forecast_advanced\",\n",
+        ")\n",
         "advanced_remote_run_infer.wait_for_completion(show_output=False)\n",
         "\n",
         "# download the inference output file to the local machine\n",
-        "advanced_remote_run_infer.download_file('outputs/predictions.csv', 'predictions_advanced.csv')"
+        "advanced_remote_run_infer.download_file(\n",
+        "    \"outputs/predictions.csv\", \"predictions_advanced.csv\"\n",
+        ")"
       ]
     },
     {
@@ -658,7 +690,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "fcst_adv_df = pd.read_csv('predictions_advanced.csv', parse_dates=[time_column_name])\n",
+        "fcst_adv_df = pd.read_csv(\"predictions_advanced.csv\", parse_dates=[time_column_name])\n",
         "fcst_adv_df.head()"
       ]
     },
@@ -675,18 +707,25 @@
         "# use automl metrics module\n",
         "scores = scoring.score_regression(\n",
         "    y_test=fcst_adv_df[target_column_name],\n",
-        "    y_pred=fcst_adv_df['predicted'],\n",
+        "    y_pred=fcst_adv_df[\"predicted\"],\n",
-        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET))\n",
+        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET),\n",
+        ")\n",
         "\n",
         "print(\"[Test data scores]\\n\")\n",
         "for key, value in scores.items():\n",
-        "    print('{}:   {:.3f}'.format(key, value))\n",
+        "    print(\"{}:   {:.3f}\".format(key, value))\n",
         "\n",
         "# Plot outputs\n",
         "%matplotlib inline\n",
-        "test_pred = plt.scatter(fcst_adv_df[target_column_name], fcst_adv_df['predicted'], color='b')\n",
+        "test_pred = plt.scatter(\n",
-        "test_test = plt.scatter(fcst_adv_df[target_column_name], fcst_adv_df[target_column_name], color='g')\n",
+        "    fcst_adv_df[target_column_name], fcst_adv_df[\"predicted\"], color=\"b\"\n",
-        "plt.legend((test_pred, test_test), ('prediction', 'truth'), loc='upper left', fontsize=8)\n",
+        ")\n",
+        "test_test = plt.scatter(\n",
+        "    fcst_adv_df[target_column_name], fcst_adv_df[target_column_name], color=\"g\"\n",
+        ")\n",
+        "plt.legend(\n",
+        "    (test_pred, test_test), (\"prediction\", \"truth\"), loc=\"upper left\", fontsize=8\n",
+        ")\n",
         "plt.show()"
       ]
     }

how-to-use-azureml/automated-machine-learning/forecasting-energy-demand/forecasting_script.py

@@ -5,62 +5,20 @@ compute instance.
 """
 
 import argparse
-import pandas as pd
-import numpy as np
 from azureml.core import Dataset, Run
-from azureml.automl.core.shared.constants import TimeSeriesInternal
 from sklearn.externals import joblib
 from pandas.tseries.frequencies import to_offset
 
-
-def align_outputs(y_predicted, X_trans, X_test, y_test, target_column_name,
-                  predicted_column_name='predicted',
-                  horizon_colname='horizon_origin'):
-    """
-    Demonstrates how to get the output aligned to the inputs
-    using pandas indexes. Helps understand what happened if
-    the output's 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
-    """
-
-    if (horizon_colname in X_trans):
-        df_fcst = pd.DataFrame({predicted_column_name: y_predicted,
-                                horizon_colname: X_trans[horizon_colname]})
-    else:
-        df_fcst = pd.DataFrame({predicted_column_name: y_predicted})
-
-    # 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()
-    X_test_full[target_column_name] = y_test
-
-    # X_test_full's index 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[[target_column_name,
-                               predicted_column_name]].notnull().all(axis=1)]
-    return(clean)
-
-
 parser = argparse.ArgumentParser()
 parser.add_argument(
-    '--target_column_name', type=str, dest='target_column_name',
+    "--target_column_name",
-    help='Target Column Name')
+    type=str,
+    dest="target_column_name",
+    help="Target Column Name",
+)
 parser.add_argument(
-    '--test_dataset', type=str, dest='test_dataset',
+    "--test_dataset", type=str, dest="test_dataset", help="Test Dataset"
-    help='Test Dataset')
+)
 
 args = parser.parse_args()
 target_column_name = args.target_column_name
@@ -76,14 +34,28 @@ X_test = test_dataset.to_pandas_dataframe().reset_index(drop=True)
 y_test = X_test.pop(target_column_name).values
 
 # generate forecast
-fitted_model = joblib.load('model.pkl')
+fitted_model = joblib.load("model.pkl")
-y_predictions, X_trans = fitted_model.forecast(X_test)
+# We have default quantiles values set as below(95th percentile)
+quantiles = [0.025, 0.5, 0.975]
+predicted_column_name = "predicted"
+PI = "prediction_interval"
+fitted_model.quantiles = quantiles
+pred_quantiles = fitted_model.forecast_quantiles(X_test)
+pred_quantiles[PI] = pred_quantiles[[min(quantiles), max(quantiles)]].apply(
+    lambda x: "[{}, {}]".format(x[0], x[1]), axis=1
+)
+X_test[target_column_name] = y_test
+X_test[PI] = pred_quantiles[PI]
+X_test[predicted_column_name] = pred_quantiles[0.5]
+# drop rows where prediction or actuals are nan
+# happens because of missing actuals
+# or at edges of time due to lags/rolling windows
+clean = X_test[
+    X_test[[target_column_name, predicted_column_name]].notnull().all(axis=1)
+]
 
-# align output
+file_name = "outputs/predictions.csv"
-df_all = align_outputs(y_predictions, X_trans, X_test, y_test, target_column_name)
+export_csv = clean.to_csv(file_name, header=True, index=False)  # added Index
-
-file_name = 'outputs/predictions.csv'
-export_csv = df_all.to_csv(file_name, header=True, index=False)  # added Index
 
 # Upload the predictions into artifacts
 run.upload_file(name=file_name, path_or_stream=file_name)

how-to-use-azureml/automated-machine-learning/forecasting-energy-demand/run_forecast.py

@@ -3,36 +3,47 @@ import shutil
 from azureml.core import ScriptRunConfig
 
 
-def run_remote_inference(test_experiment, compute_target, train_run,
+def run_remote_inference(
-                         test_dataset, target_column_name, inference_folder='./forecast'):
+    test_experiment,
+    compute_target,
+    train_run,
+    test_dataset,
+    target_column_name,
+    inference_folder="./forecast",
+):
     # Create local directory to copy the model.pkl and forecsting_script.py files into.
     # These files will be uploaded to and executed on the compute instance.
     os.makedirs(inference_folder, exist_ok=True)
-    shutil.copy('forecasting_script.py', inference_folder)
+    shutil.copy("forecasting_script.py", inference_folder)
 
-    train_run.download_file('outputs/model.pkl',
+    train_run.download_file(
-                            os.path.join(inference_folder, 'model.pkl'))
+        "outputs/model.pkl", os.path.join(inference_folder, "model.pkl")
+    )
 
     inference_env = train_run.get_environment()
 
-    config = ScriptRunConfig(source_directory=inference_folder,
+    config = ScriptRunConfig(
-                             script='forecasting_script.py',
+        source_directory=inference_folder,
-                             arguments=['--target_column_name',
+        script="forecasting_script.py",
+        arguments=[
+            "--target_column_name",
             target_column_name,
-                                        '--test_dataset',
+            "--test_dataset",
-                                        test_dataset.as_named_input(test_dataset.name)],
+            test_dataset.as_named_input(test_dataset.name),
+        ],
         compute_target=compute_target,
-                             environment=inference_env)
+        environment=inference_env,
+    )
 
-    run = test_experiment.submit(config,
+    run = test_experiment.submit(
-                                 tags={'training_run_id':
+        config,
-                                       train_run.id,
+        tags={
-                                       'run_algorithm':
+            "training_run_id": train_run.id,
-                                       train_run.properties['run_algorithm'],
+            "run_algorithm": train_run.properties["run_algorithm"],
-                                       'valid_score':
+            "valid_score": train_run.properties["score"],
-                                       train_run.properties['score'],
+            "primary_metric": train_run.properties["primary_metric"],
-                                       'primary_metric':
+        },
-                                       train_run.properties['primary_metric']})
+    )
 
-    run.log("run_algorithm", run.tags['run_algorithm'])
+    run.log("run_algorithm", run.tags["run_algorithm"])
     return run

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

@@ -94,7 +94,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -111,19 +111,19 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for the run history container in the workspace\n",
-        "experiment_name = 'automl-forecast-function-demo'\n",
+        "experiment_name = \"automl-forecast-function-demo\"\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
         "output = {}\n",
-        "output['Subscription ID'] = ws.subscription_id\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
-        "output['Workspace'] = ws.name\n",
+        "output[\"Workspace\"] = ws.name\n",
-        "output['SKU'] = ws.sku\n",
+        "output[\"SKU\"] = ws.sku\n",
-        "output['Resource Group'] = ws.resource_group\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
-        "output['Location'] = ws.location\n",
+        "output[\"Location\"] = ws.location\n",
-        "output['Run History Name'] = experiment_name\n",
+        "output[\"Run History Name\"] = experiment_name\n",
-        "pd.set_option('display.max_colwidth', -1)\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
         "outputDf.T"
       ]
     },
@@ -141,17 +141,20 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "TIME_COLUMN_NAME = 'date'\n",
+        "TIME_COLUMN_NAME = \"date\"\n",
-        "TIME_SERIES_ID_COLUMN_NAME = 'time_series_id'\n",
+        "TIME_SERIES_ID_COLUMN_NAME = \"time_series_id\"\n",
-        "TARGET_COLUMN_NAME = 'y'\n",
+        "TARGET_COLUMN_NAME = \"y\"\n",
         "\n",
-        "def get_timeseries(train_len: int,\n",
+        "\n",
+        "def get_timeseries(\n",
+        "    train_len: int,\n",
         "    test_len: int,\n",
         "    time_column_name: str,\n",
         "    target_column_name: str,\n",
         "    time_series_id_column_name: str,\n",
         "    time_series_number: int = 1,\n",
-        "                   freq: str = 'H'):\n",
+        "    freq: str = \"H\",\n",
+        "):\n",
         "    \"\"\"\n",
         "    Return the time series of designed length.\n",
         "\n",
@@ -174,14 +177,18 @@
         "    data_test = []  # type: List[pd.DataFrame]\n",
         "    data_length = train_len + test_len\n",
         "    for i in range(time_series_number):\n",
-        "        X = pd.DataFrame({\n",
+        "        X = pd.DataFrame(\n",
-        "            time_column_name: pd.date_range(start='2000-01-01',\n",
+        "            {\n",
-        "                                            periods=data_length,\n",
+        "                time_column_name: pd.date_range(\n",
-        "                                            freq=freq),\n",
+        "                    start=\"2000-01-01\", periods=data_length, freq=freq\n",
-        "            target_column_name: np.arange(data_length).astype(float) + np.random.rand(data_length) + i*5,\n",
+        "                ),\n",
-        "            'ext_predictor': np.asarray(range(42, 42 + data_length)),\n",
+        "                target_column_name: np.arange(data_length).astype(float)\n",
-        "            time_series_id_column_name: np.repeat('ts{}'.format(i), data_length)\n",
+        "                + np.random.rand(data_length)\n",
-        "        })\n",
+        "                + i * 5,\n",
+        "                \"ext_predictor\": np.asarray(range(42, 42 + data_length)),\n",
+        "                time_series_id_column_name: np.repeat(\"ts{}\".format(i), data_length),\n",
+        "            }\n",
+        "        )\n",
         "        data_train.append(X[:train_len])\n",
         "        data_test.append(X[train_len:])\n",
         "    X_train = pd.concat(data_train)\n",
@@ -190,14 +197,17 @@
         "    y_test = X_test.pop(target_column_name).values\n",
         "    return X_train, y_train, X_test, y_test\n",
         "\n",
+        "\n",
         "n_test_periods = 6\n",
         "n_train_periods = 30\n",
-        "X_train, y_train, X_test, y_test = get_timeseries(train_len=n_train_periods,\n",
+        "X_train, y_train, X_test, y_test = get_timeseries(\n",
+        "    train_len=n_train_periods,\n",
         "    test_len=n_test_periods,\n",
         "    time_column_name=TIME_COLUMN_NAME,\n",
         "    target_column_name=TARGET_COLUMN_NAME,\n",
         "    time_series_id_column_name=TIME_SERIES_ID_COLUMN_NAME,\n",
-        "                                                  time_series_number=2)"
+        "    time_series_number=2,\n",
+        ")"
       ]
     },
     {
@@ -224,11 +234,12 @@
       "source": [
         "# plot the example time series\n",
         "import matplotlib.pyplot as plt\n",
+        "\n",
         "whole_data = X_train.copy()\n",
-        "target_label = 'y'\n",
+        "target_label = \"y\"\n",
         "whole_data[target_label] = y_train\n",
-        "for g in whole_data.groupby('time_series_id'):    \n",
+        "for g in whole_data.groupby(\"time_series_id\"):\n",
-        "    plt.plot(g[1]['date'].values, g[1]['y'].values, label=g[0])\n",
+        "    plt.plot(g[1][\"date\"].values, g[1][\"y\"].values, label=g[0])\n",
         "plt.legend()\n",
         "plt.show()"
       ]
@@ -250,12 +261,12 @@
         "# We need to save thw artificial data and then upload them to default workspace datastore.\n",
         "DATA_PATH = \"fc_fn_data\"\n",
         "DATA_PATH_X = \"{}/data_train.csv\".format(DATA_PATH)\n",
-        "if not os.path.isdir('data'):\n",
+        "if not os.path.isdir(\"data\"):\n",
-        "    os.mkdir('data')\n",
+        "    os.mkdir(\"data\")\n",
         "pd.DataFrame(whole_data).to_csv(\"data/data_train.csv\", index=False)\n",
         "# Upload saved data to the default data store.\n",
         "ds = ws.get_default_datastore()\n",
-        "ds.upload(src_dir='./data', target_path=DATA_PATH, overwrite=True, show_progress=True)\n",
+        "ds.upload(src_dir=\"./data\", target_path=DATA_PATH, overwrite=True, show_progress=True)\n",
         "train_data = Dataset.Tabular.from_delimited_files(path=ds.path(DATA_PATH_X))"
       ]
     },
@@ -283,10 +294,11 @@
         "# Verify that cluster does not exist already\n",
         "try:\n",
         "    compute_target = ComputeTarget(workspace=ws, name=amlcompute_cluster_name)\n",
-        "    print('Found existing cluster, use it.')\n",
+        "    print(\"Found existing cluster, use it.\")\n",
         "except ComputeTargetException:\n",
-        "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_DS12_V2',\n",
+        "    compute_config = AmlCompute.provisioning_configuration(\n",
-        "                                                           max_nodes=6)\n",
+        "        vm_size=\"STANDARD_DS12_V2\", max_nodes=6\n",
+        "    )\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, compute_config)\n",
         "\n",
         "compute_target.wait_for_completion(show_output=True)"
@@ -315,6 +327,7 @@
       "outputs": [],
       "source": [
         "from azureml.automl.core.forecasting_parameters import ForecastingParameters\n",
+        "\n",
         "lags = [1, 2, 3]\n",
         "forecast_horizon = n_test_periods\n",
         "forecasting_parameters = ForecastingParameters(\n",
@@ -322,7 +335,7 @@
         "    forecast_horizon=forecast_horizon,\n",
         "    time_series_id_column_names=[TIME_SERIES_ID_COLUMN_NAME],\n",
         "    target_lags=lags,\n",
-        "    freq='H' # Set the forecast frequency to be hourly\n",
+        "    freq=\"H\",  # Set the forecast frequency to be hourly\n",
         ")"
       ]
     },
@@ -344,9 +357,10 @@
         "from azureml.train.automl import AutoMLConfig\n",
         "\n",
         "\n",
-        "automl_config = AutoMLConfig(task='forecasting',\n",
+        "automl_config = AutoMLConfig(\n",
-        "                             debug_log='automl_forecasting_function.log',\n",
+        "    task=\"forecasting\",\n",
-        "                             primary_metric='normalized_root_mean_squared_error',\n",
+        "    debug_log=\"automl_forecasting_function.log\",\n",
+        "    primary_metric=\"normalized_root_mean_squared_error\",\n",
         "    experiment_timeout_hours=0.25,\n",
         "    enable_early_stopping=True,\n",
         "    training_data=train_data,\n",
@@ -356,7 +370,8 @@
         "    max_concurrent_iterations=4,\n",
         "    max_cores_per_iteration=-1,\n",
         "    label_column_name=target_label,\n",
-        "                             forecasting_parameters=forecasting_parameters)\n",
+        "    forecasting_parameters=forecasting_parameters,\n",
+        ")\n",
         "\n",
         "remote_run = experiment.submit(automl_config, show_output=False)"
       ]
@@ -536,12 +551,14 @@
       "source": [
         "# generate the same kind of test data we trained on,\n",
         "# but now make the train set much longer, so that the test set will be in the future\n",
-        "X_context, y_context, X_away, y_away = get_timeseries(train_len=42, # train data was 30 steps long\n",
+        "X_context, y_context, X_away, y_away = get_timeseries(\n",
+        "    train_len=42,  # train data was 30 steps long\n",
         "    test_len=4,\n",
         "    time_column_name=TIME_COLUMN_NAME,\n",
         "    target_column_name=TARGET_COLUMN_NAME,\n",
         "    time_series_id_column_name=TIME_SERIES_ID_COLUMN_NAME,\n",
-        "                                      time_series_number=2)\n",
+        "    time_series_number=2,\n",
+        ")\n",
         "\n",
         "# end of the data we trained on\n",
         "print(X_train.groupby(TIME_SERIES_ID_COLUMN_NAME)[TIME_COLUMN_NAME].max())\n",
@@ -584,7 +601,9 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "def make_forecasting_query(fulldata, time_column_name, target_column_name, forecast_origin, horizon, lookback):\n",
+        "def make_forecasting_query(\n",
+        "    fulldata, time_column_name, target_column_name, forecast_origin, horizon, lookback\n",
+        "):\n",
         "\n",
         "    \"\"\"\n",
         "    This function will take the full dataset, and create the query\n",
@@ -599,14 +618,14 @@
         "    target_column_name: string           which column (must be in fulldata) is to be forecast\n",
         "    forecast_origin: datetime type       the last time we (pretend to) have target values\n",
         "    horizon: timedelta                   how far forward, in time units (not periods)\n",
-        "    lookback: timedelta                  how far back does the model look?\n",
+        "    lookback: timedelta                  how far back does the model look\n",
         "\n",
         "    Example:\n",
         "\n",
         "\n",
         "    ```\n",
         "\n",
-        "    forecast_origin = pd.to_datetime('2012-09-01') + pd.DateOffset(days=5) # forecast 5 days after end of training\n",
+        "    forecast_origin = pd.to_datetime(\"2012-09-01\") + pd.DateOffset(days=5) # forecast 5 days after end of training\n",
         "    print(forecast_origin)\n",
         "\n",
         "    X_query, y_query = make_forecasting_query(data,\n",
@@ -618,28 +637,30 @@
         "    ```\n",
         "    \"\"\"\n",
         "\n",
-        "    X_past = fulldata[ (fulldata[ time_column_name ] > forecast_origin - lookback) &\n",
+        "    X_past = fulldata[\n",
-        "                       (fulldata[ time_column_name ] <= forecast_origin)\n",
+        "        (fulldata[time_column_name] > forecast_origin - lookback)\n",
+        "        & (fulldata[time_column_name] <= forecast_origin)\n",
         "    ]\n",
         "\n",
-        "    X_future = fulldata[ (fulldata[ time_column_name ] > forecast_origin) &\n",
+        "    X_future = fulldata[\n",
-        "                         (fulldata[ time_column_name ] <= forecast_origin + horizon)\n",
+        "        (fulldata[time_column_name] > forecast_origin)\n",
+        "        & (fulldata[time_column_name] <= forecast_origin + horizon)\n",
         "    ]\n",
         "\n",
         "    y_past = X_past.pop(target_column_name).values.astype(np.float)\n",
         "    y_future = X_future.pop(target_column_name).values.astype(np.float)\n",
         "\n",
         "    # Now take y_future and turn it into question marks\n",
-        "    y_query = y_future.copy().astype(np.float)  # because sometimes life hands you an int\n",
+        "    y_query = y_future.copy().astype(\n",
+        "        np.float\n",
+        "    )  # because sometimes life hands you an int\n",
         "    y_query.fill(np.NaN)\n",
         "\n",
-        "\n",
         "    print(\"X_past is \" + str(X_past.shape) + \" - shaped\")\n",
         "    print(\"X_future is \" + str(X_future.shape) + \" - shaped\")\n",
         "    print(\"y_past is \" + str(y_past.shape) + \" - shaped\")\n",
         "    print(\"y_query is \" + str(y_query.shape) + \" - shaped\")\n",
         "\n",
-        "\n",
         "    X_pred = pd.concat([X_past, X_future])\n",
         "    y_pred = np.concatenate([y_past, y_query])\n",
         "    return X_pred, y_pred"
@@ -658,8 +679,16 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(X_context.groupby(TIME_SERIES_ID_COLUMN_NAME)[TIME_COLUMN_NAME].agg(['min','max','count']))\n",
+        "print(\n",
-        "print(X_away.groupby(TIME_SERIES_ID_COLUMN_NAME)[TIME_COLUMN_NAME].agg(['min','max','count']))\n",
+        "    X_context.groupby(TIME_SERIES_ID_COLUMN_NAME)[TIME_COLUMN_NAME].agg(\n",
+        "        [\"min\", \"max\", \"count\"]\n",
+        "    )\n",
+        ")\n",
+        "print(\n",
+        "    X_away.groupby(TIME_SERIES_ID_COLUMN_NAME)[TIME_COLUMN_NAME].agg(\n",
+        "        [\"min\", \"max\", \"count\"]\n",
+        "    )\n",
+        ")\n",
         "X_context.tail(5)"
       ]
     },
@@ -692,8 +721,9 @@
         "horizon = pd.DateOffset(hours=forecast_horizon)\n",
         "\n",
         "# now make the forecast query from context (refer to figure)\n",
-        "X_pred, y_pred = make_forecasting_query(fulldata, TIME_COLUMN_NAME, TARGET_COLUMN_NAME,\n",
+        "X_pred, y_pred = make_forecasting_query(\n",
-        "                                        forecast_origin, horizon, lookback)\n",
+        "    fulldata, TIME_COLUMN_NAME, TARGET_COLUMN_NAME, forecast_origin, horizon, lookback\n",
+        ")\n",
         "\n",
         "# show the forecast request aligned\n",
         "X_show = X_pred.copy()\n",
@@ -720,7 +750,7 @@
         "# show the forecast aligned\n",
         "X_show = xy_away.reset_index()\n",
         "# without the generated features\n",
-        "X_show[['date', 'time_series_id', 'ext_predictor', '_automl_target_col']]\n",
+        "X_show[[\"date\", \"time_series_id\", \"ext_predictor\", \"_automl_target_col\"]]\n",
         "# prediction is in _automl_target_col"
       ]
     },
@@ -751,12 +781,14 @@
       "source": [
         "# generate the same kind of test data we trained on, but with a single time-series and test period twice as long\n",
         "# as the forecast_horizon.\n",
-        "_, _, X_test_long, y_test_long = get_timeseries(train_len=n_train_periods,\n",
+        "_, _, X_test_long, y_test_long = get_timeseries(\n",
+        "    train_len=n_train_periods,\n",
         "    test_len=forecast_horizon * 2,\n",
         "    time_column_name=TIME_COLUMN_NAME,\n",
         "    target_column_name=TARGET_COLUMN_NAME,\n",
         "    time_series_id_column_name=TIME_SERIES_ID_COLUMN_NAME,\n",
-        "                                                  time_series_number=1)\n",
+        "    time_series_number=1,\n",
+        ")\n",
         "\n",
         "print(X_test_long.groupby(TIME_SERIES_ID_COLUMN_NAME)[TIME_COLUMN_NAME].min())\n",
         "print(X_test_long.groupby(TIME_SERIES_ID_COLUMN_NAME)[TIME_COLUMN_NAME].max())"
@@ -781,7 +813,9 @@
       "source": [
         "# What forecast() function does in this case is equivalent to iterating it twice over the test set as the following.\n",
         "y_pred1, _ = fitted_model.forecast(X_test_long[:forecast_horizon])\n",
-        "y_pred_all, _ = fitted_model.forecast(X_test_long, np.concatenate((y_pred1, np.full(forecast_horizon, np.nan))))\n",
+        "y_pred_all, _ = fitted_model.forecast(\n",
+        "    X_test_long, np.concatenate((y_pred1, np.full(forecast_horizon, np.nan)))\n",
+        ")\n",
         "np.array_equal(y_pred_all, y_pred_long)"
       ]
     },

how-to-use-azureml/automated-machine-learning/forecasting-hierarchical-timeseries/auto-ml-forecasting-hierarchical-timeseries.ipynb

@@ -0,0 +1,677 @@
+{
+  "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/forecasting-hierarchical-timeseries/auto-ml-forecasting-hierarchical-timeseries.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Hierarchical Time Series - Automated ML\n",
+        "**_Generate hierarchical time series forecasts with Automated Machine Learning_**\n",
+        "\n",
+        "---"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "For this notebook we are using a synthetic dataset portraying sales data to predict the the quantity of a vartiety of product skus across several states, stores, and product categories.\n",
+        "\n",
+        "**NOTE: There are limits on how many runs we can do in parallel per workspace, and we currently recommend to set the parallelism to maximum of 320 runs per experiment per workspace. If users want to have more parallelism and increase this limit they might encounter Too Many Requests errors (HTTP 429).**"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Prerequisites\n",
+        "You'll need to create a compute Instance by following the instructions in the [EnvironmentSetup.md](../Setup_Resources/EnvironmentSetup.md)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 1.0 Set up workspace, datastore, experiment"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613003526897
+        }
+      },
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "from azureml.core import Workspace, Datastore\n",
+        "import pandas as pd\n",
+        "\n",
+        "# Set up your workspace\n",
+        "ws = Workspace.from_config()\n",
+        "ws.get_details()\n",
+        "\n",
+        "# Set up your datastores\n",
+        "dstore = ws.get_default_datastore()\n",
+        "\n",
+        "output = {}\n",
+        "output[\"SDK version\"] = azureml.core.VERSION\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
+        "output[\"Workspace\"] = ws.name\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
+        "output[\"Location\"] = ws.location\n",
+        "output[\"Default datastore name\"] = dstore.name\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
+        "outputDf.T"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Choose an experiment"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613003540729
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.core import Experiment\n",
+        "\n",
+        "experiment = Experiment(ws, \"automl-hts\")\n",
+        "\n",
+        "print(\"Experiment name: \" + experiment.name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 2.0 Data\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "source": [
+        "### Upload local csv files to datastore\n",
+        "You can upload your train and inference csv files to the default datastore in your workspace. \n",
+        "\n",
+        "A Datastore is a place where data can be stored that is then made accessible to a compute either by means of mounting or copying the data to the compute target.\n",
+        "Please refer to [Datastore](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.datastore.datastore?view=azure-ml-py) documentation on how to access data from Datastore."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "datastore_path = \"hts-sample\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "datastore = ws.get_default_datastore()\n",
+        "datastore"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613005886349
+        },
+        "jupyter": {
+          "outputs_hidden": false,
+          "source_hidden": false
+        },
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "outputs": [],
+      "source": [
+        "datastore.upload(\n",
+        "    src_dir=\"./Data/\", target_path=datastore_path, overwrite=True, show_progress=True\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create the TabularDatasets \n",
+        "\n",
+        "Datasets in Azure Machine Learning are references to specific data in a Datastore. The data can be retrieved as a [TabularDatasets](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.tabulardataset?view=azure-ml-py)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613007017296
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.core.dataset import Dataset\n",
+        "\n",
+        "train_ds = Dataset.Tabular.from_delimited_files(\n",
+        "    path=datastore.path(\"hts-sample/hts-sample-train.csv\"), validate=False\n",
+        ")\n",
+        "inference_ds = Dataset.Tabular.from_delimited_files(\n",
+        "    path=datastore.path(\"hts-sample/hts-sample-test.csv\"), validate=False\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Register the TabularDatasets to the Workspace \n",
+        "Finally, register the dataset to your Workspace so it can be called as an input into the training pipeline in the next notebook. We will use the inference dataset as part of the forecasting pipeline. The step need only be completed once."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "registered_train = train_ds.register(ws, \"hts-sales-train\")\n",
+        "registered_inference = inference_ds.register(ws, \"hts-sales-test\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 3.0 Build the training pipeline\n",
+        "Now that the dataset, WorkSpace, and datastore are set up, we can put together a pipeline for training.\n",
+        "\n",
+        "> Note that if you have an AzureML Data Scientist role, you will not have permission to create compute resources. Talk to your workspace or IT admin to create the compute targets described in this section, if they do not already exist."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Choose a compute target\n",
+        "\n",
+        "You will need to create a [compute target](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-set-up-training-targets#amlcompute) for your AutoML run. In this tutorial, you create AmlCompute as your training compute resource.\n",
+        "\n",
+        "\\*\\*Creation of AmlCompute takes approximately 5 minutes.**\n",
+        "\n",
+        "If the AmlCompute with that name is already in your workspace this code will skip the creation process. 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/how-to-manage-quotas) on the default limits and how to request more quota."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613007037308
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.core.compute import ComputeTarget, AmlCompute\n",
+        "\n",
+        "# Name your cluster\n",
+        "compute_name = \"hts-compute\"\n",
+        "\n",
+        "\n",
+        "if compute_name in ws.compute_targets:\n",
+        "    compute_target = ws.compute_targets[compute_name]\n",
+        "    if compute_target and type(compute_target) is AmlCompute:\n",
+        "        print(\"Found compute target: \" + compute_name)\n",
+        "else:\n",
+        "    print(\"Creating a new compute target...\")\n",
+        "    provisioning_config = AmlCompute.provisioning_configuration(\n",
+        "        vm_size=\"STANDARD_D16S_V3\", max_nodes=20\n",
+        "    )\n",
+        "    # Create the compute target\n",
+        "    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)\n",
+        "\n",
+        "    # Can poll for a minimum number of nodes and for a specific timeout.\n",
+        "    # If no min node count is provided it will use the scale settings for the cluster\n",
+        "    compute_target.wait_for_completion(\n",
+        "        show_output=True, min_node_count=None, timeout_in_minutes=20\n",
+        "    )\n",
+        "\n",
+        "    # For a more detailed view of current cluster status, use the 'status' property\n",
+        "    print(compute_target.status.serialize())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Set up training parameters\n",
+        "\n",
+        "This dictionary defines the AutoML and hierarchy settings. For this forecasting task we need to define several settings inncluding the name of the time column, the maximum forecast horizon, the hierarchy definition, and the level of the hierarchy at which to train.\n",
+        "\n",
+        "| Property                           | Description|\n",
+        "| :---------------                   | :------------------- |\n",
+        "| **task**                           | forecasting |\n",
+        "| **primary_metric**                 | This is the metric that you want to optimize.<br> Forecasting supports the following primary metrics <br><i>spearman_correlation</i><br><i>normalized_root_mean_squared_error</i><br><i>r2_score</i><br><i>normalized_mean_absolute_error</i> |\n",
+        "| **blocked_models**                 | Blocked models won't be used by AutoML. |\n",
+        "| **iteration_timeout_minutes**      | Maximum amount of time in minutes that the model can train. This is optional but provides customers with greater control on exit criteria. |\n",
+        "| **iterations**                     | Number of models to train. This is optional but provides customers with greater control on exit criteria. |\n",
+        "| **experiment_timeout_hours**       | Maximum amount of time in hours that the experiment can take before it terminates. This is optional but provides customers with greater control on exit criteria. |\n",
+        "| **label_column_name**              | The name of the label column. |\n",
+        "| **forecast_horizon**               | The forecast horizon is how many periods forward you would like to forecast. This integer horizon is in units of the timeseries frequency (e.g. daily, weekly). Periods are inferred from your data. |\n",
+        "| **n_cross_validations**            | Number of cross validation splits. Rolling Origin Validation is used to split time-series in a temporally consistent way. |\n",
+        "| **enable_early_stopping**          | Flag to enable early termination if the score is not improving in the short term. |\n",
+        "| **time_column_name**               | The name of your time column. |\n",
+        "| **hierarchy_column_names**         | The names of columns that define the hierarchical structure of the data from highest level to most granular. |\n",
+        "| **training_level**                 | The level of the hierarchy to be used for training models. |\n",
+        "| **enable_engineered_explanations** | Engineered feature explanations will be downloaded if enable_engineered_explanations flag is set to True. By default it is set to False to save storage space. |\n",
+        "| **time_series_id_column_name**     | The column names used to uniquely identify timeseries in data that has multiple rows with the same timestamp. |\n",
+        "| **track_child_runs**               | Flag to disable tracking of child runs. Only best run is tracked if the flag is set to False (this includes the model and metrics of the run). |\n",
+        "| **pipeline_fetch_max_batch_size**  | Determines how many pipelines (training algorithms) to fetch at a time for training, this helps reduce throttling when training at large scale. |\n",
+        "| **model_explainability**           | Flag to disable explaining the best automated ML model at the end of all training iterations. The default is True and will block non-explainable models which may impact the forecast accuracy. For more information, see [Interpretability: model explanations in automated machine learning](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-machine-learning-interpretability-automl). |"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613007061544
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.train.automl.runtime._hts.hts_parameters import HTSTrainParameters\n",
+        "\n",
+        "model_explainability = True\n",
+        "\n",
+        "engineered_explanations = False\n",
+        "# Define your hierarchy. Adjust the settings below based on your dataset.\n",
+        "hierarchy = [\"state\", \"store_id\", \"product_category\", \"SKU\"]\n",
+        "training_level = \"SKU\"\n",
+        "\n",
+        "# Set your forecast parameters. Adjust the settings below based on your dataset.\n",
+        "time_column_name = \"date\"\n",
+        "label_column_name = \"quantity\"\n",
+        "forecast_horizon = 7\n",
+        "\n",
+        "\n",
+        "automl_settings = {\n",
+        "    \"task\": \"forecasting\",\n",
+        "    \"primary_metric\": \"normalized_root_mean_squared_error\",\n",
+        "    \"label_column_name\": label_column_name,\n",
+        "    \"time_column_name\": time_column_name,\n",
+        "    \"forecast_horizon\": forecast_horizon,\n",
+        "    \"hierarchy_column_names\": hierarchy,\n",
+        "    \"hierarchy_training_level\": training_level,\n",
+        "    \"track_child_runs\": False,\n",
+        "    \"pipeline_fetch_max_batch_size\": 15,\n",
+        "    \"model_explainability\": model_explainability,\n",
+        "    # The following settings are specific to this sample and should be adjusted according to your own needs.\n",
+        "    \"iteration_timeout_minutes\": 10,\n",
+        "    \"iterations\": 10,\n",
+        "    \"n_cross_validations\": 2,\n",
+        "}\n",
+        "\n",
+        "hts_parameters = HTSTrainParameters(\n",
+        "    automl_settings=automl_settings,\n",
+        "    hierarchy_column_names=hierarchy,\n",
+        "    training_level=training_level,\n",
+        "    enable_engineered_explanations=engineered_explanations,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Set up hierarchy training pipeline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Parallel run step is leveraged to train the hierarchy. To configure the ParallelRunConfig you will need to determine the appropriate number of workers and nodes for your use case. The `process_count_per_node` is based off the number of cores of the compute VM. The node_count will determine the number of master nodes to use, increasing the node count will speed up the training process.\n",
+        "\n",
+        "* **experiment:** The experiment used for training.\n",
+        "* **train_data:** The tabular dataset to be used as input to the training run.\n",
+        "* **node_count:** The number of compute nodes to be used for running the user script. We recommend to start with 3 and increase the node_count if the training time is taking too long.\n",
+        "* **process_count_per_node:** Process count per node, we recommend 2:1 ratio for number of cores: number of processes per node. eg. If node has 16 cores then configure 8 or less process count per node or optimal performance.\n",
+        "* **train_pipeline_parameters:** The set of configuration parameters defined in the previous section. \n",
+        "\n",
+        "Calling this method will create a new aggregated dataset which is generated dynamically on pipeline execution."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.automl.pipeline.steps import AutoMLPipelineBuilder\n",
+        "\n",
+        "\n",
+        "training_pipeline_steps = AutoMLPipelineBuilder.get_many_models_train_steps(\n",
+        "    experiment=experiment,\n",
+        "    train_data=registered_train,\n",
+        "    compute_target=compute_target,\n",
+        "    node_count=2,\n",
+        "    process_count_per_node=8,\n",
+        "    train_pipeline_parameters=hts_parameters,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline\n",
+        "\n",
+        "training_pipeline = Pipeline(ws, steps=training_pipeline_steps)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Submit the pipeline to run\n",
+        "Next we submit our pipeline to run. The whole training pipeline takes about 1h 11m using a Standard_D12_V2 VM with our current ParallelRunConfig setting."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "training_run = experiment.submit(training_pipeline)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "training_run.wait_for_completion(show_output=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Check the run status, if training_run is in completed state, continue to forecasting. If training_run is in another state, check the portal for failures."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### [Optional] Get the explanations\n",
+        "First we need to download the explanations to the local disk."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "if model_explainability:\n",
+        "    expl_output = training_run.get_pipeline_output(\"explanations\")\n",
+        "    expl_output.download(\"training_explanations\")\n",
+        "else:\n",
+        "    print(\n",
+        "        \"Model explanations are available only if model_explainability is set to True.\"\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The explanations are downloaded to the \"training_explanations/azureml\" directory."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "if model_explainability:\n",
+        "    explanations_dirrectory = os.listdir(\n",
+        "        os.path.join(\"training_explanations\", \"azureml\")\n",
+        "    )\n",
+        "    if len(explanations_dirrectory) > 1:\n",
+        "        print(\n",
+        "            \"Warning! The directory contains multiple explanations, only the first one will be displayed.\"\n",
+        "        )\n",
+        "    print(\"The explanations are located at {}.\".format(explanations_dirrectory[0]))\n",
+        "    # Now we will list all the explanations.\n",
+        "    explanation_path = os.path.join(\n",
+        "        \"training_explanations\",\n",
+        "        \"azureml\",\n",
+        "        explanations_dirrectory[0],\n",
+        "        \"training_explanations\",\n",
+        "    )\n",
+        "    print(\"Available explanations\")\n",
+        "    print(\"==============================\")\n",
+        "    print(\"\\n\".join(os.listdir(explanation_path)))\n",
+        "else:\n",
+        "    print(\n",
+        "        \"Model explanations are available only if model_explainability is set to True.\"\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "View the explanations on \"state\" level."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from IPython.display import display\n",
+        "\n",
+        "explanation_type = \"raw\"\n",
+        "level = \"state\"\n",
+        "\n",
+        "if model_explainability:\n",
+        "    display(\n",
+        "        pd.read_csv(\n",
+        "            os.path.join(explanation_path, \"{}_explanations_{}.csv\").format(\n",
+        "                explanation_type, level\n",
+        "            )\n",
+        "        )\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 5.0 Forecasting\n",
+        "For hierarchical forecasting we need to provide the HTSInferenceParameters object.\n",
+        "#### HTSInferenceParameters arguments\n",
+        "* **hierarchy_forecast_level:** The default level of the hierarchy to produce prediction/forecast on.\n",
+        "* **allocation_method:** \\[Optional] The disaggregation method to use if the hierarchy forecast level specified is below the define hierarchy training level. <br><i>(average historical proportions) 'average_historical_proportions'</i><br><i>(proportions of the historical averages) 'proportions_of_historical_average'</i>\n",
+        "\n",
+        "#### get_many_models_batch_inference_steps arguments\n",
+        "* **experiment:** The experiment used for inference run.\n",
+        "* **inference_data:** The data to use for inferencing. It should be the same schema as used for training.\n",
+        "* **compute_target:** The compute target that runs the inference pipeline.\n",
+        "* **node_count:** The number of compute nodes to be used for running the user script. We recommend to start with the number of cores per node (varies by compute sku).\n",
+        "* **process_count_per_node:** The number of processes per node.\n",
+        "* **train_run_id:** \\[Optional] The run id of the hierarchy training, by default it is the latest successful training hts run in the experiment.\n",
+        "* **train_experiment_name:** \\[Optional] The train experiment that contains the train pipeline. This one is only needed when the train pipeline is not in the same experiement as the inference pipeline.\n",
+        "* **process_count_per_node:** \\[Optional] The number of processes per node, by default it's 4."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.train.automl.runtime._hts.hts_parameters import HTSInferenceParameters\n",
+        "\n",
+        "inference_parameters = HTSInferenceParameters(\n",
+        "    hierarchy_forecast_level=\"store_id\",  # The setting is specific to this dataset and should be changed based on your dataset.\n",
+        "    allocation_method=\"proportions_of_historical_average\",\n",
+        ")\n",
+        "\n",
+        "steps = AutoMLPipelineBuilder.get_many_models_batch_inference_steps(\n",
+        "    experiment=experiment,\n",
+        "    inference_data=registered_inference,\n",
+        "    compute_target=compute_target,\n",
+        "    inference_pipeline_parameters=inference_parameters,\n",
+        "    node_count=2,\n",
+        "    process_count_per_node=8,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline\n",
+        "\n",
+        "inference_pipeline = Pipeline(ws, steps=steps)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "inference_run = experiment.submit(inference_pipeline)\n",
+        "inference_run.wait_for_completion(show_output=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Retrieve results\n",
+        "\n",
+        "Forecast results can be retrieved through the following code. The prediction results summary and the actual predictions are downloaded the \"forecast_results\" folder"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "forecasts = inference_run.get_pipeline_output(\"forecasts\")\n",
+        "forecasts.download(\"forecast_results\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Resbumit the Pipeline\n",
+        "\n",
+        "The inference pipeline can be submitted with different configurations."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "inference_run = experiment.submit(\n",
+        "    inference_pipeline, pipeline_parameters={\"hierarchy_forecast_level\": \"state\"}\n",
+        ")\n",
+        "inference_run.wait_for_completion(show_output=False)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "jialiu"
+      }
+    ],
+    "categories": [
+      "how-to-use-azureml",
+      "automated-machine-learning"
+    ],
+    "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": 4
+}

how-to-use-azureml/automated-machine-learning/forecasting-hierarchical-timeseries/auto-ml-forecasting-hierarchical-timeseries.yml

@@ -0,0 +1,4 @@
+name: auto-ml-forecasting-hierarchical-timeseries
+dependencies:
+- pip:
+  - azureml-sdk

how-to-use-azureml/automated-machine-learning/forecasting-many-models/auto-ml-forecasting-many-models.ipynb

@@ -0,0 +1,746 @@
+{
+  "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/forecasting-hierarchical-timeseries/auto-ml-forecasting-hierarchical-timeseries.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Many Models - Automated ML\n",
+        "**_Generate many models time series forecasts with Automated Machine Learning_**\n",
+        "\n",
+        "---"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "For this notebook we are using a synthetic dataset portraying sales data to predict the the quantity of a vartiety of product skus across several states, stores, and product categories.\n",
+        "\n",
+        "**NOTE: There are limits on how many runs we can do in parallel per workspace, and we currently recommend to set the parallelism to maximum of 320 runs per experiment per workspace. If users want to have more parallelism and increase this limit they might encounter Too Many Requests errors (HTTP 429).**"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Prerequisites\n",
+        "You'll need to create a compute Instance by following the instructions in the [EnvironmentSetup.md](../Setup_Resources/EnvironmentSetup.md)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 1.0 Set up workspace, datastore, experiment"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613003526897
+        }
+      },
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "from azureml.core import Workspace, Datastore\n",
+        "import pandas as pd\n",
+        "\n",
+        "# Set up your workspace\n",
+        "ws = Workspace.from_config()\n",
+        "ws.get_details()\n",
+        "\n",
+        "# Set up your datastores\n",
+        "dstore = ws.get_default_datastore()\n",
+        "\n",
+        "output = {}\n",
+        "output[\"SDK version\"] = azureml.core.VERSION\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
+        "output[\"Workspace\"] = ws.name\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
+        "output[\"Location\"] = ws.location\n",
+        "output[\"Default datastore name\"] = dstore.name\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
+        "outputDf.T"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Choose an experiment"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613003540729
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.core import Experiment\n",
+        "\n",
+        "experiment = Experiment(ws, \"automl-many-models\")\n",
+        "\n",
+        "print(\"Experiment name: \" + experiment.name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 2.0 Data\n",
+        "\n",
+        "This notebook uses simulated orange juice sales data to walk you through the process of training many models on Azure Machine Learning using Automated ML. \n",
+        "\n",
+        "The time series data used in this example was simulated based on the University of Chicago's Dominick's Finer Foods dataset which featured two years of sales of 3 different orange juice brands for individual stores. The full simulated dataset includes 3,991 stores with 3 orange juice brands each thus allowing 11,973 models to be trained to showcase the power of the many models pattern.\n",
+        "\n",
+        "  \n",
+        "In this notebook, two datasets will be created: one with all 11,973 files and one with only 10 files that can be used to quickly test and debug. For each dataset, you'll be walked through the process of:\n",
+        "\n",
+        "1. Registering the blob container as a Datastore to the Workspace\n",
+        "2. Registering a tabular dataset to the Workspace"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "source": [
+        "### 2.1 Data Preparation\n",
+        "The OJ data is available in the public blob container. The data is split to be used for training and for inferencing. For the current dataset, the data was split on time column ('WeekStarting') before and after '1992-5-28' .\n",
+        "\n",
+        "The container has\n",
+        "<ol>\n",
+        "    <li><b>'oj-data-tabular'</b> and <b>'oj-inference-tabular'</b> folders that contains training and inference data respectively for the 11,973 models. </li>\n",
+        "    <li>It also has <b>'oj-data-small-tabular'</b> and <b>'oj-inference-small-tabular'</b> folders that has training and inference data for 10 models.</li>\n",
+        "</ol>\n",
+        "\n",
+        "To create the [TabularDataset](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.tabular_dataset.tabulardataset?view=azure-ml-py) needed for the ParallelRunStep, you first need to register the blob container to the workspace."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "nteract": {
+          "transient": {
+            "deleting": false
+          }
+        }
+      },
+      "source": [
+        "<b> To use your own data, put your own data in a blobstore folder. As shown it can be one file or multiple files. We can then register datastore using that blob as shown below.\n",
+        "    \n",
+        "<h3> How sample data in blob store looks like</h3>\n",
+        "\n",
+        "['oj-data-tabular'](https://ms.portal.azure.com/#blade/Microsoft_Azure_Storage/ContainerMenuBlade/overview/storageAccountId/%2Fsubscriptions%2F102a16c3-37d3-48a8-9237-4c9b1e8e80e0%2FresourceGroups%2FAutoMLSampleNotebooksData%2Fproviders%2FMicrosoft.Storage%2FstorageAccounts%2Fautomlsamplenotebookdata/path/automl-sample-notebook-data/etag/%220x8D84EAA65DE50B7%22/defaultEncryptionScope/%24account-encryption-key/denyEncryptionScopeOverride//defaultId//publicAccessVal/Container)</b>\n",
+        "![image-4.png](mm-1.png)\n",
+        "\n",
+        "['oj-inference-tabular'](https://ms.portal.azure.com/#blade/Microsoft_Azure_Storage/ContainerMenuBlade/overview/storageAccountId/%2Fsubscriptions%2F102a16c3-37d3-48a8-9237-4c9b1e8e80e0%2FresourceGroups%2FAutoMLSampleNotebooksData%2Fproviders%2FMicrosoft.Storage%2FstorageAccounts%2Fautomlsamplenotebookdata/path/automl-sample-notebook-data/etag/%220x8D84EAA65DE50B7%22/defaultEncryptionScope/%24account-encryption-key/denyEncryptionScopeOverride//defaultId//publicAccessVal/Container)\n",
+        "![image-3.png](mm-2.png)\n",
+        "\n",
+        "['oj-data-small-tabular'](https://ms.portal.azure.com/#blade/Microsoft_Azure_Storage/ContainerMenuBlade/overview/storageAccountId/%2Fsubscriptions%2F102a16c3-37d3-48a8-9237-4c9b1e8e80e0%2FresourceGroups%2FAutoMLSampleNotebooksData%2Fproviders%2FMicrosoft.Storage%2FstorageAccounts%2Fautomlsamplenotebookdata/path/automl-sample-notebook-data/etag/%220x8D84EAA65DE50B7%22/defaultEncryptionScope/%24account-encryption-key/denyEncryptionScopeOverride//defaultId//publicAccessVal/Container)\n",
+        "\n",
+        "![image-5.png](mm-3.png)\n",
+        "\n",
+        "['oj-inference-small-tabular'](https://ms.portal.azure.com/#blade/Microsoft_Azure_Storage/ContainerMenuBlade/overview/storageAccountId/%2Fsubscriptions%2F102a16c3-37d3-48a8-9237-4c9b1e8e80e0%2FresourceGroups%2FAutoMLSampleNotebooksData%2Fproviders%2FMicrosoft.Storage%2FstorageAccounts%2Fautomlsamplenotebookdata/path/automl-sample-notebook-data/etag/%220x8D84EAA65DE50B7%22/defaultEncryptionScope/%24account-encryption-key/denyEncryptionScopeOverride//defaultId//publicAccessVal/Container)\n",
+        "![image-6.png](mm-4.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### 2.2 Register the blob container as DataStore\n",
+        "\n",
+        "A Datastore is a place where data can be stored that is then made accessible to a compute either by means of mounting or copying the data to the compute target.\n",
+        "\n",
+        "Please refer to [Datastore](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.datastore(class)?view=azure-ml-py) documentation on how to access data from Datastore.\n",
+        "\n",
+        "In this next step, we will be registering blob storage as datastore to the Workspace."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Datastore\n",
+        "\n",
+        "# Please change the following to point to your own blob container and pass in account_key\n",
+        "blob_datastore_name = \"automl_many_models\"\n",
+        "container_name = \"automl-sample-notebook-data\"\n",
+        "account_name = \"automlsamplenotebookdata\"\n",
+        "\n",
+        "oj_datastore = Datastore.register_azure_blob_container(\n",
+        "    workspace=ws,\n",
+        "    datastore_name=blob_datastore_name,\n",
+        "    container_name=container_name,\n",
+        "    account_name=account_name,\n",
+        "    create_if_not_exists=True,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### 2.3 Using tabular datasets \n",
+        "\n",
+        "Now that the datastore is available from the Workspace, [TabularDataset](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.tabular_dataset.tabulardataset?view=azure-ml-py) can be created. Datasets in Azure Machine Learning are references to specific data in a Datastore.  We are using TabularDataset, so that users who have their data which can be in one or many files (*.parquet or *.csv) and have not split up data according to group columns needed for training, can do so using out of box support for 'partiion_by' feature of TabularDataset shown in section 5.0 below."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613007017296
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.core import Dataset\n",
+        "\n",
+        "ds_name_small = \"oj-data-small-tabular\"\n",
+        "input_ds_small = Dataset.Tabular.from_delimited_files(\n",
+        "    path=oj_datastore.path(ds_name_small + \"/\"), validate=False\n",
+        ")\n",
+        "\n",
+        "inference_name_small = \"oj-inference-small-tabular\"\n",
+        "inference_ds_small = Dataset.Tabular.from_delimited_files(\n",
+        "    path=oj_datastore.path(inference_name_small + \"/\"), validate=False\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 3.0 Build the training pipeline\n",
+        "Now that the dataset, WorkSpace, and datastore are set up, we can put together a pipeline for training.\n",
+        "\n",
+        "> Note that if you have an AzureML Data Scientist role, you will not have permission to create compute resources. Talk to your workspace or IT admin to create the compute targets described in this section, if they do not already exist."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Choose a compute target\n",
+        "\n",
+        "You will need to create a [compute target](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-set-up-training-targets#amlcompute) for your AutoML run. In this tutorial, you create AmlCompute as your training compute resource.\n",
+        "\n",
+        "\\*\\*Creation of AmlCompute takes approximately 5 minutes.**\n",
+        "\n",
+        "If the AmlCompute with that name is already in your workspace this code will skip the creation process. 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/how-to-manage-quotas) on the default limits and how to request more quota."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613007037308
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.core.compute import ComputeTarget, AmlCompute\n",
+        "\n",
+        "# Name your cluster\n",
+        "compute_name = \"mm-compute\"\n",
+        "\n",
+        "\n",
+        "if compute_name in ws.compute_targets:\n",
+        "    compute_target = ws.compute_targets[compute_name]\n",
+        "    if compute_target and type(compute_target) is AmlCompute:\n",
+        "        print(\"Found compute target: \" + compute_name)\n",
+        "else:\n",
+        "    print(\"Creating a new compute target...\")\n",
+        "    provisioning_config = AmlCompute.provisioning_configuration(\n",
+        "        vm_size=\"STANDARD_D16S_V3\", max_nodes=20\n",
+        "    )\n",
+        "    # Create the compute target\n",
+        "    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)\n",
+        "\n",
+        "    # Can poll for a minimum number of nodes and for a specific timeout.\n",
+        "    # If no min node count is provided it will use the scale settings for the cluster\n",
+        "    compute_target.wait_for_completion(\n",
+        "        show_output=True, min_node_count=None, timeout_in_minutes=20\n",
+        "    )\n",
+        "\n",
+        "    # For a more detailed view of current cluster status, use the 'status' property\n",
+        "    print(compute_target.status.serialize())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Set up training parameters\n",
+        "\n",
+        "This dictionary defines the AutoML and many models settings. For this forecasting task we need to define several settings inncluding the name of the time column, the maximum forecast horizon, and the partition column name definition.\n",
+        "\n",
+        "| Property                           | Description|\n",
+        "| :---------------                   | :------------------- |\n",
+        "| **task**                           | forecasting |\n",
+        "| **primary_metric**                 | This is the metric that you want to optimize.<br> Forecasting supports the following primary metrics <br><i>spearman_correlation</i><br><i>normalized_root_mean_squared_error</i><br><i>r2_score</i><br><i>normalized_mean_absolute_error</i> |\n",
+        "| **blocked_models**                 | Blocked models won't be used by AutoML. |\n",
+        "| **iteration_timeout_minutes**      | Maximum amount of time in minutes that the model can train. This is optional but provides customers with greater control on exit criteria. |\n",
+        "| **iterations**                     | Number of models to train. This is optional but provides customers with greater control on exit criteria. |\n",
+        "| **experiment_timeout_hours**       | Maximum amount of time in hours that the experiment can take before it terminates. This is optional but provides customers with greater control on exit criteria. |\n",
+        "| **label_column_name**              | The name of the label column. |\n",
+        "| **forecast_horizon**               | The forecast horizon is how many periods forward you would like to forecast. This integer horizon is in units of the timeseries frequency (e.g. daily, weekly). Periods are inferred from your data. |\n",
+        "| **n_cross_validations**            | Number of cross validation splits. Rolling Origin Validation is used to split time-series in a temporally consistent way. |\n",
+        "| **enable_early_stopping**          | Flag to enable early termination if the score is not improving in the short term. |\n",
+        "| **time_column_name**               | The name of your time column. |\n",
+        "| **enable_engineered_explanations** | Engineered feature explanations will be downloaded if enable_engineered_explanations flag is set to True. By default it is set to False to save storage space. |\n",
+        "| **time_series_id_column_name**     | The column names used to uniquely identify timeseries in data that has multiple rows with the same timestamp. |\n",
+        "| **track_child_runs**               | Flag to disable tracking of child runs. Only best run is tracked if the flag is set to False (this includes the model and metrics of the run). |\n",
+        "| **pipeline_fetch_max_batch_size**  | Determines how many pipelines (training algorithms) to fetch at a time for training, this helps reduce throttling when training at large scale. |\n",
+        "| **partition_column_names**         | The names of columns used to group your models. For timeseries, the groups must not split up individual time-series. That is, each group must contain one or more whole time-series. |"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gather": {
+          "logged": 1613007061544
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from azureml.train.automl.runtime._many_models.many_models_parameters import (\n",
+        "    ManyModelsTrainParameters,\n",
+        ")\n",
+        "\n",
+        "partition_column_names = [\"Store\", \"Brand\"]\n",
+        "automl_settings = {\n",
+        "    \"task\": \"forecasting\",\n",
+        "    \"primary_metric\": \"normalized_root_mean_squared_error\",\n",
+        "    \"iteration_timeout_minutes\": 10,  # This needs to be changed based on the dataset. We ask customer to explore how long training is taking before settings this value\n",
+        "    \"iterations\": 15,\n",
+        "    \"experiment_timeout_hours\": 0.25,\n",
+        "    \"label_column_name\": \"Quantity\",\n",
+        "    \"n_cross_validations\": 3,\n",
+        "    \"time_column_name\": \"WeekStarting\",\n",
+        "    \"drop_column_names\": \"Revenue\",\n",
+        "    \"max_horizon\": 6,\n",
+        "    \"grain_column_names\": partition_column_names,\n",
+        "    \"track_child_runs\": False,\n",
+        "}\n",
+        "\n",
+        "mm_paramters = ManyModelsTrainParameters(\n",
+        "    automl_settings=automl_settings, partition_column_names=partition_column_names\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Set up many models pipeline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Parallel run step is leveraged to train multiple models at once. To configure the ParallelRunConfig you will need to determine the appropriate number of workers and nodes for your use case. The process_count_per_node is based off the number of cores of the compute VM. The node_count will determine the number of master nodes to use, increasing the node count will speed up the training process.\n",
+        "\n",
+        "| Property                           | Description|\n",
+        "| :---------------                   | :------------------- |\n",
+        "| **experiment**                     | The experiment used for training. |\n",
+        "| **train_data**                     | The file dataset to be used as input to the training run. |\n",
+        "| **node_count**                     | The number of compute nodes to be used for running the user script. We recommend to start with 3 and increase the node_count if the training time is taking too long. |\n",
+        "| **process_count_per_node**         | Process count per node, we recommend 2:1 ratio for number of cores: number of processes per node. eg. If node has 16 cores then configure 8 or less process count per node or optimal performance. |\n",
+        "| **train_pipeline_parameters**      | The set of configuration parameters defined in the previous section. |\n",
+        "\n",
+        "Calling this method will create a new aggregated dataset which is generated dynamically on pipeline execution."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.automl.pipeline.steps import AutoMLPipelineBuilder\n",
+        "\n",
+        "\n",
+        "training_pipeline_steps = AutoMLPipelineBuilder.get_many_models_train_steps(\n",
+        "    experiment=experiment,\n",
+        "    train_data=input_ds_small,\n",
+        "    compute_target=compute_target,\n",
+        "    node_count=2,\n",
+        "    process_count_per_node=8,\n",
+        "    run_invocation_timeout=920,\n",
+        "    train_pipeline_parameters=mm_paramters,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline\n",
+        "\n",
+        "training_pipeline = Pipeline(ws, steps=training_pipeline_steps)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Submit the pipeline to run\n",
+        "Next we submit our pipeline to run. The whole training pipeline takes about 40m using a STANDARD_D16S_V3 VM with our current ParallelRunConfig setting."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "training_run = experiment.submit(training_pipeline)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "training_run.wait_for_completion(show_output=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Check the run status, if training_run is in completed state, continue to forecasting. If training_run is in another state, check the portal for failures."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 5.0 Publish and schedule the train pipeline (Optional)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 5.1 Publish the pipeline\n",
+        "\n",
+        "Once you have a pipeline you're happy with, you can publish a pipeline so you can call it programmatically later on. See this [tutorial](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-create-your-first-pipeline#publish-a-pipeline) for additional information on publishing and calling pipelines."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# published_pipeline = training_pipeline.publish(name = 'automl_train_many_models',\n",
+        "#                                                description = 'train many models',\n",
+        "#                                                version = '1',\n",
+        "#                                                continue_on_step_failure = False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 7.2 Schedule the pipeline\n",
+        "You can also [schedule the pipeline](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-schedule-pipelines) to run on a time-based or change-based schedule. This could be used to automatically retrain models every month or based on another trigger such as data drift."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# from azureml.pipeline.core import Schedule, ScheduleRecurrence\n",
+        "\n",
+        "# training_pipeline_id = published_pipeline.id\n",
+        "\n",
+        "# recurrence = ScheduleRecurrence(frequency=\"Month\", interval=1, start_time=\"2020-01-01T09:00:00\")\n",
+        "# recurring_schedule = Schedule.create(ws, name=\"automl_training_recurring_schedule\",\n",
+        "#                                      description=\"Schedule Training Pipeline to run on the first day of every month\",\n",
+        "#                                      pipeline_id=training_pipeline_id,\n",
+        "#                                      experiment_name=experiment.name,\n",
+        "#                                      recurrence=recurrence)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 6.0 Forecasting"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Set up output dataset for inference data\n",
+        "Output of inference can be represented as [OutputFileDatasetConfig](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.data.output_dataset_config.outputdatasetconfig?view=azure-ml-py) object and OutputFileDatasetConfig can be registered as a dataset. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.data import OutputFileDatasetConfig\n",
+        "\n",
+        "output_inference_data_ds = OutputFileDatasetConfig(\n",
+        "    name=\"many_models_inference_output\", destination=(dstore, \"oj/inference_data/\")\n",
+        ").register_on_complete(name=\"oj_inference_data_ds\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "For many models we need to provide the ManyModelsInferenceParameters object.\n",
+        "\n",
+        "#### ManyModelsInferenceParameters arguments\n",
+        "| Property                           | Description|\n",
+        "| :---------------                   | :------------------- |\n",
+        "| **partition_column_names**         | List of column names that identifies groups.                                           |\n",
+        "| **target_column_name**             | \\[Optional] Column name only if the inference dataset has the target. |\n",
+        "| **time_column_name**               | \\[Optional] Column name only if it is timeseries. |\n",
+        "| **many_models_run_id**             | \\[Optional] Many models run id where models were trained. |\n",
+        "\n",
+        "#### get_many_models_batch_inference_steps arguments\n",
+        "| Property                           | Description|\n",
+        "| :---------------                   | :------------------- |\n",
+        "| **experiment**                     | The experiment used for inference run. |\n",
+        "| **inference_data**                 | The data to use for inferencing. It should be the same schema as used for training.\n",
+        "| **compute_target** The compute target that runs the inference pipeline.|\n",
+        "| **node_count**                     | The number of compute nodes to be used for running the user script. We recommend to start with the number of cores per node (varies by compute sku). |\n",
+        "| **process_count_per_node** The number of processes per node.\n",
+        "| **train_run_id**                   | \\[Optional] The run id of the hierarchy training, by default it is the latest successful training many model run in the experiment. |\n",
+        "| **train_experiment_name**          | \\[Optional] The train experiment that contains the train pipeline. This one is only needed when the train pipeline is not in the same experiement as the inference pipeline. |\n",
+        "| **process_count_per_node**         | \\[Optional] The number of processes per node, by default it's 4. |"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.automl.pipeline.steps import AutoMLPipelineBuilder\n",
+        "from azureml.train.automl.runtime._many_models.many_models_parameters import (\n",
+        "    ManyModelsInferenceParameters,\n",
+        ")\n",
+        "\n",
+        "mm_parameters = ManyModelsInferenceParameters(\n",
+        "    partition_column_names=[\"Store\", \"Brand\"],\n",
+        "    time_column_name=\"WeekStarting\",\n",
+        "    target_column_name=\"Quantity\",\n",
+        ")\n",
+        "\n",
+        "inference_steps = AutoMLPipelineBuilder.get_many_models_batch_inference_steps(\n",
+        "    experiment=experiment,\n",
+        "    inference_data=inference_ds_small,\n",
+        "    node_count=2,\n",
+        "    process_count_per_node=8,\n",
+        "    compute_target=compute_target,\n",
+        "    run_invocation_timeout=300,\n",
+        "    output_datastore=output_inference_data_ds,\n",
+        "    train_run_id=training_run.id,\n",
+        "    train_experiment_name=training_run.experiment.name,\n",
+        "    inference_pipeline_parameters=mm_parameters,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline\n",
+        "\n",
+        "inference_pipeline = Pipeline(ws, steps=inference_steps)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "inference_run = experiment.submit(inference_pipeline)\n",
+        "inference_run.wait_for_completion(show_output=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Retrieve results\n",
+        "\n",
+        "The forecasting pipeline forecasts the orange juice quantity for a Store by Brand. The pipeline returns one file with the predictions for each store and outputs the result to the forecasting_output Blob container. The details of the blob container is listed in 'forecasting_output.txt' under Outputs+logs. \n",
+        "\n",
+        "The following code snippet:\n",
+        "1. Downloads the contents of the output folder that is passed in the parallel run step \n",
+        "2. Reads the parallel_run_step.txt file that has the predictions as pandas dataframe and \n",
+        "3. Displays the top 10 rows of the predictions"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.contrib.automl.pipeline.steps.utilities import get_output_from_mm_pipeline\n",
+        "\n",
+        "forecasting_results_name = \"forecasting_results\"\n",
+        "forecasting_output_name = \"many_models_inference_output\"\n",
+        "forecast_file = get_output_from_mm_pipeline(\n",
+        "    inference_run, forecasting_results_name, forecasting_output_name\n",
+        ")\n",
+        "df = pd.read_csv(forecast_file, delimiter=\" \", header=None)\n",
+        "df.columns = [\n",
+        "    \"Week Starting\",\n",
+        "    \"Store\",\n",
+        "    \"Brand\",\n",
+        "    \"Quantity\",\n",
+        "    \"Advert\",\n",
+        "    \"Price\",\n",
+        "    \"Revenue\",\n",
+        "    \"Predicted\",\n",
+        "]\n",
+        "print(\n",
+        "    \"Prediction has \", df.shape[0], \" rows. Here the first 10 rows are being displayed.\"\n",
+        ")\n",
+        "df.head(10)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 7.0 Publish and schedule the inference pipeline (Optional)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 7.1 Publish the pipeline\n",
+        "\n",
+        "Once you have a pipeline you're happy with, you can publish a pipeline so you can call it programmatically later on. See this [tutorial](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-create-your-first-pipeline#publish-a-pipeline) for additional information on publishing and calling pipelines."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# published_pipeline_inf = inference_pipeline.publish(name = 'automl_forecast_many_models',\n",
+        "#                                                     description = 'forecast many models',\n",
+        "#                                                     version = '1',\n",
+        "#                                                     continue_on_step_failure = False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 7.2 Schedule the pipeline\n",
+        "You can also [schedule the pipeline](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-schedule-pipelines) to run on a time-based or change-based schedule. This could be used to automatically retrain or forecast models every month or based on another trigger such as data drift."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# from azureml.pipeline.core import Schedule, ScheduleRecurrence\n",
+        "\n",
+        "# forecasting_pipeline_id = published_pipeline.id\n",
+        "\n",
+        "# recurrence = ScheduleRecurrence(frequency=\"Month\", interval=1, start_time=\"2020-01-01T09:00:00\")\n",
+        "# recurring_schedule = Schedule.create(ws, name=\"automl_forecasting_recurring_schedule\",\n",
+        "#                             description=\"Schedule Forecasting Pipeline to run on the first day of every week\",\n",
+        "#                             pipeline_id=forecasting_pipeline_id,\n",
+        "#                             experiment_name=experiment.name,\n",
+        "#                             recurrence=recurrence)"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "jialiu"
+      }
+    ],
+    "categories": [
+      "how-to-use-azureml",
+      "automated-machine-learning"
+    ],
+    "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": 4
+}

how-to-use-azureml/automated-machine-learning/forecasting-many-models/auto-ml-forecasting-many-models.yml

@@ -0,0 +1,4 @@
+name: auto-ml-forecasting-many-models
+dependencies:
+- pip:
+  - azureml-sdk

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

@@ -81,7 +81,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -101,19 +101,19 @@
         "ws = Workspace.from_config()\n",
         "\n",
         "# choose a name for the run history container in the workspace\n",
-        "experiment_name = 'automl-ojforecasting'\n",
+        "experiment_name = \"automl-ojforecasting\"\n",
         "\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
         "output = {}\n",
-        "output['Subscription ID'] = ws.subscription_id\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
-        "output['Workspace'] = ws.name\n",
+        "output[\"Workspace\"] = ws.name\n",
-        "output['SKU'] = ws.sku\n",
+        "output[\"SKU\"] = ws.sku\n",
-        "output['Resource Group'] = ws.resource_group\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
-        "output['Location'] = ws.location\n",
+        "output[\"Location\"] = ws.location\n",
-        "output['Run History Name'] = experiment_name\n",
+        "output[\"Run History Name\"] = experiment_name\n",
-        "pd.set_option('display.max_colwidth', -1)\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
         "outputDf.T"
       ]
     },
@@ -146,10 +146,11 @@
         "# Verify that cluster does not exist already\n",
         "try:\n",
         "    compute_target = ComputeTarget(workspace=ws, name=amlcompute_cluster_name)\n",
-        "    print('Found existing cluster, use it.')\n",
+        "    print(\"Found existing cluster, use it.\")\n",
         "except ComputeTargetException:\n",
-        "    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D12_V2',\n",
+        "    compute_config = AmlCompute.provisioning_configuration(\n",
-        "                                                           max_nodes=6)\n",
+        "        vm_size=\"STANDARD_D12_V2\", max_nodes=6\n",
+        "    )\n",
         "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, compute_config)\n",
         "\n",
         "compute_target.wait_for_completion(show_output=True)"
@@ -169,11 +170,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "time_column_name = 'WeekStarting'\n",
+        "time_column_name = \"WeekStarting\"\n",
         "data = pd.read_csv(\"dominicks_OJ.csv\", parse_dates=[time_column_name])\n",
         "\n",
         "# Drop the columns 'logQuantity' as it is a leaky feature.\n",
-        "data.drop('logQuantity', axis=1, inplace=True)\n",
+        "data.drop(\"logQuantity\", axis=1, inplace=True)\n",
         "\n",
         "data.head()"
       ]
@@ -193,9 +194,9 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "time_series_id_column_names = ['Store', 'Brand']\n",
+        "time_series_id_column_names = [\"Store\", \"Brand\"]\n",
         "nseries = data.groupby(time_series_id_column_names).ngroups\n",
-        "print('Data contains {0} individual time-series.'.format(nseries))"
+        "print(\"Data contains {0} individual time-series.\".format(nseries))"
       ]
     },
     {
@@ -214,7 +215,7 @@
         "use_stores = [2, 5, 8]\n",
         "data_subset = data[data.Store.isin(use_stores)]\n",
         "nseries = data_subset.groupby(time_series_id_column_names).ngroups\n",
-        "print('Data subset contains {0} individual time-series.'.format(nseries))"
+        "print(\"Data subset contains {0} individual time-series.\".format(nseries))"
       ]
     },
     {
@@ -233,14 +234,17 @@
       "source": [
         "n_test_periods = 20\n",
         "\n",
+        "\n",
         "def split_last_n_by_series_id(df, n):\n",
         "    \"\"\"Group df by series identifiers and split on last n rows for each group.\"\"\"\n",
-        "    df_grouped = (df.sort_values(time_column_name) # Sort by ascending time\n",
+        "    df_grouped = df.sort_values(time_column_name).groupby(  # Sort by ascending time\n",
-        "                  .groupby(time_series_id_column_names, group_keys=False))\n",
+        "        time_series_id_column_names, group_keys=False\n",
+        "    )\n",
         "    df_head = df_grouped.apply(lambda dfg: dfg.iloc[:-n])\n",
         "    df_tail = df_grouped.apply(lambda dfg: dfg.iloc[-n:])\n",
         "    return df_head, df_tail\n",
         "\n",
+        "\n",
         "train, test = split_last_n_by_series_id(data_subset, n_test_periods)"
       ]
     },
@@ -258,8 +262,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "train.to_csv (r'./dominicks_OJ_train.csv', index = None, header=True)\n",
+        "train.to_csv(r\"./dominicks_OJ_train.csv\", index=None, header=True)\n",
-        "test.to_csv (r'./dominicks_OJ_test.csv', index = None, header=True)"
+        "test.to_csv(r\"./dominicks_OJ_test.csv\", index=None, header=True)"
       ]
     },
     {
@@ -269,7 +273,12 @@
       "outputs": [],
       "source": [
         "datastore = ws.get_default_datastore()\n",
-        "datastore.upload_files(files = ['./dominicks_OJ_train.csv', './dominicks_OJ_test.csv'], target_path = 'dataset/', overwrite = True,show_progress = True)"
+        "datastore.upload_files(\n",
+        "    files=[\"./dominicks_OJ_train.csv\", \"./dominicks_OJ_test.csv\"],\n",
+        "    target_path=\"dataset/\",\n",
+        "    overwrite=True,\n",
+        "    show_progress=True,\n",
+        ")"
       ]
     },
     {
@@ -286,8 +295,13 @@
       "outputs": [],
       "source": [
         "from azureml.core.dataset import Dataset\n",
-        "train_dataset = Dataset.Tabular.from_delimited_files(path=datastore.path('dataset/dominicks_OJ_train.csv'))\n",
+        "\n",
-        "test_dataset = Dataset.Tabular.from_delimited_files(path=datastore.path('dataset/dominicks_OJ_test.csv'))"
+        "train_dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=datastore.path(\"dataset/dominicks_OJ_train.csv\")\n",
+        ")\n",
+        "test_dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=datastore.path(\"dataset/dominicks_OJ_test.csv\")\n",
+        ")"
       ]
     },
     {
@@ -323,7 +337,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "target_column_name = 'Quantity'"
+        "target_column_name = \"Quantity\""
       ]
     },
     {
@@ -351,13 +365,17 @@
       "source": [
         "featurization_config = FeaturizationConfig()\n",
         "# Force the CPWVOL5 feature to be numeric type.\n",
-        "featurization_config.add_column_purpose('CPWVOL5', 'Numeric')\n",
+        "featurization_config.add_column_purpose(\"CPWVOL5\", \"Numeric\")\n",
         "# Fill missing values in the target column, Quantity, with zeros.\n",
-        "featurization_config.add_transformer_params('Imputer', ['Quantity'], {\"strategy\": \"constant\", \"fill_value\": 0})\n",
+        "featurization_config.add_transformer_params(\n",
+        "    \"Imputer\", [\"Quantity\"], {\"strategy\": \"constant\", \"fill_value\": 0}\n",
+        ")\n",
         "# Fill missing values in the INCOME column with median value.\n",
-        "featurization_config.add_transformer_params('Imputer', ['INCOME'], {\"strategy\": \"median\"})\n",
+        "featurization_config.add_transformer_params(\n",
+        "    \"Imputer\", [\"INCOME\"], {\"strategy\": \"median\"}\n",
+        ")\n",
         "# Fill missing values in the Price column with forward fill (last value carried forward).\n",
-        "featurization_config.add_transformer_params('Imputer', ['Price'], {\"strategy\": \"ffill\"})"
+        "featurization_config.add_transformer_params(\"Imputer\", [\"Price\"], {\"strategy\": \"ffill\"})"
       ]
     },
     {
@@ -423,16 +441,18 @@
       "outputs": [],
       "source": [
         "from azureml.automl.core.forecasting_parameters import ForecastingParameters\n",
+        "\n",
         "forecasting_parameters = ForecastingParameters(\n",
         "    time_column_name=time_column_name,\n",
         "    forecast_horizon=n_test_periods,\n",
         "    time_series_id_column_names=time_series_id_column_names,\n",
-        "    freq='W-THU' # Set the forecast frequency to be weekly (start on each Thursday)\n",
+        "    freq=\"W-THU\",  # Set the forecast frequency to be weekly (start on each Thursday)\n",
         ")\n",
         "\n",
-        "automl_config = AutoMLConfig(task='forecasting',\n",
+        "automl_config = AutoMLConfig(\n",
-        "                             debug_log='automl_oj_sales_errors.log',\n",
+        "    task=\"forecasting\",\n",
-        "                             primary_metric='normalized_mean_absolute_error',\n",
+        "    debug_log=\"automl_oj_sales_errors.log\",\n",
+        "    primary_metric=\"normalized_mean_absolute_error\",\n",
         "    experiment_timeout_hours=0.25,\n",
         "    training_data=train_dataset,\n",
         "    label_column_name=target_column_name,\n",
@@ -442,7 +462,8 @@
         "    n_cross_validations=3,\n",
         "    verbosity=logging.INFO,\n",
         "    max_cores_per_iteration=-1,\n",
-        "                             forecasting_parameters=forecasting_parameters)"
+        "    forecasting_parameters=forecasting_parameters,\n",
+        ")"
       ]
     },
     {
@@ -487,7 +508,7 @@
       "source": [
         "best_run, fitted_model = remote_run.get_output()\n",
         "print(fitted_model.steps)\n",
-        "model_name = best_run.properties['model_name']"
+        "model_name = best_run.properties[\"model_name\"]"
       ]
     },
     {
@@ -505,7 +526,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "custom_featurizer = fitted_model.named_steps['timeseriestransformer']"
+        "custom_featurizer = fitted_model.named_steps[\"timeseriestransformer\"]"
       ]
     },
     {
@@ -559,15 +580,18 @@
       "outputs": [],
       "source": [
         "from run_forecast import run_remote_inference\n",
-        "remote_run_infer = run_remote_inference(test_experiment=test_experiment, \n",
+        "\n",
+        "remote_run_infer = run_remote_inference(\n",
+        "    test_experiment=test_experiment,\n",
         "    compute_target=compute_target,\n",
         "    train_run=best_run,\n",
         "    test_dataset=test_dataset,\n",
-        "                                        target_column_name=target_column_name)\n",
+        "    target_column_name=target_column_name,\n",
+        ")\n",
         "remote_run_infer.wait_for_completion(show_output=False)\n",
         "\n",
         "# download the forecast file to the local machine\n",
-        "remote_run_infer.download_file('outputs/predictions.csv', 'predictions.csv')"
+        "remote_run_infer.download_file(\"outputs/predictions.csv\", \"predictions.csv\")"
       ]
     },
     {
@@ -588,7 +612,7 @@
       "outputs": [],
       "source": [
         "# load forecast data frame\n",
-        "fcst_df = pd.read_csv('predictions.csv', parse_dates=[time_column_name])\n",
+        "fcst_df = pd.read_csv(\"predictions.csv\", parse_dates=[time_column_name])\n",
         "fcst_df.head()"
       ]
     },
@@ -605,18 +629,23 @@
         "# use automl scoring module\n",
         "scores = scoring.score_regression(\n",
         "    y_test=fcst_df[target_column_name],\n",
-        "    y_pred=fcst_df['predicted'],\n",
+        "    y_pred=fcst_df[\"predicted\"],\n",
-        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET))\n",
+        "    metrics=list(constants.Metric.SCALAR_REGRESSION_SET),\n",
+        ")\n",
         "\n",
         "print(\"[Test data scores]\\n\")\n",
         "for key, value in scores.items():\n",
-        "    print('{}:   {:.3f}'.format(key, value))\n",
+        "    print(\"{}:   {:.3f}\".format(key, value))\n",
         "\n",
         "# Plot outputs\n",
         "%matplotlib inline\n",
-        "test_pred = plt.scatter(fcst_df[target_column_name], fcst_df['predicted'], color='b')\n",
+        "test_pred = plt.scatter(fcst_df[target_column_name], fcst_df[\"predicted\"], color=\"b\")\n",
-        "test_test = plt.scatter(fcst_df[target_column_name], fcst_df[target_column_name], color='g')\n",
+        "test_test = plt.scatter(\n",
-        "plt.legend((test_pred, test_test), ('prediction', 'truth'), loc='upper left', fontsize=8)\n",
+        "    fcst_df[target_column_name], fcst_df[target_column_name], color=\"g\"\n",
+        ")\n",
+        "plt.legend(\n",
+        "    (test_pred, test_test), (\"prediction\", \"truth\"), loc=\"upper left\", fontsize=8\n",
+        ")\n",
         "plt.show()"
       ]
     },
@@ -640,9 +669,11 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "description = 'AutoML OJ forecaster'\n",
+        "description = \"AutoML OJ forecaster\"\n",
         "tags = None\n",
-        "model = remote_run.register_model(model_name = model_name, description = description, tags = tags)\n",
+        "model = remote_run.register_model(\n",
+        "    model_name=model_name, description=description, tags=tags\n",
+        ")\n",
         "\n",
         "print(remote_run.model_id)"
       ]
@@ -662,8 +693,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "script_file_name = 'score_fcast.py'\n",
+        "script_file_name = \"score_fcast.py\"\n",
-        "best_run.download_file('outputs/scoring_file_v_1_0_0.py', script_file_name)"
+        "best_run.download_file(\"outputs/scoring_file_v_1_0_0.py\", script_file_name)"
       ]
     },
     {
@@ -684,15 +715,18 @@
         "from azureml.core.webservice import Webservice\n",
         "from azureml.core.model import Model\n",
         "\n",
-        "inference_config = InferenceConfig(environment = best_run.get_environment(), \n",
+        "inference_config = InferenceConfig(\n",
-        "                                   entry_script = script_file_name)\n",
+        "    environment=best_run.get_environment(), entry_script=script_file_name\n",
+        ")\n",
         "\n",
-        "aciconfig = AciWebservice.deploy_configuration(cpu_cores = 2, \n",
+        "aciconfig = AciWebservice.deploy_configuration(\n",
+        "    cpu_cores=2,\n",
         "    memory_gb=4,\n",
-        "                                               tags = {'type': \"automl-forecasting\"},\n",
+        "    tags={\"type\": \"automl-forecasting\"},\n",
-        "                                               description = \"Automl forecasting sample service\")\n",
+        "    description=\"Automl forecasting sample service\",\n",
+        ")\n",
         "\n",
-        "aci_service_name = 'automl-oj-forecast-01'\n",
+        "aci_service_name = \"automl-oj-forecast-01\"\n",
         "print(aci_service_name)\n",
         "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig)\n",
         "aci_service.wait_for_deployment(True)\n",
@@ -722,20 +756,27 @@
       "outputs": [],
       "source": [
         "import json\n",
+        "\n",
         "X_query = test.copy()\n",
         "X_query.pop(target_column_name)\n",
         "# We have to convert datetime to string, because Timestamps cannot be serialized to JSON.\n",
         "X_query[time_column_name] = X_query[time_column_name].astype(str)\n",
         "# The Service object accept the complex dictionary, which is internally converted to JSON string.\n",
         "# The section 'data' contains the data frame in the form of dictionary.\n",
-        "test_sample = json.dumps({\"data\": json.loads(X_query.to_json(orient=\"records\"))})\n",
+        "sample_quantiles = [0.025, 0.975]\n",
+        "test_sample = json.dumps(\n",
+        "    {\"data\": X_query.to_dict(orient=\"records\"), \"quantiles\": sample_quantiles}\n",
+        ")\n",
         "response = aci_service.run(input_data=test_sample)\n",
         "# translate from networkese to datascientese\n",
         "try:\n",
         "    res_dict = json.loads(response)\n",
-        "    y_fcst_all = pd.DataFrame(res_dict['index'])\n",
+        "    y_fcst_all = pd.DataFrame(res_dict[\"index\"])\n",
-        "    y_fcst_all[time_column_name] = pd.to_datetime(y_fcst_all[time_column_name], unit = 'ms')\n",
+        "    y_fcst_all[time_column_name] = pd.to_datetime(\n",
-        "    y_fcst_all['forecast'] = res_dict['forecast']    \n",
+        "        y_fcst_all[time_column_name], unit=\"ms\"\n",
+        "    )\n",
+        "    y_fcst_all[\"forecast\"] = res_dict[\"forecast\"]\n",
+        "    y_fcst_all[\"prediction_interval\"] = res_dict[\"prediction_interval\"]\n",
         "except:\n",
         "    print(res_dict)"
       ]
@@ -762,7 +803,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "serv = Webservice(ws, 'automl-oj-forecast-01')\n",
+        "serv = Webservice(ws, \"automl-oj-forecast-01\")\n",
         "serv.delete()  # don't do it accidentally"
       ]
     }

how-to-use-azureml/automated-machine-learning/forecasting-orange-juice-sales/forecasting_script.py

@@ -5,62 +5,20 @@ compute instance.
 """
 
 import argparse
-import pandas as pd
-import numpy as np
 from azureml.core import Dataset, Run
-from azureml.automl.core.shared.constants import TimeSeriesInternal
 from sklearn.externals import joblib
 from pandas.tseries.frequencies import to_offset
 
-
-def align_outputs(y_predicted, X_trans, X_test, y_test, target_column_name,
-                  predicted_column_name='predicted',
-                  horizon_colname='horizon_origin'):
-    """
-    Demonstrates how to get the output aligned to the inputs
-    using pandas indexes. Helps understand what happened if
-    the output's 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
-    """
-
-    if (horizon_colname in X_trans):
-        df_fcst = pd.DataFrame({predicted_column_name: y_predicted,
-                                horizon_colname: X_trans[horizon_colname]})
-    else:
-        df_fcst = pd.DataFrame({predicted_column_name: y_predicted})
-
-    # 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()
-    X_test_full[target_column_name] = y_test
-
-    # X_test_full's index 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[[target_column_name,
-                               predicted_column_name]].notnull().all(axis=1)]
-    return(clean)
-
-
 parser = argparse.ArgumentParser()
 parser.add_argument(
-    '--target_column_name', type=str, dest='target_column_name',
+    "--target_column_name",
-    help='Target Column Name')
+    type=str,
+    dest="target_column_name",
+    help="Target Column Name",
+)
 parser.add_argument(
-    '--test_dataset', type=str, dest='test_dataset',
+    "--test_dataset", type=str, dest="test_dataset", help="Test Dataset"
-    help='Test Dataset')
+)
 
 args = parser.parse_args()
 target_column_name = args.target_column_name
@@ -76,14 +34,28 @@ X_test = test_dataset.to_pandas_dataframe().reset_index(drop=True)
 y_test = X_test.pop(target_column_name).values
 
 # generate forecast
-fitted_model = joblib.load('model.pkl')
+fitted_model = joblib.load("model.pkl")
-y_predictions, X_trans = fitted_model.forecast(X_test)
+# We have default quantiles values set as below(95th percentile)
+quantiles = [0.025, 0.5, 0.975]
+predicted_column_name = "predicted"
+PI = "prediction_interval"
+fitted_model.quantiles = quantiles
+pred_quantiles = fitted_model.forecast_quantiles(X_test)
+pred_quantiles[PI] = pred_quantiles[[min(quantiles), max(quantiles)]].apply(
+    lambda x: "[{}, {}]".format(x[0], x[1]), axis=1
+)
+X_test[target_column_name] = y_test
+X_test[PI] = pred_quantiles[PI]
+X_test[predicted_column_name] = pred_quantiles[0.5]
+# drop rows where prediction or actuals are nan
+# happens because of missing actuals
+# or at edges of time due to lags/rolling windows
+clean = X_test[
+    X_test[[target_column_name, predicted_column_name]].notnull().all(axis=1)
+]
 
-# align output
+file_name = "outputs/predictions.csv"
-df_all = align_outputs(y_predictions, X_trans, X_test, y_test, target_column_name)
+export_csv = clean.to_csv(file_name, header=True, index=False)  # added Index
-
-file_name = 'outputs/predictions.csv'
-export_csv = df_all.to_csv(file_name, header=True, index=False)  # added Index
 
 # Upload the predictions into artifacts
 run.upload_file(name=file_name, path_or_stream=file_name)

how-to-use-azureml/automated-machine-learning/forecasting-orange-juice-sales/run_forecast.py

@@ -3,36 +3,47 @@ import shutil
 from azureml.core import ScriptRunConfig
 
 
-def run_remote_inference(test_experiment, compute_target, train_run,
+def run_remote_inference(
-                         test_dataset, target_column_name, inference_folder='./forecast'):
+    test_experiment,
+    compute_target,
+    train_run,
+    test_dataset,
+    target_column_name,
+    inference_folder="./forecast",
+):
     # Create local directory to copy the model.pkl and forecsting_script.py files into.
     # These files will be uploaded to and executed on the compute instance.
     os.makedirs(inference_folder, exist_ok=True)
-    shutil.copy('forecasting_script.py', inference_folder)
+    shutil.copy("forecasting_script.py", inference_folder)
 
-    train_run.download_file('outputs/model.pkl',
+    train_run.download_file(
-                            os.path.join(inference_folder, 'model.pkl'))
+        "outputs/model.pkl", os.path.join(inference_folder, "model.pkl")
+    )
 
     inference_env = train_run.get_environment()
 
-    config = ScriptRunConfig(source_directory=inference_folder,
+    config = ScriptRunConfig(
-                             script='forecasting_script.py',
+        source_directory=inference_folder,
-                             arguments=['--target_column_name',
+        script="forecasting_script.py",
+        arguments=[
+            "--target_column_name",
             target_column_name,
-                                        '--test_dataset',
+            "--test_dataset",
-                                        test_dataset.as_named_input(test_dataset.name)],
+            test_dataset.as_named_input(test_dataset.name),
+        ],
         compute_target=compute_target,
-                             environment=inference_env)
+        environment=inference_env,
+    )
 
-    run = test_experiment.submit(config,
+    run = test_experiment.submit(
-                                 tags={'training_run_id':
+        config,
-                                       train_run.id,
+        tags={
-                                       'run_algorithm':
+            "training_run_id": train_run.id,
-                                       train_run.properties['run_algorithm'],
+            "run_algorithm": train_run.properties["run_algorithm"],
-                                       'valid_score':
+            "valid_score": train_run.properties["score"],
-                                       train_run.properties['score'],
+            "primary_metric": train_run.properties["primary_metric"],
-                                       'primary_metric':
+        },
-                                       train_run.properties['primary_metric']})
+    )
 
-    run.log("run_algorithm", run.tags['run_algorithm'])
+    run.log("run_algorithm", run.tags["run_algorithm"])
     return run

how-to-use-azureml/automated-machine-learning/forecasting-recipes-univariate/auto-ml-forecasting-univariate-recipe-experiment-settings.ipynb

@@ -56,16 +56,18 @@
         "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n",
         "import matplotlib.pyplot as plt\n",
         "from pandas.plotting import register_matplotlib_converters\n",
+        "\n",
         "register_matplotlib_converters()  # fixes the future warning issue\n",
         "\n",
         "from helper_functions import unit_root_test_wrapper\n",
         "from statsmodels.tools.sm_exceptions import InterpolationWarning\n",
-        "warnings.simplefilter('ignore', InterpolationWarning)\n",
+        "\n",
+        "warnings.simplefilter(\"ignore\", InterpolationWarning)\n",
         "\n",
         "\n",
         "# set printing options\n",
-        "pd.set_option('display.max_columns', 500)\n",
+        "pd.set_option(\"display.max_columns\", 500)\n",
-        "pd.set_option('display.width', 1000)"
+        "pd.set_option(\"display.width\", 1000)"
       ]
     },
     {
@@ -75,15 +77,15 @@
       "outputs": [],
       "source": [
         "# load data\n",
-        "main_data_loc = 'data'\n",
+        "main_data_loc = \"data\"\n",
-        "train_file_name = 'S4248SM144SCEN.csv'\n",
+        "train_file_name = \"S4248SM144SCEN.csv\"\n",
         "\n",
-        "TARGET_COLNAME = 'S4248SM144SCEN'\n",
+        "TARGET_COLNAME = \"S4248SM144SCEN\"\n",
-        "TIME_COLNAME = 'observation_date'\n",
+        "TIME_COLNAME = \"observation_date\"\n",
-        "COVID_PERIOD_START = '2020-03-01'\n",
+        "COVID_PERIOD_START = \"2020-03-01\"\n",
         "\n",
         "df = pd.read_csv(os.path.join(main_data_loc, train_file_name))\n",
-        "df[TIME_COLNAME] = pd.to_datetime(df[TIME_COLNAME], format='%Y-%m-%d')\n",
+        "df[TIME_COLNAME] = pd.to_datetime(df[TIME_COLNAME], format=\"%Y-%m-%d\")\n",
         "df.sort_values(by=TIME_COLNAME, inplace=True)\n",
         "df.set_index(TIME_COLNAME, inplace=True)\n",
         "df.head(2)"
@@ -98,7 +100,7 @@
         "# plot the entire dataset\n",
         "fig, ax = plt.subplots(figsize=(6, 2), dpi=180)\n",
         "ax.plot(df)\n",
-        "ax.title.set_text('Original Data Series')\n",
+        "ax.title.set_text(\"Original Data Series\")\n",
         "locs, labels = plt.xticks()\n",
         "plt.xticks(rotation=45)"
       ]
@@ -119,7 +121,7 @@
         "# plot the entire dataset in first differences\n",
         "fig, ax = plt.subplots(figsize=(6, 2), dpi=180)\n",
         "ax.plot(df.diff().dropna())\n",
-        "ax.title.set_text('Data in first differences')\n",
+        "ax.title.set_text(\"Data in first differences\")\n",
         "locs, labels = plt.xticks()\n",
         "plt.xticks(rotation=45)"
       ]
@@ -153,7 +155,7 @@
         "# plot the entire dataset in first differences\n",
         "fig, ax = plt.subplots(figsize=(6, 2), dpi=180)\n",
         "ax.plot(df.diff().dropna())\n",
-        "ax.title.set_text('Data in first differences')\n",
+        "ax.title.set_text(\"Data in first differences\")\n",
         "locs, labels = plt.xticks()\n",
         "plt.xticks(rotation=45)"
       ]
@@ -176,8 +178,8 @@
         "\n",
         "# plot the entire dataset in first differences\n",
         "fig, ax = plt.subplots(figsize=(6, 2), dpi=180)\n",
-        "ax.plot(df['2015-01-01':].diff().dropna())\n",
+        "ax.plot(df[\"2015-01-01\":].diff().dropna())\n",
-        "ax.title.set_text('Data in first differences')\n",
+        "ax.title.set_text(\"Data in first differences\")\n",
         "locs, labels = plt.xticks()\n",
         "plt.xticks(rotation=45)"
       ]
@@ -245,10 +247,10 @@
       "source": [
         "# unit root tests\n",
         "test = unit_root_test_wrapper(df[TARGET_COLNAME])\n",
-        "print('---------------', '\\n')\n",
+        "print(\"---------------\", \"\\n\")\n",
-        "print('Summary table', '\\n', test['summary'], '\\n')\n",
+        "print(\"Summary table\", \"\\n\", test[\"summary\"], \"\\n\")\n",
-        "print('Is the {} series stationary?: {}'.format(TARGET_COLNAME, test['stationary']))\n",
+        "print(\"Is the {} series stationary?: {}\".format(TARGET_COLNAME, test[\"stationary\"]))\n",
-        "print('---------------', '\\n')"
+        "print(\"---------------\", \"\\n\")"
       ]
     },
     {
@@ -285,10 +287,10 @@
       "source": [
         "# unit root tests\n",
         "test = unit_root_test_wrapper(df[TARGET_COLNAME].diff().dropna())\n",
-        "print('---------------', '\\n')\n",
+        "print(\"---------------\", \"\\n\")\n",
-        "print('Summary table', '\\n', test['summary'], '\\n')\n",
+        "print(\"Summary table\", \"\\n\", test[\"summary\"], \"\\n\")\n",
-        "print('Is the {} series stationary?: {}'.format(TARGET_COLNAME, test['stationary']))\n",
+        "print(\"Is the {} series stationary?: {}\".format(TARGET_COLNAME, test[\"stationary\"]))\n",
-        "print('---------------', '\\n')"
+        "print(\"---------------\", \"\\n\")"
       ]
     },
     {
@@ -307,11 +309,11 @@
         "# plot original and stationary data\n",
         "fig = plt.figure(figsize=(10, 10))\n",
         "ax1 = fig.add_subplot(211)\n",
-        "ax1.plot(df[TARGET_COLNAME], '-b')\n",
+        "ax1.plot(df[TARGET_COLNAME], \"-b\")\n",
         "ax2 = fig.add_subplot(212)\n",
-        "ax2.plot(df[TARGET_COLNAME].diff().dropna(), '-b')\n",
+        "ax2.plot(df[TARGET_COLNAME].diff().dropna(), \"-b\")\n",
-        "ax1.title.set_text('Original data')\n",
+        "ax1.title.set_text(\"Original data\")\n",
-        "ax2.title.set_text('Data in first differences')"
+        "ax2.title.set_text(\"Data in first differences\")"
       ]
     },
     {

how-to-use-azureml/automated-machine-learning/forecasting-recipes-univariate/auto-ml-forecasting-univariate-recipe-run-experiment.ipynb

@@ -51,7 +51,7 @@
         "from azureml.core.compute import AmlCompute\n",
         "from azureml.core.compute import ComputeTarget\n",
         "import matplotlib.pyplot as plt\n",
-        "from helper_functions import (ts_train_test_split, compute_metrics)\n",
+        "from helper_functions import ts_train_test_split, compute_metrics\n",
         "\n",
         "import azureml.core\n",
         "from azureml.core.workspace import Workspace\n",
@@ -61,8 +61,8 @@
         "\n",
         "# set printing options\n",
         "np.set_printoptions(precision=4, suppress=True, linewidth=100)\n",
-        "pd.set_option('display.max_columns', 500)\n",
+        "pd.set_option(\"display.max_columns\", 500)\n",
-        "pd.set_option('display.width', 1000)"
+        "pd.set_option(\"display.width\", 1000)"
       ]
     },
     {
@@ -85,23 +85,28 @@
         "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",
+        "if amlcompute_cluster_name in cts and cts[amlcompute_cluster_name].type == \"AmlCompute\":\n",
         "    found = True\n",
-        "    print('Found existing compute target.')\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",
+        "    print(\"Creating a new compute target...\")\n",
-        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_D2_V2\",\n",
+        "    provisioning_config = AmlCompute.provisioning_configuration(\n",
-        "                                                                max_nodes = 6)\n",
+        "        vm_size=\"STANDARD_D2_V2\", max_nodes=6\n",
+        "    )\n",
         "\n",
         "    # Create the cluster.\\n\",\n",
-        "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, provisioning_config)\n",
+        "    compute_target = ComputeTarget.create(\n",
+        "        ws, amlcompute_cluster_name, provisioning_config\n",
+        "    )\n",
         "\n",
-        "print('Checking cluster status...')\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)"
+        "compute_target.wait_for_completion(\n",
+        "    show_output=True, min_node_count=None, timeout_in_minutes=20\n",
+        ")"
       ]
     },
     {
@@ -119,16 +124,18 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "main_data_loc = 'data'\n",
+        "main_data_loc = \"data\"\n",
-        "train_file_name = 'S4248SM144SCEN.csv'\n",
+        "train_file_name = \"S4248SM144SCEN.csv\"\n",
         "\n",
         "TARGET_COLNAME = \"S4248SM144SCEN\"\n",
         "TIME_COLNAME = \"observation_date\"\n",
-        "COVID_PERIOD_START = '2020-03-01'  # start of the covid period. To be excluded from evaluation.\n",
+        "COVID_PERIOD_START = (\n",
+        "    \"2020-03-01\"  # start of the covid period. To be excluded from evaluation.\n",
+        ")\n",
         "\n",
         "# load data\n",
         "df = pd.read_csv(os.path.join(main_data_loc, train_file_name))\n",
-        "df[TIME_COLNAME] = pd.to_datetime(df[TIME_COLNAME], format='%Y-%m-%d')\n",
+        "df[TIME_COLNAME] = pd.to_datetime(df[TIME_COLNAME], format=\"%Y-%m-%d\")\n",
         "df.sort_values(by=TIME_COLNAME, inplace=True)\n",
         "\n",
         "# remove the Covid period\n",
@@ -202,24 +209,28 @@
       "source": [
         "# choose a name for the run history container in the workspace\n",
         "if isinstance(TARGET_LAGS, list):\n",
-        "    TARGET_LAGS_STR = '-'.join(map(str, TARGET_LAGS)) if (len(TARGET_LAGS) > 0) else None\n",
+        "    TARGET_LAGS_STR = (\n",
+        "        \"-\".join(map(str, TARGET_LAGS)) if (len(TARGET_LAGS) > 0) else None\n",
+        "    )\n",
         "else:\n",
         "    TARGET_LAGS_STR = TARGET_LAGS\n",
         "\n",
-        "experiment_desc = 'diff-{}_lags-{}_STL-{}'.format(DIFFERENCE_SERIES, TARGET_LAGS_STR, STL_TYPE)\n",
+        "experiment_desc = \"diff-{}_lags-{}_STL-{}\".format(\n",
-        "experiment_name = 'alcohol_{}'.format(experiment_desc)\n",
+        "    DIFFERENCE_SERIES, TARGET_LAGS_STR, STL_TYPE\n",
+        ")\n",
+        "experiment_name = \"alcohol_{}\".format(experiment_desc)\n",
         "experiment = Experiment(ws, experiment_name)\n",
         "\n",
         "output = {}\n",
-        "output['SDK version'] = azureml.core.VERSION\n",
+        "output[\"SDK version\"] = azureml.core.VERSION\n",
-        "output['Subscription ID'] = ws.subscription_id\n",
+        "output[\"Subscription ID\"] = ws.subscription_id\n",
-        "output['Workspace'] = ws.name\n",
+        "output[\"Workspace\"] = ws.name\n",
-        "output['SKU'] = ws.sku\n",
+        "output[\"SKU\"] = ws.sku\n",
-        "output['Resource Group'] = ws.resource_group\n",
+        "output[\"Resource Group\"] = ws.resource_group\n",
-        "output['Location'] = ws.location\n",
+        "output[\"Location\"] = ws.location\n",
-        "output['Run History Name'] = experiment_name\n",
+        "output[\"Run History Name\"] = experiment_name\n",
-        "pd.set_option('display.max_colwidth', -1)\n",
+        "pd.set_option(\"display.max_colwidth\", -1)\n",
-        "outputDf = pd.DataFrame(data = output, index = [''])\n",
+        "outputDf = pd.DataFrame(data=output, index=[\"\"])\n",
         "print(outputDf.T)"
       ]
     },
@@ -230,7 +241,7 @@
       "outputs": [],
       "source": [
         "# create output directory\n",
-        "output_dir = 'experiment_output/{}'.format(experiment_desc)\n",
+        "output_dir = \"experiment_output/{}\".format(experiment_desc)\n",
         "if not os.path.exists(output_dir):\n",
         "    os.makedirs(output_dir)"
       ]
@@ -257,15 +268,19 @@
         "# split the data into train and test set\n",
         "if DIFFERENCE_SERIES:\n",
         "    # generate train/inference sets using data in first differences\n",
-        "    df_train, df_test = ts_train_test_split(df_input=df_delta,\n",
+        "    df_train, df_test = ts_train_test_split(\n",
+        "        df_input=df_delta,\n",
         "        n=FORECAST_HORIZON,\n",
         "        time_colname=TIME_COLNAME,\n",
-        "                                            ts_id_colnames=TIME_SERIES_ID_COLNAMES)\n",
+        "        ts_id_colnames=TIME_SERIES_ID_COLNAMES,\n",
+        "    )\n",
         "else:\n",
-        "    df_train, df_test = ts_train_test_split(df_input=df,\n",
+        "    df_train, df_test = ts_train_test_split(\n",
+        "        df_input=df,\n",
         "        n=FORECAST_HORIZON,\n",
         "        time_colname=TIME_COLNAME,\n",
-        "                                            ts_id_colnames=TIME_SERIES_ID_COLNAMES)"
+        "        ts_id_colnames=TIME_SERIES_ID_COLNAMES,\n",
+        "    )"
       ]
     },
     {
@@ -286,12 +301,27 @@
         "df_test.to_csv(\"test.csv\", index=False)\n",
         "\n",
         "datastore = ws.get_default_datastore()\n",
-        "datastore.upload_files(files = ['./train.csv'], target_path = 'uni-recipe-dataset/tabular/', overwrite = True,show_progress = True)\n",
+        "datastore.upload_files(\n",
-        "datastore.upload_files(files = ['./test.csv'], target_path = 'uni-recipe-dataset/tabular/', overwrite = True,show_progress = True)\n",
+        "    files=[\"./train.csv\"],\n",
+        "    target_path=\"uni-recipe-dataset/tabular/\",\n",
+        "    overwrite=True,\n",
+        "    show_progress=True,\n",
+        ")\n",
+        "datastore.upload_files(\n",
+        "    files=[\"./test.csv\"],\n",
+        "    target_path=\"uni-recipe-dataset/tabular/\",\n",
+        "    overwrite=True,\n",
+        "    show_progress=True,\n",
+        ")\n",
         "\n",
         "from azureml.core import Dataset\n",
-        "train_dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'uni-recipe-dataset/tabular/train.csv')])\n",
+        "\n",
-        "test_dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'uni-recipe-dataset/tabular/test.csv')])\n",
+        "train_dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=[(datastore, \"uni-recipe-dataset/tabular/train.csv\")]\n",
+        ")\n",
+        "test_dataset = Dataset.Tabular.from_delimited_files(\n",
+        "    path=[(datastore, \"uni-recipe-dataset/tabular/test.csv\")]\n",
+        ")\n",
         "\n",
         "# print the first 5 rows of the Dataset\n",
         "train_dataset.to_pandas_dataframe().reset_index(drop=True).head(5)"
@@ -311,17 +341,18 @@
       "outputs": [],
       "source": [
         "time_series_settings = {\n",
-        "    'time_column_name': TIME_COLNAME,\n",
+        "    \"time_column_name\": TIME_COLNAME,\n",
-        "    'forecast_horizon': FORECAST_HORIZON,\n",
+        "    \"forecast_horizon\": FORECAST_HORIZON,\n",
-        "    'target_lags': TARGET_LAGS,\n",
+        "    \"target_lags\": TARGET_LAGS,\n",
-        "    'use_stl': STL_TYPE,\n",
+        "    \"use_stl\": STL_TYPE,\n",
-        "    'blocked_models': BLOCKED_MODELS,\n",
+        "    \"blocked_models\": BLOCKED_MODELS,\n",
-        "    'time_series_id_column_names': TIME_SERIES_ID_COLNAMES\n",
+        "    \"time_series_id_column_names\": TIME_SERIES_ID_COLNAMES,\n",
         "}\n",
         "\n",
-        "automl_config = AutoMLConfig(task='forecasting',\n",
+        "automl_config = AutoMLConfig(\n",
-        "                             debug_log='sample_experiment.log',\n",
+        "    task=\"forecasting\",\n",
-        "                             primary_metric='normalized_root_mean_squared_error',\n",
+        "    debug_log=\"sample_experiment.log\",\n",
+        "    primary_metric=\"normalized_root_mean_squared_error\",\n",
         "    experiment_timeout_minutes=20,\n",
         "    iteration_timeout_minutes=5,\n",
         "    enable_early_stopping=True,\n",
@@ -331,7 +362,8 @@
         "    verbosity=logging.INFO,\n",
         "    max_cores_per_iteration=-1,\n",
         "    compute_target=compute_target,\n",
-        "                             **time_series_settings)"
+        "    **time_series_settings,\n",
+        ")"
       ]
     },
     {
@@ -404,14 +436,17 @@
       "outputs": [],
       "source": [
         "from run_forecast import run_remote_inference\n",
-        "remote_run = run_remote_inference(test_experiment=test_experiment, \n",
+        "\n",
+        "remote_run = run_remote_inference(\n",
+        "    test_experiment=test_experiment,\n",
         "    compute_target=compute_target,\n",
         "    train_run=best_run,\n",
         "    test_dataset=test_dataset,\n",
-        "                                  target_column_name=TARGET_COLNAME)\n",
+        "    target_column_name=TARGET_COLNAME,\n",
+        ")\n",
         "remote_run.wait_for_completion(show_output=False)\n",
         "\n",
-        "remote_run.download_file('outputs/predictions.csv', f'{output_dir}/predictions.csv')"
+        "remote_run.download_file(\"outputs/predictions.csv\", f\"{output_dir}/predictions.csv\")"
       ]
     },
     {
@@ -428,7 +463,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "X_trans = pd.read_csv(f'{output_dir}/predictions.csv', parse_dates=[TIME_COLNAME])\n",
+        "X_trans = pd.read_csv(f\"{output_dir}/predictions.csv\", parse_dates=[TIME_COLNAME])\n",
         "X_trans.head()"
       ]
     },
@@ -442,13 +477,13 @@
         "def convert_fcst_diff_to_levels(fcst, yt, df_orig):\n",
         "    \"\"\"Convert forecast from first differences to levels.\"\"\"\n",
         "    fcst = fcst.reset_index(drop=False, inplace=False)\n",
-        "    fcst['predicted_level'] = fcst['predicted'].cumsum()\n",
+        "    fcst[\"predicted_level\"] = fcst[\"predicted\"].cumsum()\n",
-        "    fcst['predicted_level'] = fcst['predicted_level'].astype(float) + float(yt)\n",
+        "    fcst[\"predicted_level\"] = fcst[\"predicted_level\"].astype(float) + float(yt)\n",
         "    # merge actuals\n",
-        "    out = pd.merge(fcst,\n",
+        "    out = pd.merge(\n",
-        "                   df_orig[[TIME_COLNAME, TARGET_COLNAME]], \n",
+        "        fcst, df_orig[[TIME_COLNAME, TARGET_COLNAME]], on=[TIME_COLNAME], how=\"inner\"\n",
-        "                   on=[TIME_COLNAME], how='inner')\n",
+        "    )\n",
-        "    out.rename(columns={TARGET_COLNAME: 'actual_level'}, inplace=True)\n",
+        "    out.rename(columns={TARGET_COLNAME: \"actual_level\"}, inplace=True)\n",
         "    return out"
       ]
     },
@@ -461,13 +496,13 @@
         "if DIFFERENCE_SERIES:\n",
         "    # convert forecast in differences to the levels\n",
         "    INFORMATION_SET_DATE = max(df_train[TIME_COLNAME])\n",
-        "    YT = df.query('{} == @INFORMATION_SET_DATE'.format(TIME_COLNAME))[TARGET_COLNAME]\n",
+        "    YT = df.query(\"{} == @INFORMATION_SET_DATE\".format(TIME_COLNAME))[TARGET_COLNAME]\n",
         "\n",
         "    fcst_df = convert_fcst_diff_to_levels(fcst=X_trans, yt=YT, df_orig=df)\n",
         "else:\n",
         "    fcst_df = X_trans.copy()\n",
-        "    fcst_df['actual_level'] = y_test\n",
+        "    fcst_df[\"actual_level\"] = y_test\n",
-        "    fcst_df['predicted_level'] = y_predictions\n",
+        "    fcst_df[\"predicted_level\"] = y_predictions\n",
         "\n",
         "del X_trans"
       ]
@@ -486,13 +521,11 @@
       "outputs": [],
       "source": [
         "# compute metrics\n",
-        "metrics_df = compute_metrics(fcst_df=fcst_df,\n",
+        "metrics_df = compute_metrics(fcst_df=fcst_df, metric_name=None, ts_id_colnames=None)\n",
-        "                             metric_name=None,\n",
-        "                             ts_id_colnames=None)\n",
         "# save output\n",
-        "metrics_file_name = '{}_metrics.csv'.format(experiment_name)\n",
+        "metrics_file_name = \"{}_metrics.csv\".format(experiment_name)\n",
-        "fcst_file_name = '{}_forecst.csv'.format(experiment_name)\n",
+        "fcst_file_name = \"{}_forecst.csv\".format(experiment_name)\n",
-        "plot_file_name = '{}_plot.pdf'.format(experiment_name)\n",
+        "plot_file_name = \"{}_plot.pdf\".format(experiment_name)\n",
         "\n",
         "metrics_df.to_csv(os.path.join(output_dir, metrics_file_name), index=True)\n",
         "fcst_df.to_csv(os.path.join(output_dir, fcst_file_name), index=True)"
@@ -517,9 +550,9 @@
         "\n",
         "# generate and save plots\n",
         "fig, ax = plt.subplots(dpi=180)\n",
-        "ax.plot(plot_df[TARGET_COLNAME], '-g', label='Historical')\n",
+        "ax.plot(plot_df[TARGET_COLNAME], \"-g\", label=\"Historical\")\n",
-        "ax.plot(fcst_df['actual_level'], '-b', label='Actual')\n",
+        "ax.plot(fcst_df[\"actual_level\"], \"-b\", label=\"Actual\")\n",
-        "ax.plot(fcst_df['predicted_level'], '-r', label='Forecast')\n",
+        "ax.plot(fcst_df[\"predicted_level\"], \"-r\", label=\"Forecast\")\n",
         "ax.legend()\n",
         "ax.set_title(\"Forecast vs Actuals\")\n",
         "ax.set_xlabel(TIME_COLNAME)\n",

how-to-use-azureml/automated-machine-learning/forecasting-recipes-univariate/forecasting_script.py

@@ -11,11 +11,14 @@ from sklearn.externals import joblib
 
 parser = argparse.ArgumentParser()
 parser.add_argument(
-    '--target_column_name', type=str, dest='target_column_name',
+    "--target_column_name",
-    help='Target Column Name')
+    type=str,
+    dest="target_column_name",
+    help="Target Column Name",
+)
 parser.add_argument(
-    '--test_dataset', type=str, dest='test_dataset',
+    "--test_dataset", type=str, dest="test_dataset", help="Test Dataset"
-    help='Test Dataset')
+)
 
 args = parser.parse_args()
 target_column_name = args.target_column_name
@@ -27,20 +30,41 @@ ws = run.experiment.workspace
 # get the input dataset by id
 test_dataset = Dataset.get_by_id(ws, id=test_dataset_id)
 
-X_test_df = test_dataset.drop_columns(columns=[target_column_name]).to_pandas_dataframe().reset_index(drop=True)
+X_test = (
-y_test_df = test_dataset.with_timestamp_columns(None).keep_columns(columns=[target_column_name]).to_pandas_dataframe()
+    test_dataset.drop_columns(columns=[target_column_name])
+    .to_pandas_dataframe()
+    .reset_index(drop=True)
+)
+y_test_df = (
+    test_dataset.with_timestamp_columns(None)
+    .keep_columns(columns=[target_column_name])
+    .to_pandas_dataframe()
+)
 
 # generate forecast
-fitted_model = joblib.load('model.pkl')
+fitted_model = joblib.load("model.pkl")
-y_pred, X_trans = fitted_model.forecast(X_test_df)
+# We have default quantiles values set as below(95th percentile)
+quantiles = [0.025, 0.5, 0.975]
+predicted_column_name = "predicted"
+PI = "prediction_interval"
+fitted_model.quantiles = quantiles
+pred_quantiles = fitted_model.forecast_quantiles(X_test)
+pred_quantiles[PI] = pred_quantiles[[min(quantiles), max(quantiles)]].apply(
+    lambda x: "[{}, {}]".format(x[0], x[1]), axis=1
+)
+X_test[target_column_name] = y_test_df[target_column_name]
+X_test[PI] = pred_quantiles[PI]
+X_test[predicted_column_name] = pred_quantiles[0.5]
+# drop rows where prediction or actuals are nan
+# happens because of missing actuals
+# or at edges of time due to lags/rolling windows
+clean = X_test[
+    X_test[[target_column_name, predicted_column_name]].notnull().all(axis=1)
+]
+clean.rename(columns={target_column_name: "actual"}, inplace=True)
 
-# rename target column
+file_name = "outputs/predictions.csv"
-X_trans.reset_index(drop=False, inplace=True)
+export_csv = clean.to_csv(file_name, header=True, index=False)  # added Index
-X_trans.rename(columns={TimeSeriesInternal.DUMMY_TARGET_COLUMN: 'predicted'}, inplace=True)
-X_trans['actual'] = y_test_df[target_column_name].values
-
-file_name = 'outputs/predictions.csv'
-export_csv = X_trans.to_csv(file_name, header=True, index=False)  # added Index
 
 # Upload the predictions into artifacts
 run.upload_file(name=file_name, path_or_stream=file_name)

how-to-use-azureml/automated-machine-learning/forecasting-recipes-univariate/helper_functions.py

@@ -15,22 +15,25 @@ def adf_test(series, **kw):
     :param series: series to test
     :return: dictionary of results
     """
-    if 'lags' in kw.keys():
+    if "lags" in kw.keys():
-        msg = 'Lag order of {} detected. Running the ADF test...'.format(str(kw['lags']))
+        msg = "Lag order of {} detected. Running the ADF test...".format(
+            str(kw["lags"])
+        )
         print(msg)
-        statistic, pval, critval, resstore = stattools.adfuller(series,
+        statistic, pval, critval, resstore = stattools.adfuller(
-                                                                maxlag=kw['lags'],
+            series, maxlag=kw["lags"], autolag=kw["autolag"], store=kw["store"]
-                                                                autolag=kw['autolag'],
+        )
-                                                                store=kw['store'])
     else:
-        statistic, pval, critval, resstore = stattools.adfuller(series,
+        statistic, pval, critval, resstore = stattools.adfuller(
-                                                                autolag=kw['IC'],
+            series, autolag=kw["IC"], store=kw["store"]
-                                                                store=kw['store'])
+        )
 
-    output = {'statistic': statistic,
+    output = {
-              'pval': pval,
+        "statistic": statistic,
-              'critical': critval,
+        "pval": pval,
-              'resstore': resstore}
+        "critical": critval,
+        "resstore": resstore,
+    }
     return output
 
 
@@ -41,22 +44,23 @@ def kpss_test(series, **kw):
     :param series: series to test
     :return: dictionary of results
     """
-    if kw['store']:
+    if kw["store"]:
-        statistic, p_value, critical_values, rstore = stattools.kpss(series,
+        statistic, p_value, critical_values, rstore = stattools.kpss(
-                                                                     regression=kw['reg_type'],
+            series, regression=kw["reg_type"], lags=kw["lags"], store=kw["store"]
-                                                                     lags=kw['lags'],
+        )
-                                                                     store=kw['store'])
     else:
-        statistic, p_value, lags, critical_values = stattools.kpss(series,
+        statistic, p_value, lags, critical_values = stattools.kpss(
-                                                                   regression=kw['reg_type'],
+            series, regression=kw["reg_type"], lags=kw["lags"]
-                                                                   lags=kw['lags'])
+        )
-    output = {'statistic': statistic,
+    output = {
-              'pval': p_value,
+        "statistic": statistic,
-              'critical': critical_values,
+        "pval": p_value,
-              'lags': rstore.lags if kw['store'] else lags}
+        "critical": critical_values,
+        "lags": rstore.lags if kw["store"] else lags,
+    }
 
-    if kw['store']:
+    if kw["store"]:
-        output.update({'resstore': rstore})
+        output.update({"resstore": rstore})
     return output
 
 
@@ -75,9 +79,9 @@ def format_test_output(test_name, test_res, H0_unit_root=True):
              If test failed (test_res is None), return empty dictionary.
     """
     # Check if the test failed by trying to extract the test statistic
-    if test_name in ('ADF', 'KPSS'):
+    if test_name in ("ADF", "KPSS"):
         try:
-            test_res['statistic']
+            test_res["statistic"]
         except BaseException:
             test_res = None
     else:
@@ -90,32 +94,32 @@ def format_test_output(test_name, test_res, H0_unit_root=True):
         return {}
 
     # extract necessary information
-    if test_name in ('ADF', 'KPSS'):
+    if test_name in ("ADF", "KPSS"):
-        statistic = test_res['statistic']
+        statistic = test_res["statistic"]
-        crit_val = test_res['critical']['5%']
+        crit_val = test_res["critical"]["5%"]
-        p_val = test_res['pval']
+        p_val = test_res["pval"]
-        lags = test_res['resstore'].usedlag if test_name == 'ADF' else test_res['lags']
+        lags = test_res["resstore"].usedlag if test_name == "ADF" else test_res["lags"]
     else:
         statistic = test_res.stat
-        crit_val = test_res.critical_values['5%']
+        crit_val = test_res.critical_values["5%"]
         p_val = test_res.pvalue
         lags = test_res.lags
 
     if H0_unit_root:
-        H0 = 'The process is non-stationary'
+        H0 = "The process is non-stationary"
         stationary = "yes" if p_val < 0.05 else "not"
     else:
-        H0 = 'The process is stationary'
+        H0 = "The process is stationary"
         stationary = "yes" if p_val > 0.05 else "not"
 
     out = {
-        'test_name': test_name,
+        "test_name": test_name,
-        'statistic': statistic,
+        "statistic": statistic,
-        'crit_val': crit_val,
+        "crit_val": crit_val,
-        'p_val': p_val,
+        "p_val": p_val,
-        'lags': int(lags),
+        "lags": int(lags),
-        'stationary': stationary,
+        "stationary": stationary,
-        'Null Hypothesis': H0
+        "Null Hypothesis": H0,
     }
     return out
 
@@ -136,22 +140,15 @@ def unit_root_test_wrapper(series, lags=None):
     :return: dictionary of summary table for all tests and final decision on stationary vs nonstaionary
     """
     # setting for ADF and KPSS tests
-    adf_settings = {
+    adf_settings = {"IC": "AIC", "store": True}
-        'IC': 'AIC',
-        'store': True
-    }
 
-    kpss_settings = {
+    kpss_settings = {"reg_type": "c", "lags": "auto", "store": True}
-        'reg_type': 'c',
-        'lags': 'auto',
-        'store': True
-    }
 
     arch_test_settings = {}  # settings for PP, ADF GLS and ZA tests
     if lags is not None:
-        adf_settings.update({'lags': lags, 'autolag': None})
+        adf_settings.update({"lags": lags, "autolag": None})
-        kpss_settings.update({'lags:': lags})
+        kpss_settings.update({"lags:": lags})
-        arch_test_settings = {'lags': lags}
+        arch_test_settings = {"lags": lags}
     # Run individual tests
     adf = adf_test(series, **adf_settings)  # ADF test
     kpss = kpss_test(series, **kpss_settings)  # KPSS test
@@ -160,14 +157,26 @@ def unit_root_test_wrapper(series, lags=None):
     za = unitroot.ZivotAndrews(series, **arch_test_settings)  # Zivot-Andrews test
 
     # generate output table
-    adf_dict = format_test_output(test_name='ADF', test_res=adf, H0_unit_root=True)
+    adf_dict = format_test_output(test_name="ADF", test_res=adf, H0_unit_root=True)
-    kpss_dict = format_test_output(test_name='KPSS', test_res=kpss, H0_unit_root=False)
+    kpss_dict = format_test_output(test_name="KPSS", test_res=kpss, H0_unit_root=False)
-    pp_dict = format_test_output(test_name='Philips Perron', test_res=pp, H0_unit_root=True)
+    pp_dict = format_test_output(
-    adfgls_dict = format_test_output(test_name='ADF GLS', test_res=adfgls, H0_unit_root=True)
+        test_name="Philips Perron", test_res=pp, H0_unit_root=True
-    za_dict = format_test_output(test_name='Zivot-Andrews', test_res=za, H0_unit_root=True)
+    )
+    adfgls_dict = format_test_output(
+        test_name="ADF GLS", test_res=adfgls, H0_unit_root=True
+    )
+    za_dict = format_test_output(
+        test_name="Zivot-Andrews", test_res=za, H0_unit_root=True
+    )
 
-    test_dict = {'ADF': adf_dict, 'KPSS': kpss_dict, 'PP': pp_dict, 'ADF GLS': adfgls_dict, 'ZA': za_dict}
+    test_dict = {
-    test_sum = pd.DataFrame.from_dict(test_dict, orient='index').reset_index(drop=True)
+        "ADF": adf_dict,
+        "KPSS": kpss_dict,
+        "PP": pp_dict,
+        "ADF GLS": adfgls_dict,
+        "ZA": za_dict,
+    }
+    test_sum = pd.DataFrame.from_dict(test_dict, orient="index").reset_index(drop=True)
 
     # decision based on the majority rule
     if test_sum.shape[0] > 0:
@@ -176,9 +185,9 @@ def unit_root_test_wrapper(series, lags=None):
         ratio = 1  # all tests fail, assume the series is stationary
 
     # Majority rule. If the ratio is exactly 0.5, assume the series in non-stationary.
-    stationary = 'YES' if (ratio > 0.5) else 'NO'
+    stationary = "YES" if (ratio > 0.5) else "NO"
 
-    out = {'summary': test_sum, 'stationary': stationary}
+    out = {"summary": test_sum, "stationary": stationary}
     return out
 
 
@@ -196,10 +205,12 @@ def ts_train_test_split(df_input, n, time_colname, ts_id_colnames=None):
         ts_id_colnames = []
     ts_id_colnames_original = ts_id_colnames.copy()
     if len(ts_id_colnames) == 0:
-        ts_id_colnames = ['Grain']
+        ts_id_colnames = ["Grain"]
-        df_input[ts_id_colnames[0]] = 'dummy'
+        df_input[ts_id_colnames[0]] = "dummy"
     # Sort by ascending time
-    df_grouped = (df_input.sort_values(time_colname).groupby(ts_id_colnames, group_keys=False))
+    df_grouped = df_input.sort_values(time_colname).groupby(
+        ts_id_colnames, group_keys=False
+    )
     df_head = df_grouped.apply(lambda dfg: dfg.iloc[:-n])
     df_tail = df_grouped.apply(lambda dfg: dfg.iloc[-n:])
     # drop group column name if it was not originally provided
@@ -221,30 +232,32 @@ def compute_metrics(fcst_df, metric_name=None, ts_id_colnames=None):
     if ts_id_colnames is None:
         ts_id_colnames = []
     if len(ts_id_colnames) == 0:
-        ts_id_colnames = ['TS_ID']
+        ts_id_colnames = ["TS_ID"]
-        fcst_df[ts_id_colnames[0]] = 'dummy'
+        fcst_df[ts_id_colnames[0]] = "dummy"
     metrics_list = []
     for grain, df in fcst_df.groupby(ts_id_colnames):
         try:
             scores = scoring.score_regression(
-                y_test=df['actual_level'],
+                y_test=df["actual_level"],
-                y_pred=df['predicted_level'],
+                y_pred=df["predicted_level"],
-                metrics=list(constants.Metric.SCALAR_REGRESSION_SET))
+                metrics=list(constants.Metric.SCALAR_REGRESSION_SET),
+            )
         except BaseException:
-            msg = '{}: metrics calculation failed.'.format(grain)
+            msg = "{}: metrics calculation failed.".format(grain)
             print(msg)
             scores = {}
-        one_grain_metrics_df = pd.DataFrame(list(scores.items()), columns=['metric_name', 'metric']).\
+        one_grain_metrics_df = pd.DataFrame(
-            sort_values(['metric_name'])
+            list(scores.items()), columns=["metric_name", "metric"]
+        ).sort_values(["metric_name"])
         one_grain_metrics_df.reset_index(inplace=True, drop=True)
         if len(ts_id_colnames) < 2:
-            one_grain_metrics_df['grain'] = ts_id_colnames[0]
+            one_grain_metrics_df["grain"] = ts_id_colnames[0]
         else:
-            one_grain_metrics_df['grain'] = "|".join(list(grain))
+            one_grain_metrics_df["grain"] = "|".join(list(grain))
 
         metrics_list.append(one_grain_metrics_df)
     # collect into a data frame
     grain_metrics = pd.concat(metrics_list)
     if metric_name is not None:
-        grain_metrics = grain_metrics.query('metric_name == @metric_name')
+        grain_metrics = grain_metrics.query("metric_name == @metric_name")
     return grain_metrics

how-to-use-azureml/automated-machine-learning/forecasting-recipes-univariate/run_forecast.py

@@ -3,36 +3,47 @@ import shutil
 from azureml.core import ScriptRunConfig
 
 
-def run_remote_inference(test_experiment, compute_target, train_run,
+def run_remote_inference(
-                         test_dataset, target_column_name, inference_folder='./forecast'):
+    test_experiment,
+    compute_target,
+    train_run,
+    test_dataset,
+    target_column_name,
+    inference_folder="./forecast",
+):
     # Create local directory to copy the model.pkl and forecsting_script.py files into.
     # These files will be uploaded to and executed on the compute instance.
     os.makedirs(inference_folder, exist_ok=True)
-    shutil.copy('forecasting_script.py', inference_folder)
+    shutil.copy("forecasting_script.py", inference_folder)
 
-    train_run.download_file('outputs/model.pkl',
+    train_run.download_file(
-                            os.path.join(inference_folder, 'model.pkl'))
+        "outputs/model.pkl", os.path.join(inference_folder, "model.pkl")
+    )
 
     inference_env = train_run.get_environment()
 
-    config = ScriptRunConfig(source_directory=inference_folder,
+    config = ScriptRunConfig(
-                             script='forecasting_script.py',
+        source_directory=inference_folder,
-                             arguments=['--target_column_name',
+        script="forecasting_script.py",
+        arguments=[
+            "--target_column_name",
             target_column_name,
-                                        '--test_dataset',
+            "--test_dataset",
-                                        test_dataset.as_named_input(test_dataset.name)],
+            test_dataset.as_named_input(test_dataset.name),
+        ],
         compute_target=compute_target,
-                             environment=inference_env)
+        environment=inference_env,
+    )
 
-    run = test_experiment.submit(config,
+    run = test_experiment.submit(
-                                 tags={'training_run_id':
+        config,
-                                       train_run.id,
+        tags={
-                                       'run_algorithm':
+            "training_run_id": train_run.id,
-                                       train_run.properties['run_algorithm'],
+            "run_algorithm": train_run.properties["run_algorithm"],
-                                       'valid_score':
+            "valid_score": train_run.properties["score"],
-                                       train_run.properties['score'],
+            "primary_metric": train_run.properties["primary_metric"],
-                                       'primary_metric':
+        },
-                                       train_run.properties['primary_metric']})
+    )
 
-    run.log("run_algorithm", run.tags['run_algorithm'])
+    run.log("run_algorithm", run.tags["run_algorithm"])
     return run

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

@@ -96,7 +96,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

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

@@ -95,7 +95,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

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

@@ -92,7 +92,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },

how-to-use-azureml/explain-model/azure-integration/gpu-explanation/gpu_tree_explainer.py

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Licensed under the MIT license.
+
+from azureml.core.run import Run
+import joblib
+import os
+import shap
+import xgboost
+
+OUTPUT_DIR = './outputs/'
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+run = Run.get_context()
+
+# get a dataset on income prediction
+X, y = shap.datasets.adult()
+
+# train an XGBoost model (but any other tree model type should work)
+model = xgboost.XGBClassifier()
+model.fit(X, y)
+
+explainer = shap.explainers.GPUTree(model, X)
+X_shap = X[:100]
+shap_values = explainer(X_shap)
+
+print("computed shap values:")
+print(shap_values)
+
+# write X_shap out as a pickle file for later visualization
+x_shap_pkl = 'x_shap.pkl'
+with open(x_shap_pkl, 'wb') as file:
+    joblib.dump(value=X_shap, filename=os.path.join(OUTPUT_DIR, x_shap_pkl))
+run.upload_file('x_shap_adult_census.pkl', os.path.join(OUTPUT_DIR, x_shap_pkl))
+
+model_file_name = 'xgboost_.pkl'
+# save model in the outputs folder so it automatically gets uploaded
+with open(model_file_name, 'wb') as file:
+    joblib.dump(value=model, filename=os.path.join(OUTPUT_DIR,
+                                                   model_file_name))
+
+# register the model
+run.upload_file('xgboost_model.pkl', os.path.join('./outputs/', model_file_name))
+original_model = run.register_model(model_name='xgboost_with_gpu_tree_explainer',
+                                    model_path='xgboost_model.pkl')

how-to-use-azureml/explain-model/azure-integration/gpu-explanation/train-explain-model-gpu-tree-explainer.ipynb

@@ -0,0 +1,297 @@
+{
+  "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/classification-text-dnn/auto-ml-classification-text-dnn.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Explain tree-based models on GPU using GPUTreeExplainer\n",
+        "\n",
+        "\n",
+        "_**This notebook illustrates how to use shap's GPUTreeExplainer on an Azure GPU machine.**_\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "Problem: Train a tree-based model and explain the model on an Azure GPU machine using the GPUTreeExplainer.\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",
+        "This notebook demonstrates how to use the GPUTreeExplainer on some simple datasets.  Like the TreeExplainer, the GPUTreeExplainer is specifically designed for tree-based machine learning models, but it is designed to accelerate the computations using NVIDIA GPUs.\n",
+        "\n",
+        "\n",
+        "Make sure you have executed the [configuration](../../../configuration.ipynb) before running this notebook.\n",
+        "\n",
+        "Notebook synopsis:\n",
+        "\n",
+        "1. Creating an Experiment in an existing Workspace\n",
+        "2. Configuration and remote run with a GPU machine"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import logging\n",
+        "import os\n",
+        "import shutil\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.core.compute import AmlCompute\n",
+        "from azureml.core.compute import ComputeTarget\n",
+        "from azureml.core.run import Run\n",
+        "from azureml.core.model import Model"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "This sample notebook may use features that are not available in previous versions of the Azure ML SDK."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
+        "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "As part of the setup you have already created a <b>Workspace</b>. To run the script, you also need to create an <b>Experiment</b>. An Experiment corresponds to a prediction problem you are trying to solve, while a Run corresponds to a specific approach to the problem."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ws = Workspace.from_config()\n",
+        "\n",
+        "# Choose an experiment name.\n",
+        "experiment_name = 'gpu-tree-explainer'\n",
+        "\n",
+        "experiment = Experiment(ws, experiment_name)\n",
+        "\n",
+        "output = {}\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['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 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 = './azureml-shap-gpu-tree-explainer'\n",
+        "os.makedirs(project_folder, exist_ok=True)\n",
+        "shutil.copy('gpu_tree_explainer.py', project_folder)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Set up a compute cluster\n",
+        "This section uses a user-provided compute cluster (named \"gpu-shap-cluster\" in this example). If a cluster with this name does not exist in the user's workspace, the below code will create a new cluster. You can choose the parameters of the cluster as mentioned in the comments."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.compute import ComputeTarget, AmlCompute\n",
+        "from azureml.core.compute_target import ComputeTargetException\n",
+        "\n",
+        "num_nodes = 1\n",
+        "\n",
+        "# Choose a name for your cluster.\n",
+        "amlcompute_cluster_name = \"gpu-shap-cluster\"\n",
+        "\n",
+        "# Verify that cluster does not exist already\n",
+        "try:\n",
+        "    compute_target = ComputeTarget(workspace=ws, name=amlcompute_cluster_name)\n",
+        "    print('Found existing cluster, use it.')\n",
+        "except ComputeTargetException:\n",
+        "    compute_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_NC6\",\n",
+        "                                                           # To use GPUTreeExplainer, select a GPU such as \"STANDARD_NC6\" \n",
+        "                                                           # or similar GPU option\n",
+        "                                                           # available in your workspace\n",
+        "                                                           max_nodes = num_nodes)\n",
+        "    compute_target = ComputeTarget.create(ws, amlcompute_cluster_name, compute_config)\n",
+        "\n",
+        "compute_target.wait_for_completion(show_output=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Configure & Run"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.runconfig import RunConfiguration\n",
+        "from azureml.core.conda_dependencies import CondaDependencies\n",
+        "\n",
+        "# Create a new RunConfig object\n",
+        "run_config = RunConfiguration(framework=\"python\")\n",
+        "\n",
+        "# Set compute target to AmlCompute target created in previous step\n",
+        "run_config.target = amlcompute_cluster_name\n",
+        "\n",
+        "from azureml.core import Environment\n",
+        "\n",
+        "environment_name = \"shap-gpu-tree\"\n",
+        "\n",
+        "env = Environment(environment_name)\n",
+        "\n",
+        "env.docker.enabled = True\n",
+        "env.docker.base_image = None\n",
+        "env.docker.base_dockerfile = \"\"\"\n",
+        "FROM rapidsai/rapidsai:cuda10.0-devel-ubuntu18.04\n",
+        "RUN apt-get update && \\\n",
+        "apt-get install -y fuse && \\\n",
+        "apt-get install -y build-essential && \\\n",
+        "apt-get install -y python3-dev && \\\n",
+        "source activate rapids && \\\n",
+        "apt-get install -y g++ && \\\n",
+        "printenv && \\\n",
+        "echo \"which nvcc: \" && \\\n",
+        "which nvcc && \\\n",
+        "pip install azureml-defaults && \\\n",
+        "pip install azureml-telemetry && \\\n",
+        "cd /usr/local/src && \\\n",
+        "git clone https://github.com/slundberg/shap && \\\n",
+        "cd shap && \\\n",
+        "mkdir build && \\\n",
+        "python setup.py install --user && \\\n",
+        "pip uninstall -y xgboost && \\\n",
+        "rm /conda/envs/rapids/lib/libxgboost.so && \\\n",
+        "pip install xgboost==1.4.2\n",
+        "\"\"\"\n",
+        "\n",
+        "env.python.user_managed_dependencies = True\n",
+        "\n",
+        "from azureml.core import Run\n",
+        "from azureml.core import ScriptRunConfig\n",
+        "\n",
+        "src = ScriptRunConfig(source_directory=project_folder, \n",
+        "                      script='gpu_tree_explainer.py', \n",
+        "                      compute_target=amlcompute_cluster_name,\n",
+        "                      environment=env) \n",
+        "run = experiment.submit(config=src)\n",
+        "run"
+      ]
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "ilmat"
+      }
+    ],
+    "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/gpu-explanation/train-explain-model-gpu-tree-explainer.yml

@@ -0,0 +1,5 @@
+name: train-explain-model-gpu-tree-explainer
+dependencies:
+- pip:
+  - azureml-sdk
+  - azureml-interpret

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

@@ -11,4 +11,4 @@ dependencies:
   - matplotlib
   - azureml-dataset-runtime
   - ipywidgets
-  - raiwidgets~=0.7.0
+  - raiwidgets~=0.10.0

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

@@ -10,4 +10,4 @@ dependencies:
   - ipython
   - matplotlib
   - ipywidgets
-  - raiwidgets~=0.7.0
+  - raiwidgets~=0.10.0

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

@@ -10,4 +10,4 @@ dependencies:
   - ipython
   - matplotlib
   - ipywidgets
-  - raiwidgets~=0.7.0
+  - raiwidgets~=0.10.0

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

@@ -12,4 +12,4 @@ dependencies:
   - azureml-dataset-runtime
   - azureml-core
   - ipywidgets
-  - raiwidgets~=0.7.0
+  - raiwidgets~=0.10.0

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

@@ -27,6 +27,7 @@
         "2. Running an arbitrary Python script that the customer has in DBFS\n",
         "3. Running an arbitrary Python script that is available on local computer (will upload to DBFS, and then run in Databricks) \n",
         "4. Running a JAR job that the customer has in DBFS.\n",
+        "5. How to get run context in a Databricks interactive cluster\n",
         "\n",
         "## Before you begin:\n",
         "\n",
@@ -699,14 +700,14 @@
       ]
     },
     {
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
         "### 5. Running demo notebook already added to the Databricks workspace using existing cluster\n",
         "First you need register DBFS datastore and make sure path_on_datastore does exist in databricks file system, you can browser the files by refering [this](https://docs.azuredatabricks.net/user-guide/dbfs-databricks-file-system.html).\n",
         "\n",
         "Find existing_cluster_id by opeing Azure Databricks UI with Clusters page and in url you will find a string connected with '-' right after \"clusters/\"."
-      ],
+      ]
-      "cell_type": "markdown",
-      "metadata": {}
     },
     {
       "cell_type": "code",
@@ -745,11 +746,11 @@
       ]
     },
     {
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
         "#### Build and submit the Experiment"
-      ],
+      ]
-      "cell_type": "markdown",
-      "metadata": {}
     },
     {
       "cell_type": "code",
@@ -764,11 +765,11 @@
       ]
     },
     {
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
         "#### View Run Details"
-      ],
+      ]
-      "cell_type": "markdown",
-      "metadata": {}
     },
     {
       "cell_type": "code",
@@ -781,14 +782,14 @@
       ]
     },
     {
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
-        "### 6. Running a Python script in Databricks that currenlty is in local computer with existing cluster\n",
+        "### 6. Running a Python script in Databricks that is currently in local computer with existing cluster\n",
         "When you access azure blob or data lake storage from an existing (interactive) cluster, you need to ensure the Spark configuration is set up correctly to access this storage and this set up may require the cluster to be restarted.\n",
         "\n",
         "If you set permit_cluster_restart to True, AML will check if the spark configuration needs to be updated and restart the cluster for you if required. This will ensure that the storage can be correctly accessed from the Databricks cluster."
-      ],
+      ]
-      "cell_type": "markdown",
-      "metadata": {}
     },
     {
       "cell_type": "code",
@@ -813,11 +814,11 @@
       ]
     },
     {
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
         "#### Build and submit the Experiment"
-      ],
+      ]
-      "cell_type": "markdown",
-      "metadata": {}
     },
     {
       "cell_type": "code",
@@ -832,11 +833,11 @@
       ]
     },
     {
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
         "#### View Run Details"
-      ],
+      ]
-      "cell_type": "markdown",
-      "metadata": {}
     },
     {
       "cell_type": "code",
@@ -849,18 +850,71 @@
       ]
     },
     {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### How to get run context in a Databricks interactive cluster\n",
+        "\n",
+        "Users are used to being able to use Run.get_context() to retrieve the parent_run_id for a given run_id. In DatabricksStep, however, a little more work is required to achieve this.\n",
+        "\n",
+        "The solution is to parse the script arguments and set corresponding environment variables to access the run context from within Databricks.\n",
+        "Note that this workaround is not required for job clusters. \n",
+        "\n",
+        "Here is a code sample:"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "```python\n",
+        "from azureml.core import Run\n",
+        "import argparse\n",
+        "import os\n",
+        "\n",
+        "\n",
+        "def populate_environ():\n",
+        "    parser = argparse.ArgumentParser(description='Process arguments passed to script')\n",
+        "    parser.add_argument('--AZUREML_SCRIPT_DIRECTORY_NAME')\n",
+        "    parser.add_argument('--AZUREML_RUN_TOKEN')\n",
+        "    parser.add_argument('--AZUREML_RUN_TOKEN_EXPIRY')\n",
+        "    parser.add_argument('--AZUREML_RUN_ID')\n",
+        "    parser.add_argument('--AZUREML_ARM_SUBSCRIPTION')\n",
+        "    parser.add_argument('--AZUREML_ARM_RESOURCEGROUP')\n",
+        "    parser.add_argument('--AZUREML_ARM_WORKSPACE_NAME')\n",
+        "    parser.add_argument('--AZUREML_ARM_PROJECT_NAME')\n",
+        "    parser.add_argument('--AZUREML_SERVICE_ENDPOINT')\n",
+        "\n",
+        "    args = parser.parse_args()\n",
+        "    os.environ['AZUREML_SCRIPT_DIRECTORY_NAME'] = args.AZUREML_SCRIPT_DIRECTORY_NAME\n",
+        "    os.environ['AZUREML_RUN_TOKEN'] = args.AZUREML_RUN_TOKEN\n",
+        "    os.environ['AZUREML_RUN_TOKEN_EXPIRY'] = args.AZUREML_RUN_TOKEN_EXPIRY\n",
+        "    os.environ['AZUREML_RUN_ID'] = args.AZUREML_RUN_ID\n",
+        "    os.environ['AZUREML_ARM_SUBSCRIPTION'] = args.AZUREML_ARM_SUBSCRIPTION\n",
+        "    os.environ['AZUREML_ARM_RESOURCEGROUP'] = args.AZUREML_ARM_RESOURCEGROUP\n",
+        "    os.environ['AZUREML_ARM_WORKSPACE_NAME'] = args.AZUREML_ARM_WORKSPACE_NAME\n",
+        "    os.environ['AZUREML_ARM_PROJECT_NAME'] = args.AZUREML_ARM_PROJECT_NAME\n",
+        "    os.environ['AZUREML_SERVICE_ENDPOINT'] = args.AZUREML_SERVICE_ENDPOINT\n",
+        "\n",
+        "populate_environ()\n",
+        "run = Run.get_context(allow_offline=False)\n",
+        "print(run._run_dto[\"parent_run_id\"])\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
       "source": [
         "# Next: ADLA as a Compute Target\n",
         "To use ADLA as a compute target from Azure Machine Learning Pipeline, a AdlaStep is used. This [notebook](https://aka.ms/pl-adla) demonstrates the use of AdlaStep in Azure Machine Learning Pipeline."
-      ],
+      ]
-      "cell_type": "markdown",
-      "metadata": {}
     }
   ],
   "metadata": {
     "authors": [
       {
-        "name": "sanpil"
+        "name": "shbijlan"
       }
     ],
     "category": "tutorial",

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

@@ -40,7 +40,7 @@ def get_num(arg_num, file_num):
 
 
 def write_num_to_file(num, file_path):
-    if file_path is not None and file_path is not '':
+    if file_path is not None and file_path != '':
         output_dir = file_path
     else:
         output_dir = '.'

how-to-use-azureml/machine-learning-pipelines/nyc-taxi-data-regression-model-building/scripts/prepdata/normalize.py

@@ -28,13 +28,21 @@ replaced_distance_vals_df = (replaced_stfor_vals_df.replace({"distance": ".00"},
 
 normalized_df = replaced_distance_vals_df.astype({"distance": 'float64'})
 
+
+def time_to_us(time_str):
+    hh, mm , ss = map(int, time_str.split(':'))
+    return (ss + 60 * (mm + 60 * hh)) * (10**6)
+
+
 temp = pd.DatetimeIndex(normalized_df["pickup_datetime"])
-normalized_df["pickup_date"] = temp.date
+normalized_df["pickup_date"] = pd.to_datetime(temp.date)
 normalized_df["pickup_time"] = temp.time
+normalized_df["pickup_time"] = normalized_df["pickup_time"].apply(lambda x: time_to_us(str(x)))
 
 temp = pd.DatetimeIndex(normalized_df["dropoff_datetime"])
-normalized_df["dropoff_date"] = temp.date
+normalized_df["dropoff_date"] = pd.to_datetime(temp.date)
 normalized_df["dropoff_time"] = temp.time
+normalized_df["dropoff_time"] = normalized_df["dropoff_time"].apply(lambda x: time_to_us(str(x)))
 
 del normalized_df["pickup_datetime"]
 del normalized_df["dropoff_datetime"]

how-to-use-azureml/machine-learning-pipelines/parallel-run/Code/total_file_size.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Licensed under the MIT license.
+
+import os
+
+
+def init():
+    print("Init")
+
+
+# For partition per folder/column jobs, ParallelRunStep pass an optional positional parameter `mini_batch_context`
+# to the `run` function in user's entry script, which contains information of the mini_batch.
+def run(mini_batch, mini_batch_context):
+    print(f"run method start: {__file__}, run({mini_batch}, {mini_batch_context})")
+    # `partition_key_value` is a dict that corresponds to the mini_batch, the keys of the dict are those specified
+    # in `partition_keys` in ParallelRunConfig.
+    print(f"partition_key_value = {mini_batch_context.partition_key_value}")
+    # `dataset` is the dataset object that corresponds to the mini_batch, which is a subset of the input dataset
+    # filtered by condition specified in `partition_key_value`.
+    print(f"dataset = {mini_batch_context.dataset}")
+
+    print(f"file_count_of_mini_batch = {len(mini_batch)}")
+    file_name_list = []
+    file_size_list = []
+    total_file_size_of_mini_batch = 0
+    for file_path in mini_batch:
+        file_name_list.append(os.path.basename(file_path))
+        file_size = os.path.getsize(file_path)
+        file_size_list.append(file_size)
+        total_file_size_of_mini_batch += file_size
+    print(f"total_file_size_of_mini_batch = {total_file_size_of_mini_batch}")
+    file_size_ratio_list = [file_size * 1.0 / total_file_size_of_mini_batch for file_size in file_size_list]
+
+    # If `output_action` is set to `append_row` in ParallelRunConfig for FileDataset input(as is in this sample
+    # notebook), the return value of `run` method is expected to be a list/tuple of same length with the
+    # input parameter `mini_batch`, and each element in the list/tuple would form a row in the result file by
+    # calling the Python builtin `str` function.
+    # If you want to specify the output format, please format and return str value as in this example.
+    return [
+        ",".join([str(x) for x in fields])
+        for fields in zip(
+            file_name_list,
+            file_size_list,
+            file_size_ratio_list,
+            [mini_batch_context.partition_key_value["user"]] * len(mini_batch),
+            [mini_batch_context.partition_key_value["genres"]] * len(mini_batch),
+            [total_file_size_of_mini_batch] * len(mini_batch),
+        )
+    ]

how-to-use-azureml/machine-learning-pipelines/parallel-run/Code/total_income.py

@@ -0,0 +1,17 @@
+# Copyright (c) Microsoft. All rights reserved.
+# Licensed under the MIT license.
+
+import os
+
+
+def init():
+    print("Init")
+
+
+def run(mini_batch):
+    print(f'run method start: {__file__}, run({mini_batch})')
+    total_income = mini_batch["INCOME"].sum()
+    print(f'total_income = {total_income}')
+    mini_batch["total_income"] = total_income
+
+    return mini_batch

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

@@ -32,6 +32,7 @@ To run a Batch Inference job, you will need to gather some configuration data.
     - **node_count**: number of compute nodes to use.
     - **process_count_per_node**: number of processes per node (optional, default value is 1).
     - **mini_batch_size**: the approximate amount of input data passed to each run() invocation.  For FileDataset input, this is number of files user script can process in one run() call. For TabularDataset input it is approximate size of data user script can process in one run() call. E.g. 1024, 1024KB, 10MB, 1GB (optional, default value 10 files for FileDataset and 1MB for TabularDataset.)
+    - **partition_keys**: the keys used to partition the input data into mini-batches passed to each run() invocation. This parameter is mutually exclusive with `mini_batch_size`, and it requires the input datasets to have `partition_keys` attribute, the value of which is a superset of the value of this parameter. Each run() call would process a part of data that has identical value on the `partition_keys` specified. You can follow the examples in [file-dataset-partition-per-folder.ipynb](./file-dataset-partition-per-folder.ipynb) and [tabular-dataset-partition-per-column.ipynb](./tabular-dataset-partition-per-column.ipynb) to see how to create such datasets.
     - **logging_level**: log verbosity. Values in increasing verbosity are: 'WARNING', 'INFO', 'DEBUG' (optional, default value is 'INFO').
     - **run_invocation_timeout**: run method invocation timeout period in seconds (optional, default value is 60).
     - **environment**: The environment definition. This field configures the Python environment. It can be configured to use an existing Python environment or to set up a temp environment for the experiment. The definition is also responsible for setting the required application dependencies.
@@ -121,6 +122,8 @@ pipeline_run.wait_for_completion(show_output=True)
 -  [file-dataset-image-inference-mnist.ipynb](./file-dataset-image-inference-mnist.ipynb) demonstrates how to run batch inference on an MNIST dataset using FileDataset.
 -  [tabular-dataset-inference-iris.ipynb](./tabular-dataset-inference-iris.ipynb) demonstrates how to run batch inference on an IRIS dataset using TabularDataset.
 -  [pipeline-style-transfer.ipynb](../pipeline-style-transfer/pipeline-style-transfer-parallel-run.ipynb) demonstrates using ParallelRunStep in multi-step pipeline and using output from one step as input to ParallelRunStep.
+-  [file-dataset-partition-per-folder.ipynb](./file-dataset-partition-per-folder.ipynb) demonstrates how to run batch inference on file data by treating files inside each leaf folder as a mini-batch.
+-  [tabular-dataset-partition-per-column.ipynb](./tabular-dataset-partition-per-column.ipynb) demonstrates how to run batch inference on tabular data by treating rows with identical value on specified columns as a mini-batch.
 
 # Troubleshooting guide
 

how-to-use-azureml/machine-learning-pipelines/parallel-run/file-dataset-partition-per-folder.ipynb

@@ -0,0 +1,404 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved. \n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/machine-learning-pipelines/parallel-run/file-dataset-partition-per-folder.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Using Azure Machine Learning Pipelines for Batch Inference for files input partitioned by folder structure\n",
+        "\n",
+        "In this notebook, we will demonstrate how to make predictions on large quantities of data asynchronously using the ML pipelines with Azure Machine Learning. Batch inference (or batch scoring) provides cost-effective inference, with unparalleled throughput for asynchronous applications. Batch prediction pipelines can scale to perform inference on terabytes of production data. Batch prediction is optimized for high throughput, fire-and-forget predictions for a large collection of data.\n",
+        "\n",
+        "> **Tip**\n",
+        "If your system requires low-latency processing (to process a single document or small set of documents quickly), use [real-time scoring](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-consume-web-service) instead of batch prediction.\n",
+        "\n",
+        "This example will create a sample dataset with nested folder structure, where the folder name corresponds to the attribute of the files inside it. The Batch Inference job would split the files inside the dataset according to their attributes, so that all files with identical value on the specified attribute will form up a single mini-batch to be processed.\n",
+        "\n",
+        "The outline of this notebook is as follows:\n",
+        "\n",
+        "- Create a dataset with nested folder structure and `partition_format` to interpret the folder structure into the attributes of files inside.\n",
+        "- Do batch inference on each mini-batch defined by the folder structure.\n",
+        "\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 located at https://github.com/Azure/MachineLearningNotebooks first. This sets you up with a working config file that has information on your workspace, subscription id, etc. "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Connect to workspace"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.workspace import Workspace\n",
+        "ws = Workspace.from_config()\n",
+        "print('Workspace name: ' + ws.name, \n",
+        "      'Azure region: ' + ws.location, \n",
+        "      'Subscription id: ' + ws.subscription_id, \n",
+        "      'Resource group: ' + ws.resource_group, sep = '\\n')\n",
+        "\n",
+        "datastore = ws.get_default_datastore()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "print(azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Upload local test data to datastore\n",
+        "The destination folder in the datastore is structured so that the name of each folder layer corresponds to a property of all the files inside the foler."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Dataset\n",
+        "\n",
+        "datastore.upload('test_files/disco', 'dataset_partition_test/user1/winter', overwrite=True, show_progress=False)\n",
+        "datastore.upload('test_files/orchestra', 'dataset_partition_test/user1/fall', overwrite=True, show_progress=False)\n",
+        "datastore.upload('test_files/piano', 'dataset_partition_test/user2/summer', overwrite=True, show_progress=False)\n",
+        "datastore.upload('test_files/spirituality', 'dataset_partition_test/user3/fall', overwrite=True, show_progress=False)\n",
+        "datastore.upload('test_files/piano', 'dataset_partition_test/user4/spring', overwrite=True, show_progress=False)\n",
+        "datastore.upload('test_files/piano', 'dataset_partition_test/user4/fall', overwrite=True, show_progress=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create partitioned file dataset\n",
+        "Create a file dataset partitioned by 'user', 'season', and 'genres', each corresponds to a folder layer specified in `partition_format`. You can get a partition of data by specifying the value of one or more partition keys. E.g., by specifying `user=user1 and genres=piano`, you can get all the file that matches `dataset_partition_test/user1/*/piano.wav`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "partitioned_file_dataset = Dataset.File.from_files(path=(datastore, 'dataset_partition_test/*/*/*.wav'),\n",
+        "                                                   partition_format=\"dataset_partition_test/{user}/{season}/{genres}.wav\",\n",
+        "                                                   validate=False)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "partitioned_file_dataset.partition_keys"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create or Attach existing compute resource"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "from azureml.core.compute import AmlCompute, ComputeTarget\n",
+        "\n",
+        "# choose a name for your cluster\n",
+        "compute_name = os.environ.get(\"AML_COMPUTE_CLUSTER_NAME\", \"cpu-cluster\")\n",
+        "compute_min_nodes = os.environ.get(\"AML_COMPUTE_CLUSTER_MIN_NODES\", 0)\n",
+        "compute_max_nodes = os.environ.get(\"AML_COMPUTE_CLUSTER_MAX_NODES\", 2)\n",
+        "\n",
+        "# This example uses CPU VM. For using GPU VM, set SKU to STANDARD_NC6\n",
+        "vm_size = os.environ.get(\"AML_COMPUTE_CLUSTER_SKU\", \"STANDARD_D2_V2\")\n",
+        "\n",
+        "\n",
+        "if compute_name in ws.compute_targets:\n",
+        "    compute_target = ws.compute_targets[compute_name]\n",
+        "    if compute_target and type(compute_target) is AmlCompute:\n",
+        "        print('found compute target. just use it. ' + compute_name)\n",
+        "else:\n",
+        "    print('creating a new compute target...')\n",
+        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = vm_size,\n",
+        "                                                                min_nodes = compute_min_nodes, \n",
+        "                                                                max_nodes = compute_max_nodes)\n",
+        "\n",
+        "    # create the cluster\n",
+        "    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)\n",
+        "    \n",
+        "    # can poll for a minimum number of nodes and for a specific timeout. \n",
+        "    # if no min node count is provided it 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()\n",
+        "    print(compute_target.get_status().serialize())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Intermediate/Output Data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline, PipelineData\n",
+        "\n",
+        "output_dir = PipelineData(name=\"file_dataset_inferences\", datastore=datastore)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Calculate total file size of each mini-batch partitioned by dataset partition key(s)\n",
+        "The script is to sum up the total size of files in each mini-batch."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "scripts_folder = \"Code\"\n",
+        "script_file = \"total_file_size.py\"\n",
+        "\n",
+        "# peek at contents\n",
+        "with open(os.path.join(scripts_folder, script_file)) as inference_file:\n",
+        "    print(inference_file.read())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Build and run the batch inference pipeline\n",
+        "### Specify the environment to run the script\n",
+        "You would need to specify the required private azureml packages in dependencies. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Environment\n",
+        "from azureml.core.runconfig import CondaDependencies, DEFAULT_CPU_IMAGE\n",
+        "\n",
+        "batch_conda_deps = CondaDependencies.create(pip_packages=[\"azureml-core\", \"azureml-dataset-runtime[fuse]\"])\n",
+        "batch_env = Environment(name=\"batch_environment\")\n",
+        "batch_env.python.conda_dependencies = batch_conda_deps\n",
+        "batch_env.docker.base_image = DEFAULT_CPU_IMAGE"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create the configuration to wrap the inference script\n",
+        "The parameter `partition_keys` is a list containing a subset of the dataset partition keys, specifying how is the input dataset partitioned. Each and every possible combination of values of partition_keys will form up a mini-batch. E.g., by specifying `partition_keys=['user', 'genres']` will result in 5 mini-batches, i.e. `user=halit && genres=disco`, `user=halit && genres=orchestra`, `user=chunyu && genres=piano`, `user=kin && genres=spirituality` and `user=ramandeep && genres=piano`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.steps import ParallelRunStep, ParallelRunConfig\n",
+        "\n",
+        "# In a real-world scenario, you'll want to shape your process per node and nodes to fit your problem domain.\n",
+        "parallel_run_config = ParallelRunConfig(\n",
+        "    source_directory=scripts_folder,\n",
+        "    entry_script=script_file,  # the user script to run against each input\n",
+        "    partition_keys=['user', 'genres'],\n",
+        "    error_threshold=5,\n",
+        "    output_action='append_row',\n",
+        "    append_row_file_name=\"file_size_outputs.txt\",\n",
+        "    environment=batch_env,\n",
+        "    compute_target=compute_target, \n",
+        "    node_count=2,\n",
+        "    run_invocation_timeout=600\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create the pipeline step"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "parallel_run_step = ParallelRunStep(\n",
+        "    name='summarize-file-size',\n",
+        "    inputs=[partitioned_file_dataset.as_named_input(\"partitioned_file_input\")],\n",
+        "    output=output_dir,\n",
+        "    parallel_run_config=parallel_run_config,\n",
+        "    allow_reuse=False\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Run the pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Experiment\n",
+        "from azureml.pipeline.core import Pipeline\n",
+        "\n",
+        "pipeline = Pipeline(workspace=ws, steps=[parallel_run_step])\n",
+        "\n",
+        "pipeline_run = Experiment(ws, 'file-dataset-partition').submit(pipeline)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pipeline_run.wait_for_completion(show_output=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## View the prediction results\n",
+        "In the total_file_size.py file above you can see that the ResultList with the filename and the prediction result gets returned. These are written to the DataStore specified in the PipelineData object as the output data, which in this case is called inferences. This containers the outputs from all of the worker nodes used in the compute cluster. You can download this data to view the results ... below just filters to the first 10 rows"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "import tempfile\n",
+        "\n",
+        "batch_run = pipeline_run.find_step_run(parallel_run_step.name)[0]\n",
+        "batch_output = batch_run.get_output_data(output_dir.name)\n",
+        "\n",
+        "target_dir = tempfile.mkdtemp()\n",
+        "batch_output.download(local_path=target_dir)\n",
+        "result_file = os.path.join(target_dir, batch_output.path_on_datastore, parallel_run_config.append_row_file_name)\n",
+        "\n",
+        "df = pd.read_csv(result_file, delimiter=\",\", header=None)\n",
+        "df.columns = [\"File Name\", \"File Size\", \"Ratio of Size in Partition\", \"user\", \"genres\", \"Total File Size of Partition\"]\n",
+        "print(\"Prediction has\", df.shape[0], \"rows\")\n",
+        "df.head(10)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "pansav"
+      },
+      {
+        "name": "tracych"
+      },
+      {
+        "name": "migu"
+      }
+    ],
+    "category": "Other notebooks",
+    "compute": [
+      "AML Compute"
+    ],
+    "datasets": [
+      "None"
+    ],
+    "deployment": [
+      "None"
+    ],
+    "exclude_from_index": false,
+    "framework": [
+      "None"
+    ],
+    "friendly_name": "Batch inferencing file data partitioned by folder using ParallelRunStep",
+    "index_order": 1,
+    "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.9"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}

how-to-use-azureml/machine-learning-pipelines/parallel-run/file-dataset-partition-per-folder.yml

@@ -0,0 +1,7 @@
+name: file-dataset-partition-per-folder
+dependencies:
+- pip:
+  - azureml-sdk
+  - azureml-pipeline-steps
+  - azureml-widgets
+  - pandas

how-to-use-azureml/machine-learning-pipelines/parallel-run/tabular-dataset-partition-per-column.ipynb

@@ -0,0 +1,427 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Copyright (c) Microsoft Corporation. All rights reserved. \n",
+        "Licensed under the MIT License."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/MachineLearningNotebooks/how-to-use-azureml/machine-learning-pipelines/parallel-run/tabular-dataset-partition-per-column.png)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Using Azure Machine Learning Pipelines for Batch Inference for tabular input partitioned by column value\n",
+        "\n",
+        "In this notebook, we will demonstrate how to make predictions on large quantities of data asynchronously using the ML pipelines with Azure Machine Learning. Batch inference (or batch scoring) provides cost-effective inference, with unparalleled throughput for asynchronous applications. Batch prediction pipelines can scale to perform inference on terabytes of production data. Batch prediction is optimized for high throughput, fire-and-forget predictions for a large collection of data.\n",
+        "\n",
+        "> **Tip**\n",
+        "If your system requires low-latency processing (to process a single document or small set of documents quickly), use [real-time scoring](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-consume-web-service) instead of batch prediction.\n",
+        "\n",
+        "This example will create a partitioned tabular dataset by splitting the rows in a large csv file by its value on specified column. Each partition will form up a mini-batch in the parallel processing procedure.\n",
+        "\n",
+        "The outline of this notebook is as follows:\n",
+        "\n",
+        "- Create a tabular dataset partitioned by value on specified column.\n",
+        "- Do batch inference on the dataset with each mini-batch corresponds to one partition.\n",
+        "\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 located at https://github.com/Azure/MachineLearningNotebooks first. This sets you up with a working config file that has information on your workspace, subscription id, etc. "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Connect to workspace"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.workspace import Workspace\n",
+        "ws = Workspace.from_config()\n",
+        "print('Workspace name: ' + ws.name, \n",
+        "      'Azure region: ' + ws.location, \n",
+        "      'Subscription id: ' + ws.subscription_id, \n",
+        "      'Resource group: ' + ws.resource_group, sep = '\\n')\n",
+        "\n",
+        "datastore = ws.get_default_datastore()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import azureml.core\n",
+        "print(azureml.core.VERSION)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Download OJ sales data from opendataset url"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import requests\n",
+        "\n",
+        "oj_sales_path = \"./oj.csv\"\n",
+        "r = requests.get(\"http://www.cs.unitn.it/~taufer/Data/oj.csv\")\n",
+        "open(oj_sales_path, \"wb\").write(r.content)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Upload OJ sales data to datastore"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "datastore.upload_files([oj_sales_path], \".\", \"oj_sales_data\", overwrite=True, show_progress=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create tabular dataset\n",
+        "Create normal tabular dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Dataset\n",
+        "\n",
+        "dataset = Dataset.Tabular.from_delimited_files(path=(datastore, 'oj_sales_data/*.csv'))\n",
+        "print(dataset.to_pandas_dataframe())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Partition the tabular dataset\n",
+        "Partition the dataset by column 'store' and 'brand'. You can get a partition of data by specifying the value of one or more partition keys. E.g., by specifying `store=1000 and brand='tropicana'`, you can get all the rows that matches this condition in the dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "partitioned_dataset = dataset.partition_by(partition_keys=['store', 'brand'], target=(datastore, \"partition_by_key_res\"), name=\"partitioned_oj_data\")\n",
+        "partitioned_dataset.partition_keys"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create or Attach existing compute resource"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "from azureml.core.compute import AmlCompute, ComputeTarget\n",
+        "\n",
+        "# choose a name for your cluster\n",
+        "compute_name = os.environ.get(\"AML_COMPUTE_CLUSTER_NAME\", \"cpu-cluster\")\n",
+        "compute_min_nodes = os.environ.get(\"AML_COMPUTE_CLUSTER_MIN_NODES\", 0)\n",
+        "compute_max_nodes = os.environ.get(\"AML_COMPUTE_CLUSTER_MAX_NODES\", 2)\n",
+        "\n",
+        "# This example uses CPU VM. For using GPU VM, set SKU to STANDARD_NC6\n",
+        "vm_size = os.environ.get(\"AML_COMPUTE_CLUSTER_SKU\", \"STANDARD_D2_V2\")\n",
+        "\n",
+        "\n",
+        "if compute_name in ws.compute_targets:\n",
+        "    compute_target = ws.compute_targets[compute_name]\n",
+        "    if compute_target and type(compute_target) is AmlCompute:\n",
+        "        print('found compute target. just use it. ' + compute_name)\n",
+        "else:\n",
+        "    print('creating a new compute target...')\n",
+        "    provisioning_config = AmlCompute.provisioning_configuration(vm_size = vm_size,\n",
+        "                                                                min_nodes = compute_min_nodes, \n",
+        "                                                                max_nodes = compute_max_nodes)\n",
+        "\n",
+        "    # create the cluster\n",
+        "    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)\n",
+        "    \n",
+        "    # can poll for a minimum number of nodes and for a specific timeout. \n",
+        "    # if no min node count is provided it 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()\n",
+        "    print(compute_target.get_status().serialize())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Intermediate/Output Data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.core import Pipeline, PipelineData\n",
+        "\n",
+        "output_dir = PipelineData(name=\"inferences\", datastore=datastore)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Calculate total revenue of each mini-batch partitioned by dataset partition key(s)\n",
+        "The script sum up the total revenue of a mini-batch."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "scripts_folder = \"Code\"\n",
+        "script_file = \"total_income.py\"\n",
+        "\n",
+        "# peek at contents\n",
+        "with open(os.path.join(scripts_folder, script_file)) as inference_file:\n",
+        "    print(inference_file.read())"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Build and run the batch inference pipeline\n",
+        "### Specify the environment to run the script\n",
+        "You would need to specify the required private azureml packages in dependencies. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Environment\n",
+        "from azureml.core.runconfig import CondaDependencies, DEFAULT_CPU_IMAGE\n",
+        "\n",
+        "batch_conda_deps = CondaDependencies.create(pip_packages=[\"azureml-core\", \"azureml-dataset-runtime[fuse,pandas]\"])\n",
+        "batch_env = Environment(name=\"batch_environment\")\n",
+        "batch_env.python.conda_dependencies = batch_conda_deps\n",
+        "batch_env.docker.base_image = DEFAULT_CPU_IMAGE"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create the configuration to wrap the inference script\n",
+        "The parameter `partition_keys` is a list containing a subset of the dataset partition keys, specifying how is the input dataset partitioned. Each and every possible combination of values of partition_keys will form up a mini-batch. E.g., by specifying `partition_keys=['store', 'brand']` will result in mini-batches like `store=1000 && brand=tropicana`, `store=1000 && brand=dominicks`, `store=1001 && brand=dominicks`, ..."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.steps import ParallelRunStep, ParallelRunConfig\n",
+        "\n",
+        "# In a real-world scenario, you'll want to shape your process per node and nodes to fit your problem domain.\n",
+        "parallel_run_config = ParallelRunConfig(\n",
+        "    source_directory=scripts_folder,\n",
+        "    entry_script=script_file,  # the user script to run against each input\n",
+        "    partition_keys=['store', 'brand'],\n",
+        "    error_threshold=5,\n",
+        "    output_action='append_row',\n",
+        "    append_row_file_name=\"revenue_outputs.txt\",\n",
+        "    environment=batch_env,\n",
+        "    compute_target=compute_target, \n",
+        "    node_count=2,\n",
+        "    run_invocation_timeout=600\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create the pipeline step"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "parallel_run_step = ParallelRunStep(\n",
+        "    name='summarize-revenue',\n",
+        "    inputs=[partitioned_dataset.as_named_input(\"partitioned_tabular_input\")],\n",
+        "    output=output_dir,\n",
+        "    parallel_run_config=parallel_run_config,\n",
+        "    allow_reuse=False\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Run the pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core import Experiment\n",
+        "from azureml.pipeline.core import Pipeline\n",
+        "\n",
+        "pipeline = Pipeline(workspace=ws, steps=[parallel_run_step])\n",
+        "\n",
+        "pipeline_run = Experiment(ws, 'tabular-dataset-partition').submit(pipeline)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "pipeline_run.wait_for_completion(show_output=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## View the prediction results\n",
+        "In the total_income.py file above you can see that the ResultList with the filename and the prediction result gets returned. These are written to the DataStore specified in the PipelineData object as the output data, which in this case is called inferences. This containers the outputs from all of the worker nodes used in the compute cluster. You can download this data to view the results ... below just filters to the first 10 rows"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "import tempfile\n",
+        "\n",
+        "batch_run = pipeline_run.find_step_run(parallel_run_step.name)[0]\n",
+        "batch_output = batch_run.get_output_data(output_dir.name)\n",
+        "\n",
+        "target_dir = tempfile.mkdtemp()\n",
+        "batch_output.download(local_path=target_dir)\n",
+        "result_file = os.path.join(target_dir, batch_output.path_on_datastore, parallel_run_config.append_row_file_name)\n",
+        "\n",
+        "df = pd.read_csv(result_file, delimiter=\" \", header=None)\n",
+        "\n",
+        "df.columns = [\"week\", \"logmove\", \"feat\", \"price\", \"AGE60\", \"EDUC\", \"ETHNIC\", \"INCOME\", \"HHLARGE\", \"WORKWOM\", \"HVAL150\", \"SSTRDIST\", \"SSTRVOL\", \"CPDIST5\", \"CPWVOL5\", \"store\", \"brand\", \"total_income\"]\n",
+        "print(\"Prediction has \", df.shape[0], \" rows\")\n",
+        "df.head(10)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "authors": [
+      {
+        "name": "pansav"
+      },
+      {
+        "name": "tracych"
+      },
+      {
+        "name": "migu"
+      }
+    ],
+    "category": "Other notebooks",
+    "compute": [
+      "AML Compute"
+    ],
+    "datasets": [
+      "OJ Sales Data"
+    ],
+    "deployment": [
+      "None"
+    ],
+    "exclude_from_index": false,
+    "framework": [
+      "None"
+    ],
+    "friendly_name": "Batch inferencing OJ Sales Data partitioned by column using ParallelRunStep",
+    "index_order": 1,
+    "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.9"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}

how-to-use-azureml/machine-learning-pipelines/parallel-run/tabular-dataset-partition-per-column.yml

@@ -0,0 +1,7 @@
+name: tabular-dataset-partition-per-column
+dependencies:
+- pip:
+  - azureml-sdk
+  - azureml-pipeline-steps
+  - azureml-widgets
+  - pandas

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

@@ -258,7 +258,7 @@
         "  - azureml-defaults\n",
         "  - azureml-opendatasets\n",
         "  - chainer==5.1.0\n",
-        "  - cupy-cuda90==5.1.0\n",
+        "  - cupy-cuda100==5.1.0\n",
         "  - mpi4py==3.0.0\n",
         "  - pytest"
       ]
@@ -275,7 +275,7 @@
         "chainer_env = Environment.from_conda_specification(name = 'chainer-5.1.0-gpu', file_path = './conda_dependencies.yml')\n",
         "\n",
         "# Specify a GPU base image\n",
-        "chainer_env.docker.base_image = 'mcr.microsoft.com/azureml/intelmpi2018.3-cuda9.0-cudnn7-ubuntu16.04'\n",
+        "chainer_env.docker.base_image = 'mcr.microsoft.com/azureml/openmpi3.1.2-cuda10.0-cudnn7-ubuntu18.04'\n",
         "\n",
         "docker_config = DockerConfiguration(use_docker=True)"
       ]

how-to-use-azureml/responsible-ai/auto-ml-regression-responsibleai/auto-ml-regression-responsibleai.ipynb

@@ -95,7 +95,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -386,10 +386,9 @@
         "\n",
         "# Set compute target to AmlCompute\n",
         "conda_run_config.target = compute_target\n",
-        "conda_run_config.environment.docker.enabled = True\n",
         "\n",
         "# specify CondaDependencies obj\n",
-        "conda_run_config.environment.python.conda_dependencies = automl_run.get_environment().python.conda_dependencies"
+        "conda_run_config.environment = automl_run.get_environment()"
       ]
     },
     {
@@ -589,7 +588,7 @@
         "from azureml.responsibleai.tools.model_analysis.counterfactual_config import CounterfactualConfig\n",
         "\n",
         "cf_config = CounterfactualConfig(model_analysis_run, conda_run_config)\n",
-        "cf_config.add_request(total_CFs=10, desired_range=[10, 300], feature_importance=False)\n",
+        "cf_config.add_request(total_CFs=10, desired_range=[10, 300])\n",
         "cf_run = model_analysis_run.submit_child(cf_config)\n",
         "cf_run.wait_for_completion(raise_on_error=True, wait_post_processing=True)"
       ]
@@ -630,6 +629,22 @@
       "source": [
         "counterfactual_object.visualize_as_dataframe(show_only_changes=True)"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Visualize counterfactual feature importance"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "counterfactual_object.summary_importance"
+      ]
     }
   ],
   "metadata": {

how-to-use-azureml/responsible-ai/visualize-upload-loan-decision/rai-loan-decision.yml

@@ -8,5 +8,5 @@ dependencies:
   - matplotlib
   - azureml-dataset-runtime
   - ipywidgets
-  - raiwidgets~=0.7.0
+  - raiwidgets~=0.13.0
   - liac-arff

how-to-use-azureml/track-and-monitor-experiments/logging-api/logging-api.ipynb

@@ -100,7 +100,7 @@
         "\n",
         "# Check core SDK version number\n",
         "\n",
-        "print(\"This notebook was created using SDK version 1.34.0, you are currently running version\", azureml.core.VERSION)"
+        "print(\"This notebook was created using SDK version 1.36.0, you are currently running version\", azureml.core.VERSION)"
       ]
     },
     {

how-to-use-azureml/track-and-monitor-experiments/using-mlflow/train-projects-remote/train-projects-remote.ipynb

@@ -225,9 +225,8 @@
         "\n",
         "Try out these notebooks to learn more about MLflow-Azure Machine Learning integration:\n",
         "\n",
-        " * [Train a model using remote compute on Azure Cloud](../train-on-remote/train-on-remote.ipynb)\n",
+        " * [Train a model using remote compute on Azure Cloud](../train-remote/train-remote.ipynb)\n",
-        " * [Deploy the model as a web service](../deploy-model/deploy-model.ipynb)\n",
+        " * [Train a model using Pytorch and MLflow](../../../ml-frameworks/using-mlflow/train-and-deploy-pytorch)\n",
-        " * [Train a model using Pytorch and MLflow](../../ml-frameworks/using-mlflow/train-and-deploy-pytorch)\n",
         "\n"
       ]
     }

how-to-use-azureml/track-and-monitor-experiments/using-mlflow/train-remote/train_diabetes.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft. All rights reserved.
 # Licensed under the MIT license.
 
+import matplotlib.pyplot as plt
 import numpy as np
 from sklearn.datasets import load_diabetes
 from sklearn.linear_model import Ridge
@@ -11,7 +12,6 @@ import mlflow.sklearn
 
 import matplotlib
 matplotlib.use('Agg')
-import matplotlib.pyplot as plt
 
 with mlflow.start_run():
     X, y = load_diabetes(return_X_y=True)

how-to-use-azureml/work-with-data/datasets-tutorial/pipeline-with-datasets/keras-mnist-fashion/prepare.py

@@ -4,15 +4,15 @@ import sys
 
 def convert(imgf, labelf, outf, n):
     f = open(imgf, "rb")
-    l = open(labelf, "rb")
+    temp = open(labelf, "rb")
     o = open(outf, "w")
 
     f.read(16)
-    l.read(8)
+    temp.read(8)
     images = []
 
     for i in range(n):
-        image = [ord(l.read(1))]
+        image = [ord(temp.read(1))]
         for j in range(28 * 28):
             image.append(ord(f.read(1)))
         images.append(image)
@@ -21,7 +21,7 @@ def convert(imgf, labelf, outf, n):
         o.write(",".join(str(pix) for pix in image) + "\n")
     f.close()
     o.close()
-    l.close()
+    temp.close()
 
 
 mounted_input_path = sys.argv[1]

how-to-use-azureml/work-with-data/datasets-tutorial/pipeline-with-datasets/pipeline-for-image-classification.ipynb

@@ -272,7 +272,8 @@
         "dependencies:\n",
         "- python=3.6.2\n",
         "- pip:\n",
-        "  - azureml-defaults\n",
+        "  - azureml-core\n",
+        "  - azureml-dataset-runtime\n",
         "  - keras==2.4.3\n",
         "  - tensorflow==2.4.3\n",
         "  - numpy\n",

index.md

@@ -27,7 +27,7 @@ Machine Learning notebook samples and encourage efficient retrieval of topics an
 | [Classification of credit card fraudulent transactions using Automated ML](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/classification-credit-card-fraud/auto-ml-classification-credit-card-fraud.ipynb) | Classification | Creditcard | AML Compute | None | None | remote_run, AutomatedML |
 | [Classification of credit card fraudulent transactions using Automated ML](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/experimental/classification-credit-card-fraud-local-managed/auto-ml-classification-credit-card-fraud-local-managed.ipynb) | Classification | Creditcard | AML Compute | None | None | AutomatedML |
 | [Automated ML run with featurization and model explainability.](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/regression-explanation-featurization/auto-ml-regression-explanation-featurization.ipynb) | Regression | MachineData | AML | ACI | None | featurization, explainability, remote_run, AutomatedML |
-| [Automated ML run with featurization and model explainability.](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/responsible-ai/auto-ml-regresion-responsibleai/auto-ml-regression-responsibleai.ipynb) | Regression | MachineData | AML | ACI | None | featurization, explainability, remote_run, AutomatedML |
+| [Automated ML run with featurization and model explainability.](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/responsible-ai/auto-ml-regression-responsibleai/auto-ml-regression-responsibleai.ipynb) | Regression | MachineData | AML | ACI | None | featurization, explainability, remote_run, AutomatedML |
 | :star:[Azure Machine Learning Pipeline with DataTranferStep](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-data-transfer.ipynb) | Demonstrates the use of DataTranferStep | Custom | ADF | None | Azure ML | None |
 | [Getting Started with Azure Machine Learning Pipelines](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-getting-started.ipynb) | Getting Started notebook for ANML Pipelines | Custom | AML Compute | None | Azure ML | None |
 | [Azure Machine Learning Pipeline with AzureBatchStep](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/machine-learning-pipelines/intro-to-pipelines/aml-pipelines-how-to-use-azurebatch-to-run-a-windows-executable.ipynb) | Demonstrates the use of AzureBatchStep | Custom | Azure Batch | None | Azure ML | None |
@@ -108,6 +108,8 @@ Machine Learning notebook samples and encourage efficient retrieval of topics an
 | [auto-ml-regression-model-proxy](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/experimental/regression-model-proxy/auto-ml-regression-model-proxy.ipynb) |  |  |  |  |  |  |
 | [auto-ml-forecasting-beer-remote](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/forecasting-beer-remote/auto-ml-forecasting-beer-remote.ipynb) |  |  |  |  |  |  |
 | [auto-ml-forecasting-energy-demand](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/forecasting-energy-demand/auto-ml-forecasting-energy-demand.ipynb) |  |  |  |  |  |  |
+| [auto-ml-forecasting-hierarchical-timeseries](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/forecasting-hierarchical-timeseries/auto-ml-forecasting-hierarchical-timeseries.ipynb) |  |  |  |  |  |  |
+| [auto-ml-forecasting-many-models](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/forecasting-many-models/auto-ml-forecasting-many-models.ipynb) |  |  |  |  |  |  |
 | [auto-ml-forecasting-univariate-recipe-experiment-settings](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/forecasting-recipes-univariate/auto-ml-forecasting-univariate-recipe-experiment-settings.ipynb) |  |  |  |  |  |  |
 | [auto-ml-forecasting-univariate-recipe-run-experiment](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/forecasting-recipes-univariate/auto-ml-forecasting-univariate-recipe-run-experiment.ipynb) |  |  |  |  |  |  |
 | [auto-ml-regression](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/automated-machine-learning/regression/auto-ml-regression.ipynb) |  |  |  |  |  |  |
@@ -124,6 +126,7 @@ Machine Learning notebook samples and encourage efficient retrieval of topics an
 | [production-deploy-to-aks-ssl](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/deployment/production-deploy-to-aks/production-deploy-to-aks-ssl.ipynb) |  |  |  |  |  |  |
 | [production-deploy-to-aks](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/deployment/production-deploy-to-aks/production-deploy-to-aks.ipynb) |  |  |  |  |  |  |
 | [production-deploy-to-aks-gpu](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/deployment/production-deploy-to-aks-gpu/production-deploy-to-aks-gpu.ipynb) |  |  |  |  |  |  |
+| [train-explain-model-gpu-tree-explainer](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/explain-model/azure-integration/gpu-explanation/train-explain-model-gpu-tree-explainer.ipynb) |  |  |  |  |  |  |
 | [explain-model-on-amlcompute](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/explain-model/azure-integration/remote-explanation/explain-model-on-amlcompute.ipynb) |  |  |  |  |  |  |
 | [save-retrieve-explanations-run-history](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/explain-model/azure-integration/run-history/save-retrieve-explanations-run-history.ipynb) |  |  |  |  |  |  |
 | [train-explain-model-locally-and-deploy](https://github.com/Azure/MachineLearningNotebooks/blob/master//how-to-use-azureml/explain-model/azure-integration/scoring-time/train-explain-model-locally-and-deploy.ipynb) |  |  |  |  |  |  |

setup-environment/configuration.ipynb

@@ -102,7 +102,7 @@
       "source": [
         "import azureml.core\n",
         "\n",
-        "print(\"This notebook was created using version 1.34.0 of the Azure ML SDK\")\n",
+        "print(\"This notebook was created using version 1.36.0 of the Azure ML SDK\")\n",
         "print(\"You are currently using version\", azureml.core.VERSION, \"of the Azure ML SDK\")"
       ]
     },
@@ -213,10 +213,7 @@
         "* You do not have permission to create a resource group if it's non-existing.\n",
         "* You are not a subscription owner or contributor and no Azure ML workspaces have ever been created in this subscription\n",
         "\n",
-        "If workspace creation fails, please work with your IT admin to provide you with the appropriate permissions or to provision the required resources.\n",
+        "If workspace creation fails, please work with your IT admin to provide you with the appropriate permissions or to provision the required resources.\n"
-        "\n",
-        "**Note**: A Basic workspace is created by default. If you would like to create an Enterprise workspace, please specify sku = 'enterprise'.\n",
-        "Please visit our [pricing page](https://azure.microsoft.com/en-us/pricing/details/machine-learning/) for more details on our Enterprise edition.\n"
       ]
     },
     {
@@ -237,7 +234,6 @@
         "                      resource_group = resource_group, \n",
         "                      location = workspace_region,\n",
         "                      create_resource_group = True,\n",
-        "                      sku = 'basic',\n",
         "                      exist_ok = True)\n",
         "ws.get_details()\n",
         "\n",

tutorials/machine-learning-pipelines-advanced/scripts/batch_scoring.py

@@ -25,8 +25,8 @@ def get_class_label_dict(labels_dir):
     label = []
     labels_path = os.path.join(labels_dir, 'labels.txt')
     proto_as_ascii_lines = tf.gfile.GFile(labels_path).readlines()
-    for l in proto_as_ascii_lines:
+    for temp in proto_as_ascii_lines:
-        label.append(l.rstrip())
+        label.append(temp.rstrip())
     return label
 
 

tutorials/regression-automl-nyc-taxi-data/regression-automated-ml.ipynb

@@ -60,13 +60,6 @@
         "## Download and prepare data"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Import the necessary packages. The Open Datasets package contains a class representing each data source (`NycTlcGreen` for example) to easily filter date parameters before downloading."
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -101,9 +94,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Now that the initial data is loaded, define a function to create various time-based features from the pickup datetime field. This will create new fields for the month number, day of month, day of week, and hour of day, and will allow the model to factor in time-based seasonality. \n",
+        "Remove some of the columns that you won't need for training or additional feature building.  Automate machine learning will automatically handle time-based features such as lpepPickupDatetime."
-        "\n",
-        "Use the `apply()` function on the dataframe to iteratively apply the `build_time_features()` function to each row in the taxi data."
       ]
     },
     {
@@ -112,33 +103,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "def build_time_features(vector):\n",
+        "columns_to_remove = [\"lpepDropoffDatetime\", \"puLocationId\", \"doLocationId\", \"extra\", \"mtaTax\",\n",
-        "    pickup_datetime = vector[0]\n",
-        "    month_num = pickup_datetime.month\n",
-        "    day_of_month = pickup_datetime.day\n",
-        "    day_of_week = pickup_datetime.weekday()\n",
-        "    hour_of_day = pickup_datetime.hour\n",
-        "    \n",
-        "    return pd.Series((month_num, day_of_month, day_of_week, hour_of_day))\n",
-        "\n",
-        "green_taxi_df[[\"month_num\", \"day_of_month\",\"day_of_week\", \"hour_of_day\"]] = green_taxi_df[[\"lpepPickupDatetime\"]].apply(build_time_features, axis=1)\n",
-        "green_taxi_df.head(10)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "Remove some of the columns that you won't need for training or additional feature building."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "columns_to_remove = [\"lpepPickupDatetime\", \"lpepDropoffDatetime\", \"puLocationId\", \"doLocationId\", \"extra\", \"mtaTax\",\n",
         "                     \"improvementSurcharge\", \"tollsAmount\", \"ehailFee\", \"tripType\", \"rateCodeID\", \n",
         "                     \"storeAndFwdFlag\", \"paymentType\", \"fareAmount\", \"tipAmount\"\n",
         "                    ]\n",

tutorials/regression-automl-nyc-taxi-data/regression-automated-ml.yml

@@ -2,4 +2,3 @@ name: regression-automated-ml
 dependencies:
 - pip:
   - azureml-sdk
-  - azureml-opendatasets