Free DP-100 Practice Test Questions and Answers (2026) Practice Questions

Box 1: Analysis()

The code snippet demonstrates a differentially private aggregation query (calculating the mean) rather than the generation of a synthetic dataset. In the SmartNoise SDK (based on OpenDP), the Analysis() class is the context manager used to define the computation graph, track the state of the privacy budget, and execute the query. QAUILSynthesizer and MWEMSynthesizer are used for synthesizing new, fake datasets that mimic the statistical properties of the original data, which is not the objective here.

Box 2: epsilon

The privacy_usage parameter in the dp_mean function specifies how much privacy budget this specific operation should consume. In differential privacy, the primary budget parameter is epsilon ($\epsilon$), which quantifies the privacy loss. The standard syntax for defining this usage in SmartNoise is a dictionary where the key is 'epsilon' (and optionally 'delta'). The code requires defining the specific budget spend for the mean calculation, making epsilon the correct key.

Microsoft Learn. (2023). Explore differential privacy. "Use the SmartNoise package." Retrieved from https://learn.microsoft.com/en-us/training/modules/explore-differential-privacy/2-smartnoise

Relevance: Confirms the use of with sn.Analysis() as analysis: as the standard context for running DP queries in the Azure ML SmartNoise tutorials.

Microsoft Learn. (2023). Implement differential privacy with the SmartNoise package. "Define the analysis." Retrieved from https://learn.microsoft.com/en-us/azure/machine-learning/how-to-differential-privacy

Relevance: Documents the privacy_usage parameter, showing examples of privacy_usage={'epsilon': 1}.

OpenDP/SmartNoise Core Documentation. (n.d.). System Architecture.

Relevance: Describes the Analysis class as the engine for validating and executing the privacy definition.

To produce a visualization for a diagnostic test evaluation (which is a binary classification task, e.g., Disease vs. No Disease), the standard workflow in Azure Machine Learning is:

1. Train Model: You must first train a classification algorithm using a training dataset to learn the patterns.
2. Score Model: The trained model is then applied to a testing dataset to generate predictions (scores) and probabilities.
3. Evaluate Model: The scored dataset is passed to this module to calculate metrics (accuracy, precision, recall) and generate visualizations such as the ROC curve (Receiver Operating Characteristic) and Confusion Matrix, which are standard for diagnostic evaluations.

Microsoft Learn - Evaluate Model: Describes how the module "generates a set of metrics... and visualizations" for classification models (e.g., ROC curves) and requires a "scored dataset" as input.

Source: Evaluate Model module - Azure Machine Learning

Microsoft Learn - Score Model: Explains that this module "generates predictions using a trained classification or regression model" and is a prerequisite for evaluation.

Source: Score Model module - Azure Machine Learning

Microsoft Learn - Train Model: Defines the process of training a classification model which is the necessary first step before scoring and evaluation.

Source: Train Model module - Azure Machine Learning

To define the parameter scope, you must select the Two-Class Boosted Decision Tree module and change the "Create trainer mode" property to "Parameter Range," allowing specification of value ranges. To define cross-validation settings, the Partition and Sample module is used with the "Assign to Folds" option to divide the dataset into folds. The Tune Model Hyperparameters module is used to define the metric (via the "Rank results by" property) and to train, evaluate, and compare the models, as it iterates through the parameter combinations using the defined folds and metric to output the best model.

Microsoft Azure Machine Learning Studio (Classic) Documentation, "Tune Model Hyperparameters":

"This article describes how to use the Tune Model Hyperparameters module... to determine the optimum hyperparameters for a model." "Rank results by: Specify the metric to use for ranking the models..." "The module iterates over the settings... and determines the set of parameters that produces the best results."

Source: https://learn.microsoft.com/en-us/azure/machine-learning/studio-module-reference/tune-model-hyperparameters

Microsoft Azure Machine Learning Studio (Classic) Documentation, "Partition and Sample":

"Assign to Folds: Use this option when you want to create a dataset for cross-validation."

Source: https://learn.microsoft.com/en-us/azure/machine-learning/studio-module-reference/partition-and-sample

Microsoft Azure Machine Learning Studio (Classic) Documentation, "Two-Class Boosted Decision Tree":

