MLA-C01 AWS Certified Machine Learning Engineer - Associate Questions and Answers

 Why Linear Learner?

SageMaker's Linear Learner algorithm is well-suited for binary classification problems such as fraud detection. It handles class imbalance effectively by incorporating built-in options for weight balancing across classes.

Linear Learner can capture patterns in the data while being computationally efficient.

 Key Features of Linear Learner:

Automatically weights minority and majority classes.

Supports both classification and regression tasks.

Handles interdependencies among features effectively through gradient optimization.

 Steps to Implement:

Use the SageMaker Python SDK to set up a training job with the Linear Learner algorithm.

Configure the hyperparameters to enable balanced class weights.

Train the model with the balanced dataset created using SageMaker Data Wrangler.

To pinpoint inefficiencies inside a training script, AWS recommends using Amazon SageMaker Profiler. SageMaker Profiler provides fine-grained visibility into CPU, GPU, memory, I/O usage, and framework-level operations during training.

By adding profiler annotations directly to the training script, the ML engineer can identify bottlenecks such as inefficient data loading, synchronization delays in DDP, or idle GPU time between training steps.

CloudWatch metrics provide high-level utilization trends but cannot identify exact code-level inefficiencies. CloudTrail is an auditing service and is irrelevant to performance profiling. Model Monitor focuses on data and model quality, not training resource utilization.

Therefore, SageMaker Profiler is the correct tool.

Amazon Bedrock is a fully managed AWS service and does not reside inside customer VPCs. To allow private connectivity from EC2 instances in a private subnet without using the public internet, AWS documentation recommends AWS PrivateLink.

By creating an interface VPC endpoint for Amazon Bedrock, traffic between the EC2 instances and Bedrock remains entirely within the AWS network. This approach preserves the private subnet configuration and meets strict security requirements.

Security groups alone cannot establish connectivity to a managed service endpoint. Amazon Bedrock cannot be deployed into a customer subnet, making Option C invalid. AWS Direct Connect is designed for on-premises connectivity, not for accessing AWS managed services from within a VPC.

AWS explicitly documents that PrivateLink is the correct mechanism for private access to Amazon Bedrock.

Therefore, Option B is the correct and AWS-verified answer.

This use case involves large payloads (high-resolution images), variable processing time, and a requirement to notify users upon completion. AWS documentation recommends Amazon SageMaker asynchronous inference for exactly this scenario.

Asynchronous inference allows clients to submit inference requests without waiting for a response. The request payload is stored in Amazon S3, and the inference result is written back to S3 when processing is complete. This approach is designed for workloads that cannot meet real-time latency requirements and where payload sizes exceed real-time limits.

SageMaker asynchronous inference integrates natively with Amazon SNS to send notifications when inference completes or fails, which directly satisfies the user notification requirement.

Batch transform jobs are intended for offline, scheduled processing of large datasets and do not provide built-in user notification mechanisms. Amazon EFS is not required because SageMaker natively integrates with S3 for inference input and output.

AWS explicitly documents asynchronous inference as the preferred solution for large image inference with completion notifications.

Therefore, Option B is the correct and AWS-verified answer.

In Amazon QuickSight anomaly detection, the Direction parameter controls which deviations from the expected baseline are flagged as anomalies. When Direction is set to All, QuickSight detects both higher-than-expected and lower-than-expected values. This results in a larger set of detected anomalies, increasing recall.

When the Direction parameter is changed to Lower than expected, the anomaly detection algorithm filters out all higher-than-expected anomalies and only reports unusually low values. Because the scope of detection is narrowed, the total number of detected anomalies decreases. As a result, fewer true anomalies are identified overall, which reduces recall.

Since fewer data points are evaluated as potential anomalies, the frequency of anomaly identification also decreases. This behavior is consistent with AWS documentation, which explains that directional filtering limits detection to a subset of deviations and therefore reduces overall anomaly counts.

Therefore, changing the Direction from All to Lower than expected leads to decreased anomaly identification frequency and decreased recall.

AWS ML best practices state that data preprocessing applied during training must be applied identically during inference. For min-max normalization, this requires reusing the minimum and maximum values calculated from the training dataset.

If production data is normalized using different statistics, the feature distributions will differ from what the model learned, leading to degraded prediction accuracy. AWS documentation explicitly warns against recomputing normalization parameters on inference data.

Options A, C, and D introduce data leakage or inconsistent feature scaling. Option B ensures consistency between training and inference pipelines and preserves model integrity.

Therefore, Option B is the correct and AWS-aligned solution.

The requirement is to quickly determine whether the target variable is predictable, with minimal development effort. Amazon SageMaker Autopilot is specifically designed for this purpose.

SageMaker Autopilot automatically handles data preprocessing, feature engineering, algorithm selection, model training, and evaluation. It generates multiple candidate models and provides detailed performance metrics, allowing teams to quickly assess predictability without writing custom code.

Option B requires significant manual development. Option C is incorrect because Amazon Macie is a data security and classification service, not an ML modeling service. Option D is unsuitable because Amazon Bedrock models are not intended for structured tabular prediction tasks.

Therefore, SageMaker Autopilot provides the fastest and least effort solution.

Step 1:

The company commits code changes or new training datasets to a Git repository.

This is the trigger point. A source code or data change initiates the CI/CD pipeline.

Step 2:

CodePipeline detects code changes and starts to build automatically.

CodePipeline monitors the Git repository (for example, AWS CodeCommit, GitHub, or Bitbucket) and automatically triggers the pipeline when changes are detected.

Step 3:

The company builds and deploys ML models and applications to staging servers for testing.

The pipeline runs build, training, and test stages (often using AWS CodeBuild and SageMaker) and deploys artifacts to a staging or test environment for validation.

