A team trains an MLflow model that scores customer churn risk. The model will be consumed by different downstream systems.
One system requests predictions synchronously during customer interactions.
Another system submits files containing millions of records for scheduled scoring.
You need to deploy the model by using managed inference options that match each usage pattern.
Which option should you use for each usage pattern? To answer, select the appropriate options in the answer area.
NOTE: Each correct selection is worth one point.
Explanation
Low-latency synchronous predictions: a real-time (managed online) endpoint serves requests over HTTPS and returns predictions immediately, which suits calls made during customer interactions. A batch endpoint is asynchronous, a training pipeline does not serve predictions, and a registered model artifact is only the stored model, not an inference option.
High-volume scheduled scoring: a batch endpoint runs asynchronous jobs over large files in parallel on a compute cluster and writes the results to storage, and it can be invoked on a schedule. An online endpoint with autoscaling is built for request-response traffic, not file-based scoring of millions of records; a compute cluster is only the compute a batch deployment runs on, and a model registry version is not an inference option.
You manage an Azure Machine Learning workspace. You develop a machine learning model.
You must deploy the model to use a low-priority VM with a pricing discount.
You need to deploy the model.
Which compute target should you use?
A.Azure Container Instances (ACI)
B.Azure Machine Learning compute clustersCorrect
C.Local deployment
D.Azure Kubernetes Service (AKS)
Explanation
Low-priority VMs are available for deployments through Azure Machine Learning compute clusters created with the low_priority tier, which batch endpoint deployments run on. Since March 31, 2026 those nodes are allocated as Spot VMs, so Spot pricing and eviction apply, but the compute cluster is still the target that provides the discounted capacity. Azure Container Instances, local deployment, and AKS inference targets do not offer low-priority VMs for model deployment.
A team manages an Azure Machine Learning workspace where they deploy models to online endpoints.
The team needs to introduce a new version of a model to production without disrupting existing users.
The team must validate the new version before full rollout.
You need to reduce risk during deployment.
What should you do?
A.Deploy the model to a batch endpoint.
B.Split traffic between deployments.Correct
C.Replace the existing endpoint.
D.Route all traffic to the new deployment.
Explanation
Online endpoints support several deployments behind one endpoint, so you can add the new version as a second deployment and send it a small share of live traffic (or mirrored traffic) while the current deployment keeps serving most users, then shift traffic gradually once it is validated. This is the documented safe rollout (blue-green) approach. Replacing the endpoint or routing all traffic to the new deployment removes the validation step and risks disruption, and a batch endpoint does not serve the real-time users.
You have a deployment of an Azure OpenAI Service base model.
You plan to fine-tune the model.
You need to prepare a file that contains training data.
Which file format should you use?
A.CSV
B.TSV
C.JSONLCorrect
D.JSON
Explanation
Fine-tuning training and validation data must be JSON Lines (JSONL) files, with one complete training example (for chat models, a messages array) per line. CSV and TSV are not accepted for fine-tuning uploads, and a single JSON document is not the line-delimited format the service expects.
You have a deployment of an Azure OpenAI Service base model.
You plan to fine-tune the model.
You need to prepare a file that contains training data for multi-turn chat.
Which file encoding method should you use?
A.ISO-8859-1
B.UTF-16
C.UTF-8Correct
D.ASCII
Explanation
Fine-tuning data files for Azure OpenAI models, including multi-turn chat examples, must be JSONL files encoded in UTF-8. UTF-16 and ISO-8859-1 are not supported encodings for the upload, and plain ASCII cannot represent the full range of characters that conversation data may contain.
You are fine-tuning a base language model to analyze customer feedback.
You label examples of support tickets. You must improve classification accuracy by configuring and fine-tuning the base model in Microsoft Foundry.
You need to configure and run fine-tuning.
What should you do first?
A.Use prompt flow to generate multiple prompt templates for evaluation.
B.Deploy the base model to an online endpoint before starting fine-tuning.
C.Enable tracing for all inference calls in the evaluation pipeline.
D.Format the dataset as a JSONL file with prompt-completion pairs and upload the file.Correct
Explanation
A fine-tuning job needs its training data first: the labeled examples are saved as a JSONL file, each line pairing the input with the desired response, and uploaded so the job can reference it. The base model does not need to be deployed before fine-tuning; you deploy the fine-tuned result afterward. Prompt templates and tracing support prompt engineering and evaluation, not the setup of a fine-tuning job.
A team is working in Microsoft Foundry to test and compare large language model (LLM) prompt variants in a development environment.
The team requires consistent inputs to evaluate prompt variants without relying on live user traffic.
You need to create a controlled evaluation of input data.
Which action should you perform first?
A.Generate synthetic interaction data.Correct
B.Configure content filters.
C.Apply a blocklist.
D.Enable observability metrics.
Explanation
Without production traffic, Microsoft Foundry lets you generate a synthetic evaluation dataset (or simulate interactions) so every prompt variant is scored against the same, repeatable set of inputs. That dataset is the starting point for a controlled evaluation. Content filters and blocklists control what content is allowed through, not what inputs are evaluated, and observability metrics measure behaviour after inputs exist rather than creating them.
A team maintains Infrastructure as Code (IaC) templates to provision Azure Machine Learning resources.
Provisioning must be triggered by changes in the templates and executed without manual intervention.
You need to automate resource provisioning.
Which action should you take for each requirement? To answer, move the appropriate actions to the correct requirements. You may use each action once, more than once, or not at all.
Explanation
Trigger provisioning on repository changes: a GitHub Actions workflow runs automatically on repository events such as a push or pull request that touches the template paths, so no one has to start the deployment by hand. Authenticate securely during workflow execution: the workflow signs in to Azure with the Azure Login action using a service principal (a Microsoft Entra application, preferably with an OpenID Connect federated credential), giving a non-interactive identity scoped by role assignment. A manual deployment script and Azure CLI commands run from a local machine both require a person to act, which breaks the no-manual-intervention requirement.
An organization maintains separate Azure Machine Learning workspaces for development and production.
Both environments must use the same validated assets without duplicating them.
Assets must be shared across workspaces while maintaining centralized governance and version control.
You need to enable reuse of assets across workspaces without copying them.
What should you do?
A.Enable workspace-level Git integration and sync assets between repositories.
B.Publish the asset as a pipeline component.
C.Create a shared Azure Machine Learning environment that includes the asset.
D.Publish the asset to an Azure Machine Learning registry.Correct
Explanation
An Azure Machine Learning registry is a central, versioned catalog of models, components, environments and data that any workspace in the organization can reference directly, which is exactly the cross-workspace MLOps scenario of training in dev and deploying in prod. Git sync copies files between repositories rather than sharing one governed asset. A pipeline component or an environment created in a workspace is only visible inside that workspace unless it is itself placed in a registry.
An Azure Machine Learning workspace processes sensitive training data.
The workspace must NOT be accessible from the public internet.
You need to restrict network access.
Which configuration should you implement?
A.Azure Firewall rules
B.Private endpointsCorrect
C.Network security groups
D.Service endpoints
Explanation
A private endpoint gives the workspace private IP addresses inside a virtual network through Azure Private Link, and with public network access disabled the workspace accepts connections only over those private addresses. Azure Firewall and network security groups filter traffic for resources in your virtual networks but do not take the workspace's public endpoint off the internet. Service endpoints are not the mechanism Azure Machine Learning uses to make the workspace itself private.
A team is experimenting with traditional models for a classification workflow in Azure Machine Learning.
The team requires a consistent way to manage assets that are created during experimentation.
You need to ensure that artifacts can be reused and governed across projects.
Which asset should you register?
A.ModelCorrect
B.Component
C.Environment
D.Pipeline
Explanation
The artifact an experiment produces is the trained model, and registering it as a model asset stores and versions it in the model registry, keeps lineage back to the job that trained it, and lets it be shared through a registry and reused in other projects. A component packages a reusable pipeline step (code, command and interface); it is something you author to run experiments, not the artifact experimentation creates. An environment only defines the runtime dependencies, and a pipeline is a workflow definition rather than a registered output.
You manage an Azure Machine Learning workspace named workspace1 by using the Python SDK v2.
The default datastore of workspace1 contains a folder named sample_data. The folder structure contains the following content:
```text
sample_data
├── MLTable
├── file1.txt
├── file2.txt
└── file3.txt
```
You write Python SDK v2 code to materialize the data from the files in the sample_data folder into a Pandas data frame.
You need to complete the Python SDK v2 code to use the MLTable folder as the materialization blueprint.
How should you complete the code? To answer, select the appropriate options in the answer area.
```python
import mltable
tbl = mltable.[Dropdown 1]("[Dropdown 2]")
df = tbl.to_pandas_dataframe()
```
Explanation
Dropdown 1: mltable.load() reads an existing MLTable blueprint and returns a table object that to_pandas_dataframe() can materialize. save writes a blueprint out rather than reading one, and take is a table method that returns the first rows, not a module function that opens a blueprint.
Dropdown 2: load takes the path of the folder that contains the MLTable file, so the argument is ./sample_data, as in the documented mltable.load("./titanic/") example. Pointing at ./sample_data/MLTable names the file itself instead of its folder, and a glob of the text files bypasses the blueprint entirely.
You manage an Azure Machine Learning workspace named workspace1 by using the Python SDK v2. You create a General Purpose v2 Azure storage account named mlstorage1. The storage account includes a publicly accessible container named mlcontainer1. The container stores 10 blobs with files in the CSV format.
You must develop Python SDK v2 code to create a data asset referencing all blobs in the container named mlcontainer1.
You need to complete the Python SDK v2 code.
How should you complete the code? To answer, select the appropriate options in the answer area.
```python
sample_dataset = Data(
path=[Dropdown 1]://mlstorage1.blob.core.windows.net/mlcontainer1,
type=AssetTypes.[Dropdown 2],
description="sample_dataset",
name="sample_dataset",
version='1.0'
)
```
Explanation
Dropdown 1: wasbs is the documented URI scheme for Azure Blob Storage paths on the blob.core.windows.net endpoint. abfss is for ADLS Gen2 paths on the dfs.core.windows.net endpoint, and azureml is used for datastore and asset references, not a direct storage account URL.
Dropdown 2: the data asset must reference all 10 blobs in the container, so it points at a folder and uses URI_FOLDER, the type documented for reading a folder of CSV files into pandas or Spark. URI_FILE references a single file, and the table type requires an MLTable blueprint, which the scenario does not have.
Note: This question is part of a series of questions that present the same scenario. Each question in the series contains a unique solution that might meet the stated goals. Some question sets might have more than one correct solution, while others might not have a correct solution.
You manage an Azure Machine Learning workspace. The Python script named script.py reads an argument named training_data. The training_data argument specifies the path to the training data in a file named dataset1.csv.
You plan to run the script.py Python script as a command job that trains a machine learning model.
You need to provide the command to pass the path for the dataset as a parameter value when you submit the script as a training job.
Solution: python train.py --training_data training_data
Does the solution meet the goal?
A.Yes
B.NoCorrect
Explanation
In a command job, an input is passed to the script with the ${{inputs.<input_name>}} expression, for example python script.py --training_data ${{inputs.training_data}}, which Azure Machine Learning replaces at run time with the mounted or downloaded path of the data. This solution passes the literal string training_data, so the script receives a word rather than the path to dataset1.csv. It also runs train.py instead of script.py.
Note: This question is part of a series of questions that present the same scenario. Each question in the series contains a unique solution that might meet the stated goals. Some question sets might have more than one correct solution, while others might not have a correct solution.
After you answer a question in this section, you will NOT be able to return to it. As a result, these questions will not appear on the review screen.
You manage an Azure Machine Learning workspace. The Python script named script.py reads an argument named training_data. The training_data argument specifies the path to the training data in a file named dataset1.csv.
You plan to run the script.py Python script as a command job that trains a machine learning model.
You need to provide the command to pass the path for the dataset as a parameter value when you submit the script as a training job.
Solution: You use the following command:
```bash
python script.py --trainingdata ${{inputs.training_data}}
```
Does the solution meet the goal?
A.Yes
B.NoCorrect
Explanation
The script reads an argument named training_data, so the command must pass it under that name, for example python script.py --training_data ${{inputs.training_data}}. The ${{inputs.training_data}} expression correctly resolves the job input to a path, but the flag --trainingdata does not match the argument the script parses, so argparse rejects it or the training_data argument is never set. The solution therefore does not meet the goal.
Note: This question is part of a series of questions that present the same scenario. Each question in the series contains a unique solution that might meet the stated goals. Some question sets might have more than one correct solution, while others might not have a correct solution.
After you answer a question in this section, you will NOT be able to return to it. As a result, these questions will not appear on the review screen.
You manage an Azure Machine Learning workspace. The Python script named script.py reads an argument named training_data. The training_data argument specifies the path to the training data in a file named dataset1.csv.
You plan to run the script.py Python script as a command job that trains a machine learning model.
You need to provide the command to pass the path for the dataset as a parameter value when you submit the script as a training job.
Solution: You use the following command:
```bash
python script.py dataset1.csv
```
Does the solution meet the goal?
A.Yes
B.NoCorrect
Explanation
In a command job, data paths are passed by declaring a job input and referencing it in the command with the ${{inputs.<name>}} expression, which Azure Machine Learning resolves to the mounted or downloaded path at run time. Passing the literal file name dataset1.csv neither supplies the training_data argument the script expects nor points to a location that exists on the compute. The correct form is python script.py --training_data ${{inputs.training_data}}.
You review the following Azure CLI command and the relevant Bicep excerpt. (Non-relevant sections are omitted.)
```bicep
az deployment group create \
--resource-group rg-foundry-dev \
--template-file ./foundry-environment.bicep \
--parameters location=eastus projectName=proj-dev-01
// foundry-environment.bicep (excerpt)
targetScope = 'resourceGroup'
param location string
param projectName string
resource aiFoundry 'Microsoft.CognitiveServices/accounts@2025-04-01-preview' = {
name: aiFoundryName
location: location
identity: {
type: 'SystemAssigned'
}
sku: {
name: 'S0'
}
kind: 'AIServices'
properties: {
allowProjectManagement: true
customSubDomainName: aiFoundryName
disableLocalAuth: true
}
}
```
You need to validate what the snippet will do before it is merged. For each of the following statements, select Yes if the statement is true. Otherwise, select No.
NOTE: Each correct selection is worth one point.
Explanation
Statement 1 (Yes): az deployment group create starts a deployment at resource group scope, and its required --resource-group parameter names the group to deploy into. The template's targetScope is resourceGroup, and the command does not create the group, so rg-foundry-dev must already exist (docs create it first with az group create).
Statement 2 (No): The SystemAssigned identity belongs only to the Foundry resource (Microsoft.CognitiveServices/accounts). Each Foundry project is a subresource with its own project managed identity, which is granted roles separately, so the account identity is not inherited by projects.
Statement 3 (No): The target subscription is chosen by the CLI, not the template. Use the global --subscription parameter or az account set before running the command; the Bicep file needs no subscriptionId parameter.
A team performs interactive experimentation during development. The team also runs scalable jobs for model training.
The team must minimize costs while ensuring compute resources scale when needed. Different workloads require different compute behaviors within the same workspace.
You need to configure compute targets that support each workload.
Which compute targets should you use? To answer, move the appropriate compute targets to the correct workload types. You may use each compute target once, more than once, or not at all.
NOTE: Each correct selection is worth one point.
Explanation
Interactive experimentation: an Azure Machine Learning compute instance is a managed single-node development workstation for notebooks and the terminal, and idle shutdown keeps its cost down. Scalable training jobs: an Azure Machine Learning compute cluster is a managed single- or multinode cluster that autoscales each time a job is submitted, and with a minimum of 0 nodes it costs nothing while idle. Azure Batch, Databricks, AKS and a standalone VM are unmanaged or attached targets that add management overhead and are not the native fit for these workloads.
You have an existing GitHub repository containing Azure Machine Learning project files.
You need to clone the repository to your Azure Machine Learning shared workspace file system.
Which four actions should you perform in sequence? To answer, move the appropriate actions from the list of actions to the answer area and arrange them in the correct order.
Explanation
To clone over SSH, first generate a key pair with ssh-keygen in the compute instance terminal, then display the public key with cat on the .pub file and copy it. Add that public key to the GitHub account so GitHub can authenticate the compute instance, and finally run git clone with the repository's SSH URL. The private key never leaves the compute instance, so adding a private key to GitHub is wrong.
You manage an Azure Machine Learning workspace. You have an environment for training jobs which uses an existing Docker image.
A new version of the Docker image is available.
You need to use the latest version of the Docker image for the environment configuration by using the Azure Machine Learning SDK v2.
What should you do?
A.Change the description parameter of the environment configuration.
B.Modify the conda_file to specify the new version of the Docker image.
C.Use the create_or_update method to change the tag of the image.
D.Use the Environment class to create a new version of the environment.Correct
Explanation
Environment versions are immutable except for description and tags, so changing the image requires a new environment version: define an Environment with the new image and register it with create_or_update. Changing the description does not change the image, and the conda_file describes Python dependencies, not the base Docker image. Updating tags on the existing version is allowed but only changes metadata, not the image used.
Verifying access...
Access Required
You need to purchase this exam to access practice mode
Unlock a few more questions every day for 300 points you earn free on
Godlike Academy. Everything you unlock with the Daily Climb stays open for 7 days after your last unlock.