"Create trainer mode: Select the Parameter Range option if you are not sure of the best parameters... You can then iterate over a range of values using the Tune Model Hyperparameters module."

Source: https://learn.microsoft.com/en-us/azure/machine-learning/studio-module-reference/two-class-boosted-decision-tree

When a real-time inference pipeline is generated from a training pipeline in Azure Machine Learning designer, the Web Service Input module schema is based on the original training dataset, which includes the label column. The requirement is that the deployed service should not expect the label as an input. The standard, documented procedure to resolve this is to modify the inference pipeline by inserting a Select Columns in Dataset module immediately after the Web Service Input module. This module is then configured to exclude the label column, ensuring that only the feature columns are passed to the Score Model module for prediction. This correctly adjusts the data schema within the pipeline for inference.

B: Deleting the dataset from the training pipeline is incorrect. The dataset is required for training, and the task is to modify the already-generated inference pipeline.

C: The Web Service Input module is the entry point for data in the deployed endpoint. Deleting it would make the inference pipeline non-functional.

D: The inference pipeline is generated automatically with a Web Service Input module. The standard practice is not to replace this module but to modify the data stream that flows from it.

1. Microsoft Learn Documentation. In the official tutorial for deploying a designer model

the exact scenario is addressed. After creating the real-time inference pipeline

the documentation explicitly instructs the user to "Remove the label column... using the Select Columns in Dataset module" and place it between the Web Service Input and Score Model modules.

Source: Microsoft

"Tutorial: Deploy a machine learning model with the designer

" Azure Machine Learning Documentation.

Reference: See the section "Create a real-time inference pipeline

" Step 4.

2. Microsoft Learn Documentation. The reference for the Select Columns in Dataset module describes its function as choosing a subset of columns for downstream operations

which is precisely its use case in this scenario—to filter out the label column before scoring.

Source: Microsoft

"Select Columns in Dataset component

" Azure Machine Learning Component Reference.

Reference: See the "Overview" section.

Azure Machine Learning Service, through its Python SDK, provides the necessary environment to meet all requirements. Data scientists can install the SDK and required frameworks (Caffe2, Chainer) on their personal devices. This setup allows them to write, test, and build machine learning pipelines locally, even in a disconnected network environment. When a network connection is available, they can connect to the Azure Machine Learning workspace to submit training jobs to powerful cloud compute, manage models, and update shared pipelines, fulfilling the hybrid connected/disconnected workflow.

B. Azure Machine Learning Studio: This is a web-based, visual interface that requires a constant internet connection to function and cannot be used in a disconnected environment.

C. Azure Databricks: This is a cloud-based Apache Spark platform. While powerful, its primary interface is a web-based workspace that is not designed for disconnected, local development on personal devices.

D. Azure Kubernetes Service (AKS): AKS is a container orchestration service used as a deployment or compute target. It is not a data science development environment for building pipelines.

1. Azure Machine Learning SDK for local development: Microsoft's official documentation details how to set up a local development environment using the SDK. It states

"You can configure a local development environment using the Azure Machine Learning SDK for Python... The SDK can be installed in your local environment". This supports the requirement for working on personal devices.

Source: Microsoft Docs

"Set up a development environment for Azure Machine Learning"

Section: "Local computer".

2. Support for custom frameworks: Azure Machine Learning environments allow for the use of any framework

including Caffe2 and Chainer. You can define an environment using a Conda specification file or a Dockerfile to install the necessary libraries.

Source: Microsoft Docs

"Create and use software environments in Azure Machine Learning"

Section: "What are environments?".

3. Hybrid local and cloud workflow: The SDK is designed to support a workflow where development and testing can occur locally

and then scaled-out training or pipeline execution can be submitted to cloud compute resources when connected.

Source: Microsoft Docs

"What is Azure Machine Learning?"

Section: "SDKs". This section explains how the SDK allows you to "access the service from any Python environment".

4. Distinction from Azure Machine Learning Studio: The documentation clearly distinguishes the SDK/CLI approach from the web-based Studio

noting that Studio is a "no-code and low-code option" for model development

which inherently requires a connection.

Source: Microsoft Docs