Step 4:

Human approval is provided after testing is successful.

A manual approval action is a best practice for ML workflows to ensure governance, compliance, and quality checks before production deployment.

Step 5:

CodePipeline deploys ML models and applications to production.

After approval, the pipeline automatically deploys the validated model or application to the production environment.

Preparing a training dataset that includes both categorical and numerical data is essential for maximizing the accuracy of a machine learning model. Transforming categorical data into numerical format is a critical step, as most ML algorithms require numerical input.

Why Transform Categorical Data into Numerical Data?

Model Compatibility: Many ML algorithms cannot process categorical data directly and require numerical representations.

Improved Performance: Proper encoding of categorical variables can enhance model accuracy and convergence speed.

Why Use Amazon SageMaker Data Wrangler?

Amazon SageMaker Data Wrangler offers a visual interface with over 300 built-in data transformations, including tools for encoding categorical variables.

Implementation Steps:

Import Data:

Load the dataset into SageMaker Data Wrangler from sources like Amazon S3 or on-premises databases.

Identify Categorical Features:

Use Data Wrangler's data type inference to detect categorical columns.

Apply Categorical Encoding:

Choose appropriate encoding techniques (e.g., one-hot encoding or ordinal encoding) from Data Wrangler's transformation options.

Apply the selected transformation to convert categorical features into numerical format.

Validate Transformations:

Review the transformed dataset to ensure accuracy and completeness.

Advantages of Using SageMaker Data Wrangler:

Ease of Use: Provides a user-friendly interface for data transformation without extensive coding.

Operational Efficiency: Integrates data preparation steps, reducing the need for multiple tools and minimizing operational overhead.

Flexibility: Supports various data sources and transformation techniques, accommodating diverse datasets.

By utilizing SageMaker Data Wrangler to transform categorical data into numerical format, the ML engineer can efficiently prepare the dataset, thereby enhancing the model's accuracy with minimal operational overhead.

Transform Data - Amazon SageMaker

Prepare ML Data with Amazon SageMaker Data Wrangler

Logistic regression requires numeric input features and is sensitive to how categorical variables are encoded. AWS feature engineering best practices recommend one-hot encoding for low-cardinality categorical variables with no inherent order and ordinal encoding for categorical variables with a meaningful order.

The location feature has only three distinct values and no ordinal relationship, making one-hot encoding the most appropriate method. This prevents the model from inferring a false numerical relationship between locations.

The job_seniority_level feature typically has an inherent order (for example: junior, mid-level, senior, lead). Even with more than 10 categories, ordinal encoding preserves this natural hierarchy while keeping the feature dimensionality manageable.

Tokenization is used for unstructured text, not structured categorical variables. Standard scaling applies only to continuous numeric features and is not suitable for categorical string variables.

AWS documentation explicitly highlights using one-hot encoding for nominal features and ordinal encoding for ordered categorical features when preparing data for linear models such as logistic regression.

Therefore, Option B is the correct and AWS-aligned solution.

AWS Secrets Manager is designed for securely storing, managing, and automatically rotating secrets, including API tokens. By configuring a Lambda function for custom rotation logic, the solution can automatically rotate the API tokens every 3 months as required. Secrets Manager simplifies secret management and integrates seamlessly with other AWS services, making it the ideal choice for this use case.

Using custom tags allows you to organize and categorize models in the SageMaker Model Registry without altering their existing groupings or affecting the integrity of the model artifacts. Tags are a lightweight and scalable way to improve model discoverability at scale, enabling the data scientists to filter and identify models by category (e.g., computer vision, NLP, speech recognition). This approach meets the requirements efficiently without introducing structural changes to the existing model registry setup.

For asynchronous inference on large datasets, AWS recommends SageMaker batch transform, which is designed for offline and large-scale inference workloads. Batch transform jobs do not require real-time endpoints and can process large volumes of data efficiently.

For monitoring data quality, AWS provides Amazon SageMaker Model Monitor, which supports scheduled monitoring of data quality, schema drift, and feature distribution drift. Model Monitor can publish metrics to Amazon CloudWatch and trigger alerts when thresholds are breached.

The other options lack native ML-specific monitoring capabilities. CloudTrail audits API activity, not data quality. Glue, Batch, and ECS would require extensive custom monitoring logic.

Therefore, SageMaker batch transform combined with Model Monitor is the correct solution.

1️⃣ Simultaneous calls to the endpoint must reach models with the same configuration

Correct strategy: All at once traffic shifting

Why:

“All at once” replaces the old model with the new model immediately. After the switch, all concurrent requests hit only the new model configuration, guaranteeing configuration consistency across simultaneous calls.

2️⃣ The new model must receive only a fraction of the requests for validation before receiving all the traffic

Correct strategy: Canary traffic shifting

Why:

Canary deployments route a small percentage of traffic (for example, 5% or 10%) to the new model first. This allows validation of correctness and performance before shifting 100% of traffic.

3️⃣ Traffic to the new model must increase gradually to ensure that pipelines that rely on the endpoint do not fail because of changes in latency

Correct strategy: Linear traffic shifting guardrail

Why:

Linear traffic shifting gradually increases traffic in equal increments over time and includes guardrails (such as CloudWatch alarms) to automatically roll back if latency or errors exceed thresholds.

The problem described is a patient segmentation use case, which is a classic example of unsupervised learning. The objective is to group patients with similar characteristics without predefined labels. AWS documentation clearly states that Amazon SageMaker k-means is designed specifically for clustering and segmentation tasks.

