MLA-C01 Sample Questions Answers

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

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

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

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

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

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

Step 1: Create a new model definition with updated settings by using the CreateModel action in the SageMaker AI API.

Step 2: Create a new endpoint configuration that uses the new model definition.

Step 3: Update the endpoint with the new endpoint configuration.

Do not delete and recreate the endpoint. That causes unnecessary inference interruption. SageMaker endpoint updates are designed to use a new EndpointConfig; AWS explicitly states that to update an endpoint, you must create a new endpoint configuration, then call UpdateEndpoint on the existing endpoint. During the update, SageMaker changes the endpoint to Updating and then back to InService.

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.

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

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

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

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

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.

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.

Linear regression model whose coefficients should shrink but not become zero

Answer: L2 regularization

AWS says L2 produces smaller overall weight values and is the right fit when coefficients should be reduced without being forced to zero.

Polynomial regression model with irrelevant polynomial terms that should be eliminated

Answer: L1 regularization

AWS says L1 reduces the number of features used by pushing small weights to zero, which matches elimination of irrelevant terms.

Logistic regression model that has highly correlated features to eliminate highly redundant predictors

Answer: L1 regularization

This is the nuanced one. AWS says L2 stabilizes weights when there is high correlation between features, but because the question explicitly says eliminate highly redundant predictors, L1 is the better match since it creates sparsity and removes predictors by zeroing coefficients.

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.

 Problem Description:

The training dataset has a class imbalance, meaning one class (e.g., fraudulent transactions) has fewer samples compared to the majority class (e.g., non-fraudulent transactions). This imbalance affects the model’s ability to learn patterns from the minority class.

 Why SageMaker Data Wrangler?

SageMaker Data Wrangler provides a built-in operation called " Balance Data, " which includes oversampling and undersampling techniques to address class imbalances.

Oversampling the minority class replicates samples of the minority class, ensuring the algorithm receives balanced inputs without significant additional operational overhead.

 Steps to Implement:

Import the dataset into SageMaker Data Wrangler.

Apply the " Balance Data " operation and configure it to oversample the minority class.

Export the balanced dataset for training.

 Advantages:

Ease of Use: Minimal configuration is required.

Integrated Workflow: Works seamlessly with the SageMaker ecosystem for preprocessing and model training.

Time Efficiency: Reduces manual effort compared to external tools or scripts.

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

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

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

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

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.

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.

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.

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.

SageMaker JumpStart provides access to pre-trained models, including large language models (LLMs), which can be easily deployed and fine-tuned with a low-code/no-code (LCNC) approach. Using SageMaker Autopilot with JumpStart simplifies the fine-tuning process by automating model optimization and reducing the need for extensive coding, making it the ideal solution for this requirement.

This issue occurs because target tracking auto scaling allows the endpoint to scale down to zero, and scaling up only happens after traffic arrives. At the start of the business day, no instances are running, so the first requests experience cold-start delays.

AWS documentation for Amazon SageMaker recommends using scheduled or step scaling policies when predictable traffic patterns exist. In this case, business hours are predictable, so the best practice is to proactively scale the endpoint before traffic arrives.

Option D correctly uses Amazon CloudWatch alarms with step scaling to increase the minimum instance count from zero to one at the start of the business day. This ensures at least one warm instance is ready to handle requests immediately, eliminating startup latency.

Options A, B, and C do not guarantee instance availability before traffic begins. Cooldown tuning and metric changes only react after load is detected.

Therefore, scheduled step scaling using CloudWatch alarms is the correct solution.

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

Why Athena?

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

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

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

Steps to Implement:

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

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

Run CTAS Statement:

CREATE TABLE processed_data

WITH (

format = ' PARQUET ' ,

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

partitioned_by = ARRAY[ ' transaction_date ' ]

) AS

SELECT *

FROM input_data;

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

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

AWS CodeDeploy provides predefined deployment configurations for ECS that support canary and linear traffic shifting. The ECSCanary10Percent15Minutes configuration shifts 10% of traffic initially, waits 15 minutes, and then shifts the remaining traffic.

This matches the exact requirement: a 10% initial shift followed by the remaining 90% within the specified time window.

Lambda deployment configurations are not applicable to ECS. ECSAllAtOnce does not perform gradual traffic shifting.

AWS documentation explicitly defines ECSCanary10Percent15Minutes for controlled, low-risk ECS deployments.

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

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.

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.

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.

Amazon EMR clusters consist of primary, core, and task nodes, each with a distinct role. The primary node manages the cluster, core nodes store data and run tasks, and task nodes only run tasks without storing data. AWS documentation recommends using task nodes for scaling compute capacity when workloads are compute-intensive, such as data ingestion and transformation pipelines.