"What is Azure Machine Learning?"

Section: "Comparison of studio

SDKs

and CLI".

To perform a manual evaluation in Azure AI Foundry, you first import data in CSV format (or JSONL) containing the test prompts into the Manual Evaluation interface. Once the model generates responses for these prompts, you provide thumbs up or down ratings to model responses to grade their quality (correctness, safety, etc.). Finally, you save the evaluation results to the project, allowing you to view statistics and compare performance over time.

Microsoft Learn: Evaluate generative AI apps with Azure AI Foundry

Context: Describes the manual evaluation workflow. "You can import stored Chat Completions, create data using provided default templates, or upload your own data [CSV/JSONL]... You can then review the model responses and provide a thumbs up or thumbs down rating."

Source: Learn.microsoft.com - Evaluate generative AI apps

Microsoft Learn: View and manage evaluation results

Context: "After you complete a manual evaluation, you can save the results. These results are stored in your project and can be reviewed later in the Evaluation page."

Source: Learn.microsoft.com - See evaluation results in Microsoft Foundry portal

Azure AI Foundry Documentation: Manual Evaluation

Context: "Manual evaluation... allows you to import a test dataset... manually review the application's generated outputs... [and] provide feedback (thumbs up/down)."

Source: Learn.microsoft.com - Concepts - Evaluation

First, Remove duplicate rows ensures data integrity, as duplicate observations can distort correlation calculations and bias the model. Second, Compute linear correlation is the specific diagnostic step required to quantify and identify the pairs of independent variables that are "highly correlated" (multicollinearity), as stated in the problem. Finally, Use the Filter Based Feature Selection module is the effective feature engineering action to select the subset of features that have the highest predictive power (correlation with the target), thereby excluding the redundant correlated features identified in the previous step.

Microsoft Learn - Filter Based Feature Selection: Confirms this module is used to identify the columns with the greatest predictive power and select the best feature columns, utilizing metrics like Pearson correlation.

Source: Filter Based Feature Selection component - Azure Machine Learning

Microsoft Learn - Compute Linear Correlation: Describes the module's use in calculating the Pearson correlation coefficient to measure the linear relationship between two variables, essential for detecting multicollinearity.

Source: Compute Linear Correlation component - Azure Machine Learning

Academic/Industry Standard (Multicollinearity): Standard data science methodology dictates that duplicates must be removed before statistical analysis, and multicollinearity is detected via correlation matrices before feature selection.

Context: "Multicollinearity occurs when independent variables in a regression model are correlated... This redundancy involves checking the correlation matrix."

To achieve the specific output provided, you must correctly configure the KFold cross-validator:

1. Import: The class in sklearn.model_selection used for this strategy is KFold. Note that Python is case-sensitive; "k-fold" is the concept, while KFold is the class name.
2. n_splits: The output shows 3 distinct "train/test" pairs (iterations). Therefore, n_splits must be set to 3. With 6 data points, this creates 3 folds of 2 samples each.
3. Split Method: The .split() method of the KFold object requires the dataset as its primary argument to generate the indices for the training and testing sets. In this context, the variable is data.

Scikit-learn API Reference: sklearn.model_selection.KFold documentation. Section: "Cross-validation: evaluating estimator performance." Link to Scikit-learn Documentation

Pedregosa, F. et al. (2011). "Scikit-learn: Machine Learning in Python." Journal of Machine Learning Research, 12, pp. 2825-2830. Link to JMLR

Buitinck, L. et al. (2013). "API design for machine learning software: experiences from the scikit-learn project." arXiv preprint arXiv:1309.0238. DOI: 10.48550/arXiv.1309.0238

Box 1 (container_name): When defining an AzureBlobDatastore object in the Python SDK v2, the parameter used to specify the storage location is container_name. The parameter filesystem is exclusively used for AzureDataLakeGen2Datastore, and file_share_name is used for AzureFileDatastore.

Box 2 (wasbs): The protocol parameter defines the connection protocol to the storage service. For Azure Blob Storage, the supported protocols are https (default) and wasbs (Windows Azure Storage Blob Secure). The abfss protocol is specific to Azure Data Lake Storage Gen2 (ADLS Gen2), and azureml is a URI scheme used to reference registered datastores in job inputs, not to define the connection itself.

