Practice Free MLA-C01 AWS Certified Machine Learning Engineer - Associate Exam Questions Answers With Explanation

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

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

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

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

Amazon SageMaker AI shadow testing enables ML engineers to evaluate new model versions by sending a copy of live production traffic to a shadow variant without affecting production inference responses. AWS documentation specifies that shadow variants are configured separately from production variants and can use different instance types, including higher-performance GPU instances.

The correct approach is to create a new endpoint configuration using the CreateEndpointConfig API. This configuration includes the existing production variant and a separate ShadowProductionVariants list. The shadow variant can be assigned a larger instance type to meet GPU performance requirements while leaving the production variant unchanged. After creating the configuration, the engineer deploys it using the CreateEndpoint action.

Option A is incorrect because production variant configurations cannot be directly modified to include shadow variants. Option B is incorrect because shadow variants are not defined as standard production variants; defining two production variants would route traffic differently and could affect production behavior. Option C introduces unnecessary complexity and deviates from SageMaker’s built-in shadow testing functionality.

AWS explicitly documents that shadow variants are designed to isolate testing resources, support different instance types, and ensure zero impact on production inference. Therefore, Option D is the correct and AWS-recommended 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.

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

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

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

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

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

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

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.

Callback steps in Amazon SageMaker Pipelines allow you to integrate external processes, such as AWS Glue jobs, into the pipeline workflow. By using a Callback step, the SageMaker pipeline can trigger the AWS Glue workflow and pause execution until the Glue jobs complete. This approach provides seamless integration with minimal operational overhead, as it directly ties the pipeline ' s execution flow to the completion of the AWS Glue jobs without requiring additional orchestration tools or complex setups.

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

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.

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 Kendra Experience Builder provides a fully managed, low-code solution for building conversational search and question-answering applications. AWS documentation states that Kendra natively supports semantic search, vector embeddings, and vector-based retrieval, making it well suited for RAG-style applications with minimal development effort.

When integrated with Amazon Bedrock, Kendra can act as the retrieval layer, handling document ingestion, indexing, embedding generation, and relevance ranking automatically. This eliminates the need to manually manage embedding models, vector databases, and search logic.

Options B and C require custom schema design, vector indexing, query logic, and operational management of PostgreSQL instances. Although pgvector supports vector search, it significantly increases development and maintenance effort. Option D is unrelated to vector search and is used only for metadata cataloging.

AWS explicitly positions Amazon Kendra as the fastest way to build enterprise-grade conversational assistants that integrate with foundation models.

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

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

Key Features of SageMaker Model Registry:

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

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

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

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

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

Implementation Steps:

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

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

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

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

Benefits:

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

Streamlined Deployment: Facilitates smooth transitions from development to production.

Governance and Compliance: Supports metadata association and approval processes.

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

AWS Documentation: SageMaker Model Registry

AWS Blog: Model Registry Features and Usage

AWS Glue DataBrew 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.

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.

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

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

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

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

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

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

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

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

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

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

Amazon SageMaker Clarify is the AWS service used to detect and quantify bias and fairness metrics in ML models. When bias monitoring jobs run, Clarify publishes bias metrics directly to Amazon CloudWatch.

CloudWatch metrics can be visualized using CloudWatch dashboards or integrated into other monitoring tools, making them ideal for real-time or periodic bias reporting.

CloudTrail logs API activity and does not capture ML metrics. EventBridge and SNS are used for event routing and notifications, not metric visualization.

AWS documentation explicitly states that Clarify bias metrics are emitted to Amazon CloudWatch, which is the correct source for dashboards.

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

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.

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.

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

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

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

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

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

This dataset shows severe class imbalance, with only 2% of records representing patients with the disease. AWS ML best practices recommend correcting imbalance only in the training dataset, while keeping validation and test sets representative of real-world distributions.

Synthetic Minority Oversampling Technique (SMOTE) generates synthetic samples of the minority class by interpolating between existing minority examples. This improves the model’s ability to learn disease-related patterns without discarding data.

PCA is a dimensionality reduction method, not an oversampling technique. Oversampling the majority class worsens imbalance. Altering the test dataset would invalidate evaluation results.

Therefore, applying SMOTE to the training dataset is the correct approach.

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.

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.

Amazon SageMaker Pipelines is designed for creating, automating, and managing end-to-end ML workflows, including complex data preprocessing tasks. It supports handling large datasets and can integrate with custom steps, such as NLP transformations. By combining SageMaker Pipelines with Amazon EventBridge, the entire workflow can be triggered and automated efficiently, meeting the requirements for scalability, automation, and processing complexity.

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

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

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

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

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

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

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