To reduce processing time cost-effectively, AWS strongly advises using Spot Instances for task nodes. Spot Instances provide the same compute capacity as On-Demand Instances but at a significantly reduced cost, often up to 90% lower. Because task nodes do not store HDFS data, they can be safely interrupted without risking data loss.

Increasing the number of primary nodes is not supported by EMR and would not improve performance. Increasing core nodes affects both storage and compute and is more expensive, especially when using On-Demand Instances. Option D is therefore the least cost-effective.

AWS EMR best practices explicitly state that scaling out with Spot task nodes is the preferred way to improve performance for transient, parallel workloads such as ETL, ingestion, and feature preparation.

Therefore, Option C is the most cost-effective and AWS-recommended solution.

AWS documentation strongly recommends using custom Docker containers when ML workloads require consistent access to custom dependencies across processing jobs, training jobs, and pipelines.

By building a single Docker image that contains all required libraries and hosting it in Amazon ECR, the ML engineer ensures that every SageMaker job uses the same runtime environment. This approach eliminates the need for repetitive installation steps and avoids environment drift.

Manually installing libraries in managed containers is error-prone and not reusable across jobs. Notebook instances are not designed to host production jobs and pipelines. Running code externally breaks the SageMaker workflow and increases operational complexity.

Using a custom container is a one-time setup that provides maximum reuse with minimal ongoing effort, making it the least implementation effort option in the long run.

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

Amazon SageMaker AI automatically collects aggregated metadata from training jobs to improve service reliability, performance, and operational insights. This metadata can include information such as algorithm usage, instance types, resource utilization, and job configuration details. However, AWS documentation clearly states that customers can opt out of SageMaker metadata collection to meet regulatory or compliance requirements.

SageMaker provides a supported mechanism to disable metadata tracking at the training job level. By explicitly opting out of metadata tracking when submitting training jobs—either through the AWS Management Console, AWS CLI, or SDK—the service will stop collecting aggregated metadata for those jobs. This option is specifically designed for customers with strict compliance, data residency, or regulatory constraints.

Option B is incorrect because running training jobs in a private subnet within a custom VPC controls network isolation, not service-level telemetry or metadata collection. Metadata collection occurs at the SageMaker service layer and is independent of VPC configuration.

Option C is also incorrect because encrypting training data with a customer-managed AWS KMS key protects data at rest and in transit but does not prevent SageMaker from collecting operational metadata about training jobs.

Option D is incorrect because AWS Nitro instances provide enhanced security and performance isolation at the infrastructure level but have no impact on SageMaker’s metadata collection mechanisms.

Therefore, opting out of metadata tracking for training jobs is the only solution that directly addresses the compliance requirement and is explicitly supported by AWS documentation.

In a Retrieval Augmented Generation (RAG) architecture, retrieval quality directly impacts response accuracy. AWS documentation for Bedrock and OpenSearch highlights the use of reranker models to improve relevance after initial vector search retrieval.

Vector search retrieves documents based on embedding similarity, but the top results are not always the most contextually relevant. A reranker model evaluates the retrieved documents against the user query and reorders them based on semantic relevance before sending them to the foundation model.

Option A improves readability but does not improve retrieval relevance. Option C filters data before retrieval, which can reduce recall. Option D improves performance, not relevance.

AWS explicitly recommends reranking as a best practice for improving answer quality in RAG systems.

Therefore, Option B is the correct solution.

Step 1:

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

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

Step 2:

CodePipeline detects code changes and starts to build automatically.

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

Step 3:

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

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

Step 4:

Human approval is provided after testing is successful.

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

Step 5:

CodePipeline deploys ML models and applications to production.

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

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

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

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

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

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

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

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

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

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

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

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

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

AWS recommends SageMaker Serverless Inference for workloads with intermittent or unpredictable traffic. Serverless inference automatically scales compute resources to zero when idle, eliminating costs during periods with no traffic.

For business-hour traffic spikes, provisioned concurrency ensures low-latency responses while still avoiding the cost of continuously running instances. This model is especially cost-effective for CPU-based inference workloads.

Real-time endpoints incur costs even when idle, and asynchronous inference is designed for long-running jobs rather than low-latency predictions.

AWS documentation explicitly states that Serverless Inference is the most cost-effective option for intermittent real-time workloads.

Therefore, Option B is the correct choice.

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.

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

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

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

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

SageMaker Clarify is designed to provide explainability for ML models. It can analyze feature importance and explain how input features influence the model ' s predictions. By using Clarify with the deployed SageMaker model, the ML engineer can generate insights and present them to stakeholders to explain the sentiment analysis predictions effectively.

The SageMaker Canvas user needs permissions to access the Amazon S3 bucket where the model artifacts are stored to retrieve the model for use in Canvas.

