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

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.

For cross-account Amazon S3 access, AWS requires two components:

An S3 bucket policy in the owning account (Account A) that grants access to a principal in another account

An IAM role policy in the consuming account (Account B) that allows the service to access the bucket

Amazon SageMaker training jobs assume an IAM role in the account where the job runs—in this case, Account B. Therefore, the IAM policy must be attached to the SageMaker execution role in Account B.

The S3 bucket policy must reside in Account A because bucket policies are owned and enforced by the bucket owner. This policy explicitly allows the IAM role from Account B to read the training data.

Any other combination fails either because the policy is in the wrong account or because the role is not the one used by SageMaker.

AWS documentation clearly describes this pattern as the correct way to grant cross-account access for SageMaker training jobs.

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

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.

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.

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.

Logistic regression is a suitable modeling approach for this requirement because it is designed for binary classification problems, such as predicting whether a customer will require long-term support ( " yes " or " no " ). It calculates the probability of a particular class and is widely used for tasks like this where the outcome is categorical.

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.

The core requirement is to identify and remove sensitive data from content stored in Amazon S3 with minimal operational overhead. Amazon Macie is purpose-built to automatically discover, classify, and protect sensitive data (such as PII) in Amazon S3 using machine learning. Macie continuously scans S3 objects and produces findings that identify sensitive data types and locations without requiring custom ML pipelines or infrastructure.

Once Macie identifies sensitive data, AWS Lambda can be used to automate remediation—such as redacting, masking, or deleting sensitive fields—based on Macie findings. This event-driven approach is serverless, scales automatically, and minimizes operations.

Option A increases overhead by moving the model and building custom detection logic. Option B introduces unnecessary compute orchestration (ECS/Fargate and Batch). Option D uses Amazon Comprehend for entity detection, which is not optimized for broad S3 data discovery and requires EC2 management.

Therefore, using Amazon Macie for detection and Lambda for remediation is the most efficient and AWS-recommended solution.

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.

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.

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.

An oscillating loss pattern during training with stochastic gradient descent (SGD) is a strong indicator that the learning rate is too high. When the learning rate is excessive, the optimizer takes overly large steps during gradient updates, causing the model to repeatedly overshoot the optimal minimum of the loss function. This results in unstable convergence behavior, where training and validation loss decrease briefly and then increase again in a repeating cycle.

AWS Machine Learning documentation and general deep learning best practices recommend reducing the learning rate when training loss and validation loss both remain high and fluctuate rather than steadily decreasing. Lowering the learning rate allows the optimizer to take smaller, more precise steps toward the minimum, leading to smoother convergence and improved generalization on the test dataset.

Option A, early stopping, is used primarily to prevent overfitting when validation loss increases while training loss continues to decrease. In this scenario, both losses remain high and unstable, indicating an optimization issue rather than overfitting.

Option B is incorrect because increasing the test set size does not affect the training dynamics or convergence behavior of the model.

Option C would worsen the problem, as increasing the learning rate would further amplify oscillations and instability.

Therefore, decreasing the learning rate is the correct corrective action to stabilize SGD training and improve model performance.

AWS recommends shadow testing to evaluate a new model against a production model with minimal operational overhead. Using production variants on a single SageMaker endpoint allows traffic to be routed to multiple models without managing additional endpoints.

With a shadow variant, the new model receives a copy of live traffic but does not affect production responses. Performance metrics such as latency, accuracy, and error rates can be compared directly against the current model using Amazon CloudWatch metrics. This approach is natively supported by Amazon SageMaker Endpoints.

Options A, B, and D introduce unnecessary complexity by requiring additional endpoints, traffic routing infrastructure, or custom code.

Therefore, deploying the new model as a shadow variant on the same endpoint is the most efficient solution.

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.

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 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.

A sudden drop in model performance after a long period of stability is a classic indicator of data drift. According to AWS ML documentation, production data distribution drift occurs when the statistical properties of incoming data change over time compared to the training dataset.