The SageMaker k-means algorithm groups data points into clusters based on feature similarity and requires the user to define the number of clusters using the k hyperparameter. This directly satisfies the requirement to “determine the number of groups by using hyperparameters.” AWS recommends k-means for applications such as customer segmentation, risk grouping, and pattern discovery in healthcare data.

Option A (XGBoost) is a supervised learning algorithm used for classification and regression. The max_depth hyperparameter controls tree complexity, not the number of groups, making it unsuitable for this task.

Option C (DeepAR) is a time-series forecasting algorithm optimized for predicting future values, not clustering patients.

Option D (Random Cut Forest) is an anomaly detection algorithm. While useful for identifying outliers or unusual patient behavior, it does not perform clustering or group segmentation.

AWS SageMaker documentation explicitly identifies k-means as the correct choice when the goal is to partition data into a predefined number of clusters using a tunable hyperparameter.

Therefore, Option B is the correct and AWS-verified answer.

AWS Key Management Service (AWS KMS) is the recommended service for encryption and key access control. By creating a customer-managed KMS key, the company can define granular IAM policies that control which applications and roles can use the key.

The AWS Encryption CLI integrates directly with KMS and enables client-side encryption of files before storing them in Amazon S3. This approach ensures data is encrypted at rest and that only authorized principals can decrypt it.

SSH keys and API keys are not designed for data encryption. IAM roles alone do not create or manage encryption keys—they only grant permissions.

AWS documentation explicitly states that KMS customer-managed keys provide centralized key management, auditing, and access control.

Therefore, Option D is the correct and AWS-aligned solution.

Step 1: An S3 event notification invokes the pipeline when new data is uploaded.

Step 2: SageMaker retrains the model by using the data in the S3 bucket.

Step 3: The pipeline deploys the model to a SageMaker endpoint.

Step 1: An S3 Event Notification Invokes the Pipeline When New Data is Uploaded

Why? The CI/CD pipeline should be triggered automatically whenever new training data is uploaded to Amazon S3. S3 event notifications can be configured to send events to AWS services like Lambda, which can then invoke AWS CodePipeline.

How? Configure the S3 bucket to send event notifications (e.g., s3:ObjectCreated:*) to AWS Lambda, which in turn triggers the CodePipeline.

Step 2: SageMaker Retrains the Model by Using the Data in the S3 Bucket

Why? The uploaded data is used to retrain the ML model to incorporate new information and maintain performance. This step is critical to updating the model with fresh data.

How? Define a SageMaker training step in the CI/CD pipeline, which reads the training data from the S3 bucket and retrains the model.

Step 3: The Pipeline Deploys the Model to a SageMaker Endpoint

Why? Once retrained, the updated model must be deployed to a SageMaker endpoint to make it available for real-time inference.

How? Add a deployment step in the CI/CD pipeline, which automates the creation or update of the SageMaker endpoint with the retrained model.

Order Summary:

An S3 event notification invokes the pipeline when new data is uploaded.

SageMaker retrains the model by using the data in the S3 bucket.

The pipeline deploys the model to a SageMaker endpoint.

This configuration ensures an automated, efficient, and scalable CI/CD pipeline for continuous retraining and deployment of the ML model in Amazon SageMaker.

This problem describes a recommendation system with millions of records, many categorical variables, and a high-dimensional sparse feature space created by one-hot encoding. AWS documentation explicitly recommends Amazon SageMaker Factorization Machines (FM) for such use cases.

Factorization Machines are designed to handle sparse datasets efficiently and to model interactions between categorical features without explicitly enumerating all feature combinations. This capability makes FM particularly well-suited for recommendation problems such as predicting user-item interactions, including destination recommendations.

With 2,000 possible airport destinations, the target space is large and sparse. One-hot encoding further increases sparsity. Factorization Machines address this challenge by learning latent factors that capture relationships between features, even when many feature combinations are rarely observed.

Option A (CatBoost) is not an Amazon SageMaker built-in algorithm and therefore does not meet the requirement. Option B (DeepAR) is a time-series forecasting algorithm, not intended for recommendation or classification problems. Option D (k-means) is an unsupervised clustering algorithm and cannot directly predict a specific destination label.

AWS documentation explicitly lists recommendation systems and click prediction as primary use cases for the SageMaker Factorization Machines algorithm.

Therefore, Option C is the correct and AWS-verified choice.

Apache Parquet is a columnar storage file format optimized for complex and large datasets. It provides efficient reading and processing by accessing only the required columns, which reduces I/O and speeds up data handling. This makes it ideal for use with Amazon SageMaker Canvas, where minimizing processing time is important for training ML models. Parquet is also compatible with S3 and widely supported in data analytics and ML workflows.

Scenario: The company needs to run a batch job for 90 minutes every weekend over the next 6 months. The processing can handle interruptions, and cost-effectiveness is a priority.

Why Spot Instances?

Cost-Effective: Spot Instances provide up to 90% savings compared to On-Demand Instances, making them the most cost-effective option for batch processing.

Interruption Tolerance: Since the processing can tolerate interruptions, Spot Instances are suitable for this workload.

Batch-Friendly: Spot Instances can be requested for specific durations or automatically re-requested in case of interruptions.

Steps to Implement:

Create a Spot Instance Request:

Use the EC2 console or CLI to request Spot Instances with desired instance type and duration.

Use Auto Scaling: Configure Spot Instances with an Auto Scaling group to handle instance interruptions and ensure job completion.

Run the Batch Job: Use tools like AWS Batch or custom scripts to manage the processing.

Comparison with Other Options:

Reserved Instances: Suitable for predictable, continuous workloads, but less cost-effective for a job that runs only once a week.

On-Demand Instances: More expensive and unnecessary given the tolerance for interruptions.

Dedicated Instances: Best for isolation and compliance but significantly more costly.

