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

The scenario describes a classic overfitting problem: the XGBoost model performs well on the training dataset but poorly on the test hold-out dataset. According to AWS Machine Learning and XGBoost documentation, overfitting occurs when a model is too complex and learns noise and patterns specific to the training data rather than generalizable relationships.

One effective way to address overfitting is to reduce model complexity. Option B, reducing the number of features, simplifies the hypothesis space and lowers the risk of fitting spurious correlations. Feature reduction is a recommended best practice when the model shows a large generalization gap between training and test error.

Another effective method is to increase regularization. Option D, increasing the L2 regularization parameter (lambda in XGBoost), penalizes large weights and discourages overly complex trees. AWS documentation explicitly notes that L2 regularization helps improve generalization by smoothing model parameters and reducing variance.

Option A would worsen overfitting by increasing complexity. Option C is incorrect because reducing the number of training samples generally increases overfitting risk. Option E would decrease regularization strength and further degrade test performance.

Therefore, reducing feature complexity and increasing L2 regularization are the correct changes.

Amazon SageMaker Pipelines provides native orchestration of ML workflows with fine-grained control, DAG-based visualization, and seamless integration with SageMaker Studio. AWS documentation explicitly states that Pipelines is designed for end-to-end ML workflow automation and visualization.

SageMaker ML Lineage Tracking records relationships between datasets, models, training jobs, and endpoints, enabling full auditability and governance, which is essential for compliance.

SageMaker Experiments tracks experiment metrics but does not provide lineage-level governance. CodePipeline is a general CI/CD service and lacks ML-specific DAG visualization and lineage tracking.

AWS best practices recommend combining SageMaker Pipelines + SageMaker Studio + ML Lineage Tracking for enterprise-grade ML workflow management.

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

To minimize communication overhead during distributed training:

1. Same VPC Subnet: Ensures low-latency communication between training instances by keeping the network traffic within a single subnet.

2. Same AWS Region and Availability Zone: Reduces network latency further because cross-AZ communication incurs additional latency and costs.

3. Data in the Same Region and AZ: Ensures that the training data is accessed with minimal latency, improving performance during training.

This configuration optimizes communication efficiency and minimizes overhead.

Option C is correct because the requirement has two separate parts: first, the company must track model versions; second, it needs recommendations for which instance types to use for hosting the model in SageMaker AI. AWS documentation identifies the SageMaker Model Registry as the SageMaker feature used to register and manage model packages and versions as part of the ML lifecycle. For hosting recommendations, AWS documentation says Amazon SageMaker Inference Recommender helps select the best instance type and configuration for ML models and workloads by automating benchmarking and load testing across SageMaker AI instances.

The AWS Inference Recommender documentation is especially important here because it explicitly says you can use it after you register a model to the SageMaker Model Registry with model artifacts. It also states that Inference Recommender helps choose the best endpoint type and configuration and returns recommendations that include the instance type in the resulting endpoint configuration. That is an exact match to the question’s requirement to recommend hosting instance types for a model that has not yet been hosted on SageMaker AI.

The other options do not match AWS service purposes. Amazon ECR stores container images, not model versions. AWS Compute Optimizer is not the SageMaker-native service documented for inference benchmarking of ML models. SageMaker Autopilot is for automated model building, not inference instance recommendations. SageMaker Experiments tracks experiment metadata, trials, and runs, but it does not recommend deployment instance types. Therefore, the fully verified AWS-docs answer is C.

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.

Option A is correct because Amazon SageMaker Model Monitor is the AWS service specifically built to monitor data quality and model quality for ML models in production. AWS documentation states that Model Monitor supports continuous monitoring with a batch transform job that runs regularly and also supports on-schedule monitoring for asynchronous batch transform jobs. That aligns directly with the scenario of a hospital running a nightly batch inference job and needing a daily report on both the incoming data and the model’s predictive performance.

AWS documentation also separates the two monitoring needs very clearly. Data quality monitoring can be scheduled for batch transform jobs by using DefaultModelMonitor with a BatchTransformInput. Model quality monitoring can also be scheduled for batch transform jobs by using ModelQualityMonitor, which compares predictions against actual ground-truth labels stored in Amazon S3. Since the question explicitly asks for both model data quality and model performance, SageMaker Model Monitor is the documented feature that covers both requirements together.

Option B is not sufficient because CloudWatch dashboards show operational and resource metrics, not the full ML-specific data quality and model quality reports required here. Option C is incorrect because AWS Glue DataBrew is for data preparation and profiling, not model performance monitoring. Option D is partially plausible because SageMaker Pipelines integrates with QualityCheck steps and can run monitoring jobs on demand, but the AWS docs position Model Monitor as the native solution for scheduled monitoring of production batch inference workloads. Therefore, the best AWS-documented answer is A.