This drift can be caused by changes in user behavior, market conditions, seasonal trends, or upstream data pipelines. When drift occurs, the model’s learned patterns no longer align with real-world data, leading to degraded accuracy and other performance metrics.

Lack of training data (Option A) and overfitting (Option D) are issues that typically manifest during initial training, not after months of stable production performance. Compute constraints (Option C) may affect latency but do not usually cause sustained accuracy degradation.

AWS recommends using SageMaker Model Monitor to detect such drift and trigger retraining workflows.

Therefore, drift in the production data distribution is the most likely cause of the observed performance degradation.

Amazon FSx for NetApp ONTAP allows mounting the file system as a network-attached storage (NAS) volume. Since the FSx for ONTAP file system and SageMaker instance are in the same VPC, you can directly mount the file system to the SageMaker instance. This approach ensures efficient access to the 6 TB of training data without the need to duplicate or transfer the data, meeting the requirements with minimal complexity and operational overhead.

Amazon SageMaker Data Wrangler supports both direct and cataloged connections. To ensure data is always up to date, AWS recommends using cataloged connections backed by AWS Glue Data Catalog.

Cataloged connections allow Data Wrangler to reference the source systems dynamically, ensuring that each import reflects the latest data changes without manual reconfiguration. This approach supports Amazon S3, Amazon Redshift, and Snowflake and integrates securely using managed credentials.

Direct connections are point-in-time imports and do not automatically reflect schema or data updates. Glue and Lambda-based solutions introduce unnecessary complexity and operational overhead.

Therefore, using cataloged connections in Data Wrangler is the correct solution.

Step 1: Use AWS Glue crawlers to infer the schemas and available columns.

Step 2: Use AWS Glue DataBrew for data cleaning and feature engineering.

Step 3: Store the resulting data back in Amazon S3.

Step 1: Use AWS Glue Crawlers to Infer Schemas and Available Columns

Why? The data is stored in .csv files with unlabeled columns, and Glue Crawlers can scan the raw data in Amazon S3 to automatically infer the schema, including available columns, data types, and any missing or incomplete entries.

How? Configure AWS Glue Crawlers to point to the S3 bucket containing the .csv files, and run the crawler to extract metadata. The crawler creates a schema in the AWS Glue Data Catalog, which can then be used for subsequent transformations.

Step 2: Use AWS Glue DataBrew for Data Cleaning and Feature Engineering

Why? Glue DataBrew is a visual data preparation tool that allows for comprehensive cleaning and transformation of data. It supports imputation of missing values, renaming columns, feature engineering, and more without requiring extensive coding.

How? Use Glue DataBrew to connect to the inferred schema from Step 1 and perform data cleaning and feature engineering tasks like filling in missing rows/columns, renaming unlabeled columns, and creating derived features.

Step 3: Store the Resulting Data Back in Amazon S3

Why? After cleaning and preparing the data, it needs to be saved back to Amazon S3 so that it can be used for training machine learning models.

How? Configure Glue DataBrew to export the cleaned data to a specific S3 bucket location. This ensures the processed data is readily accessible for ML workflows.

Order Summary:

Use AWS Glue crawlers to infer schemas and available columns.

Use AWS Glue DataBrew for data cleaning and feature engineering.

Store the resulting data back in Amazon S3.

This workflow ensures that the data is prepared efficiently for ML model training while leveraging AWS services for automation and scalability.

SageMaker Debugger provides built-in rules to automatically detect issues like vanishing gradients, underutilized GPU, and overfitting during training jobs. It generates real-time metrics and allows users to define predefined actions that are triggered when specific issues occur. This solution minimizes operational overhead by leveraging the managed monitoring capabilities of SageMaker Debugger without requiring custom setups or extensive manual intervention.

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.

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.

This scenario clearly describes an overfitting problem. The neural network performs well on training data but fails to generalize to evaluation data. According to AWS Machine Learning and deep learning best practices, overfitting occurs when a model learns noise or overly specific patterns in the training data instead of generalizable relationships.