Microsoft Learn - Python SDK v2 Reference: Validates that the AzureBlobDatastore class uses container_name and supports wasbs or https as protocols.

Source: azure.ai.ml.entities.AzureBlobDatastore class | Microsoft Learn

Microsoft Learn - Data Concepts: Confirms URI schemes where wasbs applies to Blob Storage and abfss applies to ADLS Gen2.

Source: "Data concepts in Azure Machine Learning" - Section: URIs

GitHub - AzureML Examples: Provides explicit code examples where protocol="wasbs" is used for AzureBlobDatastore.

Source: AzureML SDK v2 Datastore Notebook Examples (official Microsoft GitHub repository)

In Azure Machine Learning studio, the Profile tab for a data asset generates a comprehensive statistical summary and visualizations for each column. For a numeric column like column1, this profile includes a histogram, which visually represents the data's distribution. By observing if the histogram forms a bell-shaped curve, you can visually assess normality. The profile also provides key statistics like mean, median, standard deviation, skewness, and kurtosis, which are quantitative measures used to formally check for a normal distribution.

A. Max: The maximum value is a single statistic indicating the upper bound of the data. It does not provide information about the overall shape of the distribution.

B. Type: The data type (e.g., decimal) describes the format of the data in the column, not the statistical distribution of its values.

D. Mean: The mean is a measure of central tendency. While it is a key parameter of a normal distribution, it alone is insufficient to determine the distribution's shape.

1. Microsoft Documentation: Create data assets.

Reference: In the "Explore the data" section

it states: "In the data asset details page

select the Profile tab. The profile tab provides a variety of summary statistics for the data... For numeric columns

you'll see summary statistics like min

max

mean

median

standard deviation

and a histogram of the distribution." This confirms that the Profile feature is the tool used to analyze distributions.

Source: Microsoft

"Create data assets - Azure Machine Learning

" Microsoft Learn

accessed May 20

2024. [Link to specific section on data exploration/profiling in the official documentation].

2. Microsoft Documentation: Tutorial: Create a production machine learning pipeline with Python SDK v2.

Reference: In Step 4

"Create training script

" the tutorial discusses data preparation and understanding. The concept of profiling data to understand its characteristics

including distribution

is a fundamental step implicitly covered by the data exploration capabilities of the platform

which are visually represented by the Profile tab in the UI.

Source: Microsoft

"Tutorial: Create a production machine learning pipeline with Python SDK v2 - Part 3 of 4

" Microsoft Learn

accessed May 20

2024. [Link to the tutorial section discussing data handling].

The solution fails because it attempts to pass data between steps using a Pandas DataFrame (data_output = pd.read_csv(...)), which resides in local memory. In an Azure Machine Learning pipeline, steps typically run on remote compute targets (like aml_compute). To pass data between these isolated steps, you must use a PipelineData object (v1) or Output/Input types (v2). The current code treats a local variable as a pipeline output, which is not supported; the training step will not have access to the data processed by the first step. Additionally, PythonScriptStep expects a list of OutputFileDatasetConfig or PipelineData for the outputs parameter, not a DataFrame object.

A. Yes This is incorrect because a Pandas DataFrame cannot act as a data bridge between remote pipeline steps; it lacks the necessary metadata and persistence to be serialized across compute nodes.

Official Vendor Documentation: Microsoft Azure Machine Learning SDK v1 - PipelineData Class. Link: Microsoft Learn - PipelineData

Official Vendor Documentation: How to move data in machine learning pipeline steps (Python). Section: "Use PipelineData for intermediate data." Link: Microsoft Learn - Moving Data

Official Vendor Documentation: PythonScriptStep Class Reference. Parameters: outputs and inputs. Link: Microsoft Learn - PythonScriptStep

The model fit issue indicated by the options is overfitting (high variance), likely in a regression scenario. To correct this, you should perform the following sequence:

1. Augment the data: Increasing the size and diversity of the training dataset is the most effective way to help a model generalize better and reduce overfitting.
2. Add the Bayesian Linear Regression module: Unlike standard Linear Regression, the Bayesian approach uses probability distributions for weights (priors). It is explicitly recommended in Azure documentation for small datasets and is inherently robust against overfitting.
3. Configure the regularization weight: The Bayesian Linear Regression module includes a "Regularization weight" parameter (default 1.0). Adjusting this weight controls the penalty on the model's complexity, further mitigating overfitting.

Microsoft Learn - Azure Machine Learning Studio (classic) Module Reference: Bayesian Linear Regression.

Quote: "This approach is often useful when you have a small dataset... and it is robust to overfitting."

Parameter Reference: "Regularization weight: Defines the regularization weight. Regularization prevents overfitting."

Link: https://learn.microsoft.com/en-us/previous-versions/azure/machine-learning/studio-module-reference/bayesian-linear-regression

Microsoft Learn - Cloud-scale analytics: Machine learning glossary of terms.

Context: Defines Overfitting and suggests solutions including adding more data (augmenting) and using regularization.

Link: https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/innovate/best-practices/ml-glossary#overfitting

Microsoft Learn - Configure the Linear Regression Module:

Context: Discusses the use of the L2 regularization weight parameter to prevent overfitting in regression models.

Link: https://learn.microsoft.com/en-us/previous-versions/azure/machine-learning/studio-module-reference/linear-regression

The scenario describes a compute cluster that is "fully-utilized" and cannot meet the inferencing demand, indicating that its maximum capacity has been reached. The most direct, efficient, and least disruptive way to increase the total processing capacity of a compute cluster like Azure Kubernetes Service (AKS) is through horizontal scaling, which involves adding more compute nodes. This action allows the service to handle more concurrent requests by distributing the load across a larger number of machines. This approach directly addresses the performance bottleneck with minimal administrative effort and without requiring service redeployment, thus ensuring minimal downtime.

A. Increasing the minimum node count only affects the baseline number of nodes for autoscaling; it does not raise the maximum capacity, which is the current limitation.

B. Creating a new cluster and redeploying is a complex migration process (blue-green deployment) that requires significant administrative effort and planning, contradicting the requirements.

C. Increasing the VM size (vertical scaling) is more disruptive than adding nodes, often requiring the creation of a new node pool and draining the old one, which is not a minimal effort task.

1. Microsoft Azure Documentation

"Troubleshoot model deployment": In the section on autoscaling

the documentation explains that when a service fails because the cluster is at maximum capacity

the solution is to increase the capacity. It states

"To change the maximum number of nodes in the cluster

you need to update the compute target." This directly supports increasing the node count to handle higher loads.

Source: Microsoft Corporation. (2023). Troubleshoot model deployment with Azure Machine Learning. Microsoft Docs. Retrieved from https://docs.microsoft.com/en-us/azure/machine-learning/how-to-troubleshoot-deployment#autoscaling (Refer to the section on Autoscaling).

2. Microsoft Azure Documentation

"Scale cluster in Azure Kubernetes Service (AKS)": This document details the procedures for scaling an AKS cluster. It highlights that scaling the node count is the primary method for adjusting compute capacity to meet application demands. The process can be done manually with a single command (az aks scale)

which exemplifies minimal administrative effort and is designed to be non-disruptive to running applications.

Source: Microsoft Corporation. (2023). Scale the node count in an Azure Kubernetes Service (AKS) cluster. Microsoft Docs. Retrieved from https://docs.microsoft.com/en-us/azure/aks/scale-cluster (Refer to the "Manually scale cluster nodes" section).

3. Microsoft Azure Documentation

"Deploy a model to an Azure Kubernetes Service cluster": This guide explains how to configure an AKS cluster for machine learning workloads

including setting autoscaling parameters. It notes that if autoscaling is not enabled

the cluster operates with a fixed number of nodes

which can be changed manually. If autoscaling is enabled but the maximum is reached

the solution is to increase the autoscalemaxnodes parameter when updating the compute target. Both actions are equivalent to increasing the node count.

Source: Microsoft Corporation. (2023). Deploy a model to an Azure Kubernetes Service cluster. Microsoft Docs. Retrieved from https://docs.microsoft.com/en-us/azure/machine-learning/how-to-deploy-azure-kubernetes-service (Refer to the "Autoscaling" section).