Amazon SageMaker automatically tracks the Invocations metric, which represents the number of API calls made to the endpoint, in Amazon CloudWatch. By adding this metric to a CloudWatch dashboard, you can monitor the endpoint's activity in real-time. Setting up a CloudWatch alarm allows the system to send notifications whenever the API call events exceed the defined threshold, meeting both the monitoring and notification requirements efficiently.

Amazon Kendra is an AI-powered search service designed for semantic search use cases. It allows ingestion of documents from an Amazon S3 bucket using the Amazon Kendra S3 connector. Once the documents are ingested, Kendra enables semantic searches with its built-in capabilities, removing the need to manually generate embeddings or manage a vector database. This approach is efficient, requires minimal operational effort, and meets the requirements for a Retrieval Augmented Generation (RAG) application.

Problem Description:

The F1 score, which is a balance of precision and recall, has decreased significantly. This indicates the model's predictions are no longer aligned with the real-world data distribution.

Why Concept Drift?

Concept drift occurs when the statistical properties of the target variable or features change over time. For example, customer behaviors or subscription cancellation patterns may have shifted, leading to reduced model accuracy.

Signs of Concept Drift:

Deviation in performance metrics (e.g., F1 score) over time.

Declining prediction accuracy for certain groups or scenarios.

Solution:

Monitor for drift using tools like SageMaker Model Monitor.

Regularly retrain the model with updated data to account for the drift.

Why Not Other Options?:

B: Model complexity is unrelated if the model initially performed well.

C: Data quality issues would have been detected during baseline analysis.

D: Incorrect ground truth labels would have resulted in a consistently poor baseline.

Conclusion: The decrease in F1 score is most likely due to concept drift in the customer data, requiring retraining of the model with new data.

Scenario: The ML engineer needs a low-overhead solution to query thousands of existing and new CSV objects stored in Amazon S3 based on a transaction date.

Why Athena?

Serverless: Amazon Athena is a serverless query service that allows direct querying of data stored in S3 using standard SQL, reducing operational overhead.

Ease of Use: By using the CTAS statement, the engineer can create a table with optimized partitions based on the transaction date. Partitioning improves query performance and minimizes costs by scanning only relevant data.

Low Operational Overhead: No need to manage or provision additional infrastructure. Athena integrates seamlessly with S3, and CTAS simplifies table creation and optimization.

Steps to Implement:

Organize Data in S3: Store CSV files in a bucket in a consistent format and directory structure if possible.

Configure Athena: Use the AWS Management Console or Athena CLI to set up Athena to point to the S3 bucket.

Run CTAS Statement:

CREATE TABLE processed_data

WITH (

format = 'PARQUET',

external_location = 's3://processed-bucket/',

partitioned_by = ARRAY['transaction_date']

) AS

SELECT *

FROM input_data;

This creates a new table with data partitioned by transaction date.

Query the Data: Use standard SQL queries to fetch data based on the transaction date.

AWS recommends Amazon SageMaker Model Monitor as the native service for detecting data drift, model drift, and bias drift in deployed ML models. Model Monitor continuously compares incoming inference data against a baseline dataset captured during training.

When Model Monitor detects drift beyond configured thresholds, it can emit Amazon CloudWatch events. These events can trigger an AWS Lambda function, which is a common AWS-documented pattern for orchestrating automated workflows such as model retraining.

This Lambda function can then initiate a SageMaker Pipeline execution, starting a retraining job with updated data. This architecture aligns with AWS best practices for building automated, event-driven ML pipelines.

Option A is incorrect because AWS Glue is designed for data cataloging and ETL, not for ML-specific drift detection. Option B is unnecessary and overly complex for this use case. Option D is incorrect because Amazon QuickSight anomaly detection is intended for business intelligence analytics, not ML model monitoring.

AWS documentation explicitly positions SageMaker Model Monitor + Lambda automation as the recommended approach for continuous ML monitoring and retraining.

Therefore, Option C is the correct and AWS-verified answer.

Amazon Data Firehose supports near real-time delivery by configuring the buffer interval and buffer size. AWS documentation states that setting the buffer interval to the minimum (as low as 1 second) enables low-latency ingestion.

By using zero or minimal buffering and tuning PutRecordBatch, data is delivered to OpenSearch almost immediately, enabling sub-second dashboard updates.

DataSync and SQS are not designed for real-time streaming analytics. Increasing the buffer interval worsens latency.

AWS explicitly recommends Firehose with minimal buffering for real-time OpenSearch ingestion.

Therefore, Option A is the correct and AWS-verified solution.

Accuracy measures the proportion of correctly predicted labels (both positive and negative) out of the total predictions. It is the appropriate metric when the goal is to maximize the correct predictions of both positive and negative labels. However, it assumes that the classes are balanced; if the classes are imbalanced, other metrics like precision, recall, or specificity may be more relevant depending on the specific needs.

Shadow testing allows you to send a copy of live production traffic to a shadow variant of the new model while keeping the existing production model unaffected. This enables you to evaluate the performance of the new model in real-time with live data without impacting end users. SageMaker endpoints support this setup by allowing traffic mirroring to the shadow variant, making it an ideal solution for assessing the new model's performance.

Amazon Comprehend provides the ImportModel API operation, which allows you to copy a custom model between AWS accounts. By creating a resource-based IAM policy on the model in Account A, you can grant Account B the necessary permissions to access and import the model. This approach requires minimal development effort and is the AWS-recommended method for sharing custom models across accounts.

In Amazon SageMaker, distributed training and distributed processing jobs often involve multiple instances exchanging data over the network. By default, when these jobs run inside a VPC, network traffic remains private but is not automatically encrypted between instances. When compliance or security requirements mandate encryption of in-transit data, additional configuration is required.