Amazon Q Business allows configuring blocked phrases to exclude specific terms or phrases from the responses. By adding the competitor ' s name as a blocked phrase, the company can ensure that it will not appear in the API responses, meeting the requirement efficiently with minimal configuration.

For real-time anomaly detection on streaming data, AWS recommends using Amazon Managed Service for Apache Flink, which provides serverless, scalable stream processing with built-in ML functions.

Apache Flink includes a native RANDOM_CUT_FOREST (RCF) function for unsupervised anomaly detection. This eliminates the need to deploy, manage, or scale custom ML endpoints. When combined with Amazon Kinesis Data Streams, the solution can process thousands of records per second with very low latency.

Option B introduces multiple services and custom logic, increasing operational overhead. Option C requires managing EC2 infrastructure and Kafka clusters. Option D is batch-oriented and does not meet real-time requirements.

AWS documentation explicitly highlights Kinesis + Managed Flink + RCF as the lowest-overhead solution for real-time anomaly detection.

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

Using Amazon EventBridge with an event pattern that matches S3 upload events provides an automated, low-effort solution. When new data is uploaded to the S3 bucket, the EventBridge rule triggers the SageMaker pipeline. This approach minimizes operational overhead by eliminating the need for custom scripts or external orchestration tools while seamlessly integrating with the existing S3 and SageMaker setup.

The correct answer is C. Class imbalance ratio.

Amazon SageMaker Clarify provides both pre-training and post-training bias detection capabilities to help data scientists ensure fairness in ML models. Pre-training bias metrics specifically analyze the training dataset to detect underrepresentation of certain groups or features before a model is trained. The class imbalance ratio measures how evenly different classes or sensitive attributes are represented in the dataset. A high imbalance indicates that a particular segment of customers (e.g., certain age groups, genders, or ethnicities) may be underrepresented, which could lead to biased predictions when the model is deployed.

Feature attribution bias (Option B) and prediction distribution skew (Option A) are post-training metrics. Feature attribution bias evaluates whether the model relies disproportionately on certain features for predictions, while prediction distribution skew examines whether the model’s outputs are skewed for specific groups. Model performance gap (Option D) is also a post-training measure, focusing on differences in accuracy or other performance metrics between groups.

By using the class imbalance ratio during pre-training analysis, the company can identify and mitigate underrepresentation before training the model. Actions may include resampling the dataset, weighting underrepresented classes, or applying synthetic data augmentation to ensure that the model is trained on a balanced, fair dataset. This aligns with AWS best practices for ML solution monitoring, maintenance, and security, particularly for responsible AI and fairness assessment.

In summary, the class imbalance ratio allows proactive bias detection at the dataset level, preventing unfair recommendations and ensuring equitable treatment across all customer segments in the recommendation system.

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.

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.

Option A is correct because the requirement is to detect changes in the input data distribution of model features, which is a data quality / data drift monitoring problem. AWS documentation states that Amazon SageMaker Model Monitor uses rules to detect data drift and alerts you when it happens. The documented workflow is to enable data capture, create a baseline from training data, and then run monitoring jobs that compare incoming inference data against that baseline. That directly matches the need to automatically detect changes in feature distributions.

AWS also documents that Model Monitor can emit metrics to Amazon CloudWatch, and those metrics can be used with CloudWatch alarms to notify teams when data quality drifts beyond acceptable thresholds. That makes Option A the lowest-operational-overhead solution because it uses SageMaker’s built-in monitoring capability plus managed alerting, rather than requiring custom drift logic. The inclusion of emit_metrics and CloudWatch alarming is consistent with the SageMaker monitoring pattern for automated notification.

The other options are weaker. Option B is for model quality monitoring, which focuses on prediction performance against ground truth, not shifts in the input feature distribution. Option C uses SageMaker Debugger, which is aimed at training-time debugging and custom rule analysis rather than managed production data drift monitoring. Option D relies on manual log analysis and endpoint performance metrics, which does not directly solve feature-distribution drift detection and adds more operational effort. Therefore, the best AWS-documented answer is A.

Amazon SageMaker Asynchronous Inference is specifically designed for long-running inference requests and large payloads. It supports payload sizes up to 1 GB and processing times of up to 1 hour, while automatically queuing requests.

Asynchronous inference stores results in Amazon S3 and allows clients to retrieve inference outputs after processing completes. It also supports auto scaling down to zero when there are no incoming requests, reducing cost.

Batch transform is intended for offline, bulk inference and does not return per-request results in an asynchronous request–response pattern. Serverless and real-time inference have strict payload size and timeout limits that do not support 1-hour processing.

Therefore, asynchronous inference is the only SageMaker inference option that meets all stated requirements.