L1 and L2 regularization are well-established techniques to combat overfitting. They work by penalizing large weight values during optimization, effectively constraining the model’s complexity. L1 regularization encourages sparsity, while L2 regularization (weight decay) smooths the weight distribution. AWS documentation recommends regularization as a primary method for improving generalization when a model shows a large gap between training and evaluation performance.

Option B is incorrect because removing dropout layers would increase overfitting, not reduce it. Dropout is itself a regularization technique.

Option C would likely worsen overfitting, as training for more epochs allows the model to memorize the training data even further.

Option D increases model complexity, which again exacerbates overfitting rather than resolving it.

Therefore, penalizing large weights using L1 or L2 regularization 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.

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.

Amazon SageMaker Data Wrangler is a comprehensive tool that streamlines the process of data preparation and offers built-in capabilities for anomaly detection and visualization.

Key Features of SageMaker Data Wrangler:

Data Importation: Connects seamlessly to various data sources, including Amazon S3 and on-premises databases, facilitating the aggregation of transaction logs, customer profiles, and MySQL tables.

Anomaly Detection: Provides built-in analyses to detect anomalies in time series data, enabling the identification of outliers that may indicate fraudulent activities.

Visualization: Offers a suite of visualization tools, such as histograms and scatter plots, to help understand data distributions and relationships, which are crucial for feature engineering and model development.

Implementation Steps:

Data Aggregation:

Import data from Amazon S3 and on-premises MySQL databases into SageMaker Data Wrangler.

Utilize Data Wrangler ' s data flow interface to combine and preprocess datasets, ensuring a unified dataset for analysis.

Anomaly Detection:

Apply the anomaly detection analysis feature to identify outliers in the dataset.

Configure parameters such as the anomaly threshold to fine-tune the detection sensitivity.

Visualization:

Use built-in visualization tools to create charts and graphs that depict data distributions and highlight anomalies.

Interpret these visualizations to gain insights into potential fraud patterns and feature interdependencies.

Advantages of Using SageMaker Data Wrangler:

Integrated Workflow: Combines data preparation, anomaly detection, and visualization within a single interface, streamlining the ML development process.

Operational Efficiency: Reduces the need for multiple tools and complex integrations, thereby minimizing operational overhead.

Scalability: Handles large datasets efficiently, making it suitable for extensive transaction logs and customer profiles.

By leveraging SageMaker Data Wrangler, the ML engineer can effectively detect anomalies and visualize results, facilitating the development of a robust fraud detection model.

Analyze and Visualize - Amazon SageMaker

Transform Data - Amazon SageMaker

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.

Scenario: The dataset contains duplicate records that need to be detected with minimal code development.

Why FindMatches in AWS Glue?

Purpose-Built for Deduplication: The FindMatches transform in AWS Glue is specifically designed to identify duplicate records in structured or semi-structured datasets.

Machine Learning-Based: It uses ML to identify duplicates based on configurable thresholds and provides flexibility for tuning accuracy.

Low Code Overhead: Minimal development effort is required as Glue provides an interactive console for configuring and running FindMatches transforms.

Steps to Implement:

Prepare the Data: Upload the unstructured dataset to an S3 bucket and define a schema if needed.

Create a Glue Job:

Use the AWS Glue Studio to create a job and select the FindMatches transform.

Specify key attributes for deduplication.

Run and Evaluate: Execute the Glue job, and review the results for duplicates.

Resolve Duplicates: Export results to an S3 bucket or process them as needed.

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.

Amazon SageMaker batch transform is ideal for obtaining inferences from large datasets in an asynchronous manner, as it processes data in batches rather than requiring real-time inputs.

SageMaker Model Monitor allows scheduled monitoring of data quality, detecting shifts in input data characteristics, and generating alerts when changes in data quality occur.

This solution provides a fully managed, efficient way to handle both asynchronous inference and data quality monitoring with minimal operational overhead.

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.

