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

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

@@ -17,7 +17,6 @@ dependencies:
 - notebook
 - pywin32==227
 - PySocks==1.7.1
-- Pygments==2.11.2
 - conda-forge::pyqt==5.12.3
 
 - pip:

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

@@ -242,6 +242,34 @@
         ")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### 2.4 Configure data with ``OutputFileDatasetConfig`` objects\n",
+        "This step shows how to configure output data from a pipeline step. One of the use cases for this step is when you want to do some preprocessing before feeding the data to training step. Intermediate data (or output of a step) is represented by an ``OutputFileDatasetConfig`` object. ``output_data`` is produced as the output of a step. Optionally, this data can be registered as a dataset by calling the ``register_on_complete`` method. If you create an ``OutputFileDatasetConfig`` in one step and use it as an input to another step, that data dependency between steps creates an implicit execution order in the pipeline.\n",
+        "\n",
+        "``OutputFileDatasetConfig`` objects return a directory, and by default write output to the default datastore of the workspace.\n",
+        "\n",
+        "Since instance creation for class ``OutputTabularDatasetConfig`` is not allowed, we first create an instance of this class. Then we use the ``read_parquet_files`` method to read the parquet file into ``OutputTabularDatasetConfig``."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.data.output_dataset_config import OutputFileDatasetConfig\n",
+        "\n",
+        "output_data = OutputFileDatasetConfig(\n",
+        "    name=\"processed_data\", destination=(dstore, \"outputdataset/{run-id}/{output-name}\")\n",
+        ").as_upload()\n",
+        "# output_data_dataset = output_data.register_on_complete(\n",
+        "#     name='processed_data', description = 'files from prev step')\n",
+        "output_data = output_data.read_parquet_files()"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -303,6 +331,48 @@
         "    print(compute_target.status.serialize())"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Configure the training run's environment\n",
+        "The next step is making sure that the remote training run has all the dependencies needed by the training steps. Dependencies and the runtime context are set by creating and configuring a RunConfiguration object.\n",
+        "\n",
+        "The code below shows two options for handling dependencies. As presented, with ``USE_CURATED_ENV = True``, the configuration is based on a [curated environment](https://docs.microsoft.com/en-us/azure/machine-learning/resource-curated-environments). Curated environments have prebuilt Docker images in the [Microsoft Container Registry](https://hub.docker.com/publishers/microsoftowner). For more information, see [Azure Machine Learning curated environments](https://docs.microsoft.com/en-us/azure/machine-learning/resource-curated-environments).\n",
+        "\n",
+        "The path taken if you change ``USE_CURATED_ENV`` to False shows the pattern for explicitly setting your dependencies. In that scenario, a new custom Docker image will be created and registered in an Azure Container Registry within your resource group (see [Introduction to private Docker container registries in Azure](https://docs.microsoft.com/en-us/azure/container-registry/container-registry-intro)). Building and registering this image can take quite a few minutes."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.core.runconfig import RunConfiguration\n",
+        "from azureml.core.conda_dependencies import CondaDependencies\n",
+        "from azureml.core import Environment\n",
+        "\n",
+        "aml_run_config = RunConfiguration()\n",
+        "aml_run_config.target = compute_target\n",
+        "\n",
+        "USE_CURATED_ENV = True\n",
+        "if USE_CURATED_ENV:\n",
+        "    curated_environment = Environment.get(\n",
+        "        workspace=ws, name=\"AzureML-sklearn-0.24-ubuntu18.04-py37-cpu\"\n",
+        "    )\n",
+        "    aml_run_config.environment = curated_environment\n",
+        "else:\n",
+        "    aml_run_config.environment.python.user_managed_dependencies = False\n",
+        "\n",
+        "    # Add some packages relied on by data prep step\n",
+        "    aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(\n",
+        "        conda_packages=[\"pandas\", \"scikit-learn\"],\n",
+        "        pip_packages=[\"azureml-sdk\", \"azureml-dataset-runtime[fuse,pandas]\"],\n",
+        "        pin_sdk_version=False,\n",
+        "    )"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -366,6 +436,46 @@
         ")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Construct your pipeline steps\n",
+        "Once you have the compute resource and environment created, you're ready to define your pipeline's steps. There are many built-in steps available via the Azure Machine Learning SDK, as you can see on the [reference documentation for the azureml.pipeline.steps package](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps?view=azure-ml-py). The most flexible class is [PythonScriptStep](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.python_script_step.pythonscriptstep?view=azure-ml-py), which runs a Python script.\n",
+        "\n",
+        "Your data preparation code is in a subdirectory (in this example, \"data_preprocessing_tabular.py\" in the directory \"./scripts\"). As part of the pipeline creation process, this directory is zipped and uploaded to the compute_target and the step runs the script specified as the value for ``script_name``.\n",
+        "\n",
+        "The ``arguments`` values specify the inputs and outputs of the step. In the example below, the baseline data is the ``input_ds_small`` dataset. The script data_preprocessing_tabular.py does whatever data-transformation tasks are appropriate to the task at hand and outputs the data to ``output_data``, of type ``OutputFileDatasetConfig``. For more information, see [Moving data into and between ML pipeline steps (Python)](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-move-data-in-out-of-pipelines). The step will run on the machine defined by ``compute_target``, using the configuration ``aml_run_config``.\n",
+        "\n",
+        "Reuse of previous results (``allow_reuse``) is key when using pipelines in a collaborative environment since eliminating unnecessary reruns offers agility. Reuse is the default behavior when the ``script_name``, ``inputs``, and the parameters of a step remain the same. When reuse is allowed, results from the previous run are immediately sent to the next step. If ``allow_reuse`` is set to False, a new run will always be generated for this step during pipeline execution.\n",
+        "\n",
+        "> Note that we only support partitioned FileDataset and TabularDataset without partition when using such output as input."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from azureml.pipeline.steps import PythonScriptStep\n",
+        "\n",
+        "dataprep_source_dir = \"./scripts\"\n",
+        "entry_point = \"data_preprocessing_tabular.py\"\n",
+        "ds_input = input_ds_small.as_named_input(\"train_10_models\")\n",
+        "\n",
+        "data_prep_step = PythonScriptStep(\n",
+        "    script_name=entry_point,\n",
+        "    source_directory=dataprep_source_dir,\n",
+        "    arguments=[\"--input\", ds_input, \"--output\", output_data],\n",
+        "    compute_target=compute_target,\n",
+        "    runconfig=aml_run_config,\n",
+        "    allow_reuse=False,\n",
+        ")\n",
+        "\n",
+        "input_ds_small = output_data"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},