In the Azure Machine Learning designer, the asset library on the left pane lists all available assets, such as datasets and components. This library includes assets from the current workspace as well as from any connected registries, including the built-in system registry. To filter this list and display only the assets that have been created or registered specifically within the current workspace (in this case, proj1), you must use the "Registry name" filter and set its value to workspace. This keyword is the designated identifier for the collection of assets local to the active workspace.

A. proj1: This is the specific name of the workspace instance, not the generic filter keyword used in the designer UI to refer to the current workspace's local assets.

C. azureml-meta: This refers to a system registry used by Azure Machine Learning for metadata and internal components, not for user-defined assets within a specific workspace.

D. azureml: This is the name of the primary system registry that contains the built-in, Microsoft-provided components available across all workspaces, such as "Train Model" or "Evaluate Model".

1. Microsoft Learn. (2023). Use components in Azure Machine Learning designer.

Section: Find assets in the asset library

Quote: "The asset library on the left of the designer canvas contains components and datasets. You can find your workspace assets

and assets in registries under the Asset tab... You can use the registry filter to explore assets in different registries. Workspace is the registry for all assets in your current workspace." This directly confirms that workspace is the correct filter value.

2. Microsoft Learn. (2023). What is Azure Machine Learning designer?

Section: The designer homepage

Content: This document describes the designer interface

including the asset library which contains "custom components" (those in your workspace) and "prebuilt components" (those from the azureml registry)

reinforcing the distinction between workspace-level assets and registry assets.

For the Learning rate, the requirement specifies a "continuous hyperparameter between 0.001 and 0.1". In Azure Machine Learning, the uniform(min_value, max_value) function is used to define a continuous search space distributed uniformly between a specified minimum and maximum value.

For the Batch size, the requirement lists specific discrete integer values: "32, 64, or 128". The choice function is designed for discrete hyperparameters, allowing the model to select a value from a finite, explicit list of options. Other options like Normal or QNormal define statistical distributions rather than specific discrete sets or bounded continuous ranges.

Microsoft Learn. (2024). Hyperparameter tuning a model (v2) - Define the search space. Retrieved from https://learn.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters#define-the-search-space

Relevant Quote: "Choice: Use choice to specify discrete values... Uniform: Returns a value uniformly distributed between min_value and max_value."

Microsoft Learn. (2024). azure.ai.ml.sweep module - Uniform & Choice. Retrieved from https://learn.microsoft.com/en-us/python/api/azure-ai-ml/azure.ai.ml.sweep

Documentation confirms the syntax and usage of uniform for continuous ranges and choice for discrete lists.

Statement 1 (No): Although max_total_runs is set to 50, the use of GridParameterSampling limits the runs to the Cartesian product of the discrete values. With 4 values for max_depth and 3 for learning_rate, only 12 runs will occur.

Statement 2 (No): The policy parameter is specifically for early termination policies (e.g., Bandit, Median Stopping) to stop poorly performing runs, not for security configurations.

Statement 3 (No): pe.choice creates a discrete set. The experiment will only test the specific values 0.05, 0.1, and 0.15, not a continuous range.

Microsoft Azure Documentation: Tune hyperparameters for your model (v1), section "Grid sampling". It specifies that grid sampling only searches over the specific values defined in the choice expression.

Microsoft Azure Documentation: HyperDriveConfig Class, section "Parameters". Defines policy as an early termination policy.

Microsoft Azure SDK for Python: azureml.train.hyperdrive module reference, GridParameterSampling section (exhausts combinations of discrete values).

Microsoft Learn: Optimize model hyperparameters, Unit 4: "Define a search space" (explaining choice vs. continuous distributions like uniform).

In Azure Machine Learning SDK v1, the AutoMLConfig class is used to define the settings for an automated ML experiment. When you have pre-split your data into training and validation sets (using random_split as shown in the code), you assign the training subset to the training_data parameter and the validation subset to the validation_data parameter. To identify the target variable for the regression task (in this case, the 'price' column), you must provide the string name of that column to the label_column_name parameter. This allows the AutoML engine to distinguish between features and the target label within the provided datasets.