This requirement combines asynchronous inference on large datasets with automated data quality monitoring and alerting. AWS documentation explicitly recommends Amazon SageMaker batch transform for large-scale, asynchronous inference workloads. Batch transform jobs process large datasets stored in Amazon S3 without requiring a persistent endpoint, making them cost-effective and scalable.

For data quality monitoring, Amazon SageMaker Model Monitor is the AWS-native solution. Model Monitor can be scheduled to analyze inference data, compare it against a baseline, and detect data quality issues such as missing values, schema changes, or statistical drift. When violations occur, Model Monitor emits metrics to Amazon CloudWatch, where alarms can trigger alerts.

Options A, B, and C lack ML-aware data quality monitoring capabilities. AWS Glue and Batch are not designed for model data quality analysis, and CloudTrail tracks API activity—not data quality.

AWS best practices clearly position Batch Transform + Model Monitor as the correct architecture for asynchronous inference with automated monitoring and alerting.

Therefore, Option D is the correct and AWS-verified 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.

The correct answer is A. Create Amazon Managed Streaming for Apache Kafka (Amazon MSK) Serverless clusters to process the data.

Amazon MSK Serverless allows organizations to run Apache Kafka workloads without managing or provisioning the underlying infrastructure. Unlike MSK Provisioned clusters (Option B), serverless clusters automatically scale to accommodate variable workloads and handle operational tasks such as patching, scaling, and monitoring. This meets the company’s requirement to avoid managing or scaling infrastructure while providing near real-time streaming analytics.

Option C, using Amazon Kinesis Data Streams with Application Auto Scaling, provides a managed streaming solution but is not based on open-source technology. While Kinesis can handle near real-time data, the question specifically emphasizes the company’s desire for open-source technology, which points toward Kafka.

Option D, self-hosting Apache Flink on EC2, requires manual management of servers, scaling, patching, and container orchestration. This approach contradicts the requirement of not managing or scaling infrastructure and introduces operational complexity.

MSK Serverless provides seamless integration with open-source Kafka APIs, enabling applications to produce and consume streaming data in real time while AWS handles scaling and availability. It is ideal for analytics pipelines where data ingestion is continuous and variable, and infrastructure overhead must be minimized.

By choosing MSK Serverless, the company can implement near real-time updates for its analytics platform using open-source Kafka without the operational burden of cluster management, fully aligning with AWS best practices for deployment and orchestration of ML workflows in a managed, scalable, and serverless manner.

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.

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.

To generate images, the application must invoke a foundation model hosted on Amazon Bedrock. Invoking the Amazon Titan Image Generator requires the bedrock:InvokeModel permission. Read-only permissions such as bedrock:Get* do not allow inference execution and are insufficient.

The application also interacts with Amazon Simple Queue Service. To process messages, the application must be able to receive messages from the queue and delete them after successful processing. These actions require sqs:ReceiveMessage and sqs:DeleteMessage.

sqs:GetQueueAttributes alone does not allow message consumption. SageMaker permissions are unrelated because Bedrock is a separate service.

Therefore, permissions to invoke the model and receive/delete SQS messages are required.

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 target_precision hyperparameter in the Amazon SageMaker linear learner controls the trade-off between precision and recall for the model. Increasing the target_precision prioritizes minimizing false positives by making the model more cautious in its predictions. This approach is effective for use cases where false positives have higher consequences than false negatives.

Option A is correct because Amazon SageMaker Feature Store is the AWS service designed to act as a centralized repository for ML features that are used consistently across training and inference. AWS documentation states that SageMaker Feature Store simplifies how you create, store, share, and manage features for data exploration, model training, and model inference. This directly matches the requirement to create a repository for streamed song ratings that will be used in both batch training and real-time inference.

The most important requirement in the question is that the data must stay synchronized between batch training and real-time inference. AWS documents explain that Feature Store provides both an offline store and an online store. The offline store is used for historical data, model training, and batch inference, while the online store is a low-latency, high-availability store intended for real-time lookup during inference. This dual-store design is exactly why Feature Store is used to maintain feature consistency across training and serving workflows. AWS Well-Architected guidance also explicitly says Feature Store provides online storage for real-time inference and offline storage for model training and batch inference.