Registering the model in the SageMaker Model Registry allows the model to be tracked and managed within the SageMaker ecosystem. This makes it accessible for tuning and deployment through SageMaker Canvas.

This combination ensures proper access control and integration within SageMaker, enabling the Canvas user to work with the model.

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.

One-hot encoding is the appropriate technique for transforming categorical data, such as color information, into a format suitable for input to a neural network. This technique creates a binary vector representation where each unique category (color) is represented as a separate binary column, ensuring that the model does not infer ordinal relationships between categories. This approach preserves the categorical nature of the data and avoids introducing unintended biases.

This scenario indicates overfitting. AWS documentation for XGBoost recommends increasing the L2 regularization parameter (lambda) to reduce overfitting and improve generalization.

Increasing num_round worsens overfitting. Changing evaluation metrics does not change model behavior. Collecting more data is effective but requires significant effort.

Regularization is a low-effort, high-impact fix.

Therefore, Option D is correct.

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.

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.

This scenario describes a severely imbalanced classification problem. In such cases, accuracy is a misleading metric, because the model can achieve high accuracy by predicting only the majority class.

AWS ML best practices recommend using F1 score (or precision/recall) when evaluating imbalanced datasets. The F1 score balances false positives and false negatives, making it ideal for assessing minority-class performance.

For image data, image augmentation (rotations, flips, crops, color jitter) is the preferred technique to increase minority-class representation. SMOTE is designed for tabular data and is not suitable for image pixel data.

Therefore, the correct solution is to optimize for F1 score and apply image augmentation.

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

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

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

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

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

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

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 recommends Amazon SageMaker Model Monitor for detecting data drift and model drift in deployed models. Model Monitor works by comparing live inference data against a baseline, which must first be created from the training dataset.

AWS documentation clearly specifies the required order:

Create a baseline using training data statistics

Create a monitoring schedule to compare incoming data against the baseline

Option A reverses this order and is therefore incorrect. Option C is incorrect because SageMaker Clarify focuses on bias and explainability, not ongoing drift detection. Option D is reactive and does not provide continuous monitoring.

Model Monitor integrates with Amazon CloudWatch, enabling automated alerts and downstream retraining workflows. This proactive approach allows companies to detect degradation early and maintain model quality.

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.

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.

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.

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

Why Spot Instances?

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

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

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

Steps to Implement:

Create a Spot Instance Request:

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

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

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

Comparison with Other Options:

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

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

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

Class imbalance occurs when one class significantly outnumbers another, causing models to bias predictions toward the majority class. In this case, images without defects (1,800) vastly outnumber images with defects (200). AWS ML best practices recommend oversampling the minority class to improve class representation without discarding valuable data.

Oversampling techniques—such as duplicating minority samples or applying data augmentation—help the model better learn defect-related features. This approach preserves all available data and improves recall and precision for underrepresented defect classes.

Option B is incorrect because undersampling the minority class would further worsen imbalance. Option A unnecessarily reduces dataset size. Option D does not address the imbalance problem.

Thus, oversampling defect images is the correct solution.

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.

Amazon FSx for Lustre is designed for high-performance workloads like ML training. It provides fast, low-latency access to data by linking directly to the existing S3 bucket and caching frequently accessed files locally. This significantly improves training performance compared to directly accessing millions of files from S3. It requires minimal changes to the training job and avoids the overhead of transferring or restructuring data, making it the fastest and most efficient solution.

To implement a manual approval-based workflow ensuring that only approved models are deployed to production endpoints, Amazon SageMaker provides integrated tools such as SageMaker Pipelines and the SageMaker Model Registry.

SageMaker Pipelines is a robust service for building, automating, and managing end-to-end machine learning workflows. It facilitates the orchestration of various steps in the ML lifecycle, including data preprocessing, model training, evaluation, and deployment. By integrating with the SageMaker Model Registry, it enables seamless tracking and management of model versions and their approval statuses.

Implementation Steps:

Define the Pipeline:

Create a SageMaker Pipeline encompassing steps for data preprocessing, model training, evaluation, and registration of the model in the Model Registry.

Incorporate a Condition Step to assess model performance metrics. If the model meets predefined criteria, proceed to the next step; otherwise, halt the process.

Register the Model:

Utilize the RegisterModel step to add the trained model to the Model Registry.

Set the ModelApprovalStatus parameter to PendingManualApproval during registration. This status indicates that the model awaits manual review before deployment.

Manual Approval Process:

Notify the designated approver upon model registration. This can be achieved by integrating Amazon EventBridge to monitor registration events and trigger notifications via AWS Lambda functions.

The approver reviews the model ' s performance and, if satisfactory, updates the model ' s status to Approved using the AWS SDK or through the SageMaker Studio interface.

Deploy the Approved Model:

Configure the pipeline to automatically deploy models with an Approved status to the production endpoint. This can be managed by adding deployment steps conditioned on the model ' s approval status.

Advantages of This Approach:

Automated Workflow: SageMaker Pipelines streamline the ML workflow, reducing manual interventions and potential errors.

Governance and Compliance: The manual approval step ensures that only thoroughly evaluated models are deployed, aligning with organizational standards.

Scalability: The solution supports complex ML workflows, making it adaptable to various project requirements.

By implementing this solution, the company can establish a controlled and efficient process for deploying models, ensuring that only approved versions reach production environments.

Network ACLs (Access Control Lists) operate at the subnet level and allow for rules to explicitly deny traffic from specific IP addresses. By creating an inbound rule in the network ACL to deny traffic from the suspicious IP address, the company can block traffic to the Amazon SageMaker domain from that IP. This approach works because network ACLs are evaluated before traffic reaches the security groups, making them effective for blocking traffic at the subnet level.

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.

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.

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.

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.

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 provides Amazon SageMaker Data Wrangler as a native tool for importing, transforming, and analyzing data from multiple sources directly into SageMaker Studio. Data Wrangler supports Amazon S3, Amazon Athena, and Snowflake as built-in data sources through managed connectors.

Using Data Wrangler, ML engineers can query data from Athena using SQL, load structured files from S3, and securely connect to Snowflake without writing custom ingestion code. This approach significantly reduces development effort and aligns with AWS best practices for rapid ML experimentation.

Option A is incorrect because AWS Glue DataBrew is designed for data preparation but does not natively integrate with SageMaker training workflows. Option B introduces unnecessary complexity and is not intended for direct ML data loading. Option C focuses on feature storage, not raw historical data ingestion.

Therefore, SageMaker Data Wrangler is the correct solution.

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.

Step 1: Create a feature group.

Step 2: Ingest the records.

Step 3: Access the store to build datasets for training.

Step 1: Create a Feature Group

Why? A feature group is the foundational unit in SageMaker Feature Store, where features are defined, stored, and organized. Creating a feature group specifies the schema (name, data type) for the features and the primary keys for data identification.

How? Use the SageMaker Python SDK or AWS CLI to define the feature group by specifying its name, schema, and S3 storage location for offline access.

Step 2: Ingest the Records

Why? After creating the feature group, the raw data must be ingested into the Feature Store. This step populates the feature group with data, making it available for both real-time and offline use.

How? Use the SageMaker SDK or AWS CLI to batch-ingest historical data or stream new records into the feature group. Ensure the records conform to the feature group schema.

Step 3: Access the Store to Build Datasets for Training

Why? Once the features are stored, they can be accessed to create training datasets. These datasets combine relevant features into a single format for machine learning model training.

How? Use the SageMaker Python SDK to query the offline store or retrieve real-time features using the online store API. The offline store is typically used for batch training, while the online store is used for inference.

Order Summary:

Create a feature group.

Ingest the records.

Access the store to build datasets for training.

This process ensures the features are properly managed, ingested, and accessible for model training using Amazon SageMaker Feature Store.

Logging the metrics to Amazon CloudWatch allows the metrics to be tracked and monitored effectively.

CloudWatch Alarms can be configured to trigger when metrics breach a predefined threshold.

The alarm can be set to notify through Amazon Simple Notification Service (SNS), which can send email messages to the configured recipients.

This is the standard and most efficient way to achieve the desired functionality.

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.

Option A is correct because AWS Glue provides the lowest-overhead managed pattern for this scenario: use a crawler to keep the AWS Glue Data Catalog updated for the S3 dataset, then use AWS Glue Data Quality to evaluate rules against that cataloged data. AWS documentation states that crawlers can automatically discover and catalog new or updated S3 data sources, reducing manual metadata management overhead. AWS Glue Data Quality is also documented as a managed, serverless capability for measuring and monitoring data quality.

This option is especially strong because the dataset is already in Amazon S3 and partitioned by date, and the requirement is simply to automatically check quality before the data is sent to QuickSight. AWS Glue Data Quality supports the Data Catalog as an entry point, and AWS documentation notes that this approach is intended for datasets that are already cataloged and for ongoing governance-style quality evaluation. The docs also show that scheduling is supported for Data Catalog-based quality checks. That means the company can run the crawler monthly, then evaluate a ruleset against the cataloged table without needing custom ETL code.

The other options add more operational work. Option B requires a custom PySpark job and custom functions, which is more maintenance-heavy than using catalog-based quality rules directly. Option C depends on bespoke Lambda scripts. Option D does not use the right service for data quality validation. Because the question asks for the least operational overhead, the most AWS-aligned answer is A: monthly Glue crawler plus Glue Data Quality rules.

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

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

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

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

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.

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.

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.

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.

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.