The correct solution is to enable inter-container traffic encryption, which ensures that all network communication between containers running on different instances is encrypted using TLS. Amazon SageMaker provides a built-in feature for this purpose. When inter-container traffic encryption is enabled, SageMaker automatically configures secure communication channels between all nodes participating in a distributed job, including training clusters and processing jobs.

Option A (Network isolation) is incorrect because network isolation prevents containers from making outbound network calls and accessing the internet. It does not encrypt traffic between instances.

Option B (Security groups) is incorrect because security groups control network access and traffic flow, not encryption. They can restrict which instances can communicate, but they do not provide data-in-transit encryption.

Option D (VPC flow logs) is incorrect because VPC flow logs are used for monitoring and auditing network traffic, not for encrypting it.

AWS documentation explicitly states that enabling inter-container traffic encryption is the recommended and supported approach for encrypting data exchanged between instances during distributed SageMaker jobs. This feature aligns with enterprise security best practices and regulatory requirements for protecting sensitive ML training data in transit.

Therefore, Option C is the only solution that directly fulfills the encryption requirement for distributed SageMaker workloads.

Different data types require different encoding strategies. The Feedback column contains long, unstructured text responses. According to AWS ML documentation, text data must first be converted into tokens before it can be vectorized using techniques such as embeddings or bag-of-words. Tokenization is the correct preprocessing step for textual features.

The Satisfaction Level column is categorical but has a natural ordering (Low < Medium < High). AWS best practices recommend ordinal encoding for such ordered categorical variables because it preserves the inherent ranking information.

Option A is incorrect because one-hot encoding is not suitable for free-form text and would create an unmanageable number of features. Option B has the same issue for the Feedback column. Option C incorrectly applies label encoding to text and binary encoding to a three-class ordinal variable.

Therefore, tokenization for text data and ordinal encoding for satisfaction levels is the correct solution.

In the Amazon SageMaker Python SDK, the fit() method is used to start a training job after an estimator has been configured. AWS documentation explicitly states that once an estimator (such as PyTorch or TensorFlow) is defined with parameters like instance type, framework version, and hyperparameters, the fit() method is responsible for launching the training process.

The fit() method accepts the training data location (commonly an Amazon S3 URI) and initiates the managed training job on SageMaker infrastructure. SageMaker then provisions the required compute resources, stages the data, executes the training script, and stores model artifacts in Amazon S3.

The create_model() method is used after training to create a SageMaker model object from trained artifacts. The deploy() method deploys a trained model to an endpoint for inference. The predict() method is used only after deployment to request predictions from an endpoint.

AWS documentation clearly separates these lifecycle steps and identifies fit() as the correct method to initiate training.

Therefore, Option A is the correct and AWS-verified answer.

Change the number of samples used in each iteration of training

Correct selection:

Change the batch size

Why:

Increasing the batch size reduces the number of iterations per epoch, which can significantly shorten training time while maintaining model quality when tuned appropriately. AWS explicitly recommends batch size tuning as a primary performance optimization.

Increase the number of instances used during training

Correct selection:

Use the SageMaker AI distributed data parallelism (SMDDP) library

Why:

SMDDP is designed to efficiently distribute training data across multiple GPU instances with optimized gradient synchronization. This accelerates training without affecting model convergence or accuracy, unlike naive scaling approaches.

Stop training before the maximum number of epochs are reached if performance is sufficient and not improving

Correct selection:

Use early stopping on the training job

Why:

Early stopping automatically terminates training when validation metrics stop improving. AWS recommends this to reduce wasted compute time while preserving optimal model performance.

The described behavior indicates overfitting, where the model starts to memorize training data instead of generalizing.

Early stopping halts training when validation performance stops improving, preventing the model from overfitting further. AWS documentation recommends early stopping as a primary regularization technique.

Dropout randomly disables neurons during training, forcing the model to learn robust representations and reducing reliance on specific neurons. Increasing dropout is a well-established method for improving generalization.

Increasing layers or neurons increases model capacity and worsens overfitting. Model bias is unrelated to epoch-based degradation.

Therefore, Options A and B are correct.

Amazon SageMaker Automated Model Tuning supports several hyperparameter search strategies. Bayesian optimization is explicitly designed to model the relationship between hyperparameters and objective metrics using regression techniques. Based on results from previous training jobs, Bayesian optimization predicts which hyperparameter combinations are most likely to improve model performance and evaluates those next.

AWS documentation highlights Bayesian optimization as the preferred strategy when the hyperparameter search space is small to medium and when training jobs are expensive. Because the algorithm learns from prior runs, it avoids wasting resources on unpromising configurations and converges efficiently.

Grid search exhaustively evaluates all combinations and becomes inefficient even with moderately sized search spaces. Random search does not use information from prior runs and is less efficient. Hyperband focuses on aggressive early stopping and resource allocation, not regression-based sequential selection.

Therefore, Option C is the correct and AWS-verified solution.

By creating IAM policies with specific permissions, you can restrict access to Amazon S3 buckets or objects based on the user's business group. These policies can be attached to IAM users or IAM roles associated with the ML engineers, ensuring that each engineer can only access training data belonging to their group. This approach is secure, scalable, and aligns with AWS best practices for access control.

Scenario: The company wants to perform online validation of a new ML model on 10% of the traffic before fully deploying the model in production. The setup must have minimal operational overhead.

Why Use SageMaker Production Variants?

Built-In Traffic Splitting: Amazon SageMaker endpoints support production variants, allowing multiple models to run on a single endpoint. You can direct a percentage of incoming traffic to each variant by adjusting the variant weights.