The other options do not solve the full problem. Athena CTAS can organize query results but does not provide a synchronized feature repository for online and offline ML use. Lake Formation governs access to data lakes but is not a feature repository for training and inference consistency. Data Wrangler Generate Data Insights is for analysis and preparation, not synchronized feature serving. Therefore, the best AWS-documented answer is A.

Amazon Comprehend provides pre-built functionality for key phrase extraction and can identify meaningful keywords from documents with minimal setup or operational overhead. It eliminates the need for manual preprocessing, stemming, or stop-word removal and does not require custom model development or infrastructure management. This makes it the most efficient and low-maintenance solution for the task.

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 documentation identifies SageMaker Pipelines as the native CI/CD service for ML workflows. Pipelines allow engineers to define automated steps for data processing, training, evaluation, and deployment, making them ideal for retraining models when new data arrives in Amazon S3.

For version tracking and auditing, SageMaker Model Registry is explicitly designed to manage model versions, metadata, approval status, and deployment history. This satisfies regulatory and audit requirements without custom tooling.

AWS Lambda is not suitable for handling large datasets (10 GB), and CodeBuild is not ML-aware and lacks built-in model governance. Manual notebook workflows do not meet CI/CD or automation requirements.

AWS best practices strongly recommend SageMaker Pipelines combined with the Model Registry for scalable, auditable, and production-grade ML CI/CD pipelines.

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

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.

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.

The requirement that each parameter trial is built based on the performance of the previous trial is the defining characteristic of Bayesian optimization. In Amazon SageMaker Automatic Model Tuning, Bayesian optimization uses prior trial results to intelligently select the next set of hyperparameters, making it far more efficient than grid or random search—especially in large, mixed search spaces.

This scenario includes both categorical (20) and continuous (7) hyperparameters and allows up to 1,000 training jobs, which is well within the supported limits of SageMaker AMT. Bayesian optimization natively supports mixed parameter types and is explicitly recommended by AWS for large, high-dimensional search spaces where exhaustive grid search is impractical.

Option A and D (grid search) do not meet the requirement because grid search evaluates combinations independently and does not learn from previous trials. Additionally, grid search becomes computationally infeasible as dimensionality increases.

Option B (random search) also evaluates trials independently and does not leverage previous results, violating the core requirement.

Therefore, defining both categorical and continuous parameters and using Bayesian optimization with a maximum of 1,000 jobs is the correct and AWS-recommended solution.

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.

For Amazon EMR, the primary node and core nodes handle the critical functions of the cluster, including data storage (HDFS) and processing. Running them on On-Demand Instances ensures high availability and prevents data loss, as Spot Instances can be interrupted. The task nodes, which handle additional processing but do not store data, can use Spot Instances to reduce costs without compromising the cluster ' s resilience or data integrity. This configuration balances cost-effectiveness and reliability.

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.

Problem Description:

The dataset includes multiple data sources:

Transaction logs and customer profiles in Amazon S3.

Tables in an on-premises MySQL database.

There is a class imbalance in the dataset and interdependencies among features that need to be addressed.

The solution requires data aggregation from diverse sources for centralized processing.

Why AWS Lake Formation?

AWS Lake Formation is designed to simplify the process of aggregating, cataloging, and securing data from various sources, including S3, relational databases, and other on-premises systems.

It integrates with AWS Glue for data ingestion and ETL (Extract, Transform, Load) workflows, making it a robust choice for aggregating data from Amazon S3 and on-premises MySQL databases.

How It Solves the Problem:

Data Aggregation: Lake Formation collects data from diverse sources, such as S3 and MySQL, and consolidates it into a centralized data lake.

Cataloging and Discovery: Automatically crawls and catalogs the data into a searchable catalog, which the ML engineer can query for analysis or modeling.

