DP-100 Practice Questions

Create Scatterplot module: The first requirement is to "visually identify" outliers. A scatterplot is the standard visualization tool to visually inspect the distribution of the 'Age' column and spot data points that deviate significantly from the trend (outliers).

Summarize Data: The second requirement is to "quantify" the outliers. The Summarize Data module generates detailed descriptive statistics (including mean, median, standard deviation, minimum, maximum, and box plot quartiles), which allows you to numerically quantify the range and extent of the outliers observed in the previous step.

Clip Values: Finally, after identifying and quantifying, you use the Clip Values module to define the specific thresholds (peaks/subpeaks) for the outliers. This module is explicitly designed to detect and handle (clip or replace) outliers based on the criteria established in the previous steps.

Microsoft Learn (Azure Machine Learning Studio - Classic): "Use the Clip Values module to identify and optionally replace data values that are above or below a specified threshold. This is useful when you want to remove outliers or replace them with a mean, a constant, or other substitute value."

Source: Azure Machine Learning Studio (classic) Module Reference - Clip Values.

Microsoft Learn (Azure Machine Learning Studio - Classic): "The Summarize Data module... generates a statistical report for each column in the input dataset... The report includes the following statistics: Mean, Median, Mode, Standard Deviation, etc."

Source: Azure Machine Learning Studio (classic) Module Reference - Summarize Data.

edX / Microsoft (DAT203x Data Science Essentials): Course material on "Data Cleansing" explicitly outlines the workflow of visualizing data (histograms/scatterplots), using summary statistics to understand the distribution, and applying the Clip Values module to treat outliers.

Source: Microsoft Professional Program for Data Science - DAT203x Lab Manual.

Deleting an existing Jupyter kernel is not a prerequisite for adding a new one. A compute instance in Azure Machine Learning can support multiple kernels simultaneously. The correct procedure to add a new kernel involves creating a new environment (for example, a Conda environment), activating it, installing the ipykernel package within that environment, and then using the ipykernel command to register the new environment as a kernel. Deleting the default Python 3.6 - AzureML kernel is an unnecessary and potentially disruptive action that does not facilitate the addition of a new kernel.

A. Yes: This is incorrect because deleting the default kernel is not a required step. New kernels are added alongside existing ones, and the system is designed to manage multiple kernels.

1. Microsoft Azure Documentation: Add new Jupyter kernels to a compute instance. This official guide details the process for adding a new kernel. The steps are: 1. Use the terminal to create a new environment. 2. Activate the environment. 3. Install the pip and ipykernel package into the new environment. 4. Install the new kernel. The documentation makes no mention of deleting an existing kernel as a prerequisite.

Source: Microsoft Docs

"How to create and manage an Azure Machine Learning compute instance"

Section: "Add new Jupyter kernels".

2. Microsoft Azure Documentation: Customize a compute instance with a startup script. This document shows advanced customization

including setting up environments and kernels. It demonstrates adding new kernels without removing the default ones

reinforcing that deletion is not a required step.

Source: Microsoft Docs

"Customize a compute instance with a startup script"

Section: "Example scripts".

3. Jupyter Project Documentation: Kernels for different environments. The official documentation for Jupyter (the underlying technology in Azure ML Notebooks) explains how to install kernels. The process always involves creating an environment and registering it

allowing multiple kernels to coexist.

Source: IPython/Jupyter Documentation

"Kernels for different environments"

Section: "Installing a kernel".

To assess fairness using the Fairlearn dashboard in Azure Machine Learning, you must follow a specific configuration flow:

1. Model Selection: First, you must identify the supported model type. The Fairlearn dashboard primarily supports binary classification and regression models. (While the open-source package has expanded, the Azure integration and this specific exam question focus on these core supported types, excluding clustering).
2. Feature Selection: Next, you must select the sensitive feature (model feature to be evaluated), such as "Gender" or "Race." This allows the dashboard to slice the data into cohorts for comparison.
3. Metric Selection: Finally, you select the performance metric to be measured (e.g., Accuracy, Precision) and the specific fairness metric (e.g., Demographic Parity difference) to quantify the disparity between the selected groups.

Source 1: Microsoft Learn. "Assess model fairness in Azure Machine Learning." This documentation outlines the supported scenarios (classification and regression) and the workflow of configuring the dashboard by defining sensitive features and performance metrics.

Relevant Quote: "Fairlearn allows you to assess the fairness of your model... It supports classification and regression models." "To assess fairness, you need to... select the sensitive feature... select the performance metric."

URL: https://learn.microsoft.com/en-us/azure/machine-learning/how-to-machine-learning-fairness-aml

Source 2: Fairlearn Official Documentation (User Guide - Dashboard).

Relevant Context: The dashboard setup wizard explicitly asks users to select the sensitive feature first ("Select a sensitive feature") before asking for the performance metric ("Select a performance metric").

URL: https://fairlearn.org/v0.7.0/user_guide/dashboard.html (Note: Fairlearn is the underlying open-source tool integrated into Azure ML).

Source 3: Microsoft Learn - "Use the Fairlearn dashboard".