AWS recommends SageMaker shadow testing as the safest way to validate a new model version using real production traffic without impacting production responses. A shadow variant receives a copy of inference requests but does not return predictions to end users. This completely eliminates the risk of exposing incorrect predictions.

Options A and B are canary deployments. While useful, they still allow v2 to return responses to real users, which violates the requirement to prevent disruption. Option C sends 100% of traffic to v2 externally and is risky.

Shadow variants are explicitly designed to minimize risk while using real data, making them the AWS best practice for pre-production validation.

Therefore, Option D is correct.

When predicting continuous variables, such as apartment prices, it ' s essential to evaluate the model ' s performance using appropriate regression metrics. The Mean Absolute Error (MAE) is a widely used metric for this purpose.

Understanding Mean Absolute Error (MAE):

MAE measures the average magnitude of errors in a set of predictions, without considering their direction. It calculates the average absolute difference between predicted values and actual values, providing a straightforward interpretation of prediction accuracy.

Advantages of MAE:

Interpretability: MAE is expressed in the same units as the target variable, making it easy to understand.

Robustness to Outliers: Unlike metrics that square the errors (e.g., Mean Squared Error), MAE does not disproportionately penalize larger errors, making it more robust to outliers.

Comparison with Other Metrics:

Accuracy, AUC, F1 Score: These metrics are designed for classification tasks, where the goal is to predict discrete labels. They are not suitable for regression problems involving continuous target variables.

Mean Squared Error (MSE): While MSE also measures prediction errors, it squares the differences, giving more weight to larger errors. This can be useful in certain contexts but may be sensitive to outliers.

Conclusion:

For evaluating the performance of a model predicting apartment prices—a continuous variable—MAE is an appropriate and effective metric. It provides a clear indication of the average prediction error in the same units as the target variable, facilitating straightforward interpretation and comparison.

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

Amazon EC2 Spot Instances provide unused compute capacity at discounts of up to 90%. AWS documentation strongly recommends Spot Instances for interruptible workloads such as long-running ML training jobs that can resume from checkpoints.

By enabling automatic checkpointing, SageMaker saves model state periodically to Amazon S3. If the Spot Instance is interrupted, training can resume with minimal loss of progress.

Reserved Instances and Savings Plans require long-term commitment and are not as cost-effective for sporadic workloads. On-Demand Instances are the most expensive option.

Therefore, Option D is the most cost-effective solution.

Amazon MSK Serverless provides a fully managed Apache Kafka-compatible service that automatically handles provisioning, scaling, and capacity management. AWS documentation states that MSK Serverless is designed for customers who want Kafka functionality without managing infrastructure.

Option B requires capacity planning and scaling management. Option C uses proprietary technology rather than open source. Option D requires full infrastructure management.

MSK Serverless delivers near real-time streaming with minimal operational overhead while maintaining compatibility with open-source Kafka tooling.

Therefore, Option A is the correct solution.

Option B is correct because AWS documentation states that speculative decoding is specifically a technique to speed up the decoding process of large language models. The question highlights that the model generates one token at a time and that users are unhappy with the time needed to generate lengthy responses. That is exactly the stage of inference targeted by speculative decoding. AWS explains that this method improves latency without compromising the quality of the generated text.

According to AWS, speculative decoding works by using a smaller, faster draft model to generate candidate tokens first. The larger target model then verifies those tokens. AWS further explains that the draft model can generate multiple candidate tokens quickly, and the target model evaluates them in parallel, which speeds up the final response. This directly addresses the problem in the scenario: the customer support agent is slow not because of startup time, but because long answers require many decoding steps.

The other options are not the best fit. Compilation reduces deployment time and auto-scaling latency through ahead-of-time compilation, but AWS documents it primarily as helping model deployment and hardware optimization rather than token-by-token response generation. Quantization reduces hardware requirements and can lower cost, but the docs do not present it as the most direct answer to slow sequential decoding. Fast model loading improves how quickly the model loads onto instances, which helps startup and scale-out time, not long response generation after the model is already serving traffic. Therefore, the best AWS-documented answer is B.

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.

The task described is unsupervised topic modeling, where topics are unknown in advance. Latent Dirichlet Allocation (LDA) is a probabilistic generative model specifically designed to discover latent topics from a corpus of documents without labeled data. AWS provides LDA as a built-in algorithm in Amazon SageMaker, making it well suited for this requirement.

LDA models documents as mixtures of topics and topics as mixtures of words, enabling interpretable topic discovery at scale. This aligns precisely with the need to organize documents into topics when the topics are not predefined.

BlazingText is optimized for word embeddings and supervised text classification, not topic modeling. Sequence-to-sequence models are used for translation or summarization. Object2Vec creates embeddings but does not itself perform topic discovery without additional clustering steps.

Therefore, LDA is the correct and purpose-built solution.