Data Transformation: Prepares data using Glue jobs to handle preprocessing tasks such as addressing class imbalance (e.g., oversampling, undersampling) and handling interdependencies among features.

Security and Governance: Offers fine-grained access control, ensuring secure and compliant data management.

Steps to Implement Using AWS Lake Formation:

Step 1: Set up Lake Formation and register data sources, including the S3 bucket and on-premises MySQL database.

Step 2: Use AWS Glue to create ETL jobs to transform and prepare data for the ML pipeline.

Step 3: Query and access the consolidated data lake using services such as Athena or SageMaker for further ML processing.

Why Not Other Options?

Amazon EMR Spark jobs: While EMR can process large-scale data, it is better suited for complex big data analytics tasks and does not inherently support data aggregation across sources like Lake Formation.

Amazon Kinesis Data Streams: Kinesis is designed for real-time streaming data, not batch data aggregation across diverse sources.

Amazon DynamoDB: DynamoDB is a NoSQL database and is not suitable for aggregating data from multiple sources like S3 and MySQL.

Conclusion: AWS Lake Formation is the most suitable service for aggregating data from S3 and on-premises MySQL databases, preparing the data for downstream ML tasks, and addressing challenges like class imbalance and feature interdependencies.

AWS Lake Formation Documentation

AWS Glue for Data Preparation

Step 1: Update the existing endpoint with a shadow variant. Pick a suitable duration. Start the shadow test.

Step 2: Create a shadow test.

Step 3: Use the SageMaker shadow testing dashboard to analyze the performance differences between the variants.

This is the correct order because SageMaker shadow testing can run against an existing production endpoint. The production variant continues to receive and respond to inference requests, while the shadow variant receives replicated real-time requests but does not return responses to users. That satisfies the requirement to analyze the new model with real inference traffic without affecting the production endpoint. AWS also states that the SageMaker shadow testing dashboard provides side-by-side comparison metrics for the production and shadow variants, such as latency and error rate.

Do not choose “Create a new endpoint that includes the production model and the shadow model,” because the question explicitly says the analysis must not affect the existing production endpoint. Also, do not use the Amazon SageMaker Model Monitoring dashboard here; the specific feature for comparing variants in this scenario is the SageMaker shadow testing dashboard.

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 recommends Retrieval Augmented Generation (RAG) using Amazon Bedrock knowledge bases as the most cost-effective solution for incorporating frequently updated documents into LLM-powered applications.

A Bedrock knowledge base allows the company to store documents in Amazon S3, index them using vector embeddings, and retrieve relevant context dynamically at inference time. This approach eliminates the need for retraining or fine-tuning the model when documents change.

Training or fine-tuning an LLM is expensive, time-consuming, and unnecessary for frequently changing data. Bedrock guardrails are designed for safety and policy enforcement, not knowledge integration.

AWS documentation explicitly states that knowledge bases are the preferred method for dynamic, updatable enterprise content in chat applications.

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

The correct answer is C. Create a pipeline in Amazon SageMaker Pipelines for re-training. Configure an Amazon EventBridge rule to monitor S3 PutObject creation events and invoke the pipeline.

Amazon SageMaker Pipelines provides a fully managed workflow orchestration framework for ML model training, validation, and deployment. In this scenario, the company requires automatic re-training of the churn prediction model whenever new user engagement data becomes available in S3. By integrating SageMaker Pipelines with EventBridge, the pipeline can be triggered immediately upon an S3 PutObject event, ensuring minimal latency between data arrival and model re-training.

Option A, running an ECS task hourly, introduces fixed-time delays, as the new data may arrive at any time within the hour and would not be processed until the next scheduled run. Option B, invoking a Lambda function, is limited by execution duration and compute capacity; re-training ML models entirely within Lambda is not practical for large datasets or complex model architectures. Option D, using a scheduled SageMaker pipeline, reduces operational complexity but also introduces latency proportional to the schedule interval, which may delay model updates unnecessarily.