Ease of Management: Using production variants eliminates the need for additional infrastructure like separate endpoints or custom ALB configurations.

Monitoring with CloudWatch: SageMaker automatically integrates with CloudWatch, enabling real-time monitoring of model performance and invocation metrics.

Steps to Implement:

Deploy the New Model as a Production Variant:

Update the existing SageMaker endpoint to include the new model as a production variant. This can be done via the SageMaker console, CLI, or SDK.

Example SDK Code:

import boto3

sm_client = boto3.client('sagemaker')

response = sm_client.update_endpoint_weights_and_capacities(

EndpointName='existing-endpoint-name',

DesiredWeightsAndCapacities=[

{'VariantName': 'current-model', 'DesiredWeight': 0.9},

{'VariantName': 'new-model', 'DesiredWeight': 0.1}

]

)

Set the Variant Weight:

Assign a weight of 0.1 to the new model and 0.9 to the existing model. This ensures 10% of traffic goes to the new model while the remaining 90% continues to use the current model.

Monitor the Performance:

Use Amazon CloudWatch metrics, such as InvocationCount and ModelLatency, to monitor the traffic and performance of each variant.

Validate the Results:

Analyze the performance of the new model based on metrics like accuracy, latency, and failure rates.

Why Not the Other Options?

Option B: Setting the weight to 1 directs all traffic to the new model, which does not meet the requirement of splitting traffic for validation.

Option C: Creating a new endpoint introduces additional operational overhead for traffic routing and monitoring, which is unnecessary given SageMaker's built-in production variant capability.

Option D: Configuring the ALB to route traffic requires manual setup and lacks SageMaker's seamless variant monitoring and traffic splitting features.

Conclusion:

Using production variants with a weight of 0.1 for the new model on the existing SageMaker endpoint provides the required traffic split for online validation with minimal operational overhead.

AWS Glue DataBrew provides an easy-to-use interface for preparing and transforming data, including masking or obfuscating sensitive information. It offers built-in data masking features, allowing the ML engineer to handle sensitive data securely while retaining its structure and meaning. This solution is efficient and requires minimal coding, making it ideal for ensuring sensitive data is masked before model building begins.

AWS strongly recommends converting large CSV datasets into columnar formats such as Apache Parquet to improve query performance. Parquet reduces I/O by reading only the required columns and applies compression, which significantly speeds up analytics workloads.

AWS Glue ETL jobs provide a fully managed, serverless way to perform this conversion with minimal operational overhead. Once converted, the Parquet files can be queried efficiently by services such as Amazon Athena, Redshift Spectrum, and SageMaker processing jobs.

Splitting CSV files does not address inefficient storage format. Dropping columns risks data loss. Amazon EMR introduces infrastructure management overhead and is unnecessary for a straightforward format conversion.

AWS documentation clearly identifies CSV-to-Parquet conversion using Glue ETL as a best practice for scalable analytics.

Therefore, Option C is the correct answer.

When GPU resources are limited and the hyperparameter search space is large, AWS documentation strongly recommends Bayesian optimization combined with early stopping. Bayesian optimization uses past evaluation results to intelligently select the next set of hyperparameters to test, focusing exploration on promising regions of the search space rather than testing all combinations.

In Amazon SageMaker, Bayesian optimization is the default and recommended strategy for hyperparameter tuning jobs. It significantly reduces the number of training runs required compared to grid or random search, making it highly cost-efficient for deep learning workloads.

Early stopping further improves efficiency by terminating training jobs that show poor validation performance in early epochs. This prevents wasted GPU time on configurations that are unlikely to perform well. AWS explicitly documents early stopping as a key feature for controlling training cost and duration.

Grid search and exhaustive search are computationally expensive and impractical for large hyperparameter spaces. Manual tuning is slow, error-prone, and does not scale.

By combining Bayesian optimization with early stopping, the company can rapidly converge on high-performing hyperparameter configurations while minimizing resource usage.

Therefore, Option B is the correct and AWS-aligned solution.

A serverless inference endpoint in Amazon SageMaker is ideal for use cases where the model is invoked infrequently, such as running one time each night. It eliminates the cost of idle resources when the model is not in use. Setting the MaxConcurrency parameter to 1 ensures cost-efficiency while supporting the required single nightly invocation. This solution minimizes costs and matches the requirement to process a small amount of data quickly.

AWS documentation identifies Amazon SageMaker Clarify as the primary service for detecting, measuring, and explaining bias in ML models, particularly across demographic and sensitive attributes such as age, gender, and location. Clarify can analyze bias before training, after training, and during inference, making it suitable for audit and compliance requirements.

SageMaker Clarify generates bias reports using established fairness metrics such as difference in positive proportions, disparate impact, and conditional demographic disparity. These reports are exportable and auditor-friendly, directly meeting the requirement to explain bias to an external party.

AWS Glue DataBrew focuses on data preparation and quality, not bias detection. Amazon QuickSight does not provide ML fairness metrics. Amazon CloudWatch captures operational metrics, not demographic bias indicators.

AWS best practices explicitly recommend SageMaker Clarify for model transparency, fairness evaluation, and regulatory reporting.

Therefore, Option A is the correct and AWS-verified solution.

The key requirements in this scenario are variable traffic patterns and cost efficiency. The workload has unpredictable spikes during evenings and weekends, followed by long periods of low or no usage. According to AWS Machine Learning documentation, Amazon SageMaker Serverless Inference is specifically designed for such use cases.

SageMaker Serverless Inference automatically provisions, scales, and shuts down compute resources based on incoming inference requests. Customers are billed only for the compute time used during inference, not for idle resources. This makes it highly cost-effective for workloads with intermittent or spiky traffic, such as real-time chat moderation in gaming environments.