Option A is correct because AWS documentation states that regularization helps prevent linear models from overfitting, and specifically that L1 regularization reduces the number of features used in the model by pushing small feature weights to zero. AWS further explains that L1 regularization produces sparse models and reduces noise. That is the exact combination needed in this scenario: the model is overfitting, and the data contains unnecessary features whose impact should be reduced.

AWS guidance on overfitting also says that to reduce model overfitting, you should reduce model flexibility by using feature selection and increasing the amount of regularization. L1 regularization is especially suitable here because it does both in practice: it acts as a regularizer and also effectively performs feature selection by shrinking unhelpful feature coefficients to zero. Even though the option wording says “apply L1 regularization to the training data,” the only answer choice that aligns with AWS-documented techniques for both overfitting reduction and unnecessary-feature suppression is L1 regularization with retraining.

The other options do not meet both requirements. SageMaker Debugger monitors and helps analyze training jobs, but it is not the feature that “applies L1 regularization” to a running model. Increasing training iterations can make overfitting worse, not better. Decreasing training iterations may reduce overfitting in some cases, but it does not specifically address the presence of unnecessary features. Therefore, the AWS-aligned choice that best reduces overfitting and the impact of irrelevant features is A.

Amazon SageMaker real-time inference endpoints are designed to provide low-latency predictions in production environments. They offer built-in auto scaling to handle unpredictable bursts of requests, ensuring high availability and responsiveness. This approach is fully managed, reduces operational complexity, and is optimized for the range of request sizes (1 KB to 3 MB) specified in the requirements.

Amazon Comprehend is a fully managed natural language processing (NLP) service that includes a built-in sentiment analysis feature. It can quickly and efficiently analyze text data to determine whether the sentiment is positive, negative, neutral, or mixed. Using Amazon Comprehend requires minimal setup and provides accurate results without the need to train and deploy custom models, making it the fastest and most efficient solution for this task.

When Model Monitor identifies data quality issues, it might be due to a shift in the data distribution compared to the original baseline. By creating a new baseline using the most recent production data and updating Model Monitor to evaluate against this baseline, the ML engineer ensures that the monitoring is aligned with the current data patterns. This approach mitigates false positives and reflects the updated data characteristics without immediately retraining the model.

AWS documentation strongly recommends using columnar storage formats to optimize analytical query performance on large datasets stored in Amazon S3. Apache Parquet is a columnar, compressed, and splittable file format that significantly improves query speed and reduces I/O compared to row-based formats such as CSV.

By using AWS Glue to convert CSV files into Parquet format, the company can achieve faster query execution with minimal operational overhead. Glue is fully managed, serverless, and integrates natively with S3, Amazon Athena, and Amazon Redshift Spectrum.

Option A does not improve query efficiency; splitting files still leaves the data in an inefficient row-based format. Option B may reduce data size but does not address the fundamental inefficiency of CSV for analytics. Option D introduces significant operational overhead because Amazon EMR requires cluster provisioning, scaling, and maintenance.

Therefore, converting CSV files to Apache Parquet using AWS Glue ETL is the most efficient and low-maintenance solution.

City (name): One-hot encoding

Type_year (type of home and year the home was built): Feature splitting

Size of the building (square feet or square meters): Standardized distribution

City (name): One-hot encoding

Why? The " City " is a categorical feature (non-numeric), so one-hot encoding is used to transform it into a numeric format. This encoding creates binary columns for each unique category (e.g., cities like " New York " or " Los Angeles " ), which the model can interpret.

Type_year (type of home and year the home was built): Feature splitting

Why? " Type_year " combines two pieces of information into one column, which could confuse the model. Feature splitting separates this column into two distinct features: " Type of home " and " Year built, " enabling the model to process each feature independently.

Size of the building (square feet or square meters): Standardized distribution

Why? Size is a continuous numerical variable, and standardization (scaling the feature to have a mean of 0 and a standard deviation of 1) ensures that the model treats it fairly compared to other features, avoiding bias from differences in feature scale.

By applying these feature engineering techniques, the ML engineer can ensure that the input data is correctly formatted and optimized for the model to make accurate predictions.

SageMaker script mode allows ML engineers to bring existing training scripts written for frameworks such as PyTorch and TensorFlow directly into SageMaker with minimal changes. AWS documentation explicitly states that script mode is designed to support migration of existing ML workloads.

With script mode, the user provides a custom training script, and SageMaker handles infrastructure provisioning, distributed training, logging, and model artifact storage. This makes script mode ideal for companies that want to reuse established codebases without rewriting them.

Built-in algorithms require adopting AWS-provided implementations. SageMaker Canvas is a no-code tool, and JumpStart provides pretrained models and templates but does not focus on custom script reuse.

Therefore, Option D is the correct and AWS-recommended choice.