Step-by-step confirmation: The UI workflow guides the user to "Select the attribute" (Feature) -> "Select the metric" (Metric).

URL: https://learn.microsoft.com/en-us/azure/machine-learning/concept-fairness-ml

To add a new Jupyter kernel based on a specific set of dependencies, you must follow a standard environment setup workflow in the terminal.

1. Create: First, isolate the dependencies by creating a new Conda environment (conda create -n "python_env").
2. Activate: Switch the terminal context to this new environment (conda activate "python_env") to ensure subsequent commands apply to it.
3. Install: Install the required packages listed in the requirements file. While standard Conda syntax uses --file, the provided option (conda install -r...) represents this installation step in the context of the available choices.
4. Register: Finally, register the environment with Jupyter so it appears as a selectable kernel in the interface (ipython kernel install...).

Microsoft Learn - Access a compute instance terminal in your workspace (Add new kernels): This article details the exact process of creating a conda environment, activating it, installing ipykernel (or dependencies), and registering the kernel.

Source: https://learn.microsoft.com/en-us/azure/machine-learning/how-to-access-terminal?view=azureml-api-2#add-new-kernels

IPython Documentation - Kernels for different environments: Documents the command ipython kernel install (or python -m ipykernel install) to register a kernel for the current user.

Source: https://ipython.readthedocs.io/en/stable/install/kernel_install.html

In Azure Machine Learning jobs, when defining an output (such as a trained MLflow model), the mode property specifies how the data is made available to the job on the compute target and written to the destination storage. The three valid modes for job outputs are:

rwmount (Read-Write Mount): This mode mounts the specified storage location as a read-write directory on the compute target. The job can directly read from and write to the storage location during execution.

upload: In this mode, the job writes its output to a temporary local directory on the compute target. After the job completes, the contents of this directory are uploaded to the specified destination storage. This is the default mode for outputs.

direct: This mode is typically used in pipelines to pass metadata or simple data types between steps without writing to a storage account.

B. romount: This is a read-only mount mode. It is used for job inputs, not outputs, as outputs require write permissions.

D. download: This mode is used for job inputs. It downloads the data from the storage location to the compute target before the job starts.

1. Microsoft Official Documentation: Read and write data in a job. This document explicitly lists the data access modes for both inputs and outputs.

Section: "Output modes"

Content: "For job outputs

Azure Machine Learning supports three modes: rwmount

upload

direct."

2. Microsoft Official Documentation: YAML: command job. This reference for the command job YAML schema details the properties for job inputs and outputs.

Section: "Job outputs" -> "Table" -> "mode"

Content: The documentation specifies that the accepted values for the mode property of an output are upload

rwmount

and direct.

3. Microsoft Official Documentation: azure.ai.ml.Output Class Reference. The Python SDK v2 documentation for the Output class confirms the available modes.

Parameter: mode

Content: "Mode of the output. Can be romount

rwmount

download

upload

or direct. The default is upload for outputs." (Note: While the docstring lists all modes

romount and download are functionally for inputs

and the context of an output requires a writeable mode like rwmount or upload).

The user's goal is to find the optimal combination of batch size and learning rate for a custom training script by minimizing the validation loss. This process is known as hyperparameter tuning. Azure Machine Learning provides the HyperDrive service specifically for this task. A HyperDriveConfig object is used to configure the tuning experiment. It defines the script to run (via a ScriptRunConfig), the hyperparameter space to search, the sampling method, the primary metric to optimize (validation loss), and an optional early termination policy. HyperDrive then automates launching and managing multiple child runs to efficiently find the best hyperparameter combination based on the logged metric.

A. Run the script in an experiment based on an AutoMLConfig object

Automated ML (AutoML) automatically selects and tunes algorithms from its own predefined set; it does not tune the hyperparameters of a user-provided custom script.

B. Create a PythonScriptStep object for the script and run it in a pipeline

A PythonScriptStep is for executing a single script within a larger workflow. It does not provide the automated search and optimization capabilities required for hyperparameter tuning.

C. Use the Automated Machine Learning interface in Azure Machine Learning studio

This is the user interface for AutoML (Option A). It is used for automated model selection and tuning, not for optimizing a custom user script.

D. Run the script in an experiment based on a ScriptRunConfig object

A ScriptRunConfig is used to configure and submit a single training run. While it is a necessary component for a HyperDrive run, it cannot perform the tuning process on its own.

1. Microsoft Azure Official Documentation

"Tune hyperparameters for your model with Azure Machine Learning": This document explicitly states

"Automate efficient hyperparameter tuning by using Azure Machine Learning HyperDrive package." It details the required components for a HyperDrive run: a training script

a defined hyperparameter space

a primary metric to optimize

and a termination policy

which directly aligns with the user's scenario.

Source: Microsoft Learn

learn.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters

Section: "What is hyperparameter tuning?".

2. Microsoft Azure Official Documentation

HyperDriveConfig class: The SDK reference for the HyperDriveConfig class shows that its constructor requires a run configuration (like ScriptRunConfig)

a hyperparametersampling object

and a primarymetricname. This confirms it is the specific object designed to configure a hyperparameter tuning experiment around a user's script.