Using EventBridge-triggered SageMaker Pipelines ensures the shortest possible delay because the re-training pipeline is invoked immediately when new data arrives. This design follows AWS best practices for ML workflow orchestration and deployment, ensuring automated, event-driven retraining that keeps models up-to-date with the latest data. It also provides observability, logging, and error handling within the SageMaker Pipelines framework, reducing manual intervention and operational overhead while maintaining production-quality ML workflow management.

This approach is ideal for streaming and high-velocity datasets where model freshness is critical for predictive accuracy and business outcomes.

Option A is correct because Amazon SageMaker Ground Truth is the AWS service specifically designed to build labeled datasets for machine learning, including video classification and video frame labeling use cases. AWS documentation states that Ground Truth can take video files in MP4 format stored in Amazon S3, automatically connect to that data, and extract video frames for labeling. This directly matches the scenario in the question, where the source data is MP4 in S3 and the company needs to relabel or expand training data for retraining an existing SageMaker workflow.

Ground Truth is also the best choice because AWS documents explain that it can reduce labeling time and cost through automated data labeling (active learning) for supported built-in task types. Instead of relying only on manual human labeling for every item, Ground Truth can use ML-assisted labeling to lower the total amount of human work needed, which is exactly what the company wants after previously spending four months labeling frames.

The other options do not fit as well. JumpStart provides pretrained models and solution templates, but AWS documentation does not position it as the service for running a video-frame labeling operation. Data Wrangler is for data preparation, transformation, and feature engineering, not human labeling of video frames. Amazon A2I with Rekognition is mainly documented for human review workflows such as Rekognition moderation outputs, not as the primary service for large-scale MP4 video-frame annotation used to create training datasets.

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

AWS provides Amazon SageMaker Pipelines as the native CI/CD solution for ML. Pipelines can automatically trigger retraining when new data arrives in Amazon S3, handle large datasets (such as 10 GB files), and orchestrate preprocessing, training, evaluation, and deployment steps.

For governance and auditing, Amazon SageMaker Model Registry integrates directly with Pipelines to manage model versions, approval status, and metadata such as training metrics. This combination eliminates the need for custom tracking logic and ensures traceability across the ML lifecycle.

Option A lacks native ML lineage and version governance. Option C is unsuitable for large data and complex workflows. Option D is manual and not scalable.

Therefore, using SageMaker Pipelines with the Model Registry is the correct and AWS-recommended solution.

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.

Amazon SageMaker auto scaling uses cooldown periods to control how frequently scaling activities occur. When scale-out happens too quickly, new instances may receive traffic before they are fully initialized, leading to inefficiencies and latency.

AWS documentation recommends increasing the scale-out cooldown period to give newly launched instances sufficient time to initialize and become healthy before additional scaling events occur. This ensures stable performance during traffic spikes without impacting response times.

Multi-model endpoints address model hosting efficiency, not scaling timing. API Gateway and Lambda add unnecessary latency and complexity. Decreasing scale-in cooldown does not address scale-out issues.

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

Step 1

Create an IAM role for Amazon Redshift to use to access the Data Catalog and the S3 bucket that contains underlying data.

This role must include:

Permissions for AWS Glue Data Catalog (e.g., glue:GetDatabase, glue:GetTables)

Permissions for the Amazon S3 bucket that stores the underlying data

Step 2

Attach the IAM role to the Redshift namespace.

Redshift Serverless uses a namespace, not a cluster, so the role must be associated with the namespace to allow Redshift to assume it when querying external data.

Step 3

Create an external schema in Amazon Redshift to point to the Data Catalog database.

The external schema maps Redshift to the Glue Data Catalog database so Redshift can query the tables stored in S3.

In regression problems such as house price prediction, extreme values can significantly distort model learning. In this dataset, the presence of a large mansion and an extremely small apartment represents clear outliers in the Square Meters feature. According to AWS Machine Learning best practices, outliers can disproportionately influence loss functions (such as mean squared error), leading to poor predictions for the majority of typical data points.