AWS Bedrock Knowledge Bases support multiple chunking strategies to optimize retrieval quality. Hierarchical chunking is specifically designed for structured documents such as PDFs with headings, sections, and subsections.

Hierarchical chunking allows fine-grained retrieval at the subsection level while automatically preserving parent section context. This ensures that when a small portion is retrieved, the surrounding section is also provided to the foundation model for better understanding.

Fixed-size and maximum-token chunking can split content arbitrarily, breaking semantic and structural boundaries. Semantic chunking focuses on meaning but does not guarantee structured context preservation without additional logic.

AWS documentation highlights hierarchical chunking as the preferred strategy when documents are structured and contextual integrity is required.

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

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.

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.

Int8 quantization

Low-rank adaptation (LoRA)

Fully Sharded Data Parallel (FSDP)

These three mappings align with AWS documentation for large-model training and optimization in SageMaker AI.

For 1, the correct answer is Int8 quantization. AWS documentation explains that quantization reduces hardware and memory requirements by using a less precise data type for weights and activations, including INT8 formats. AWS Prescriptive Guidance also states that quantization reduces memory footprint by converting higher-precision weights to lower-precision formats such as FP16 to INT8. That matches the description of reducing memory usage by representing model weights with lower precision.

For 2, the correct answer is Low-rank adaptation (LoRA). In practice, LoRA is a standard parameter-efficient fine-tuning (PEFT) method that updates only a small subset of trainable parameters instead of full-model fine-tuning. In SageMaker JumpStart workflows for large language models, LoRA is used specifically to make fine-tuning large models more efficient by training adapter-style low-rank updates rather than all original model weights. This matches the description of a PEFT technique that trains only a subset of model parameters.

For 3, the correct answer is Fully Sharded Data Parallel (FSDP). AWS documentation states that SageMaker model parallelism integrates with PyTorch FSDP, which shards model states across GPUs and supports large-scale distributed training. That directly matches the description of a distributed training technique used to share or shard model parameters across GPUs.

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.

SageMaker Pipelines provides a directed acyclic graph (DAG) view for managing and visualizing ML workflows with fine-grained control. It integrates seamlessly with SageMaker Studio, offering an intuitive interface for workflow orchestration.

SageMaker ML Lineage Tracking keeps a running history of experiments and tracks the lineage of datasets, models, and training jobs. This feature supports model governance, auditing, and compliance verification requirements.

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.

The correct answer is C. Use SageMaker Model Monitor to detect data drift. Use an AWS Lambda function to automate the re-training job.

Amazon SageMaker Model Monitor is the AWS-recommended solution for automatically detecting data drift in ML pipelines. Data drift occurs when the statistical properties of input features change over time, potentially reducing model accuracy. Model Monitor continuously analyzes incoming data and compares it to the baseline training dataset to identify deviations. It can track both feature distributions and prediction quality metrics.

Once Model Monitor detects data drift, it can trigger automated workflows using AWS Lambda or Amazon EventBridge. An AWS Lambda function can initiate a SageMaker training job to re-train the model using updated datasets, ensuring the ML model remains accurate and reliable. This setup fully automates the response to drift events, meeting the requirement of automatically initiating re-training.

Option A (AWS Glue) is designed for ETL processes but does not natively detect ML-specific data drift. Option B (Amazon Managed Service for Apache Flink) can process streaming data but does not provide native drift detection for ML pipelines. Option D (Amazon QuickSight anomaly detection) focuses on business intelligence and visual anomaly detection, not automated re-training workflows for ML models.

By integrating SageMaker Model Monitor with Lambda, the ML engineer can maintain model performance proactively, implement automated re-training, and align with AWS best practices for ML solution monitoring, maintenance, and security. This approach ensures continuous validation of model inputs and outputs, reduces operational overhead, and prevents degradation in production ML performance due to unseen data changes.

SageMaker Data Wrangler provides a no-code/low-code interface for preparing and transforming data, including dropping unnecessary columns. By creating a data flow and configuring a transform step, the ML engineer can easily remove correlated or unneeded columns from the Parquet file with minimal effort. This approach avoids the need for custom coding or managing additional infrastructure.

AWS Compute Optimizer analyzes the resource usage of Amazon EC2 instances, ECS services, Lambda functions, and Amazon EBS volumes. It provides actionable recommendations to optimize resource utilization and reduce costs, such as resizing instances, moving workloads to Spot Instances, or changing volume types. This solution requires the least development effort because Compute Optimizer is a managed service that automatically generates insights and recommendations based on historical usage data.

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.

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.

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.

S3 Gateway Endpoint: Allows private access to S3 from within a VPC without requiring a public IPv4 address, ensuring that data transfer between the primary and secondary accounts is secure and private.

Bucket Policy Update: The S3 bucket policy in the secondary account must explicitly allow access from the primary account ' s IAM principals to provide the necessary permissions.