Option A is incorrect because batch transform jobs are intended for offline, large-scale inference and require fixed capacity during job execution. They are not suitable for real-time NLP moderation.

Option C is also incorrect because reserving an EC2 GPU instance incurs continuous costs regardless of utilization. This would be inefficient given the long idle periods described in the scenario.

Option D, SageMaker Asynchronous Inference, is designed for workloads with long processing times or large payloads and still requires endpoint provisioning. While it can handle traffic spikes, it does not scale down to zero in the same cost-efficient manner as Serverless Inference.

Therefore, Amazon SageMaker Serverless Inference is the most cost-effective and operationally efficient solution for deploying an NLP moderation model with highly variable usage patterns.

Predicting apartment prices is a regression problem, where the target variable is continuous. AWS documentation states that classification metrics such as accuracy, AUC, and F1 score are not appropriate for regression tasks.

Mean Absolute Error (MAE) measures the average absolute difference between predicted values and actual values. MAE is easy to interpret because it is expressed in the same units as the target variable (for example, dollars), making it especially useful for business-facing problems like price prediction.

AWS best practices recommend MAE for evaluating regression models when understanding average prediction error magnitude is important and when robustness to outliers is desired.

Therefore, Option D is the correct and AWS-aligned answer.

Amazon SageMaker Model Registry is a feature designed to manage machine learning (ML) models throughout their lifecycle. It allows users to catalog, version, and deploy models systematically, ensuring efficient model governance and management.

Key Features of SageMaker Model Registry:

Centralized Cataloging: Organizes models into Model Groups, each containing multiple versions.

Version Control: Maintains a history of model iterations, making it easier to track changes.

Metadata Association: Attach metadata such as training metrics and performance evaluations to models.

Approval Status Management: Allows setting statuses like PendingManualApproval or Approved to ensure only vetted models are deployed.

Seamless Deployment: Direct integration with SageMaker deployment capabilities for real-time inference or batch processing.

Implementation Steps:

Create a Model Group: Organize related models into groups to simplify management and versioning.

Register Model Versions: Each model iteration is registered as a version within a specific Model Group.

Set Approval Status: Assign approval statuses to models before deploying them to ensure quality control.

Deploy the Model: Use SageMaker endpoints for deployment once the model is approved.

Benefits:

Centralized Management: Provides a unified platform to manage models efficiently.

Streamlined Deployment: Facilitates smooth transitions from development to production.

Governance and Compliance: Supports metadata association and approval processes.

By leveraging the SageMaker Model Registry, the company can ensure organized management of models, version control, and efficient deployment workflows with minimal operational overhead.

AWS Documentation: SageMaker Model Registry

AWS Blog: Model Registry Features and Usage

AWS Glue DataBrew is specifically designed to provide no-code and low-code data preparation for analytics and machine learning. It supports common file formats such as Apache Parquet and integrates directly with Amazon S3.

Using DataBrew, users can visually create recipes that apply transformations such as one-hot encoding without writing any code. Once the recipe is defined, a DataBrew job can be run to process the dataset and store the transformed output back into Amazon S3.

Options B, C, and D all require writing SQL or code, which violates the no-code requirement. AWS documentation clearly identifies DataBrew as the correct service for interactive, visual data transformation at scale.

Therefore, Option A is the correct solution.

Patient ID is a unique identifier and does not contain predictive information. Including it can cause the model to overfit by memorizing records rather than learning meaningful patterns.

AWS ML best practices recommend removing identifiers that are not causally related to the target variable. Age, medical conditions, and test results are clinically relevant features and should be retained. The target column must remain for supervised learning.

Therefore, Option A is the correct and AWS-aligned choice.

AWS ML best practices recommend A/B testing to validate model improvements in production while minimizing risk. By routing a controlled portion of live traffic (for example, 20%) to the new model and keeping the majority of traffic on the existing model, the company can directly compare real-world performance using the same data distribution.

This approach allows statistically meaningful comparison of business metrics such as customer retention, rather than relying solely on offline accuracy. It also limits potential negative impact if the new model underperforms in production.

Deploying the new model to 100% of traffic (Option A) introduces unnecessary risk. Offline analysis (Option C) does not reflect live user behavior. Alternating deployments (Option D) introduces confounding factors such as time-based effects.

Therefore, A/B testing is the correct solution.

Amazon SageMaker Data Wrangler provides a comprehensive solution for importing, consolidating, and preparing datasets for ML. It offers tools to handle missing values, duplicates, and outliers through its built-in cleansing and enrichment functionalities, allowing the ML engineer to efficiently prepare the data in a single environment with minimal manual effort.

AWS Glue Data Quality provides managed, declarative data quality checks with minimal configuration. Combined with Glue crawlers, it enables automatic schema discovery and quality validation without custom code.

Option A uses native AWS services designed for this exact purpose, minimizing operational overhead. Options B and C require custom code and maintenance. Option D is not designed for data validation.

AWS documentation explicitly recommends Glue Data Quality rules for scalable, automated data quality checks in analytics pipelines.

Therefore, Option A is the correct and AWS-aligned solution.

The key requirement in this scenario is detecting customer intent without having any training data. According to AWS Machine Learning and Generative AI documentation, zero-shot learning is specifically designed for situations where labeled training data is unavailable. Zero-shot learning allows a pre-trained large language model (LLM) to perform tasks it has not been explicitly trained on by leveraging its general knowledge and language understanding.

Amazon Bedrock provides fully managed access to foundation models (FMs) and LLMs that support zero-shot and few-shot learning. By using an LLM from Amazon Bedrock, the company can directly infer customer intent from natural language inputs without building, training, or fine-tuning a custom model. This approach is ideal for conversational interfaces where rapid deployment and scalability are required.