Source: Microsoft Learn

learn.microsoft.com/en-us/python/api/azureml-train-hyperdrive/azureml.train.hyperdrive.hyperdriveconfig

Class constructor parameters.

3. Microsoft Azure Official Documentation

"What is automated machine learning (AutoML)?": This document clarifies that AutoML is for training and tuning models on a given dataset by iterating over algorithms and feature selections. It does not integrate and tune an external

user-defined training script.

Source: Microsoft Learn

learn.microsoft.com/en-us/azure/machine-learning/concept-automated-ml

Section: "When to use AutoML".

First, the Import Data module is required to ingest the raw dataset into the experiment. Second, to address the "high degree of missing values," the Clean Missing Data module must be applied; it provides specific methods (like MICE or mean substitution) to impute or remove incomplete rows, ensuring the data is analysis-ready. Finally, to "divide the data into four subsets," you must use the Partition and Sample module. Unlike the "Split Data" module (which only supports a 2-way split), Partition and Sample includes an "Assign to Folds" mode that allows you to specify exactly four folds or partitions for cross-validation or subsampling.

Microsoft Learn - Clean Missing Data component: "Use this component to remove, replace, or infer missing values... The goal of such cleaning operations is to prevent problems caused by missing data."

Source: Clean Missing Data component reference

Microsoft Learn - Partition and Sample component: "Use the Assign to Folds option when you want to divide the dataset into subsets of the data... This option is useful when you want to create a custom number of folds for cross-validation."

Source: Partition and Sample component reference

Microsoft Learn - Import Data component: Describes the necessity of loading data from various sources to begin an experiment.

Source: Import Data component reference

The solution is incorrect because it proposes using amltoken authentication. Azure Machine Learning tokens (amltoken) are time-bound security artifacts that expire, requiring clients to periodically request a new token. The goal explicitly requires a non-expiring artifact. The appropriate authentication method for this requirement is key-based authentication (authmode = 'key'), which provides static primary and secondary keys that do not expire unless they are manually regenerated by the user. Since the proposed solution uses an authentication method with an expiring artifact, it does not meet the stated goal.

A. Yes: This is incorrect. The amltoken authentication method uses tokens that expire, which directly contradicts the requirement for a non-expiring artifact for application access.

1. Microsoft. (2023). Authenticate clients for online endpoints. Microsoft Learn. Retrieved from https://learn.microsoft.com/en-us/azure/machine-learning/how-to-authenticate-online-endpoint.

Section: Authenticate with keys: This section states

"Authentication with a key is common for existing clients and is a simple approach... Keys don't expire

but they can be regenerated." This confirms that keys are non-expiring artifacts.

Section: Authenticate with tokens: This section explicitly states

"Azure Machine Learning tokens (amltoken) and Azure Active Directory tokens (aadtoken) both have an expiration." This confirms that amltoken is an expiring artifact

making it unsuitable for the stated goal.

To partition a dataset based on a specific text criterion in a column, the Regular expression splitting mode is the most effective approach. In the Azure Machine Learning designer's Split Data module, when using the "Regular expression" mode, the syntax requires specifying the column name followed by the pattern to match.

The syntax \"nation" USA targets the column named nation and filters for rows where the value is USA. The first output (Result dataset 1) will contain all rows matching this expression (USA data), while the second output (Result dataset 2) will contain all remaining rows (all other nations), satisfying the requirement.

Microsoft Official Documentation: Split Data module reference - Azure Machine Learning. [Online]. Available: https://learn.microsoft.com/en-us/azure/machine-learning/component-reference/split-data. (Section: "Regular Expression")

Microsoft Learn: Create a machine learning model with Azure Machine Learning designer. [Online]. Available: https://learn.microsoft.com/en-us/training/modules/create-regression-model-azure-machine-learning-designer/.

Microsoft Azure Documentation: Filter and transform data in Azure Machine Learning designer. (Document ID: aml-designer-transform-data).

Causal analysis is the correct component for observing the "impact of treatment policy." It uses historical data to estimate the real-world effect of an intervention (treatment) on a specific outcome, allowing users to understand how changing a policy might affect metrics.

Counterfactual analysis is the correct component for observing the "effect of change in data" (specifically, examples with minimal changes that alter the prediction). It generates synthetic data points—closest to the original input—that result in a different model prediction (e.g., flipping a loan denial to approval), identifying the minimal perturbation required.

Microsoft Learn. (2023). Responsible AI dashboard in Azure Machine Learning studio. Retrieved from https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard

Relevant Section: "Causal analysis" (describes estimating the effect of treatment features on real-world outcomes).

Relevant Section: "Counterfactual analysis and what-if" (describes generating diverse counterfactual examples with minimal changes to see prediction flips).

Microsoft Learn. (2023). Generate a Responsible AI dashboard with YAML and Python. Retrieved from https://learn.microsoft.com/en-us/azure/machine-learning/how-to-responsible-ai-dashboard

Relevant Section: "Component-specific parameters" covers the configuration for both causal (treatment features) and counterfactual (desired range, perturbation).