Interface VPC Endpoints: Required for private communication between the VPC and Amazon SageMaker and Amazon Redshift services, ensuring the solution operates without public internet access.

This configuration meets the requirement to avoid public IPv4 addresses and allows secure and private communication between the accounts.

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.

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.

Amazon SageMaker Automatic Model Tuning extracts objective metrics directly from training logs. For custom containers, AWS requires the ML engineer to define a metric definition that specifies a regular expression to parse the desired metric value from standard output.

The ObjectiveMetricName in the tuning job must match the metric captured by the regex. This is the only supported method for integrating custom metrics with SageMaker AMT.

TrainingInputMode does not define metrics. CloudWatch metrics cannot be used as tuning objectives. AMT cannot read metrics from S3 artifacts.

AWS documentation explicitly states that regex-based metric definitions are required for custom metrics in hyperparameter tuning jobs.

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

Amazon SageMaker supports direct file system access for training jobs through Amazon FSx. AWS documentation states that FSx for NetApp ONTAP file systems can be mounted directly to SageMaker training instances when they are located in the same VPC.

Mounting the FSx file system allows SageMaker to stream large datasets efficiently without copying data into Amazon S3. This is ideal for very large datasets such as 6 TB of image data and avoids unnecessary storage duplication.

Options involving SageMaker Data Wrangler are intended for data preparation and exploration, not large-scale training data access. Mountpoint for Amazon S3 is not required and introduces additional complexity.

Therefore, Option A 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.

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.

Amazon SageMaker Pipelines is purpose-built for orchestrating end-to-end ML workflows, including data ingestion, training, evaluation, and deployment. It supports automation, versioning, and deployment of the latest model versions.

MWAA orchestrates general workflows but lacks ML-native features. Lambda cannot handle long-running ML training. Spark processes data but does not manage ML lifecycle.

Therefore, Option A is the correct AWS-native solution.

AWS documentation recommends using RecordIO format with lazy loading to optimize data input pipelines for image-based training workloads. RecordIO is a binary data format that enables sequential reads, reducing I/O overhead and improving throughput during training.

By converting JPEG images into RecordIO format, the training job can read data more efficiently from Amazon S3. Lazy loading ensures that only the required data is loaded into memory when needed, which optimizes CPU utilization during computationally intensive preprocessing steps.

Option A (file mode) results in many small S3 GET requests, which can become a bottleneck for large image datasets. Option B changes training behavior and can negatively affect convergence and performance. Option C reduces image quality, which directly impacts model accuracy and violates the requirement.

AWS SageMaker documentation explicitly highlights RecordIO and lazy loading as best practices for high-performance image training pipelines, especially when preprocessing is CPU-intensive.

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

Option A is correct because Amazon Rekognition provides a built-in EyeDirection attribute that indicates the direction a person’s eyes are gazing, expressed through pitch and yaw. AWS documentation describes EyeDirection as showing where the eyes are looking independently of head pose. For a driver-monitoring use case, this is directly useful for identifying whether a driver is looking away from the road and may be distracted.

AWS also announced that Rekognition’s eye gaze direction detection is intended to support safety use cases and to help identify where users focus their attention. That makes it a strong match for monitoring in-vehicle cameras for distraction detection. Because Rekognition is a fully managed service with ready-to-use computer vision capabilities, it requires far less operational effort than collecting data, labeling it, training a custom model in SageMaker, and maintaining that model over time.

The other options are less appropriate. Option B could work technically, but building and maintaining a custom SageMaker model would require significantly more engineering and operational work than using a managed Rekognition feature. Option C introduces unnecessary complexity by adding a third-party system when AWS already provides a directly relevant managed capability. Option D is unrelated because Amazon Comprehend analyzes text, while the input here is camera footage. Since the question asks for the solution with the least operational effort, the best AWS-aligned answer is to use the managed Rekognition eye gaze detection capability. Therefore, the fully verified answer is A.

A high max_depth value in XGBoost can lead to overfitting, where the model learns the training dataset too well but fails to generalize to new and unseen data. By decreasing the max_depth, the model becomes less complex, reducing overfitting and improving its ability to detect fraud in new transactions. This adjustment helps the model focus on general patterns rather than memorizing specific details in the training data.

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.

For real-time video content moderation with minimal operational overhead, AWS documentation recommends using fully managed, purpose-built AI services. Amazon Rekognition provides real-time video analysis capabilities, including content moderation, unsafe content detection, and label recognition for live video streams.

By integrating Rekognition with AWS Lambda, the company can automatically process video frames, extract moderation metadata, and take immediate action (such as flagging or stopping a stream) without managing servers, models, or infrastructure. This serverless architecture scales automatically and minimizes operational complexity.

Option B introduces unnecessary complexity. While Amazon Bedrock LLMs are powerful, they are not required for image-based moderation tasks that Rekognition already handles natively.