For near real-time predictions, AWS documentation recommends Amazon SageMaker real-time inference endpoints. These endpoints support automatic scaling based on metrics such as ConcurrentInvocationsPerInstance, ensuring low latency and high availability during traffic spikes.

For long-running historical analysis, SageMaker Processing jobs are the appropriate solution. Processing jobs are designed for batch workloads, can run for hours, and integrate cleanly with SageMaker pipelines. Scheduling them with Amazon EventBridge provides a fully managed, scalable, and serverless solution.

AWS Lambda is unsuitable for multi-hour workloads. EC2 Auto Scaling adds unnecessary infrastructure management overhead.

Therefore, Options A and C together meet all requirements and align with AWS best practices.

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.

AWS Glue DataBrew is designed specifically for no-code and low-code data preparation, making it the fastest and lowest-overhead solution for resolving common data quality issues. DataBrew provides built-in transformations for deduplication, missing value imputation, and outlier handling while preserving data integrity.

Option A uses standard statistical techniques such as median imputation and value normalization, which are widely accepted and maintain the distribution of the data. DataBrew jobs are fully managed and do not require infrastructure setup or maintenance.

Option B deletes records, which can lead to data loss and does not preserve integrity. Option C introduces unnecessary infrastructure complexity and uses poor data imputation practices. Option D provides advanced capabilities but requires more configuration and ML expertise, increasing operational overhead.

AWS documentation clearly positions DataBrew as the preferred solution for quick, reliable data cleaning with minimal effort.

Therefore, Option A is the correct answer.

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

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

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

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

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

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.

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

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

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

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

The key requirement is semantic search over text documents that already reside in Amazon S3. AWS provides Amazon Kendra, a fully managed service specifically designed for semantic and natural language search across unstructured text.

Amazon Kendra natively supports S3 connectors, which can ingest documents directly from an S3 bucket, automatically process the text, generate embeddings, and index the content for semantic retrieval. This removes the need for the company to manage embedding generation, vector storage, or similarity search infrastructure. Queries can be expressed in natural language, making Kendra well suited for RAG-style applications.

Option A and B require building and maintaining a custom embedding pipeline and do not provide a true vector similarity search engine using SQL. SageMaker Feature Store is not intended to function as a vector database for semantic search.

Option D is incorrect because Amazon Textract is an OCR service for extracting text from scanned documents and images; it does not support semantic search.

Therefore, ingesting documents using the Amazon Kendra S3 connector and querying Kendra is the correct and AWS-recommended solution.

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

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

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

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

Therefore, Options A and B are correct.

The temperature parameter controls the randomness in the model ' s responses. Lowering the temperature makes the model produce more deterministic and consistent answers.

The top_k parameter limits the number of tokens considered for generating the next word. Reducing top_k further constrains the model ' s options, ensuring more predictable responses.

By decreasing both parameters, the responses become more focused and consistent, reducing variability in similar queries.

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.

This solution is the most efficient and involves the least operational overhead:

Amazon Kinesis data streams efficiently handle real-time ingestion of high-volume streaming data.

Amazon Managed Service for Apache Flink provides a fully managed environment for stream processing with built-in support for RANDOM_CUT_FOREST, an algorithm designed for anomaly detection in real-time streaming data.

This approach eliminates the need for deploying and managing additional infrastructure like SageMaker endpoints, Lambda functions, or external tools, making it the most scalable and operationally simple solution.

SageMaker script mode allows you to bring existing custom Python scripts and run them on AWS with minimal changes. SageMaker provides prebuilt containers for ML frameworks like PyTorch, simplifying the migration process. This approach enables the company to leverage their existing Python scripts and domain knowledge while benefiting from the scalability and managed environment of SageMaker. It requires the least effort compared to building custom containers or retraining models from scratch.

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.

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.

The problem is a time series forecasting task with historical data and categorical features. Amazon SageMaker DeepAR is purpose-built for this use case. DeepAR uses recurrent neural networks to learn temporal patterns across multiple related time series and supports categorical covariates.

The context length hyperparameter controls how much historical data the model uses as input, while the prediction length specifies how far into the future the model forecasts. Correctly setting these hyperparameters is critical for capturing trends and seasonality.

XGBoost is a general-purpose tabular algorithm and does not model temporal dependencies natively. k-means is a clustering algorithm. Random Cut Forest is used for anomaly detection, not forecasting.

Therefore, DeepAR with appropriate context and prediction lengths is the correct and AWS-recommended solution.

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

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

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

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

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

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

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

The correct answer is A. The AWS Glue service quotas have been reached. AWS Glue is commonly used in ML data preparation pipelines to perform ETL operations before model training or feature engineering. When AWS Glue workloads exceed account-level or Region-level service quotas, jobs can be delayed, queued, throttled, or fail. AWS documentation states that AWS Glue has service quotas, also called limits, for resources and operations in each account and Region. These include quotas for concurrent compute capacity measured in DPUs, crawlers, jobs, triggers, queued job runs, and other Glue resources.