Microsoft Learn / Azure SDK for Python: AutoMLConfig Class (azureml.train.automl.automlconfig).

Microsoft Learn: Configure automated ML experiments in Python. Section: "Data source and format".

Azure Machine Learning Documentation: Train a regression model with automated machine learning.

To use an existing DSVM outside your workspace, you must first create a configuration object. The RemoteCompute class provides the attach_configuration method, which defines the connection parameters (resource ID, SSH port, and credentials). Once the configuration object is created, you use the ComputeTarget.attach method to register that specific resource into your Azure Machine Learning workspace. The attach method is used for existing resources (like DSVM or HDInsight), whereas create would be used for managed compute like Azure Machine Learning Compute (AmlCompute).

Microsoft Documentation: Attach an existing compute resource to your workspace. Azure Machine Learning SDK v1 - RemoteCompute class.

Microsoft Documentation: ComputeTarget class - attach method. Azure Machine Learning SDK v1 - ComputeTarget.

Azure SDK for Python: azureml.core.compute.RemoteCompute.attach_configuration parameters and usage for DSVM.

Microsoft Learn: Set up a compute target for model training. Section: "External compute" (DSVM).

Overfitting occurs when a model learns the training data too well, including its noise and specific patterns, at the expense of its ability to generalize to new, unseen data. This phenomenon is identified by monitoring the model's performance on both the training and validation datasets during training. The classic sign of overfitting is when the training loss continues to decrease, indicating the model is still improving its fit to the training data, while the validation loss, after an initial decrease, begins to increase. This divergence shows that the model is losing its generalization capability.

A. Constant losses for both training and validation indicate that the model is not learning effectively, which is a sign of underfitting, not overfitting.

B. An increasing training loss is contrary to the goal of training and suggests a problem with the training process itself, not a standard overfitting scenario.

D. A constant training loss while validation loss decreases is a highly improbable scenario, as it implies the model is generalizing better without learning from the training data.

1. Microsoft Learn

"Prevent overfitting and underfitting": In the learning path for DP-100

this document states

"A classic sign of overfitting is when the validation metric starts to get worse while the training metric continues to improve." This directly corresponds to a decreasing training loss and an increasing validation loss.

Source: Microsoft

"Build and operate machine learning solutions with Azure Machine learning

" Module: "Train a model with a script

" Unit: "Prevent overfitting and underfitting."

2. Goodfellow

I.

Bengio

Y.

& Courville

A. (2016). Deep Learning. MIT Press.

Section 5.2.2

Capacity

Overfitting and Underfitting: "As training progresses

training error tends to decrease... By contrast

the generalization error... begins to increase again. This phenomenon is known as overfitting." (Note: Generalization error is measured using a validation or test set).

3. Stanford University

CS231n: Convolutional Neural Networks for Visual Recognition.

Course Notes

"Training Neural Networks

Part 1"

Section: "Track your learning process": The notes illustrate overfitting with a graph showing the training accuracy continually increasing while the validation accuracy reaches a peak and then starts to decrease. The inverse is true for loss: training loss decreases while validation loss begins to increase. This gap between training and validation performance is the indicator of overfitting.

In the Azure Machine Learning Python SDK v2, the @command_component decorator is used to define a component that executes a specific command or Python function. It encapsulates the inputs, outputs, and environment specification required for a single step in a pipeline. The @pipeline decorator is reserved for defining the workflow that connects multiple components, while tool is not a standard decorator for this context.

For the second selection, the Python import statement follows the syntax from <module_name> import <function_name>. Since the prompt explicitly states that the logic is contained in the file named model_train.py, the module name corresponds to the filename without the extension. Therefore, the correct code is from model_train import train.

Microsoft. (n.d.). Create and run machine learning pipelines using components with the Azure Machine Learning SDK v2. Microsoft Learn. Retrieved from https://learn.microsoft.com/en-us/azure/machine-learning/how-to-create-component-pipeline-python (Refer to section: "Define a component using the Python function").

Microsoft. (n.d.). azure.ai.ml package - command_component. Azure SDK for Python. Retrieved from https://learn.microsoft.com/en-us/python/api/azure-ai-ml/azure.ai.ml?view=azure-python#azure-ai-ml-command-component