Option C is incorrect because using Amazon SageMaker would require model training, endpoint management, and scaling, significantly increasing operational overhead.

Option D is incorrect because Amazon Transcribe and Amazon Comprehend are designed for audio and text analysis, not image or video frame moderation.

Therefore, Amazon Rekognition with AWS Lambda is the most efficient, scalable, and low-maintenance solution for real-time video moderation during live streaming events.

Option D is correct because Amazon SageMaker AI Random Cut Forest (RCF) is documented by AWS as an unsupervised algorithm for detecting anomalous data points within a data set. The question describes a healthcare use case where the company wants to detect irregularities in patient vital signs and only has an unlabeled dataset. That is a direct match for anomaly detection with an unsupervised method rather than a supervised classification or regression algorithm. AWS documentation also notes that anomalies can appear as unexpected spikes, breaks in patterns, or otherwise unusual observations.

RCF is a strong fit because it does not require labeled target outcomes to begin identifying unusual observations. AWS explains that RCF assigns an anomaly score to each data point, where higher scores indicate potentially anomalous records. This is especially suitable for early warning scenarios in healthcare, where the goal is to surface unusual combinations of vitals, medication history, and lifestyle changes for further review.

The hyperparameter in the answer, num_trees, is a valid RCF hyperparameter and controls the number of trees used in the forest. In AWS examples and documentation, this is one of the key parameters used when configuring the algorithm. By contrast, XGBoost is generally used for supervised tasks, k-means is for clustering rather than anomaly scoring, and DeepAR is for forecasting time series rather than general anomaly detection across an unlabeled multidimensional dataset.

Therefore, the fully verified AWS-docs answer is D, because Random Cut Forest is the AWS-native unsupervised anomaly detection algorithm best aligned to this healthcare irregularity-detection requirement.

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.

The correct answer is C. Download the training data to the estimator by using fast file mode. Point the data loader to the location specified by the S3 path.

When training neural network models in Amazon SageMaker, I/O operations can become a bottleneck, especially when reading large datasets directly from S3. SageMaker provides a fast file mode that allows the training job to cache data locally on the compute instance before training. This significantly reduces data-loading latency, as the model can access the data from local storage instead of repeatedly fetching it over the network from S3.

Fast file mode automatically handles staged caching of S3 data in the container’s file system or attached EBS volumes, ensuring that the estimator sees high-throughput access to the dataset. This approach improves overall training speed without requiring manual configuration of EBS or EFS volumes.

Option A, provisioning EBS with io1 storage, may increase I/O performance but requires manual copying of the data and adds operational complexity. Option B, using EFS, introduces network-based I/O overhead and is not optimized for high-throughput sequential reads, which are typical in neural network training. Option D, changing the S3 path to a hyperparameter, has no effect on I/O performance or data-loading speed—it is merely a way to pass metadata to the training job.

Using fast file mode is AWS-recommended when profiling shows that training is bottlenecked by data access. It provides a managed, high-throughput, low-latency caching layer, allowing ML engineers to focus on model architecture and hyperparameter tuning rather than data transfer optimizations. This aligns with best practices for ML model development by reducing training time while maintaining scalability and simplicity in SageMaker training workflows.

Large Parquet files can cause out-of-memory (OOM) issues during training if individual files exceed the memory capacity of the training instances. AWS documentation recommends repartitioning large datasets into smaller files to enable efficient streaming and parallel loading.

By using Apache Spark on Amazon EMR to repartition the Parquet files, the ML engineer can split the dataset into multiple smaller files that can be read incrementally during training. This approach avoids loading a single large file into memory and improves data parallelism.

Attaching larger EBS volumes increases storage capacity but does not solve memory constraints. Switching to memory-optimized instances increases cost and is not necessary when the dataset can be restructured. SageMaker distributed data parallelism focuses on model parameter synchronization across GPUs, not dataset file size.

AWS best practices explicitly recommend partitioning large Parquet datasets to improve memory efficiency during training.

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

The AWS::SageMaker::Model resource in AWS CloudFormation is used to create an ML model in Amazon SageMaker. This model can then be hosted on an endpoint by using the AWS::SageMaker::Endpoint resource. The model resource defines the container or algorithm to use for hosting and the S3 location of the model artifacts.

AWS provides Amazon SageMaker Model Monitor as a native solution for detecting data drift and model quality issues in production ML pipelines. Model Monitor continuously analyzes incoming inference data and compares it with baseline training data to identify schema drift, feature distribution drift, and data quality anomalies.

When drift thresholds are violated, Model Monitor generates CloudWatch metrics and alerts. These alerts can directly trigger an AWS Lambda function, which can then programmatically initiate a SageMaker retraining job or start a SageMaker Pipeline execution. This design is explicitly documented by AWS as the recommended architecture for automated retraining workflows.