The key clue in the question is “throttling errors in the ETL jobs.” AWS specifically explains that Glue API requests are throttled on a per-account, per-Region basis to maintain service performance. If the team is running many jobs, processing a large amount of sensor data, or starting too many Glue job runs concurrently, the workload can exceed the permitted quota and cause throttling.

Option B is less likely because insufficient network bandwidth between IoT devices and the AWS Region would mainly explain slower ingestion into S3, but it would not directly explain AWS Glue ETL throttling errors. Option C might cause poor job performance, but lack of parallel optimization usually causes long runtimes, not service-level throttling. Option D is incorrect because missing Amazon S3 permissions would typically cause access-denied or authorization failures, not throttling. Therefore, the best cause is that the AWS Glue service quotas, such as concurrent job runs, API rate limits, or DPU capacity limits, have been reached.

Option D is correct because the company’s primary goal is to identify as many fraudulent transactions as possible. In AWS documentation, recall is defined as TP / (TP + FN), where TP is true positives and FN is false negatives. Recall measures how well a model finds all actual positive cases. In a fraud-detection setting, the “positive” class is the fraudulent transaction, so maximizing recall means minimizing missed fraud cases.

AWS documentation also explains the business tradeoff clearly: a use case that needs to correctly predict as many positive examples as possible should prioritize high recall, even if that means accepting some additional false positives and therefore only moderate precision. That matches this question exactly, because the requirement is not to be most selective or most balanced overall; it is specifically to catch the largest possible number of fraudulent transactions.

The other metrics are less aligned to the stated goal. Precision focuses on how many predicted fraud cases are actually fraud, which is most important when false positives are very costly. F1 score balances precision and recall, but the question does not ask for balance; it asks for finding as many fraudulent transactions as possible. AUC is useful for overall ranking and threshold-independent model discrimination, but it is not the most direct metric for optimizing missed-fraud detection in this scenario. Based on AWS metric definitions, when the cost of missing true positives is the main concern, recall is the best evaluation metric. Therefore, the best verified answer is D.

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.

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.

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.

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.

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.

Use case 1:

Summarize the text of a research paper

?? Sequence-to-Sequence (seq2seq) algorithm

Why:

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

Use case 2:

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

?? Semantic segmentation algorithm

Why:

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

Use case 3:

Identify abnormal data points in a dataset

?? Random Cut Forest (RCF) algorithm

Why:

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

Step 1

Upload the existing models to the same Amazon S3 bucket path.

Multi-model endpoints require all models to be stored under a single S3 prefix so SageMaker can dynamically load them on demand.

Step 2

Create a SageMaker AI model with multi-model endpoints enabled.

This creates a SageMaker model resource that uses a multi-model–capable container (for example, XGBoost, PyTorch, or TensorFlow MME-compatible containers).

Step 3

Create an endpoint configuration that references a multi-model container.

The endpoint configuration defines:

Instance type

Initial instance count

The multi-model container reference

Step 4

Deploy a real-time inference endpoint by using the endpoint configuration.

Real-time endpoints ensure low-latency inference, which is a strict customer requirement.

Step 5

Update the models to use the new endpoint ID. Pass the model IDs to the new endpoint.

Each inference request specifies a model ID so SageMaker knows which model to load from S3.

The company already has custom Python training scripts, proprietary datasets, and uses PyTorch, with significant domain-specific logic embedded in the model. The goal is to migrate these workloads to AWS with the least development effort.

According to AWS documentation, Amazon SageMaker AI script mode is explicitly designed for this scenario. Script mode allows customers to bring their existing training scripts with minimal or no code changes and run them using prebuilt SageMaker framework containers, including PyTorch. This approach eliminates the need to redesign models or rewrite training logic while still benefiting from SageMaker’s managed infrastructure, scalability, monitoring, and security.

Option A is incorrect because SageMaker built-in algorithms require adapting data formats and training logic to AWS-provided implementations, which would increase development effort and may not support proprietary domain logic.

Option C is also incorrect because building and maintaining a custom container requires additional effort for containerization, dependency management, security updates, and lifecycle maintenance—making it more complex than necessary.

Option D is not viable because purchasing models from AWS Marketplace would not support the company’s proprietary datasets or unique domain knowledge embedded in existing models.

Therefore, using SageMaker AI script mode with prebuilt PyTorch containers is the fastest, most efficient, and AWS-recommended migration path that minimizes development effort while preserving existing workflows.

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.

The requirement is event-driven automation when new data arrives in Amazon S3, followed by training and model registration. Amazon EventBridge natively supports S3 object creation events and can trigger downstream workflows immediately.

