Amazon Practice Questions, Discussions & Exam Topics by our Authors
An ML engineer has developed a binary classification model outside of Amazon SageMaker. The ML engineer needs to make the model accessible to a SageMaker Canvas user for additional tuning.
The model artifacts are stored in an Amazon S3 bucket. The ML engineer and the Canvas user are part of the same SageMaker ...
To determine the correct combination of requirements that must be met so the ML engineer can share the model with the SageMaker Canvas user, we need to focus on how SageMaker Canvas accesses external models and how it integrates with models trained outside of SageMaker Studio. Here’s a breakdown of each option:
---
✅ B) The Canvas user must have permissions to access the S3 bucket where the model artifacts are stored.
Selected because:
SageMaker Canvas relies on Amazon S3 to access model artifacts such as trained model files.
For the Canvas user to import and tune the model, they must have the IAM permissions to read from the S3 bucket where the model is stored.
Without access, the user cannot load or work with the model in Canvas.
---
✅ C) The model must be registered in the SageMaker Model Registry.
Selected because:
SageMaker Canvas can import models from the SageMaker Model Registry, which acts as a centralized place to store, version, and share models across users in the same domain.
Registering the model enables cross-user visibility and governance, a key requirement for sharing a model across users (like from the ML engineer to the Canvas user).
Canvas can ...
Author: Leo · Last updated Jul 27, 2026
A company is building a deep learning model on Amazon SageMaker. The company uses a large amount of data as the training dataset. The company needs to optimize the model's hyperparameters to minimize the loss function on the validation da...
To determine the \\best hyperparameter tuning strategy with the least computation time on Amazon SageMaker, we must evaluate the four options—Hyperband, Grid Search, Bayesian Optimization, and Random Search—based on efficiency, scalability, and performance under large datasets.
---
🔍 Key Factors to Consider:
1. Computation Time Efficiency: The strategy must reduce time and cost.
2. Search Effectiveness: The method should find good hyperparameters without exhaustively trying all possibilities.
3. Scalability: It should scale with large datasets and large hyperparameter spaces.
4. Early Stopping Capability: Ability to stop unpromising jobs early is crucial for time saving.
---
✅ Option A: Hyperband
Selected
Why? Hyperband is a multi-fidelity optimization algorithm that uses early stopping to discard underperforming hyperparameter configurations quickly. It starts many trials but quickly eliminates the worst performers, allocating more resources only to promising trials.
Best For: Large datasets, high training costs, and large hyperparameter spaces.
Computational Efficiency: High. It avoids wasting resources by dynamically reallocating computation.
Amazon SageMaker Support: Yes. SageMaker supports Hyperband natively, ...
Author: Harper · Last updated Jul 27, 2026
A company is planning to use Amazon Redshift ML in its primary AWS account. The source data is in an Amazon S3 bucket in a secondary account.
An ML engineer needs to set up an ML pipeline in the primary account to access the S3 bucket in the secondar...
To identify the best solution for securely accessing an Amazon S3 bucket in a secondary AWS account from a Redshift ML pipeline in the primary account, without using public IPv4 addresses, we must evaluate each option based on network configuration, security posture, simplicity, and AWS best practices.
---
Key Requirements:
No public IPv4 addresses used.
Primary account needs access to S3 bucket in a secondary account.
Use Redshift ML (requires Redshift and SageMaker).
Must adhere to secure, scalable AWS architecture.
---
Option A: VPC peering, no public access, remove route to 0.0.0.0/0
Why it's not selected:
VPC peering works only for direct communication between instances and services within VPCs, not for accessing S3.
S3 is a regional service, not inside a VPC, so peering doesn't help access S3.
Removing the default route to the internet (0.0.0.0/0) may break service functionality unless very carefully managed.
Peering is not needed for S3 cross-account access; bucket policy and gateway endpoint are better suited.
Use Case: Useful when both VPCs need to directly communicate with private IPs, such as EC2-to-EC2 communication — not applicable for S3 access.
---
Option B: Direct Connect and Transit Gateway
Why it's not selected:
AWS Direct Connect is an expensive and unnecessary enterprise-level solution for accessing S3.
Adds complexity with transit gateway, which is suited for large-scale, hybrid networks.
Still doesn’t directly help with S3 cross-account access, which is better handled by bucket policie...
Author: Ahmed97 · Last updated Jul 27, 2026
A company is using an AWS Lambda function to monitor the metrics from an ML model. An ML engineer needs to implement a solution to send an email message when the m...
To determine the correct solution for sending an email alert when ML model metrics breach a threshold, we must evaluate each option against AWS services’ core functions and best practices.
---
✅ Correct Option: C
C) Log the metrics from the Lambda function to Amazon CloudWatch. Configure a CloudWatch alarm to send the email message.
Why this is correct:
Amazon CloudWatch is AWS’s monitoring and observability service. It can collect custom metrics from Lambda functions.
Lambda can log metrics directly to CloudWatch using the embedded `PutMetricData` API.
CloudWatch Alarms can be configured on those metrics to trigger notifications.
To send an email, you can integrate the alarm with Amazon SNS, which supports email notifications.
This approach follows AWS best practices and is widely used for monitoring applications and sending alerts based on threshold breaches.
---
❌ A) Log the metrics from the Lambda function to AWS CloudTrail. Configure a CloudTrail trail to send the email message.
Why this is incorrect:
AWS CloudTrail is for logging API calls and user activity, not application or performance metrics.
You cannot trigger an email directly from CloudTrail based on metric values.
It is not designed for operational monitoring or threshold-based alerts.
When it might be used...
Author: Akash · Last updated Jul 27, 2026
A company has used Amazon SageMaker to deploy a predictive ML model in production. The company is using SageMaker Model Monitor on the model. After a model update, an ML engineer notices data quality issues in the Model Monitor checks.
...
To determine the best option for mitigating the data quality issues identified by Amazon SageMaker Model Monitor after a model update, we must understand what Model Monitor actually does and what data quality issues typically mean in this context.
---
Understanding SageMaker Model Monitor
SageMaker Model Monitor tracks the quality of input data, model predictions, and feature distributions in production by comparing them to a baseline. If deviations from the baseline are detected — such as missing values, schema changes, out-of-range features, or unexpected distributions — it flags data quality issues.
This means the problem is not with the model itself, but with the input data it is receiving post-deployment.
---
Option Analysis
A) Adjust the model's parameters and hyperparameters
Rejected
Tuning model parameters or hyperparameters addresses model performance, not input data quality.
It won't help if the features are missing, improperly formatted, or outside expected ranges.
Scenario where valid: When model underperforms on correct input data, e.g., low accuracy or high latency.
---
B) Initiate a manual Model Monitor job that uses the most recent production data
Rejected
While this may help re-run the checks, it doesn't solve the underlying data quality issue.
It’s useful for diagnostics, not remediation.
Scenario where valid: To confirm or debug issues after deployment, but not for long...
Author: Julian · Last updated Jul 27, 2026
A company has an ML model that generates text descriptions based on images that customers upload to the company's website. The images can be up to 50 MB in total size.
An ML engineer decides to store the images in an Amazon S3 bucket. The ML engineer must implement a processing solution that...
To identify the solution with the LEAST operational overhead that can scale with demand, let’s evaluate each option carefully using key factors such as:
Scalability: Can the solution automatically scale based on the volume of uploaded images?
Operational overhead: How much manual work or infrastructure management is involved?
Suitability for asynchronous, image-based inference: How well does it handle potentially large input files and long-running ML inference tasks?
Cost efficiency and event-driven suitability
---
✅ Option B: Create an Amazon SageMaker Asynchronous Inference endpoint and a scaling policy. Run a script to make an inference request for each image.
Why it is selected:
Scalability: SageMaker Asynchronous Inference supports auto-scaling and is specifically designed for workloads where inference takes time or involves large payloads (such as 50MB images).
Low operational overhead: Fully managed by AWS; no need to manage infrastructure. Scaling, queuing, and invocation retries are handled.
Handles large payloads well: Supports up to 1 GB input/output payloads using Amazon S3.
Best for bursty or unpredictable traffic: Queued invocations help smooth out load.
Event-driven architecture: You can easily integrate with S3 event notifications to trigger requests when new images are uploaded.
🟢 Best choice for asynchronous, variable-demand, large-payload inference with minimal ops effort.
---
❌ Option A: Create an Amazon SageMaker batch transform job to process all the images in the S3 bucket.
Why it is rejected:
Not ideal for continuous/on-demand inference: Batch transform is great for large datasets processed at once, not for ...
Author: MoonlitPantherX · Last updated Jul 27, 2026
An ML engineer needs to use AWS services to identify and extract meaningful unique keywords from documents.
Which solution will mee...
Solution Analysis
Option A: Use the Natural Language Toolkit (NLTK) library on Amazon EC2 instances for text pre-processing. Use the Latent Dirichlet Allocation (LDA) algorithm to identify and extract relevant keywords.
Pros:
Customizable and Flexible: LDA is a powerful algorithm for topic modeling and can be tailored to specific needs.
Scalable: EC2 instances can be scaled up based on requirements.
Cons:
Operational Overhead: Managing EC2 instances involves significant operational overhead (e.g., provisioning, monitoring, scaling, patching).
Complexity: Requires managing the NLTK library and LDA setup manually.
Time and Resource Intensive: Pre-processing with NLTK, applying LDA, and fine-tuning the model can take considerable effort.
Best Use Case: When you have specific control over the algorithm and need advanced customization.
---
Option B: Use Amazon SageMaker and the BlazingText algorithm. Apply custom pre-processing steps for stemming and removal of stop words. Calculate term frequency-inverse document frequency (TF-IDF) scores to identify and extract relevant keywords.
Pros:
Managed Service: SageMaker is a fully managed service, reducing operational overhead.
Efficient: BlazingText is optimized for text classification and keyword extraction tasks and performs well at scale.
Customizable: You can perform custom pre-processing (stemming, stop word removal), and integrate TF-IDF calculation.
Scalable: Easily scales based on the volume of documents.
Cons:
Operational Complexity: Although SageMaker reduces management overhead, it still requires a higher level of expertise to configure and manage the workflow.
Cost: Using SageMaker and BlazingText could incur higher costs, depending on the scale.
Best Use Case: When the use case involves large-scale text data and requires a managed service with high customization.
---
Option C: Store the documents in an Amazon S3 bucket. Create AWS Lambda functions to process the documents and run Python scripts for stemming and removal of stop words. Use bigram and trigram techniques to identify and extract relevant keywords.
Pros:
Serverless: AWS Lambda is serverless, reducing the need to manage infrastructure.
Scalable: Lambda automatically scales based on the volume of documents.
Low Cost: You pay for the compute time, making it potentially cost-effective for smaller workloads.
Cons:
Limited Execution Time: Lambda has a maximum execution time limit (15 minutes), which may not be ideal for large documents or complex processing tasks.
Manual Handlin...
Author: Emma Brown · Last updated Jul 27, 2026
A company needs to give its ML engineers appropriate access to training data. The ML engineers must access training data from only their own business group. The ML engineers must not be allowed to access training data from other business groups.
The company uses a single AWS account and stores all the training data in Ama...
Let's analyze each option carefully against the requirements:
Requirements recap:
ML engineers must access training data only for their own business group.
ML engineers must NOT access training data from other business groups.
Single AWS account.
Data stored in S3 buckets.
Model training happens in SageMaker.
---
Option A) Enable S3 bucket versioning.
What it does: Versioning keeps multiple versions of an object in the bucket.
Relevance: Versioning helps in data protection and recovery but does not provide access control.
Conclusion: Versioning won't restrict or grant access based on business groups or users.
Use case: Useful for data recovery, not for access control.
Reject.
---
Option B) Configure S3 Object Lock settings for each user.
What it does: Object Lock prevents objects from being deleted or overwritten for a fixed time or indefinitely.
Relevance: This is about immutability and protection against deletion. It does not control read or write access by users.
Conclusion: Object Lock does not address the requirement to restrict access to specific groups.
Use case: Regulatory compliance for immutable data, not access segmentation.
Reject.
---
Option C) Add cross-origin resource sharing (CORS) policies to the S3 buckets.
What it does: CORS enables controlled access to resources from different domains in web browsers.
Relevance: CO...
Author: Zara · Last updated Jul 27, 2026
A company needs to host a custom ML model to perform forecast analysis. The forecast analysis will occur with predictable and sustained load during the same 2-hour period every day.
Multiple invocations during the analysis period will require quick responses. The company needs A...
Problem Summary:
The company needs to host a custom ML model for forecast analysis with predictable, sustained load for a 2-hour period every day. Multiple invocations during the analysis period will require quick responses. Additionally, the company wants AWS to manage the underlying infrastructure and auto-scaling activities.
Option Evaluation:
A) Schedule an Amazon SageMaker batch transform job by using AWS Lambda.
Use Case: SageMaker batch transform jobs allow you to run large-scale, asynchronous inference jobs on datasets. AWS Lambda could be used to schedule and trigger these jobs.
Why it's rejected: Batch transform jobs are designed for large datasets and asynchronous processing, not for real-time, low-latency responses that are required during the 2-hour forecast analysis period. The load is predictable, but batch processing will not offer the quick, low-latency responses needed for multiple invocations during the analysis period.
Scenario: Batch transform jobs are better for bulk processing, not real-time or near-real-time needs with quick responses.
B) Configure an Auto Scaling group of Amazon EC2 instances to use scheduled scaling.
Use Case: Configuring an Auto Scaling group of EC2 instances allows scaling up or down based on demand. Scheduled scaling could be configured to scale based on the 2-hour window of forecast analysis.
Why it's rejected: Although EC2 Auto Scaling can manage infrastructure, it doesn't handle auto-scaling in real-time based on the number of invocations or the quick response requirements during the analysis period. It requires more manual infrastructure management and may not be the most efficient solution compared to serverless offerings. Additionally, EC2 instances may involve managing more infrastructure overhead, which the company likely wants to avoid.
Scenario: This could be useful for general-purpose applications but does not meet the need for serverless infrastructure management and quick, low-latency responses as efficiently as some of the other options.
C) Use Amazon SageMaker Serverless Inference with provisioned concurrency.
Use Case: Amazon SageMaker Serverless Inference automatically scales the compute resources based on the inference requests. It handles underlying infrastructure...
Author: Carlos Garcia · Last updated Jul 27, 2026
A company's ML engineer has deployed an ML model for sentiment analysis to an Amazon SageMaker endpoint. The ML engineer needs to explain to company stakeholders how the model makes pred...
Let's analyze each option carefully in the context of explaining how the model makes predictions (i.e., model interpretability/explainability):
---
A) Use SageMaker Model Monitor on the deployed model.
What it does: SageMaker Model Monitor continuously monitors the quality of ML models in production, detecting data drift, prediction drift, and other anomalies.
Key factor: This tool focuses on monitoring model performance and data quality over time, not explaining the logic or rationale behind individual predictions.
Why rejected: It does not provide explanations or insights into how a model made a specific prediction, only whether the input data or prediction output is drifting or anomalous.
---
B) Use SageMaker Clarify on the deployed model.
What it does: SageMaker Clarify provides model explainability and bias detection capabilities. It can generate feature importance scores and SHAP values for individual predictions, explaining which features influenced the model's decision.
Key factor: This is designed specifically to explain model predictions (local explanations) and provide global feature impact insights.
Why selected: It directly addresses the requirement to explain how the model makes predictions and can be integrated with deployed models to generate explanations for stakeholders.
---
C) Show the distribution of inferences from testing in Amazon CloudWatch.
What it does: C...
Author: Rahul · Last updated Jul 27, 2026
An ML engineer is using Amazon SageMaker to train a deep learning model that requires distributed training. After some training attempts, the ML engineer observes that the instances are not performing as expected. The ML engineer identifies communication overhead between ...
Let's analyze each option with the goal of minimizing communication overhead between distributed training instances in Amazon SageMaker.
---
Key Factors for Minimizing Communication Overhead
1. Network Latency and Bandwidth:
Communication overhead between instances mainly depends on network latency and throughput. Lower latency and higher bandwidth improve synchronization speed during distributed training.
2. Instance Placement:
Instances within the same subnet and Availability Zone (AZ) generally have lower latency and higher throughput between them compared to instances spread across AZs or regions.
3. Data Locality:
Storing data close to the compute instances reduces data transfer latency and cost. If data is in a different region, data transfer between regions adds significant latency.
---
Option A:
Place the instances in the same VPC subnet. Store the data in a different AWS Region from where the instances are deployed.
Instance placement: Same subnet is good for low latency between instances.
Data location: Different region means high latency and cross-region data transfer costs. This will add overhead especially when instances fetch data or exchange intermediate data.
Verdict: Good instance placement but poor data locality → not ideal to minimize overhead.
---
Option B:
Place the instances in the same VPC subnet but in different Availability Zones. Store the data in a different AWS Region from where the instances are deployed.
Instance placement: Different AZs increases latency and network hops between instances compared to ...
Author: Amelia · Last updated Jul 27, 2026
A company is running ML models on premises by using custom Python scripts and proprietary datasets. The company is using PyTorch. The model building requires unique domain knowledge. The company needs to mo...
Let's analyze each option carefully with respect to the company’s requirements:
Key factors in reasoning:
The company uses custom Python scripts and proprietary datasets.
The company uses PyTorch as the ML framework.
The model requires unique domain knowledge.
The goal is to migrate to AWS with the least effort.
The company needs to retain flexibility for custom code and datasets.
The solution should support custom training logic without heavy re-engineering.
---
Option A: Use SageMaker built-in algorithms to train the proprietary datasets
Pros: Built-in algorithms are fully managed, easy to use, and optimized.
Cons: Built-in algorithms are generic and typically do not support custom training scripts or complex domain-specific logic.
Requires re-implementing or adapting custom logic to fit built-in algorithms.
Likely high effort to migrate unique domain knowledge and custom Python code.
Not suitable because of the company’s heavy reliance on custom scripts and proprietary domain-specific models.
Conclusion: Rejected because it does not support custom training scripts or domain-specific model logic easily.
---
Option B: Use SageMaker script mode and premade images for ML frameworks
Pros:
Supports running custom Python scripts directly.
Uses pre-built SageMaker Docker images with frameworks like PyTorch.
Eases migration by allowing the company to bring their existing code and datasets.
SageMaker manages infrastructure, scaling, and training jobs.
Cons: Limited flexibility if very custom system dependencies are needed beyond what the premade images offer.
Still the lowest effort compared to building custom containers.
Con...
Author: Lucas Carter · Last updated Jul 27, 2026
A company is using Amazon SageMaker and millions of files to train an ML model. Each file is several megabytes in size. The files are stored in an Amazon S3 bucket. The company needs to improve training...
Let's analyze each option considering the key factors: data size (millions of multi-MB files), training performance, integration with SageMaker, and time to implement.
---
Option A: Transfer data to a new S3 bucket with S3 Express One Zone storage
S3 Express One Zone is a cheaper, single Availability Zone storage class.
It doesn’t improve throughput or performance; it just reduces cost.
It does not reduce latency or increase data access speed.
Migrating millions of files to a new bucket will take time and adds operational overhead.
This option does not directly improve training performance.
Rejected: Because no performance gain is expected; only cost optimization, and data migration takes time.
---
Option B: Create an Amazon FSx for Lustre file system linked to the S3 bucket
Amazon FSx for Lustre is a high-performance, low-latency file system designed for fast processing of data, tightly integrated with S3.
It automatically imports S3 data and caches it locally for fast access.
It is commonly used to accelerate machine learning training workloads where large datasets need to be accessed quickly.
Setup is relatively quick because it links directly to the existing S3 bucket without requiring a data copy.
It significantly reduces data access latency and boosts throughput, leading to faster training jobs.
Fits perfectly for scenarios with large datasets on S3 requiring fast, repeated access in ML training.
---
Option C: Create an Amazon Elastic File System (EFS) and transfer data
Amazon EFS is a scalable file system but is optimiz...
Author: Ethan · Last updated Jul 27, 2026
A company wants to develop an ML model by using tabular data from its customers. The data contains meaningful ordered features with sensitive information that should not be discarded. An ML engineer must ensure that the sensitive data ...
Let's analyze each option carefully based on the key requirements:
Key Requirements:
Data contains meaningful ordered features that should not be discarded.
Sensitive data must be masked (not just removed or randomized in a way that destroys order or meaning).
Masking should be done before another team starts model building.
The solution should be practical and manageable within AWS services.
---
Option A: Use Amazon Macie to categorize the sensitive data.
What it does: Amazon Macie is a security service that uses machine learning to automatically discover, classify, and protect sensitive data in AWS.
Pros: It helps identify and categorize sensitive data.
Cons: Macie does not mask or transform data itself. It only discovers and classifies sensitive data.
Use case: Good for identifying sensitive data but not for masking or modifying it.
Verdict: This option does not meet the requirement to mask the data.
---
Option B: Prepare the data by using AWS Glue DataBrew.
What it does: AWS Glue DataBrew is a visual data preparation tool that enables cleaning and normalizing data without writing code.
Pros: DataBrew supports data masking and transformations on tabular data, including masking, obfuscation, and preserving data order and types.
Can handle sensitive data with custom transformations and masking recipes.
Easy to use for non-coders or ETL pipelines.
Use case: Best for data cleaning, masking, and transforming tabular data interactively and efficiently.
Verdict: This option meets the requirements to mask sensitive data while preserving meaningful features.
---
Option C: Run an AWS Batch j...
Author: IceDragon2023 · Last updated Jul 27, 2026
An ML engineer needs to deploy ML models to get inferences from large datasets in an asynchronous manner. The ML engineer also needs to implement scheduled monitoring of the data quality of the models. The ML engineer must ...
Let's analyze each option carefully based on the key requirements:
Requirements Recap:
Asynchronous inference on large datasets.
Scheduled monitoring of data quality.
Alerts when data quality changes occur.
---
Option A:
Deploy models using scheduled AWS Glue jobs. Use Amazon CloudWatch alarms to monitor data quality and send alerts.
AWS Glue is primarily an ETL (Extract, Transform, Load) service for data preparation and integration.
While Glue can run scheduled jobs, it’s not primarily designed for deploying ML models or running inference.
CloudWatch alarms can monitor metrics but it’s not specialized for detailed data quality monitoring.
This approach may require heavy custom coding to perform inference and data quality checks.
Best for: ETL pipelines, data integration, but not ideal for model deployment & built-in data quality monitoring.
---
Option B:
Deploy models using scheduled AWS Batch jobs. Use AWS CloudTrail to monitor data quality and send alerts.
AWS Batch can run batch jobs asynchronously on large datasets, which fits the inference requirement.
However, AWS CloudTrail is for logging API calls and user activity, not data quality monitoring.
CloudTrail cannot send alerts on data quality issues; it’s not a monitoring or alerting tool for dataset changes.
This option would require custom data quality monitoring and alerting mechanisms outside of CloudTrail.
Best for: Batch processing workloads but not for automated data quality monitoring or alerting.
---
Option C:
Deploy models using Amazon ECS on AWS Fargate. Use Amazon EventBridge to monitor data quality and send alerts.
ECS Fargate is great for running containerized applications without managing servers.
It can handle asynchronous inference if properly architected.
EventBridge is an event bus service that can trigger actions based on events.
However, EventBridge itself doesn’t monitor data quality directly; it reacts to events.
Data quality monitoring would require custom events generated from monitoring jobs.
So ...
Author: Michael · Last updated Jul 27, 2026
An ML engineer normalized training data by using min-max normalization in AWS Glue DataBrew. The ML engineer must normalize the production inference data in the same way as the training data before passing the produc...
Let's analyze each option carefully with respect to the requirement: The production inference data must be normalized in the same way as the training data, specifically using min-max normalization.
---
Key Factors to Consider:
Consistency: The model expects input normalized the same way as during training.
Reproducibility: The normalization statistics (min and max values) used during training must be applied to production.
Data distribution: Production data distribution might differ, but changing normalization stats on production data alone breaks consistency.
Real-time or batch inference: Whether inference is real-time or batch can affect whether per-sample or batch normalization is feasible.
---
Option A:
"Apply statistics from a well-known dataset to normalize the production samples."
Problem: Using a completely different dataset's statistics will very likely result in mismatched scaling, leading to poor or invalid model predictions.
Scenario where it might be used: Only if the production data is unavailable or if training data statistics are lost—but this is suboptimal and generally discouraged.
Reject because: It breaks consistency between training and inference data normalization.
---
Option B:
"Keep the min-max normalization statistics from the training set. Use these values to normalize the production samples."
This is the ideal approach.
The model was trained on data scaled with specific min and max values; to maintain input consistency, production data must be scaled with the same min and max.
This guarantees that the model sees data in the same scale as training.
Scenario: This approach is standard practice in ML pipelines for preprocessing.
---
Option C:
"Calculate a new set of min-max normalization statistics ...
Author: Liam123 · Last updated Jul 27, 2026
A company is planning to use Amazon SageMaker to make classification ratings that are based on images. The company has 6 =D0=A2=D0=92 of training data that is stored on an Amazon FSx for NetApp ONTAP system virtual machine (SVM). The SVM is in the same VPC as SageMaker.
An ML engineer must make...
Let's analyze each option carefully based on the scenario and requirements:
---
Scenario Summary:
Training data (6 TB) stored on Amazon FSx for NetApp ONTAP SVM.
FSx ONTAP SVM is in the same VPC as SageMaker.
Need to make the training data accessible for ML models running in SageMaker.
Data is image data used for classification.
Goal: Access the training data efficiently for SageMaker training jobs.
---
Option A:
Mount the FSx for ONTAP file system as a volume to the SageMaker Instance.
Feasibility: SageMaker training instances (or notebooks) can mount NFS shares or FSx volumes if network access allows.
Since the FSx ONTAP SVM is in the same VPC, network connectivity exists.
You can mount the file system via NFS or SMB directly on the SageMaker instance.
This approach allows SageMaker training jobs direct, high-throughput, low-latency access to the 6 TB of image data.
Key factor: FSx ONTAP supports NFS/SMB protocols that can be mounted as file system storage, enabling SageMaker jobs to access data as if local files.
This avoids data copying, reduces delays, and keeps data consistent.
Verdict: This is a straightforward, performant, and recommended approach when FSx is in the same VPC.
---
Option B:
Create an Amazon S3 bucket. Use Mountpoint for Amazon S3 to link the S3 bucket to the FSx for ONTAP file system.
Mountpoint for Amazon S3 is a solution that allows FSx for ONTAP to access S3 as a namespace.
Here, the direction is FSx -> S3.
The requirement is to make FSx data accessible to SageMaker.
This option suggests linking S3 bucket to FSx rather than the other way around.
SageMaker natively works very well with S3 for data access.
However, data is currently on FSx, and using Mountpoint does not directly expose FSx data to SageMaker via S3.
It would require migrating or syncing data from FSx to S3, which can be time-consuming or inefficient for large data sets.
This option adds complexity and latency.
Verdict: Not ideal here because it complicates access and does not directly solve the access problem from SageMaker to FSx.
---
Option C:
Create a catalog connection from SageMaker Data Wrangler to the FSx for ONTAP file system.
SageMaker Data Wrangler provides GUI and tools for data preparation and catalog management.
A catalog connection typically integrates with databases, data lakes, or catalogs like AWS Glue Data Catalog.
FSx ONTAP is a file system, not a data catalog or database.
Data Wrangler can connect...
Author: Isabella · Last updated Jul 27, 2026
A company regularly receives new training data from the vendor of an ML model. The vendor delivers cleaned and prepared data to the company's Amazon S3 bucket every 3-4 days.
The company has an Amazon SageMaker pipeline to retrain the model. An ML engineer needs to implement a solution to run the pi...
Let's analyze each option carefully, focusing on operational effort, scalability, simplicity, and best practice for triggering workflows on new data uploads in S3.
---
Option A:
Create an S3 Lifecycle rule to transfer the data to the SageMaker training instance and to initiate training.
Lifecycle rules in S3 are primarily designed for data management tasks like transitioning storage classes or deleting old data.
Lifecycle rules cannot trigger training jobs or workflows directly. They manage data retention and movement but are not designed to initiate processing tasks.
Using lifecycle rules to "initiate training" is not supported.
Rejected because lifecycle rules don’t support triggering compute workflows or pipelines.
---
Option B:
Create an AWS Lambda function that scans the S3 bucket. Program the Lambda function to initiate the pipeline when new data is uploaded.
Lambda can be triggered directly by S3 events on object creation (upload). So Lambda can be invoked immediately when new data arrives.
The Lambda function can initiate the SageMaker pipeline programmatically via the SDK.
Requires writing and maintaining code to scan/check for new files and trigger the pipeline.
May involve some operational overhead maintaining the Lambda, handling errors, retries, and scaling.
However, Lambda is a serverless, low-maintenance compute service, so operational effort is low but not zero.
This is a common and flexible approach for event-driven workflows triggered by S3.
---
Option C:
Create an Amazon EventBridge rule that has an event pattern that matches the S3 upload. Configure the pipeline as the target of the rule.
EventBridge can directly listen to S3 events (like `ObjectCreated`) without needing Lambda as a bridge.
EventBridge supports SageMaker pipeline as a direct target, so it can trigger the pipeline automatically and immediately on new uploads.
This ...
Author: Isabella · Last updated Jul 27, 2026
An ML engineer is developing a fraud detection model by using the Amazon SageMaker XGBoost algorithm. The model classifies transactions as either fraudulent or legitimate.
During testing, the model excels at identifying fraud in the training dataset. However, the model is inefficient at identif...
Let's analyze the problem and each option carefully:
---
Problem Summary:
The model performs very well on training data (detecting fraud in training transactions).
The model performs poorly on new/unseen data (fails to detect fraud on test/real-world transactions).
This suggests the model is overfitting — it learned training data patterns too well, including noise or specifics that don't generalize.
---
Option A: Increase the learning rate
Learning rate controls how much the model weights are updated during training.
Increasing learning rate can speed up convergence but might cause instability or worse performance if too high.
It won't directly help with overfitting; usually, a high learning rate can hurt performance.
Typically, when overfitting, you'd consider lowering the learning rate or regularizing more, rather than increasing it.
Use case: Increasing learning rate is used to speed training or escape shallow local minima, not to address overfitting.
Conclusion: Not a good option here.
---
Option B: Remove some irrelevant features from the training dataset
Removing irrelevant or noisy features can reduce overfitting because the model has fewer chances to fit noise.
Feature selection improves generalization by keeping only meaningful features.
However, this requires knowing which features are irrelevant or doing feature importance analysis.
This option can be good but may not be the most direct or simplest first step.
Use case:...
Author: Noah Williams · Last updated Jul 27, 2026
A company has a binary classification model in production. An ML engineer needs to develop a new version of the model.
The new model version must maximize correct predictions of positive labels and negative labels. The ML engineer must use a metric to recalib...
Let's analyze the problem carefully:
Problem Statement Recap:
Binary classification model.
Need to maximize correct predictions of both positive and negative labels.
Metric must be used to recalibrate the model to meet these requirements.
---
Understanding the options:
A) Accuracy
Definition: (TP + TN) / (Total samples) — the proportion of all correct predictions (both positive and negative) out of total samples.
Use case: Accuracy measures overall correctness. It balances true positives and true negatives, reflecting the model’s ability to classify both classes correctly.
Limitations: Can be misleading in imbalanced datasets because a model predicting mostly the majority class can still have high accuracy.
Relevance here: Since the goal is to maximize correct predictions for both positive and negative classes, accuracy directly measures that combined correctness. It is a straightforward metric to recalibrate the threshold or model to optimize overall correctness.
---
B) Precision
Definition: TP / (TP + FP) — among predicted positives, how many are truly positive.
Use case: Precision is important when the cost of false positives is high (e.g., spam detection, fraud alerts).
Limitations: Does not consider false negatives or true negatives. Maximizing precision alone can reduce the number of positive predictions, hurting recall.
Relevance here: Focuses only on the positive predictions, ignoring negative class performance, so it doesn’t align with maximizing correct predictions on both classes.
---
C) Recall (Sensitivity, True Positive Ra...
Author: Ravi Patel · Last updated Jul 27, 2026
A company is using Amazon SageMaker to create ML models. The company's data scientists need fine-grained control of the ML workflows that they orchestrate. The data scientists also need the ability to visualize SageMaker jobs and workflows as a directed acyclic graph (DAG). The data scientists must keep a running history of model di...
Let's analyze the requirements and options carefully.
---
Requirements:
1. Fine-grained control of ML workflows — data scientists want to orchestrate workflows with detailed control.
2. Ability to visualize SageMaker jobs and workflows as a DAG — clear visualization of dependencies and steps.
3. Running history of model discovery experiments — track experiments over time.
4. Model governance for auditing and compliance — need lineage tracking and auditability.
---
Understanding the options:
AWS CodePipeline:
A general CI/CD service designed mainly for software deployment workflows. While it can integrate with SageMaker, it’s not purpose-built for ML workflows.
It does not inherently support DAG visualization specific to ML workflows or detailed experiment tracking.
SageMaker Pipelines:
A purpose-built ML workflow orchestration service.
Provides native support for defining workflows as directed acyclic graphs (DAGs).
Has tight integration with SageMaker Studio and experiment tracking.
Designed to give data scientists fine-grained control over each step in the ML lifecycle.
Supports ML lineage tracking and experiment management.
SageMaker Experiments:
Helps organize, track, compare, and evaluate ML experiments and model versions.
Mainly focused on experiment tracking and history, but not on orchestrating or visualizing workflows as DAGs.
SageMaker ML Lineage Tracking:
Tracks data and artifacts flow for audit and governance purposes, to see the full lineage of models, datasets, and training jobs.
---
Option-by-option analysis:
Option A: Use AWS CodePipeline + SageMaker Studio + SageMaker ML Lineage Tracking
AWS CodePipeline is not optimized for ML workflows or DAG visualization.
SageMaker ML Lineage Tracking is great for governance and audit but CodePipeline limits fine-grained workflow control and visualization.
Rejected due to poor fit for ML workflow orchestration and DAG visualization.
Option B: Use AWS CodePipeline + SageMaker Experiments
CodePipeline still lacks ML workflow orchestration and DAG visualization.
SageMaker Experiments tracks experiments well but does not orchestrate or visualize workflows as DAGs.
Rejected for the same reasons as A: lack of DAG visualization and fine control.
Option C: Use SageMaker Pipelines + SageMaker Studio + SageMaker ML Lineage Tracking
SageMaker Pipelines supports DAG visualization and fine-grained workflow control.
SageMaker...
Author: Abigail · Last updated Jul 27, 2026
A company wants to reduce the cost of its containerized ML applications. The applications use ML models that run on Amazon EC2 instances, AWS Lambda functions, and an Amazon Elastic Container Service (Amazon ECS) cluster. The EC2 workloads and ECS workloads use Amazon Elastic Block Store (Amazon EBS) volumes to save predictions and artifacts.
An ML engineer must identify resources that are being used ineffic...
Let's analyze each option carefully in the context of the requirement:
---
Problem Summary:
Reduce cost of containerized ML applications.
Applications run on EC2, AWS Lambda, and ECS.
EC2 and ECS use EBS volumes.
Need to identify inefficient resource usage.
Generate recommendations to reduce cost.
Minimize development effort.
---
Option A: Create code to evaluate each instance's memory and compute usage
Pros: Custom, can be tailored to exact needs.
Cons: High development effort required to build monitoring, analyze metrics, and generate recommendations.
Also, EC2, ECS, and Lambda require different monitoring approaches.
Would require setting up metric collection, thresholds, and logic.
Not an out-of-the-box solution, not minimal effort.
Use case: When very customized or domain-specific analysis is required and automation isn't available.
Rejected because: It requires significant development effort, against the requirement of "LEAST development effort."
---
Option B: Add cost allocation tags to the resources. Activate the tags in AWS Billing and Cost Management
Pros: Tags help allocate cost per team, application, or environment.
Helps identify which resources cost more.
Easy to implement, relatively low effort.
Cons:
Tags alone don’t identify inefficiency or recommend cost savings.
They help with cost visibility and allocation, but not with usage or right-sizing recommendations.
Tagging requires some governance but no automation for recommendations.
Use case: When you want to allocate and track costs by business unit or project but not for efficiency analysis or optimization.
Rejected because: Does not meet the requirement to identify inefficient usage or generate cost-saving recommendations.
---
Option C: Check AWS CloudTrail event history for the creation of the resources
Pros: Provides audit trail of resource creation and changes.
Helps understand who or what created resources.
Useful for governance, security, or troubleshooting.
Cons:
Does not provide usage metrics or cost insights.
No information about resource efficienc...
Author: Amelia · Last updated Jul 27, 2026
A company needs to create a central catalog for all the company's ML models. The models are in AWS accounts where the company developed the models initially. The models are hosted in Amazon Elastic Cont...
Let's analyze each option carefully against the key requirements:
Requirements Recap:
Central catalog for all company ML models
Models reside in multiple AWS accounts where they were developed
Models are stored in Amazon ECR repositories
Central catalog must allow discovery and visibility across accounts
---
Option A:
Configure ECR cross-account replication for each existing ECR repository. Ensure that each model is visible in each AWS account.
Pros:
Cross-account replication can automatically sync images across accounts.
Each account can see the models if replication is set up correctly.
Cons:
Does not create a central catalog; it creates multiple copies of the same images across all accounts.
Managing replication rules for many repos and accounts can be complex and error-prone.
Not scalable for many models/accounts.
Replication means duplication of storage and management overhead.
Best scenario for:
When a few accounts and repos are involved, and you want to ensure image availability in all accounts without a single catalog.
---
Option B:
Create a new AWS account with a new ECR repository as the central catalog. Configure ECR cross-account replication between the initial ECR repositories and the central catalog.
Pros:
Centralizes model images into one ECR repo in a dedicated account, fulfilling the “central catalog” need.
Replication keeps the central catalog updated with models from multiple accounts.
Central account can provide consolidated access management and auditing.
Cons:
Replication involves duplication of images, storage costs increase.
Sync delays possible, meaning central catalog might not be real-time.
Best scenario for:
Organizations that want a physical centralized ECR repository as a source of truth and can accept duplication.
When a “single pane of glass” in a dedicated account is a hard requirement.
---
Option C:
Use the Amazon SageMaker Model Registry to create a model group for models hosted in Amazon ECR. Create a new AWS account. In the new account, use the SageMaker Model Registry as the central ca...
Author: Ishaan · Last updated Jul 27, 2026
A company has developed a new ML model. The company requires online model validation on 10% of the traffic before the company fully releases the model in production. The company uses an Amazon SageMaker endpoint behind an Application Load Balancer (ALB) to s...
Let's analyze each option carefully based on the requirements and key factors:
Requirements:
Online validation of the new ML model on 10% of the traffic before full production release.
The company uses Amazon SageMaker endpoint behind an Application Load Balancer (ALB).
Least operational overhead is desired.
Need to monitor model invocations.
---
Option A:
Use production variants to add the new model to the existing SageMaker endpoint. Set the variant weight to 0.1 for the new model. Monitor the number of invocations by using Amazon CloudWatch.
How it works:
SageMaker endpoints can host multiple production variants (models). You can assign traffic weights to each variant, and SageMaker will route a percentage of inference requests accordingly. Setting the variant weight to 0.1 routes 10% of traffic to the new model.
Operational overhead:
Low, because you are using a single SageMaker endpoint. No need to manage multiple endpoints or ALB routing rules.
Monitoring:
CloudWatch provides built-in metrics for each production variant's invocations and latency.
Best fit:
Ideal for online validation with traffic splitting and minimal operational complexity.
---
Option B:
Use production variants to add the new model to the existing SageMaker endpoint. Set the variant weight to 1 for the new model. Monitor the number of invocations by using Amazon CloudWatch.
How it works:
Routing 100% of the traffic to the new model immediately.
Issue:
Does not meet the requirement of validating on only 10% of the traffic; it's a full switch.
When to use:
When fully deploying a new model, not for gradual validation.
Rejection reason:
Does not meet the 10% traffic validation requirement.
---
Option C:
Create a new SageMaker endpoint. Use production variants to add the new model to the new endpoint. Monitor the number of invocations by using Amazon CloudWatch.
How it works:
A separate SageMaker endpoint is created to host the new ...
Author: Ella · Last updated Jul 27, 2026
A company needs to develop an ML model. The model must identify an item in an image and must provide the location of the item.
Whic...
Let's analyze the requirements and the options one by one:
Requirements:
Identify an item in an image
Provide the location of the item in the image
---
Option A: Image Classification
What it does: Assigns a label or category to the whole image.
Key factor: It tells what is in the image but does not provide the location of the item.
When to use: When you only need to identify the class or category of the image as a whole (e.g., "dog" or "cat").
Rejected because: It cannot localize or output the bounding box coordinates of the item in the image.
---
Option B: XGBoost
What it does: Gradient-boosted decision trees for tabular data, classification, or regression tasks.
Key factor: Works with structured, tabular data, not images directly.
When to use: Predicting outcomes from tabular data, not images.
Rejected because: It is not designed for image processing or localization tasks.
---
Option C: Object Detection
What it does: Identifies and classifies objects in an image and also provides their locations as bounding boxes.
Key factor: This algorithm outputs both the class and location (bounding box coordinates) of each detected item.
When to use: When you need to detect multiple objects and their positions in...
Author: Vikram · Last updated Jul 27, 2026
A company has an Amazon S3 bucket that contains 1 =D0=A2=D0=92 of files from different sources. The S3 bucket contains the following file types in the same S3 folder: CSV, JSON, XLSX, and Apache Parquet.
An ML engineer must implement a solution that uses AWS Glue DataBrew to process the data. The ML engineer also must...
Let's analyze the problem carefully and evaluate each option based on the key requirements and constraints.
---
Problem Summary:
S3 bucket has 1 TB of files from different sources.
Files of different types (CSV, JSON, XLSX, Apache Parquet) are all in the same S3 folder.
Must use AWS Glue DataBrew to process the data.
Final output must be stored back in S3.
Output must be consumable by AWS Glue in the future.
---
Key Factors to Consider:
1. Data Format Handling by DataBrew:
DataBrew can read and process multiple file formats (CSV, JSON, XLSX, Parquet).
However, DataBrew does not support mixing file types in the same dataset/job. It expects uniform input format or separated datasets per format.
2. Folder Structure & File Separation:
Having multiple file types in the same folder complicates ingestion.
Best practice: separate files by format to create reliable DataBrew datasets.
3. Output Format Compatibility:
AWS Glue supports Apache Parquet format natively.
There is no such thing as “AWS Glue Parquet format” — Apache Parquet is a standard format, used by Glue.
Output should be stored in Apache Parquet for efficient querying and compatibility.
4. Processing scale & maintainability:
1 TB of data is large; processing needs to be efficient.
Processing data by file type individually improves reliability and scalability.
---
Option-by-Option Analysis:
---
A) Use DataBrew to process the existing S3 folder. Store the output in Apache Parquet format.
Problem: All file types are mixed in the same S3 folder.
DataBrew does not support multiple formats simultaneously in one dataset.
This option would cause ingestion failure or incorrect processing.
Output in Apache Parquet is correct, but input handli...
Author: Joseph · Last updated Jul 27, 2026
A manufacturing company uses an ML model to determine whether products meet a standard for quality. The model produces an output of "Passed" or "Failed." Robots separate the products into the two categories by using the model to analyze photos on th...
Let's analyze the options for evaluating the ML model that classifies products as "Passed" or "Failed" for quality control:
---
Context:
Problem type: Binary classification (Passed vs. Failed).
Goal: Assess model performance in separating products into two categories.
Key factors:
False positives (products incorrectly marked as Passed)
False negatives (products incorrectly marked as Failed)
It's critical to understand how well the model detects defective products without letting poor-quality products pass or rejecting good products mistakenly.
---
Option A: Precision and Recall
Precision measures: Of all products predicted as Passed, how many actually Passed?
Recall measures: Of all products that actually Passed, how many were correctly predicted?
Use case: Excellent for classification tasks, especially where the cost of false positives and false negatives matters.
Relevance here: Important to balance because:
High precision means fewer bad products slipping through (false positives).
High recall means catching most good products without rejecting them (false negatives).
Verdict: Good choice.
---
Option B: Root mean square error (RMSE) and mean absolute percentage error (MAPE)
These are regression metrics measuring the error between predicted and actual numeric values.
Not applicable here because the...
Author: Amira · Last updated Jul 27, 2026
An ML engineer needs to encrypt all data in transit when an ML training job runs. The ML engineer must ensure that encryption in transit is applied to processes that Amazon SageMaker...
Great question! Let’s break down each option carefully, focusing on the key requirement: encrypt all data in transit during an Amazon SageMaker training job.
---
Key factors to consider:
Data in transit encryption means protecting data as it moves between components or nodes, i.e., network-level encryption.
SageMaker training jobs involve distributed training (potentially multiple nodes), communication between SageMaker processes, and potentially data moving between S3 and the training instances.
AWS offers encryption in transit via TLS by default for communication between SageMaker and other AWS services.
When encryption of data at rest is required, KMS keys come into play.
Batch processing and training clusters differ in their architecture and communication patterns.
KMS keys are mainly used for encryption at rest or for signing, not directly for encrypting network traffic in transit.
---
Option A: Encrypt communication between nodes for batch processing
Batch processing refers typically to SageMaker Batch Transform jobs, not training jobs.
Encrypting communication between nodes for batch processing is not applicable here because batch transform jobs don’t involve multiple nodes communicating; they are more about processing input data in batches independently.
This option is irrelevant for a training job scenario, which often requires distributed communication.
Scenario: Useful if you are running batch inference jobs that require secure communication between distributed components (rare).
Reject — Not relevant for training jobs and in-transit encryption during training.
---
Option B: Encrypt communication between nodes in a training cluster
This option directly targets in-transit encryption between nodes during a distributed training job.
Distributed training jobs communicate over network, exchanging gradients, model parameters, and control info.
SageMaker supports ...
Author: VioletCheetah55 · Last updated Jul 27, 2026
An ML engineer needs to use metrics to assess the quality of a time-series forecasting model.
Whic...
Let's analyze the options carefully to determine which metrics apply to assessing the quality of a time-series forecasting model.
---
A) Recall
What it measures: Recall is a classification metric that measures the proportion of actual positives correctly identified by the model.
Why reject: Time-series forecasting typically deals with continuous numeric predictions over time, not classification into categories. Recall does not apply to regression or forecasting tasks.
Scenario: Useful in classification tasks, such as detecting fraudulent transactions, where identifying all positive cases is critical.
---
B) LogLoss
What it measures: Logarithmic loss measures the performance of a classification model where the output is a probability between 0 and 1.
Why reject: Again, LogLoss is a classification metric, not applicable to continuous value forecasting in time series.
Scenario: Used in binary or multi-class classification problems where probabilistic outputs are evaluated.
---
C) Root Mean Square Error (RMSE)
What it measures: RMSE is a common regression metric that quantifies the average magnitude of errors between predicted and actual continuous values, emphasizing larger errors due to squaring.
Why select: Time-series forecasting models output numeric values over time, and RMSE is highly appropriate to measure the model’s prediction accuracy on continuous data.
Scenario: Used when large errors are particularly undesirable and the model predict...
Author: SolarFalcon11 · Last updated Jul 27, 2026
A company runs Amazon SageMaker ML models that use accelerated instances. The models require real-time responses. Each model has different scaling requirements. The company must not al...
Let's analyze each option carefully against the requirements:
Requirements Recap:
Use Amazon SageMaker ML models with accelerated instances (likely GPU-based).
Models require real-time responses (low latency).
Each model has different scaling requirements.
No cold start allowed (meaning the models must be always ready to serve without startup delay).
---
Option A:
Create a SageMaker Serverless Inference endpoint for each model. Use provisioned concurrency for the endpoints.
Serverless inference is designed for on-demand, event-driven workloads and auto-scales automatically.
While provisioned concurrency can reduce cold start latency, Serverless inference doesn't currently support accelerated instances like GPUs.
Also, serverless is not ideal for consistent real-time low-latency needs under heavy load, especially with GPU requirements.
Therefore, this option is rejected due to lack of support for accelerated instances and uncertain latency guarantees.
---
Option B:
Create a SageMaker Asynchronous Inference endpoint for each model. Create an auto scaling policy for each endpoint.
Asynchronous inference is intended for batch jobs or long-running inference tasks that don’t require immediate responses.
It is not designed for real-time, low-latency inference.
The question specifically requires real-time responses, so asynchronous inference is not suitable.
Therefore, rejected because it does not support real-time inference requirements.
---
Option C:
Create a SageMaker endpoint. Create an inference component for each model. In the inference component settings, specify the newly created endpoint. Create an auto scaling policy for each inference component. Set the parameter for the minimum number of copies to at least 1.
This describes creating a multi-model SageMaker endpoint with multiple inference components (each mapping to a model).
You can specify minimum number of instances to at least 1, preventing cold starts.
You can enable auto-scaling individually per inference component to meet different scaling needs.
SageMaker multi-model endpoints support accelerated instances and r...
Author: Kunal · Last updated Jul 27, 2026
A company uses Amazon SageMaker for its ML process. A compliance audit discovers that an Amazon S3 bucket for training data uses server-side encryption with S3 managed keys (SSE-S3).
The company requires customer managed keys. An ML engineer changes the S3 bucket to use server-side encryption with AWS KMS keys (SSE-KMS). The ML engineer makes no other configuration changes.
Af...
Let's analyze the problem and each option carefully:
---
Problem Summary:
The training data S3 bucket was initially encrypted using SSE-S3 (S3 managed keys).
The company requires customer managed keys (CMKs), so the bucket is changed to use SSE-KMS (KMS-managed keys).
After this change, SageMaker training jobs fail with AccessDenied errors.
The ML engineer did not make any other configuration changes.
---
Understanding the problem:
When using SSE-KMS, access to the data requires permissions not only on the S3 bucket/object but also on the KMS key used for encryption/decryption.
The SageMaker training job runs with an execution role that needs:
S3 permissions to read the training data.
KMS permissions to decrypt (and sometimes encrypt) the data using the customer managed key.
---
Analyze options:
---
Option A: Update the IAM policy attached to the execution role for the training jobs. Include the `s3:ListBucket` and `s3:GetObject` permissions.
These are basic S3 read permissions.
If these were missing, jobs would fail even before changing encryption.
The job was working before the encryption change, so the execution role likely already has these permissions.
The error is specifically AccessDenied after changing to SSE-KMS, which indicates a KMS permission problem, not S3 permission problem.
Verdict: Not the main issue, but necessary in general. Likely not sufficient or the root cause here.
---
Option B: Update the S3 bucket policy attached to the S3 bucket. Set the value of the `aws:SecureTransport` condition key to True.
This forces requests to use SSL (HTTPS).
This is a good security practice but unrelated to KMS key access.
The error is about AccessDenied after changing encryption; network security conditions are unrelated.
If the bucket policy requires `aws:SecureTransport=True`, and if the request is not HTTPS, errors would be different.
This option does not grant KMS permissions or resolve the encryption issue.
Verdict: Irrelevant to KMS access errors.
---
Option C: Up...
Author: Ahmed97 · Last updated Jul 27, 2026
A company runs training jobs on Amazon SageMaker by using a compute optimized instance. Demand for training runs will remain constant for the next 55 weeks. The instance needs to run for 35 hours each week. The comp...
Let's analyze each option carefully based on the requirements and key factors:
---
Requirements and Key Factors:
Training jobs run on compute-optimized instance (likely `C` class instances like `C5`, `C6`).
Demand is constant for 55 weeks.
Instance needs to run 35 hours per week.
Goal: reduce training costs.
SageMaker training jobs, not inference.
Training duration per week is relatively predictable and steady.
---
Option A: Use a serverless endpoint with provisioned concurrency of 35 hours per week; run training on the endpoint.
Serverless endpoints are designed for inference, not training.
They don't support training jobs directly.
Provisioned concurrency applies to Lambda and serverless inference, not to training hours.
Running training on an endpoint is conceptually wrong; training is done using training jobs, not endpoints.
Rejected: Not suitable for training, no cost benefit for training jobs.
---
Option B: Use SageMaker Edge Manager for training, specifying instance requirements in edge device configuration.
SageMaker Edge Manager is for optimizing, monitoring, and deploying models on edge devices.
It is not designed to run or reduce costs for training jobs on SageMaker instances.
Edge Manager helps with model monitoring and deployment at the edge, not training cost optimization.
Rejected: Not applicable to training jobs or cost savings for training.
---
Option C: Use heterogeneous cluster feature of SageMaker Training by configuring `instance_type`, `instance_count`, and `instance_groups`.
This allows splitting training across different types of instances.
Potential cost optimization if some instances are cheaper but still performant.
However, the question states the company uses a compute-optimized instance alr...
Author: Aarav · Last updated Jul 27, 2026
A company deployed an ML model that uses the XGBoost algorithm to predict product failures. The model is hosted on an Amazon SageMaker endpoint and is trained on normal operating data. An AWS Lambda function provides the predictions to the company's application.
An ML engineer must implement a so...
Great question! Let’s break down the options by considering key factors for detecting model accuracy degradation over time, specifically focusing on model drift detection and the best tools for this in the AWS ecosystem.
---
Key Factors:
Model Accuracy Monitoring requires comparison of live inference data with training data or expected data distribution.
Drift Detection often means detecting data distribution changes (data drift or concept drift).
Automated monitoring tools that can compare live data to a baseline are preferred.
Alerting should be part of the solution to notify when drift occurs.
SageMaker built-in tools are specialized for this purpose, supporting ease of integration and robustness.
---
Option A: Use Amazon CloudWatch to create a dashboard that monitors real-time inference data and model predictions. Use the dashboard to detect drift.
Reasoning: CloudWatch is great for monitoring logs, metrics, and creating dashboards for visual insights.
Limitations: It does not have built-in capabilities to analyze data distributions or detect drift between live data and training baselines automatically.
Manual setup and analysis would be required, which is error-prone and inefficient for real-time drift detection.
Use case: Best for monitoring system metrics, errors, latency, not for statistical model drift detection.
Reject because: No built-in data drift analysis, requires manual interpretation.
---
Option B: Modify the Lambda function to calculate model drift by using real-time inference data and model predictions. Program the Lambda function to send alerts.
Reasoning: Lambda can process data and perform custom logic, so theoretically, it can calculate drift metrics.
Limitations:
Drift detection involves statistical analysis comparing live data distributions with baseline data—complex and requires significant coding.
Lambda functions have time and resource limitations which may not be suited for heavy statistical calculations or storing historical data.
This approach duplicates effort, is less maintainable, and lacks standardization compared to built-in AWS tools.
Use case: Suitable for lightweight custom alerting or processing, but not for robust model drift d...
Author: VioletCheetah55 · Last updated Jul 27, 2026
A company has an ML model that uses historical transaction data to predict customer behavior. An ML engineer is optimizing the model in Amazon SageMaker to enhance the model's predictive accuracy. The ML engineer must examine the input data and the resulting predictions to identify trends ...
Let's analyze each option based on the requirement:
Requirement:
Examine input data and resulting predictions
Identify trends that could skew model performance across different demographics
Enhance model predictive accuracy by understanding bias or skew in data or model outputs
---
A) Use Amazon CloudWatch to monitor network metrics and CPU metrics for resource optimization during model training.
What it does: CloudWatch is mainly for infrastructure monitoring — CPU usage, memory, network I/O, disk, etc.
Relevance: This option focuses on resource utilization and operational health, not on analyzing input data or model predictions.
Use case: Useful for optimizing resource allocation or detecting training infrastructure issues, not for data or bias analysis.
Conclusion: Rejected because it does not address data or prediction analysis or bias detection.
---
B) Create AWS Glue DataBrew recipes to correct the data based on statistics from the model output.
What it does: DataBrew is a visual data preparation tool to clean and normalize data, create transformations, and generate recipes for consistent processing.
Relevance: While DataBrew can correct and prepare data, it doesn’t natively analyze model outputs or detect biases or trends related to demographics.
Use case: Best when data cleaning or transformation is needed before training, not directly for model output analysis.
Conclusion: Rejected because it doesn’t analyze predictions or model bias; it's mainly for data cleaning.
---
C) Use SageMaker Clarify to evaluate the model and training data f...
Author: Chloe · Last updated Jul 27, 2026
A company uses 10 Reserved Instances of accelerated instance types to serve the current version of an ML model. An ML engineer needs to deploy a new version of the model to an Amazon SageMaker real-time inference endpoint.
The solution must use the original 10 instances to serve both versions of the model. The solution also must include one additional Reserved Instance that is available...
Let's analyze the problem carefully:
---
Problem Breakdown:
Current setup: 10 Reserved Instances serving version 1 of the ML model.
Need to deploy version 2 using the same 10 instances for both versions.
There is 1 additional Reserved Instance available for the deployment process.
No downtime or service interruptions during the transition.
The new version must be deployed smoothly, leveraging reserved capacity efficiently.
---
Options analysis:
A) Blue/green deployment with all-at-once traffic shifting
Blue/green deployment creates a separate environment (green) with the new model.
All-at-once traffic shifting means switching 100% of traffic immediately to the new environment.
Problem: You need to have enough capacity to run both old and new environments in parallel.
The company has only 1 extra instance, but would need the full 10 new instances to run the new model while keeping the old model active.
Hence, not feasible because the new environment requires additional capacity equal to the current environment (10 instances), which is not available.
Rejected due to insufficient capacity to support a full green environment for 10 instances.
---
B) Blue/green deployment with canary traffic shifting and a size of 10%
Canary traffic shifting means sending a small portion (10%) of traffic to the new model in the green environment, gradually increasing.
This allows testing with limited traffic before full cutover.
Still requires enough capacity to run the green environment.
With 10 instances currently running old model, you'd need a new environment scaled to support at least 1 instance (10% of 10) — which matches the 1 extra reserved instance available.
This fits perfectly: the 1 extra reserved instance can serve the canary traffic for the new version, while the original 10 serve the old version.
Gradually, as you shift traffic, you can scale down old version instances accordingly.
This deployment style supports no downtime and gradual traffic shifting, minimizing risk.
This is a valid and recommended approach in this scenario.
---
C) Shadow test with a traffic sampling percentage of 10%
Shadow testing sends a copy of the live traffic to the new version without affecting user response.
New version processes 10% of the traffic, but does not serve actual user responses.
Useful for testing, but the new ...
Author: Layla · Last updated Jul 27, 2026
An IoT company uses Amazon SageMaker to train and test an XGBoost model for object detection. ML engineers need to monitor performance metrics when they train the model with variants in hyperparameters. The ML engineers also need to send Short Mess...
Let's break down the requirements and analyze each option carefully.
Requirements:
1. Monitor performance metrics during training with different hyperparameters
This involves tracking and visualizing model training metrics (e.g., accuracy, loss) over time or across different training jobs.
2. Send SMS text messages after training completion
SMS messages must be delivered as notifications after the training job finishes.
---
Key factors to consider:
Monitoring performance metrics for ML training jobs:
Amazon SageMaker integrates with Amazon CloudWatch to push metrics and logs. CloudWatch is the standard AWS service to collect, monitor, and visualize metrics in near real-time.
AWS CloudTrail records API calls and changes to AWS resources — it is primarily for auditing and compliance, not for monitoring runtime performance metrics like model accuracy or loss.
Sending SMS notifications:
For sending SMS, Amazon SNS (Simple Notification Service) is the service designed to deliver notifications including SMS, email, and push messages.
Amazon SQS (Simple Queue Service) is a message queue designed for decoupling and buffering messages between distributed systems. It does not send SMS or email directly; it only stores messages for other consumers.
---
Option analysis:
A) Use Amazon CloudWatch to monitor performance metrics. Use Amazon SQS for message delivery.
Monitoring: CloudWatch is appropriate here.
SMS delivery: SQS is not designed to send SMS. It’s a queue service; someone would have to poll SQS and then send SMS using another service.
Verdict: Not ideal because SQS does not directly send SMS.
B) Use Amazon CloudWatch to monitor performance m...
Author: Noah · Last updated Jul 27, 2026
A company is working on an ML project that will include Amazon SageMaker notebook instances. An ML engineer must ensure that the SageMaker notebook instances do not allow root access.
Which...
Let's analyze each option carefully in the context of preventing SageMaker notebook instances that allow root access from being deployed.
---
Key context:
Goal: Prevent deployment of SageMaker notebook instances that allow root access (not just detect or delete them after deployment).
Important factor: Root access setting is a property of the notebook instance (e.g., `RootAccess` property in SageMaker Notebook instance configuration).
---
Option A: Use IAM condition keys to stop deployments of SageMaker notebook instances that allow root access.
Explanation:
IAM policies can use condition keys to restrict API actions based on certain request parameters.
Amazon SageMaker supports some condition keys that can be used in IAM policies to restrict the creation of resources based on their configuration.
Relevance:
You can create an IAM policy that denies the `CreateNotebookInstance` or `UpdateNotebookInstance` API calls if the `RootAccess` parameter is set to "Enabled".
This prevents the user from creating notebook instances with root access at the API level, effectively blocking deployment before it happens.
When to use:
When you want to enforce a policy at the permission level, ensuring that non-compliant resource creation attempts are rejected outright.
Conclusion:
This is a direct and preventive approach aligned with the requirement.
---
Option B: Use AWS Key Management Service (AWS KMS) keys to stop deployments of SageMaker notebook instances that allow root access.
Explanation:
KMS keys control encryption and access to encrypted data.
KMS does not natively control or restrict resource creation based on resource configurations like root access flags.
Relevance:
This is unrelated to preventing root access configuration in notebook instances.
When to use:
Primarily used for controlling access to encrypted data or enforcing encryption-related policies, not resource deployment restrictions.
Conclusion:
Not applicable here, so rejected.
---
Option C: Monitor resource creation by using Amazon EventBridge events. Create an AWS Lambda function that deletes all deployed SageMaker notebook instances that allow root access.
Explanation:
EventBridge can capture events like SageMaker notebook instance creation, and a Lambda function can react by deleting instances that violate the root access policy.
Relevance:
This is a reactive approach — the notebook instance is created first, then detected and deleted.
...
Author: Sofia · Last updated Jul 27, 2026
A company is using Amazon SageMaker to develop ML models. The company stores sensitive training data in an Amazon S3 bucket. The model training must have network iso...
Let's analyze each option carefully based on the key requirement: SageMaker training must have network isolation from the internet while accessing sensitive training data stored in S3.
---
A) Run the SageMaker training jobs in private subnets. Create a NAT gateway. Route traffic for training through the NAT gateway.
Explanation:
Running jobs in private subnets is good for isolation. However, creating a NAT gateway allows traffic to go through the internet (NAT gateway routes traffic to the internet), which breaks the network isolation requirement. Although the NAT gateway hides the internal IPs, it still means training jobs can access the internet.
Verdict:
Rejected because NAT gateway allows internet access, violating strict network isolation.
---
B) Run the SageMaker training jobs in private subnets. Create an S3 gateway VPC endpoint. Route traffic for training through the S3 gateway VPC endpoint.
Explanation:
Running in private subnets ensures no direct internet access. Using an S3 gateway VPC endpoint means all S3 traffic remains inside the AWS network and does not traverse the internet, maintaining network isolation. This meets the requirement of accessing S3 securely and privately.
Verdict:
Selected because it maintains network isolation, and securely accesses S3 without internet access.
---
C) Run the SageMaker training jobs in public subnets that have an attached security group. In the security group, use inbound rules to limit traffic from the internet. Encrypt SageMaker instanc...
Author: Isabella · Last updated Jul 27, 2026
A company needs an AWS solution that will automatically create versions of ML models as the models are create...
Let's analyze the requirement and each option carefully:
Requirement:
Automatically create versions of ML models as models are created.
This means the solution must track model versions and manage the lifecycle of these models.
---
Option A: Amazon Elastic Container Registry (Amazon ECR)
ECR is a managed container image registry service.
It is designed to store, manage, and deploy Docker container images.
While it can store containers used for serving models, it does NOT inherently provide model versioning or lifecycle management for ML models themselves.
Use case: Best when you want to manage container images for deployment, not for model versioning.
Reject: Does not handle ML model versioning or lifecycle tracking directly.
---
Option B: Model packages from Amazon SageMaker Marketplace
Model packages are pre-built models or algorithms available for purchase or use on SageMaker from the marketplace.
This is more about acquiring third-party models, not managing or versioning your own model development lifecycle.
Use case: When you want to buy or share models in a marketplace, not for internal versioning.
Reject: Not designed for automatic versioning of your own created models.
---
Option C: Amazon SageMaker ML Lineage Tracking
SageMaker Lineage Tracking captures metadata about ML workflows, including datasets, training jobs, models, and endpoints.
It provides visibility into t...
Author: Maya · Last updated Jul 27, 2026
A company needs to use Retrieval Augmented Generation (RAG) to supplement an open source large language model (LLM) that runs on Amazon Bedrock. The company's data for RAG is a set of documents in an Amazon S3 bucket. The documents consist of .csv...
To determine which option meets the requirements with the least operational overhead, let's break down each solution:
A) Create a pipeline in Amazon SageMaker Pipelines to generate a new model. Call the new model from Amazon Bedrock to perform RAG queries.
Analysis:
This approach involves creating a new model pipeline in Amazon SageMaker, which is a complex and high-maintenance process. You’d have to manage the model creation, training, and then the integration with Amazon Bedrock.
Operational overhead is significant because it requires building, maintaining, and monitoring the pipeline, which involves managing training data, tuning hyperparameters, and model updates.
Why Rejected: This solution is overkill for the given requirements, as it involves a full model creation pipeline, which is unnecessary if you just need to perform RAG queries using the existing model.
B) Convert the data into vectors. Store the data in an Amazon Neptune database. Connect the database to Amazon Bedrock. Call the Amazon Bedrock API to perform RAG queries.
Analysis:
This involves several steps: converting your documents into vector representations (embedding), storing those vectors in Amazon Neptune, and setting up the integration with Amazon Bedrock. While Amazon Neptune is optimized for graph data, it does introduce additional complexity in terms of database management and the embedding generation process.
Operational overhead includes:
Managing a Neptune instance
Regularly updating vector embeddings
Ensuring smooth interaction between Neptune and Bedrock
Why Rejected: This option introduces a heavy operational burden with database management and the need to convert documents into embeddings. It’s suitable if you're working with highly structured relationships or need a graph database, but it’s unnecessarily complicated for this scenario.
C) Fine-tune an existing LLM by using an AutoML job in Amazon SageMaker. Configure the S3 bucket as a dat...
Author: Leo · Last updated Jul 27, 2026
A company plans to deploy an ML model for production inference on an Amazon SageMaker endpoint. The average inference payload size will vary from 100 MB to 300 MB. Inference requests must be processed i...
To determine the best Amazon SageMaker inference option for this use case, let's analyze the key factors such as payload size, processing time, and the specific nature of the inference request (real-time vs. batch processing). Here's a breakdown of each option:
A) Serverless Inference
Use Case: Serverless inference is designed for workloads with unpredictable or low-volume inference requests, where users do not want to manage the underlying infrastructure. It allows for auto-scaling and is ideal for smaller, variable loads.
Payload Size Limitation: The serverless inference option has a payload size limit of 5 MB, which is far too small for the requirement of 100 MB to 300 MB payload size.
Processing Time: Serverless inference is optimized for fast, low-latency responses but may not be suitable for large payloads requiring significant time for processing.
Rejection Reason: The payload size exceeds the limit for serverless inference, making this option inappropriate.
B) Asynchronous Inference
Use Case: Asynchronous inference is well-suited for long-running inference requests, where the processing time might vary or exceed typical real-time response requirements. The results are delivered after the inference is completed.
Payload Size: It supports large payloads, including the 100 MB to 300 MB range, making it a good fit for handling large input data.
Processing Time: This option is suitable for scenarios where the inference time is not strictly bound by real-time requirements. The model may take several minutes or even hours to process requests.
Rejection Reason: Although this option can handle large payloads, it does not guarantee real-time processing (i.e., within 60 minutes), which is a strict requirement in this scenario. While it could work for long-running requests, real-time constraints rule it out.
C) Real-time Inference
Use Case: Real-time inference is designed for low-latency, interactive applications where quick responses are cri...
Author: CrimsonViperX · Last updated Jul 27, 2026
An ML engineer notices class imbalance in an image classification training job.
What should the M...
Class imbalance in an image classification training job refers to the situation where one class (or multiple classes) in the dataset has significantly fewer examples than others, which can lead to the model learning biased patterns that favor the majority class. To address this issue, the machine learning engineer can consider various approaches.
Option A: Reduce the size of the dataset
Explanation: Reducing the size of the dataset could lead to losing valuable data, especially from the majority class. This would make the model potentially underperform, as it would have fewer examples to learn from. In addition, reducing the dataset size doesn't solve the class imbalance problem but rather exacerbates it.
Reason for Rejection: This option is not appropriate for class imbalance as it would reduce the overall diversity of the data, potentially hurting model performance.
Option B: Transform some of the images in the dataset
Explanation: Transforming images (through augmentation) is a common technique to increase the diversity of training examples. Augmentation methods like rotation, flipping, scaling, and cropping can help generate more examples of underrepresented classes, effectively balancing the dataset.
Reason for Rejection: While this is an effective solution to address class imbalance, it’s not the most direct one in terms of resolution. It can be more time-consuming to design appropriate augmentations compared to other methods (like oversampling). Moreover, it’s not always guaranteed that augmentations will fully solve the imbalance problem, as it depends on how much the augmentations resemble real-world variations.
Option C: Apply random oversampling on the dataset
Explanation: Random oversampling involves duplicating instances from the minority class so that the number of examples in each class becomes more balanced....
Author: John · Last updated Jul 27, 2026
A company receives daily .csv files about customer interactions with its ML model. The company stores the files in Amazon S3 and uses the files to retrain the model. An ML engineer needs to implement a solution to mask credit card numbers in the files b...
To solve this problem, the main goal is to mask credit card numbers in the incoming .csv files stored in Amazon S3 with minimal development effort. Let's evaluate each option based on key factors such as development complexity, automation capabilities, scalability, and cost-effectiveness.
Option A: Create a discovery job in Amazon Macie. Configure the job to find and mask sensitive data.
Pros:
Minimal Development: Amazon Macie is a managed service designed to automatically discover and protect sensitive data (like credit card numbers). It uses machine learning to identify sensitive information in your data with little configuration.
Automation: Macie can be set up to run on a schedule and automatically detect sensitive data in new files without needing custom code.
Scalability: It is fully managed by AWS and can scale with your data without additional infrastructure setup.
Cons:
Cost: Amazon Macie has associated costs, especially as the volume of data increases. Depending on the number of files processed, it might become more expensive than some of the other options.
Masking Limitation: While Macie can discover sensitive data, it is not primarily designed to perform complex data transformations, like masking sensitive data in real time. Additional steps would be required for actually masking the data (perhaps integration with Lambda functions or another process).
Conclusion: While Macie can detect sensitive data effectively, it is not designed for directly masking or modifying data. It is better suited for discovering and classifying data rather than performing operations like masking.
Option B: Create Apache Spark code to run on an AWS Glue job. Use the Sensitive Data Detection functionality in AWS Glue to find and mask sensitive data.
Pros:
Automated Processing: AWS Glue is a fully managed ETL (Extract, Transform, Load) service, and it can run Spark jobs that process large datasets in S3.
Sensitive Data Detection: AWS Glue offers built-in sensitive data detection, which can automatically detect sensitive information, such as credit card numbers, in files.
Scalability: AWS Glue can scale automatically, which is important for handling large datasets.
Integration: AWS Glue integrates well with S3, making it easy to set up automated jobs that trigger when new files are uploaded.
Cons:
Complexity: While this option provides a more automated approach than Option A, setting up AWS Glue with sensitive data detection might require some configuration and learning.
Cost: AWS Glue can incur additional costs, especially for large-scale data processing, although these costs may still be manageable.
Conclusion: AWS Glue is a strong candidate because i...
Author: CrimsonViperX · Last updated Jul 27, 2026
A medical company is using AWS to build a tool to recommend treatments for patients. The company has obtained health records and self-reported textual information in English from patients. The company needs to use this information to gain ins...
To address this requirement of extracting insights from patients' health records and self-reported textual information with the least development effort, let’s analyze each option:
Option A: Use Amazon SageMaker to build a recurrent neural network (RNN) to summarize the data.
Pros: Customizable for complex tasks like summarizing unstructured data. RNNs are suitable for text-based tasks.
Cons: Building, training, and deploying an RNN model requires significant development effort, data labeling, and expertise in machine learning and deep learning techniques. You would need to handle all stages, including data preprocessing, training, hyperparameter tuning, and model evaluation.
Scenario: This approach is suitable if you need a completely custom model tailored to the specific dataset or the use case, but it’s overkill for this scenario.
Option B: Use Amazon Comprehend Medical to summarize the data.
Pros: Amazon Comprehend Medical is specifically designed to process and extract insights from medical text, including clinical notes, patient records, and other health-related information. It identifies entities such as medical conditions, treatments, medications, and relationships between them. It offers pre-trained models, which means minimal development work is required. It’s also easy to use and integrates well with AWS services.
Cons: It’s not specifically tailored to generate "summaries," but more for extracting key medical entities, relationships, and insights.
Scenario: Ideal when the goal is to extract medical entities, conditions, and relationships rather than generating summaries in natural language.
Option C: Use Amazon Kendra to create a quick-search tool to query the data.
Pros: Amazon Kendra is a powerful search service that allows you to search through unstructured data and retrieve ...
Author: NebulaEagle11 · Last updated Jul 27, 2026
A company needs to extract entities from a PDF document to build a classifier model.
Which solution will extract ...
When selecting the most efficient solution for extracting entities from a PDF document and storing them, we need to focus on speed, accuracy, and ease of integration. Here's a breakdown of each option:
Option A: Use Amazon Comprehend to extract the entities. Store the output in Amazon S3.
Advantages:
Amazon Comprehend is a powerful service designed specifically for natural language processing (NLP), and it can extract entities from text-based data such as PDFs that have been converted to text.
The workflow is straightforward and automated.
Disadvantages:
If the PDF is scanned or image-based, it will not be directly usable by Amazon Comprehend unless OCR is applied first.
It assumes the PDF is already in text format, so you may need an additional step for OCR before using Comprehend if the document is scanned.
Option B: Use an open-source AI OCR tool on Amazon SageMaker to extract the entities. Store the output in Amazon S3.
Advantages:
SageMaker allows the flexibility of using custom machine learning models and open-source OCR tools.
If you need high customization for complex documents or specific use cases, this could be an advantage.
Disadvantages:
This option involves building an OCR model or integrating an existing one, which can be time-consuming and may require advanced skills.
The overhead of setting up and maintaining the solution could lead to delays and complexity.
Option C: Use Amazon Textract to extract the entities. Use Amazon Comprehend to convert the entities to text. Store the output in Amazon S3.
Advantages:
Amazon Textract is specifically designed to extract text and structured data (like tables, forms, and entities) from scanned documents, including PDFs.
Amazon Comprehend can be used afterward to identify and classify entities from the extracted text, making it a powerful combination for comprehensive analysis.
Disadvantages:
In this workflow, the document is first processed by Textract, then passed to Comprehend. This introduces an additional step, whi...
Author: Nia · Last updated Jul 27, 2026
A company shares Amazon SageMaker Studio notebooks that are accessible through a VPN. The company must enforce access controls to prevent malicious actors from exploiting presigned...
To determine the best solution for enforcing access controls to prevent malicious actors from exploiting presigned URLs in the scenario provided, let’s analyze each option and its relevance to the problem:
1. Option A: Set up Studio client IP validation by using the `aws:sourceIp` IAM policy condition
Explanation: The `aws:sourceIp` condition allows restricting access based on the source IP address from which the request is originating. This is useful if you want to enforce that only requests coming from specific, trusted IPs (such as within the company's VPN or internal network) are allowed to access the notebooks.
Pros: This can ensure that only users within the VPN or on specific trusted networks can access the notebooks. It’s a strong way to limit access to known sources.
Cons: IP validation can be bypassed if a malicious actor gets access to a trusted IP address (e.g., by exploiting vulnerabilities in the VPN). It doesn’t provide deep-level control over other aspects like user identity or roles.
When to use: This is best when access needs to be restricted by location (network or VPN), but it isn't sufficient on its own for a full security posture.
2. Option B: Set up Studio client VPC validation by using the `aws:sourceVpc` IAM policy condition
Explanation: The `aws:sourceVpc` condition allows you to restrict access based on the VPC from which the request is made. This can be useful if the notebooks should only be accessed from specific VPCs that have been designated as trusted.
Pros: VPC-based controls can be effective in a cloud environment where all access is expected to come from specific networks within the company's infrastructure.
Cons: This can be restrictive, and it may not be granular enough for all use cases. VPC validation doesn’t directly tie to the individual user or their role.
When to use: This is useful if all users should only access the notebooks from a specific, controlled VPC and you need to enforce network-level security.
3. Option C: Set up Studio client role endpoint validation by using the `aws:PrimaryTag` IAM policy condition
Explanation: The `aws:PrimaryTag` condition allows you to control access based on the tags applied to resources or roles. In this case, it would be related to the tags on the role used to access the notebooks.
Pros: This option provides flexibility if your access control policies are tied to roles with specific tags, such as tags indicating trusted personnel or teams. It can also integrate with other AWS services.
Cons: This option focuses on roles and tagging but doesn’t address network access concerns directly. If the tags aren’t implemented consistently, it could lead to misconfigurations.
When to use: This would be useful if you have a sophisticated tagging strategy ...
Author: Sophia Clark · Last updated Jul 27, 2026
An ML engineer needs to merge and transform data from two sources to retrain an existing ML model. One data source consists of .csv files that are stored in an Amazon S3 bucket. Each .csv file consists of millions of records. The other data source is an Amazon Aurora DB cluster.
The result of the merge process must be written to a second S3 bucket. The ...
To meet the requirements of merging and transforming data from two sources (CSV files in Amazon S3 and an Amazon Aurora DB cluster) on a weekly basis with minimal operational overhead, let’s assess the available options based on key factors such as scalability, ease of maintenance, cost, and time to implementation.
Option A: Create a transient Amazon EMR cluster every week. Use the cluster to run an Apache Spark job to merge and transform the data.
Pros:
EMR is a powerful, scalable solution for processing large datasets (like the millions of records in the CSV files).
Apache Spark on EMR can efficiently handle complex transformations and merges.
Good for large-scale data processing.
Cons:
Operational overhead: Setting up and tearing down the cluster every week adds operational overhead. Managing EMR clusters can be complex, especially if you need to deal with configuration, security, and job orchestration.
Cost: Starting a transient EMR cluster for weekly use might incur significant costs, particularly when considering the computational resources needed for large datasets.
Maintenance: Managing the cluster’s performance, debugging, and troubleshooting adds complexity.
Conclusion for Option A: While powerful, this option would add more operational overhead and higher costs for the task, especially if the process needs to be automated weekly.
---
Option B: Create a weekly AWS Glue job that uses the Apache Spark engine. Use DynamicFrame native operations to merge and transform the data.
Pros:
Low operational overhead: AWS Glue is a fully managed ETL service that abstracts away the infrastructure management. It automatically scales resources based on the size of the data.
Cost-effective: Glue charges based on usage (per DPU-hour), and it’s ideal for processing and transforming large data sets on a regular basis.
Ease of use: AWS Glue provides a graphical interface and built-in support for common ETL tasks. Spark's native operations via DynamicFrames can handle CSV-to-DB merging and transformations efficiently.
Integration with S3 and Aurora: AWS Glue integrates natively with both Amazon S3 and Aurora, making it easy to connect to these data sources.
Built-in scheduler: You can schedule the Glue job weekly, reducing manual effort.
Cons:
Potential complexity in transformations: Depending on the complexity of the transformations, there may be a slight learning curve to leverage DynamicFrames and Glue’s native operations.
Conclusion for Option B: This is a fully managed service with low operational overhead, integrates seamlessly with the required data sources, and offers scalability. It’s ideal for periodic, complex ETL tasks like this one.
---
Option C: Create an AWS Lambda function that runs Apa...
Author: Krishna · Last updated Jul 27, 2026
An ML engineer has deployed an Amazon SageMaker model to a serverless endpoint in production. The model is invoked by the InvokeEndpoint API operation.
The model's latency in production is higher than the baseline latency in the test environment. The ML engineer thinks that the i...
To confirm or deny whether the increased latency is due to model startup time, the ML engineer needs to monitor the model setup or loading time that happens when the endpoint is first invoked or when there is a cold start.
Let's evaluate each option in detail:
A) Schedule a SageMaker Model Monitor job. Observe metrics about model quality.
This option would help the ML engineer monitor the quality of the model's predictions over time (e.g., bias, data drift, accuracy). However, it does not specifically help measure startup time or latency. This job focuses on monitoring the performance of the model post-invocation, rather than the initial startup time. Therefore, this option is not directly relevant to confirming latency due to model startup.
B) Schedule a SageMaker Model Monitor job with Amazon CloudWatch metrics enabled.
While this option brings in CloudWatch metrics, it still focuses on monitoring model performance, which is not focused on startup latency. The combination of Model Monitor and CloudWatch could be useful for quality metrics but would not provide the granularity needed for model startup metrics. Thus, this option is not the best fit for diagnosing increased latency from startup.
C) Enable Amazon CloudWatch metrics. Observe the ModelSetupTime metric in the SageMaker namespace.
...
Author: Nia · Last updated Jul 27, 2026
An ML engineer needs to ensure that a dataset complies with regulations for personally identifiable information (PII). The ML engineer will use the data to train an ML model on Amazon SageMaker instances. SageMaker must not use any...
To determine which solution meets the requirements in the most operationally efficient way, let’s evaluate each option based on key factors like data processing efficiency, ease of integration with SageMaker, data security, and scalability.
Option A: Use the Amazon Comprehend DetectPiiEntities API call to redact the PII from the data. Store the data in an Amazon S3 bucket. Access the S3 bucket from the SageMaker instances for model training.
Data Processing: Amazon Comprehend is a well-suited tool for detecting and redacting PII in text. This is efficient and specialized for text-based PII identification.
Data Storage: S3 is scalable, secure, and widely supported by SageMaker. It offers easy integration for training models.
Efficiency: Redacting the data using Amazon Comprehend and then storing it in S3 is a straightforward, automated process. Accessing data from S3 in SageMaker is native and optimized.
Why Rejected: This option is very operationally efficient. It does not have significant drawbacks compared to others.
Option B: Use the Amazon Comprehend DetectPiiEntities API call to redact the PII from the data. Store the data in an Amazon Elastic File System (Amazon EFS) file system. Mount the EFS file system to the SageMaker instances for model training.
Data Processing: Using Amazon Comprehend to redact the data is a good choice for text-based PII.
Data Storage: While EFS can be mounted to SageMaker, it is often more suited for file-based workloads requiring a shared file system. EFS can introduce additional operational overhead due to the complexity of managing the mount and access controls.
Efficiency: Although EFS works, it’s more complex than S3. EFS is typically used in scenarios requiring shared file systems for distributed workloads, not necessarily for isolated, simple training setups.
Why Rejected: S3 is a more efficient and simpler solution for storing data in most machine learning workflows compared to EFS.
Option C: Use AWS Glue DataBrew to cleanse the dataset of PII. Store the data in an Amazon Elastic File System (Amazon EFS) file system. Mount the EFS file system to the SageMaker instances for model training.
Data Processing: AWS Glue DataBrew is a powerful data preparation tool, but it may be an overkill for simply redacting PII. It is...
Author: Isabella · Last updated Jul 27, 2026
A company must install a custom script on any newly created Amazon SageMaker notebook instances.
Which solution will meet...
To meet the requirement of installing a custom script on newly created Amazon SageMaker notebook instances with the least operational overhead, let's examine each option in terms of factors like ease of implementation, maintainability, and scalability.
Option A: Create a lifecycle configuration script to install the custom script when a new SageMaker notebook is created.
Advantages:
SageMaker lifecycle configurations are specifically designed for this kind of task (custom script installation). This is a native feature of SageMaker and directly integrates with notebook instances.
Once set up, no additional management is needed.
The solution is highly automated and doesn’t require external services.
The lifecycle configuration runs automatically every time a notebook is created, making it very efficient.
Disadvantages:
Requires some upfront configuration to create the lifecycle script and attach it to each notebook instance. However, this is minimal overhead compared to other options.
This is a straightforward and effective solution for the task. Since lifecycle configurations are tailored for custom installations when creating notebook instances, this option is the least complex.
Option B: Create a custom Amazon Elastic Container Registry (Amazon ECR) image that contains the custom script.
Advantages:
This option allows you to create custom images that can be reused across different notebooks, providing flexibility.
Works well if you need a consistent and controlled environment.
Disadvantages:
Involves more overhead because you need to manage custom ECR images and ensure that they are regularly updated and maintained.
This approach also requires extra configuration when creating SageMaker Studio domains and selecting kernels, adding more complexity.
Not as seamless as lifecycle configurations when you only need to install a script on new notebooks.
This is a more complex solution a...