Option A is incorrect because AWS Glue is a data integration service and does not provide ML-specific drift detection capabilities.

Option B is incorrect because Apache Flink is designed for stream processing, not ML data drift detection.

Option D is incorrect because Amazon QuickSight anomaly detection is intended for business intelligence metrics, not ML feature drift.

Therefore, using SageMaker Model Monitor with AWS Lambda automation is the correct, AWS-native solution for drift-driven retraining.

For near real-time inference with low latency and variable traffic, AWS recommends deploying models to managed SageMaker endpoints. By enabling auto scaling, the endpoint automatically adjusts the number of instances based on request volume, ensuring consistent performance while optimizing cost.

Amazon SageMaker Endpoints abstracts infrastructure management, health checks, scaling, and model deployment. This provides lower operational overhead than managing EC2 instances manually.

Batch transform is for offline inference. API Gateway with S3 cannot serve ML models. EC2-based deployments require manual scaling and monitoring.

Therefore, a SageMaker endpoint with auto scaling is the correct solution.

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.

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.

AWS Lake Formation provides fine-grained access control and simplifies data governance for data lakes. By configuring Lake Formation tags to map ML engineers to their specific campaigns, you can restrict access to both structured and unstructured data in the data lake. This method is operationally efficient, as it centralizes access control management within Lake Formation and ensures consistency across Amazon Athena and S3 bucket access without requiring manual updates to policies or DynamoDB-based custom logic.

The day_of_week feature is a categorical variable with a small, fixed number of unique values and no inherent ordinal relationship. AWS machine learning best practices strongly recommend one-hot encoding for this type of categorical data when preparing features for classification models.

One-hot encoding converts each unique category into a separate binary feature (0 or 1). For example, “Monday” becomes a column where Monday = 1 and all other days = 0. This ensures that the ML model does not incorrectly assume a numeric or ordered relationship between categories.

Option B (label encoding) assigns integer values to categories (e.g., Monday = 1, Tuesday = 2). AWS documentation cautions against this approach for nominal data because models may incorrectly infer ordinal meaning, leading to biased or inaccurate predictions.

Option A (binary encoding) is typically used for high-cardinality categorical features to reduce dimensionality. With only seven categories, AWS recommends one-hot encoding for clarity and interpretability.

Option D (tokenization) is used for text processing, such as NLP tasks, and is not appropriate for structured categorical features.

AWS SageMaker feature engineering guidelines emphasize that one-hot encoding is the preferred method for low-cardinality categorical variables in classification models, especially when using algorithms such as logistic regression, neural networks, and tree-based models.

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

Amazon Macie is a fully managed data security and privacy service that uses machine learning to discover and classify sensitive data in Amazon S3. It is purpose-built to identify sensitive data with minimal operational overhead. After identifying the sensitive data, you can use AWS Lambda functions to automate the process of removing or redacting the sensitive data, ensuring efficiency and integration with the hybrid cloud environment. This solution requires the least development effort and aligns with the requirement to handle sensitive data effectively.

This is a classic class imbalance problem, where fraudulent transactions (minority class) are severely underrepresented. AWS documentation for SageMaker Data Wrangler recommends SMOTE (Synthetic Minority Oversampling Technique) as an effective approach for improving model performance in such scenarios.

SMOTE generates synthetic minority samples by interpolating between existing minority class examples. This improves the model’s ability to learn decision boundaries without simply duplicating data, which can cause overfitting.

Random undersampling removes valuable majority class data, reducing overall model robustness. Random oversampling duplicates data and increases overfitting risk. Changing algorithms does not address the root cause.

AWS best practices highlight SMOTE as the preferred technique for fraud detection and other highly imbalanced datasets.

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

The requirement has two key constraints: detect class imbalance and balance classes without losing any existing data. AWS provides Amazon SageMaker Clarify as the native tool to detect pre-training bias, including class imbalance (CI). CI measures differences in label distributions between classes, and a CI value greater than 0 indicates imbalance.

Once imbalance is detected, the engineer must rebalance the dataset without discarding data. Random undersampling would remove samples from the majority class, violating the requirement. Instead, oversampling is required. SMOTE (Synthetic Minority Oversampling Technique) creates synthetic samples for the minority class, preserving all original data while improving class balance.

Amazon SageMaker Data Wrangler natively supports SMOTE, making it the correct AWS-managed tool for this preprocessing task.

Options C and D are incorrect because SageMaker JumpStart is used for pretrained models and solutions, not for bias detection reporting. Option A is incorrect because it uses undersampling and misinterprets CI = 0 (which actually indicates no imbalance).

Therefore, detecting imbalance with SageMaker Clarify and correcting it using SMOTE in Data Wrangler is the correct solution.