Removing these outliers helps the model focus on learning patterns that apply to the majority of houses and apartments, which aligns with the requirement to produce accurate predictions for typical properties. After removing outliers, applying a log transformation to the Square Meters feature further improves model performance by reducing skewness and stabilizing variance. Log transformations are commonly recommended in AWS and general ML documentation when numerical features span multiple orders of magnitude.

Option B is incorrect because normalization alone does not address the undue influence of extreme outliers. Option C and D are incorrect because one-hot encoding is intended for categorical variables, not continuous numerical features such as square meters.

Therefore, removing outliers and applying a log transformation is the most statistically sound preprocessing approach.

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.

Option C is correct because the company needs Kubernetes hosting, does not want to manage the control plane, wants repeatable infrastructure provisioning, and requires that provisioning be done by using Python. Amazon EKS is AWS’s managed Kubernetes service, so it satisfies the requirement to avoid managing the Kubernetes control plane directly. The AWS CDK documentation also confirms that Python is a fully supported client language for defining infrastructure as code.

AWS CDK is the best fit because it lets engineers define cloud infrastructure programmatically in Python and deploy it in a repeatable way. The AWS CDK EKS construct library specifically supports defining Amazon EKS clusters and related Kubernetes resources. This makes it a strong match for infrastructure that must be reproducible and expressed in code rather than provisioned manually. Since the model is already packaged in a container, storing the image in Amazon ECR and then deploying it to Amazon EKS follows the normal AWS container workflow.

The other options are less suitable. Option A requires setting up and managing a Kubernetes cluster on EC2, which violates the requirement to avoid control-plane management. Option B uses the AWS CLI, but the question specifically requires infrastructure provisioning by using Python, not command-line provisioning. Option D uses CloudFormation, which is repeatable infrastructure as code, but the question explicitly says the infrastructure must be provisioned by using Python. AWS CDK uniquely satisfies both the IaC and Python requirements while using managed Kubernetes with EKS.

Therefore, the best verified AWS-docs answer is C.

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.

AWS Glue DataBrew supports datasets sourced directly from Amazon S3 paths. To clean and normalize data, AWS documentation specifies using DataBrew recipes, which define transformation steps such as standardization, deduplication, and formatting.

A profile job is used only for data analysis and statistics generation, not for transformation. A recipe job applies actual transformations to the data and writes the output to Amazon S3.

JDBC connections are used for relational databases, not S3 buckets. Therefore, options C and D are invalid.

AWS clearly documents that the correct workflow is:

Create a DataBrew dataset from an S3 path

Define transformations using a recipe

Run a recipe job to produce cleaned data

Thus, Option B is the correct and AWS-aligned answer.

Recall measures the ability of a model to correctly identify all positive cases (true positives) out of all actual positives, minimizing false negatives. Since the cost of false negatives is much higher than false positives in this scenario, the ML engineer should prioritize models with high recall to reduce the likelihood of missing positive cases.

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.

Option A is correct because the issue is that the lead ML engineer’s local notebook environment does not yet contain the latest merged changes from the shared Git repository. In Git, the operation used to fetch remote updates and merge them into the local branch is git pull. AWS documentation for SageMaker notebook collaboration explains that Git repositories can be associated with SageMaker notebook instances so distributed teams can share notebooks and collaborate in a source-control environment.

AWS documentation is even more explicit in the SageMaker Git operations guide: to fetch notebooks committed by other users, you should do a pull from the project repository. That is exactly the situation described in the question. Other team members have already merged their notebook changes into the repository, and the lead engineer needs the latest notebook updates in the local SageMaker notebook environment. Therefore, running !git pull origin master is the correct command among the available choices.

The other options do not solve the problem. git commit records local changes in the user’s own repository history; it does not download new remote content. git push origin master uploads local commits to the remote repository; it is used when you want to send your own changes outward, not retrieve teammates’ updates. git branch only lists or manages branches and does not synchronize notebook content. Because the requirement is to see the latest merged notebook made by others, the necessary operation is a pull from the remote repository. So the best verified answer is A.