Option A is incorrect because fine-tuning a sequence-to-sequence (seq2seq) model in Amazon SageMaker JumpStart still requires labeled training data. Since the company explicitly does not have training data, this option does not meet the requirement.

Option C is also incorrect because the Amazon Comprehend DetectEntities API is designed for named entity recognition (NER), such as detecting names, dates, locations, or monetary values. It does not perform intent detection and is not suitable for conversational AI intent classification.

Option D is partially misleading. While it is technically possible to run an LLM on Amazon EC2, this does not inherently solve the problem of intent detection without training data. Additionally, Amazon Bedrock already abstracts infrastructure management, scaling, and model hosting, making direct EC2 deployment unnecessary and less efficient.

Therefore, using an LLM from Amazon Bedrock with zero-shot learning is the most appropriate, scalable, and AWS-recommended solution for intent detection without training data.

Monitoring bias drift in deployed machine learning models is crucial to ensure fairness and accuracy over time. Amazon SageMaker Clarify provides tools to detect bias in ML models, both during training and after deployment. To monitor bias drift for models deployed to real-time endpoints, an effective approach involves orchestrating SageMaker Clarify jobs using AWS Lambda functions.

Implementation Steps:

Set Up Data Capture:

Enable data capture on the SageMaker endpoint to record input data and model predictions. This captured data serves as the basis for bias analysis.

Develop a Lambda Function:

Create an AWS Lambda function configured to initiate a SageMaker Clarify job. This function will process the captured data to assess bias metrics.

Schedule or Trigger the Lambda Function:

Configure the Lambda function to run on-demand or at scheduled intervals using Amazon CloudWatch Events or EventBridge. This setup allows for regular bias monitoring as per the application's requirements.

Analyze and Respond to Results:

After each Clarify job completes, review the generated bias reports. If bias drift is detected, take appropriate actions, such as retraining the model or adjusting data preprocessing steps.

Advantages of This Approach:

Automation: Utilizing AWS Lambda for orchestrating Clarify jobs enables automated and scalable bias monitoring without manual intervention.

Cost-Effectiveness: AWS Lambda's serverless nature ensures that you only pay for the compute time consumed during the execution of the function, optimizing resource usage.

Flexibility: The solution can be tailored to specific monitoring needs, allowing for adjustments in monitoring frequency and analysis parameters.

By implementing this solution, the company can effectively monitor bias drift in real-time, ensuring that the AI application maintains fairness and accuracy throughout its lifecycle.

Adding resource tagging to the SageMaker user profile enables tracking and monitoring of costs associated with specific SageMaker resources.

AWS Budgets allows setting thresholds and automated alerts for costs and usage, making it the ideal service to notify the ML engineer when compute costs reach a specified limit.

This solution is efficient and integrates seamlessly with SageMaker and AWS cost management tools.

AWS Glue is a serverless data integration service that is well-suited for creating data ingestion pipelines, especially when raw data is stored in Amazon S3. It can clean, transform, and catalog data, making it accessible for downstream ML tasks.

Amazon SageMaker Studio Classic provides a comprehensive environment for building, training, and deploying ML models. It includes built-in tools and capabilities to create efficient model deployment pipelines with minimal setup.

This combination ensures seamless integration of data ingestion and ML model deployment with minimal operational overhead.

The text feature contains high-cardinality categorical values with minor spelling variations, which is a common real-world data quality issue. Traditional encoding techniques such as ordinal encoding (Option A) or one-hot encoding (Option C) would treat each misspelled value as a completely separate category, resulting in poor generalization and very high dimensionality.

Similarity encoding addresses this problem by grouping or encoding categories based on string similarity. Categories that differ only slightly—such as spelling errors—are encoded with similar numerical representations. Amazon SageMaker Data Wrangler supports similarity encoding specifically for such noisy categorical features.

Target encoding (Option D) depends on the target label distribution and risks target leakage if not carefully applied.

Therefore, similarity encoding is the most appropriate and AWS-recommended solution.

Hyperband is a hyperparameter tuning strategy designed to minimize computation time by adaptively allocating resources to promising configurations and terminating underperforming ones early. It efficiently balances exploration and exploitation, making it ideal for large datasets and deep learning models where training can be computationally expensive.

SageMaker Asynchronous Inference is designed for long-running inference workloads and large payloads (up to 1 GB). Requests are queued, processed asynchronously, and results are written to Amazon S3.

Real-time endpoints have payload and timeout limits. EC2 and ECS require infrastructure management, increasing operational overhead.

AWS documentation explicitly recommends asynchronous inference for workloads with large inputs and long execution times.

Therefore, Option C is the correct and most efficient solution.

Use case 1:

Summarize the text of a research paper

➡️ Sequence-to-Sequence (seq2seq) algorithm

Why:

Seq2seq models are designed for natural language generation tasks such as text summarization, translation, and paraphrasing. AWS documentation explicitly lists text summarization as a primary use case for the SageMaker seq2seq algorithm.

Use case 2:

Scan every pixel of an image to help self-driving cars identify objects in their path

➡️ Semantic segmentation algorithm

Why:

Semantic segmentation performs pixel-level classification, assigning a class label to every pixel in an image. This is exactly what is required for applications such as autonomous driving, road scene understanding, and object boundary detection.

Use case 3:

Identify abnormal data points in a dataset

➡️ Random Cut Forest (RCF) algorithm

Why:

Random Cut Forest is an unsupervised anomaly detection algorithm. AWS SageMaker RCF is purpose-built to identify outliers, unusual patterns, and anomalies in numerical datasets, making it ideal for fraud detection, monitoring, and abnormal data point detection.