By using EventBridge to start an AWS Step Functions workflow that includes a training step and a SageMaker Model Registry registration step, the pipeline runs automatically as soon as new data is uploaded—well within the 24-hour requirement.

Option A introduces unnecessary polling and delay. Option B is time-based and does not ensure alignment with data readiness. Option C is invalid because S3 Lifecycle rules manage object transitions, not workflow execution.

Therefore, EventBridge-triggered Step Functions is the correct solution.

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

Implementation Steps:

Set Up Data Capture:

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

Develop a Lambda Function:

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

Schedule or Trigger the Lambda Function:

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

Analyze and Respond to Results:

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

Advantages of This Approach:

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

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

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

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

Step 1:

Create a Shapley Additive Explanations (SHAP) baseline for the model by using Amazon SageMaker Clarify.

Step 2:

Schedule an hourly model explainability monitor.

Step 3:

Check the analysis results on the SageMaker Studio console.

When monitoring a deployed model for data drift and explainability, AWS prescribes a specific workflow using SageMaker Clarify and SageMaker Model Monitor:

Create a SHAP baseline (Step 1)Before any monitoring can occur, SageMaker Clarify must establish a baseline explainability configuration. This baseline captures the reference SHAP values for feature importance using training or baseline data. Model Monitor uses this baseline to compare future inferences and detect drift in feature attributions.

Schedule the model explainability monitor (Step 2)After the baseline is created, an explainability monitoring schedule must be configured (hourly in this case). The monitor periodically analyzes inference data, compares it against the SHAP baseline, and generates reports that highlight drift or anomalies in feature contributions.

Inspect results in SageMaker Studio (Step 3)Once monitoring jobs run, SageMaker stores the analysis results in Amazon S3 and surfaces them in the SageMaker Studio console, where engineers can review metrics, violations, and visual reports.

This sequence is mandatory because:

A monitor cannot run without a baseline

Results cannot be reviewed until the monitor executes

AWS best practices recommend event-driven architectures to automate ML workflows with minimal operational overhead. Amazon EventBridge natively integrates with Amazon S3 and Amazon SageMaker Pipelines, making it the most efficient solution for triggering retraining when new data arrives.

Amazon S3 automatically emits object creation events. By creating an EventBridge rule that listens for these events and targets a SageMaker Pipeline execution, the pipeline can start immediately when new training data is uploaded. This solution requires no custom code, no polling, and no infrastructure management.

Option A is incorrect because S3 lifecycle rules manage storage transitions, not workflow execution. Option B introduces custom code and periodic scanning, which increases operational complexity and cost. Option D (MWAA) is powerful but requires maintaining an Airflow environment and is unnecessary for a simple event-based trigger.

AWS documentation explicitly highlights EventBridge + SageMaker Pipelines as the recommended pattern for automated retraining workflows triggered by data arrival.

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

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

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

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

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

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

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.

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.

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.

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.

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.

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.

Problem Description:

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

Why Concept Drift?

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

Signs of Concept Drift:

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

Declining prediction accuracy for certain groups or scenarios.

Solution:

Monitor for drift using tools like SageMaker Model Monitor.

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

Why Not Other Options?:

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

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

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

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

The correct answer is A. Ingest real-time data into Amazon Kinesis data streams. Use the built-in RANDOM_CUT_FOREST function in Amazon Managed Service for Apache Flink to process the data streams and to detect data anomalies.

Amazon Kinesis Data Streams is a fully managed service that can handle high-volume, real-time data streams with low latency and high scalability. By integrating Amazon Managed Service for Apache Flink (MSK for Flink) with the built-in RANDOM_CUT_FOREST (RCF) algorithm, the company can perform real-time anomaly detection directly on streaming data without building or managing custom infrastructure. RCF is designed for unsupervised anomaly detection on streaming datasets, making it ideal for financial market data that arrives continuously and at high velocity.

Option B adds operational complexity because it requires deploying a SageMaker endpoint, setting up Lambda functions, and maintaining the orchestration between Kinesis and Lambda. Option C further increases overhead by requiring self-managed Apache Kafka clusters on EC2, combined with SageMaker and Lambda orchestration. Option D introduces SQS and batch ETL processing via AWS Glue, which is not suitable for real-time anomaly detection and significantly increases latency.

Using Kinesis + Managed Flink + RCF provides a serverless, fully managed, and scalable solution with minimal operational overhead. It handles ingestion, streaming processing, and anomaly detection natively. The architecture eliminates the need for provisioning compute clusters or managing real-time orchestration, reducing operational cost while achieving sub-second detection for thousands of JSON records per second.

This approach aligns with AWS best practices for ML solution monitoring, maintenance, and security, particularly for real-time anomaly detection in high-volume, structured or semi-structured data streams.