Amazon Practice Questions, Discussions & Exam Topics by our Authors
A data scientist at a retail company is forecasting sales for a product over the next 3 months. After preliminary analysis, the data scientist identifies that sales are seasonal and that holidays affect sales. The data scientist also determines that sales of the product are correlated with sales of other products in the same category.
The data scientist n...
Option Evaluation:
A) Use Amazon Forecast with Holidays featurization and the built-in autoregressive integrated moving average (ARIMA) algorithm to train the model.
- Reason for Rejection: ARIMA is a traditional statistical method that performs well for simple time-series data, but it doesn't easily account for complex seasonality patterns, especially with non-linear or multi-dimensional relationships like the effect of holidays and correlations with other products. In this case, since the sales data is seasonal, affected by holidays, and correlated with other products, ARIMA may struggle to capture all of these relationships adequately. Additionally, ARIMA can be complex to configure and maintain when these factors are involved, making it less suited for this scenario.
B) Use Amazon Forecast with Holidays featurization and the built-in DeepAR+ algorithm to train the model.
- Reason for Selection: DeepAR+ is a probabilistic forecasting algorithm designed to handle time-series data with multiple features, such as seasonality and holidays. It also has the ability to capture dependencies between different related time series (e.g., sales of other products in the same category). The built-in holiday featurization will automatically incorporate the impact of holidays, which is one of the key requirements. This approach is more flexible, handles complex patterns well, and is designed for business users with minimal setup effort. Therefore, this option offers the least development effort while meeting the business requirements effectively.
C) Use Amazon SageMaker Processing to enrich the data with holiday information. Train the model by using the SageMaker DeepAR built-in algorithm.
- Reason for Rejection: While SageMaker DeepAR is a strong algorithm for time-series forecasting, using Amazon SageMaker Processing to enrich the data with holiday information a...
Author: Ella · Last updated Jul 26, 2026
A company is building a predictive maintenance model for its warehouse equipment. The model must predict the probability of failure of all machines in the warehouse. The company has collected 10,000 event samples within 3 months. The event samples include 100 failure cases that are evenly distribu...
To improve the accuracy of the predictive maintenance model, we need to address the class imbalance between failure and non-failure events. Given that there are only 100 failure cases (a minority class) among 10,000 event samples, the model might be biased toward predicting non-failure cases, which can reduce its overall accuracy for failure prediction. The goal is to improve the model's ability to predict failure events while avoiding bias and overfitting.
Let’s break down each option:
A) Adjust the class weight to account for each machine type.
- Selection Reasoning: Adjusting class weights helps address class imbalance by assigning higher weights to failure events, making them more significant during training. This technique is effective in cases with imbalanced classes because it encourages the model to pay more attention to the minority class (failures). Additionally, adjusting for machine types can help capture the variability across different types of machines, which may have different failure rates. This approach allows the model to retain all event data without oversampling or undersampling, maintaining the integrity of the data.
- Scenario Usefulness: This method is effective when there is an imbalance across different machine types and failure cases. It works well when the dataset has sufficient representation for both classes but needs correction for the imbalance.
B) Oversample the failure cases by using the Synthetic Minority Oversampling Technique (SMOTE).
- Rejection Reasoning: SMOTE is a technique that creates synthetic samples by interpolating between existing minority class instances. While it can increase the number of failure cases, it can also introduce synthetic data that might not reflect real-world scenarios accurately. Since there are 50 different machine types, SMOTE could generate synthetic data that might not be specific to individual machine types, leading to a less generalizable model. This option does not account for the machine-type differences effectiv...
Author: Samuel · Last updated Jul 26, 2026
A company stores its documents in Amazon S3 with no predefined product categories. A data scientist needs to build a machine learning model to categorize the documents for all the company's products...
Option Evaluation:
A) Build a custom clustering model. Create a Dockerfile and build a Docker image. Register the Docker image in Amazon Elastic Container Registry (Amazon ECR). Use the custom image in Amazon SageMaker to generate a trained model.
- Reason for Rejection: While building a custom clustering model in Docker offers full control over the model and its environment, this option involves a significant amount of effort to design, implement, and maintain the custom model and Docker image. It requires manual intervention for packaging and deploying the solution in Amazon SageMaker, which increases operational complexity. Additionally, custom clustering models may not directly address document categorization in a robust and efficient manner compared to more specialized approaches that handle text data.
B) Tokenize the data and transform the data into tabular data. Train an Amazon SageMaker k-means model to generate the product categories.
- Reason for Rejection: Using k-means clustering with tokenized and transformed text data may not be ideal because k-means is designed for numeric or structured data, not text data. Tokenizing text data and converting it into tabular format might lead to a loss of semantic information, which is essential for understanding and categorizing documents. While k-means can cluster documents, it may not capture the nuances of text data as effectively as specialized text-based models. Additionally, k-means doesn't inherently deal with topic modeling, which is more aligned with the problem of document categorization.
C) Train an Amazon SageMaker Neural Topic Model (NTM) model to generate the product categories.
- Reason for Selection: Neural Topic Models (NTM) are specifically designed to work with text data and automatically extract topics from large collections of ...
Author: Elijah · Last updated Jul 26, 2026
A sports analytics company is providing services at a marathon. Each runner in the marathon will have their race ID printed as text on the front of their shirt. The company needs to extract race IDs from images of the...
Option Evaluation:
A) Use Amazon Rekognition.
- Reason for Selection: Amazon Rekognition is a fully managed service designed to identify and extract text from images, including race IDs printed on the shirts of marathon runners. Rekognition offers built-in text detection capabilities (optical character recognition, or OCR), which is specifically tailored for text extraction from images. This service is quick to set up and has minimal operational overhead because it does not require custom model training or management. It can handle a wide range of image types and automatically processes the images to extract text, making it a suitable solution with the least effort.
B) Use a custom convolutional neural network (CNN).
- Reason for Rejection: While a CNN could be trained to identify and extract race IDs, it would require a significant amount of development, training, and ongoing maintenance. Building and training a custom CNN for this purpose involves collecting and annotating a large dataset of images with labeled race IDs, followed by model training and testing. Additionally, this would introduce significant operational overhead for managing the custom model, handling updates, and ensuring scalability, which makes it a more complex and resource-intensive solution compared to Amazon Rekognition.
C) Use the Amazon SageMaker Object Detection algorithm.
- Reason for Rejection: The SageMaker Object Detection algorithm is designed for detecting objects within images (...
Author: Henry · Last updated Jul 26, 2026
A manufacturing company wants to monitor its devices for anomalous behavior. A data scientist has trained an Amazon SageMaker scikit-learn model that classifies a device as normal or anomalous based on its 4-day telemetry. The 4-day telemetry of each device is collected in a separate file and is placed in an Amazon S3 bucket once every hour. The total time to run the model across the...
To determine the most cost-effective solution for running the trained Amazon SageMaker scikit-learn model across the telemetry of devices, we need to consider the workload characteristics and choose the best approach based on the time, scalability, and pricing model. The time to run the model is quite short (5 minutes), and the company needs to process telemetry files stored in an S3 bucket.
Let’s break down each option:
A) SageMaker Batch Transform
- Selection Reasoning: SageMaker Batch Transform is designed for batch inference, especially when you have large datasets that need to be processed in bulk. It is well-suited for scenarios where data is already stored in S3, as it can process the data in parallel across multiple instances, thus allowing efficient and cost-effective large-scale inference. Given that the telemetry data is stored in S3 and the processing time per device is short, Batch Transform would be ideal since it is designed for this type of job.
- Scenario Usefulness: This approach is highly effective for batch processing of telemetry data. The fact that the data is already in S3 and the processing time is short makes it well-suited for Batch Transform. The costs are based on the type and number of instances used, and since it processes multiple files in parallel, it could be cost-effective, especially for low-frequency inference like this.
B) SageMaker Asynchronous Inference
- Rejection Reasoning: SageMaker Asynchronous Inference is used for handling large-scale, long-running inference jobs that might require multiple hours or days of processing, especially when the results are not needed immediately. It is useful for situations where you don't need the model's output immediately but still need to process data in bulk. However, for the current scenario where inference takes just 5 minutes per device and the results are likely needed quickly, this option may not be the most cost-effective, as it’s typically designed for longer, more complex tasks.
- Scenario Usefulness: While it can handle large workloads asynchronously, it introduces unnecessary complexity for this case where the pr...
Author: Harper · Last updated Jul 26, 2026
A company wants to segment a large group of customers into subgroups based on shared characteristics. The company's data scientist is planning to use the Amazon SageMaker built-in k-means clustering algorithm for this task. The data scientist needs to determine the optimal num...
To determine the optimal number of subgroups (k) for k-means clustering, the data scientist is looking for a method that evaluates the clustering results in a clear and reliable way. Let's evaluate each option to find the most accurate one for this scenario.
Option A: Using PCA and scatter plots
- Approach: Calculate the principal components using PCA, run the k-means algorithm for a range of k values, and create scatter plots of clusters using only the first two PCA components. The optimal value of k is identified when the clusters start appearing reasonably separated.
- Strengths: This method can visually give an idea of how distinct the clusters are for different values of k, making it easier to observe the number of meaningful subgroups.
- Weaknesses: This method depends on visual inspection, which can be subjective. Additionally, reducing the dataset to just two PCA components may not preserve the full variance of the data, leading to potentially misleading conclusions.
- Best Use Case: Suitable when looking for a quick visual inspection of clusters but not ideal for definitive statistical validation.
Option B: Using PCA and explained variance
- Approach: Create a line plot showing the explained variance for each PCA component. The optimal number of k is determined by where the explained variance curve starts to level off, indicating diminishing returns from additional components.
- Strengths: PCA explained variance is useful for determining how many components capture the most important features of the data. However, this method does not directly apply to determining the optimal k for clustering.
- Weaknesses: This method is more related to dimensionality reduction rather than clustering. It doesn't directly help in selecting the optimal number of clusters (k) for k-means.
- Best Use Case: Used for understanding data dimensionality rather than clustering k determination.
Option C: Using t-SNE and perplexity
- Approach: Run t-SNE for a range of perplexity values and eval...
Author: Scarlett · Last updated Jul 26, 2026
A data scientist at a financial services company used Amazon SageMaker to train and deploy a model that predicts loan defaults. The model analyzes new loan applications and predicts the risk of loan default. To train the model, the data scientist manually extracted loan data from a database. The data scientist performed the model training and deployment steps in a Jupyter notebook that is hosted on SageMaker Studio notebooks. The mode...
To maintain the model's accuracy effectively and operationally, the data scientist needs a streamlined, automated workflow for retraining and monitoring the model's performance over time. Let's break down each option and evaluate the most efficient steps.
Option A: Use SageMaker Pipelines to create an automated workflow
- Approach: SageMaker Pipelines allows you to automate the entire machine learning (ML) lifecycle, including data extraction, model training, and deployment. This would create a streamlined, repeatable process for retraining and deploying models with fresh data.
- Strengths: Automating the workflow reduces human intervention, ensures that the model is regularly updated with fresh data, and ensures operational efficiency. This reduces the likelihood of manual errors and improves model maintenance.
- Weaknesses: This approach requires some initial setup and understanding of SageMaker Pipelines, but once configured, it is very efficient.
- Best Use Case: This is ideal for automated model training and deployment, especially when model accuracy needs to be maintained consistently over time.
Option B: Configure SageMaker Model Monitor with an accuracy threshold
- Approach: SageMaker Model Monitor automatically monitors the model's performance and checks for model drift (i.e., when the model's predictions become less accurate over time). By setting an accuracy threshold, an alarm can be triggered in CloudWatch when the model's performance degrades. This can then initiate an automatic retraining workflow through SageMaker Pipelines.
- Strengths: Model Monitor can track changes in model performance over time, and the automated triggering of retraining ensures that model degradation is addressed quickly. Integrating with CloudWatch alarms and SageMaker Pipelines makes it an end-to-end solution for maintaining accuracy.
- Weaknesses: Requires configuration and ongoing monitoring of thresholds and alarms. However, once set up, it provides continuous monitoring and retraining.
- Best Use Case: Ideal for proactive model maintenance and ensuring that performance degradation triggers automatic corrective actions.
Option C: Store the model predictions in Amazon S3 and create a daily processing job
- Approach: This option involves saving the predictions and then running a daily processing job to check for accuracy changes. If a significant change is detected, an email notification is sent.
- Strengths: This approach allows monitoring of model predictions over time, providing visibility into accuracy shifts....
Author: Ahmed97 · Last updated Jul 26, 2026
A retail company wants to create a system that can predict sales based on the price of an item. A machine learning (ML) engineer built an initial linear model that resulted in the following residual plot:
Which actions should the ML engi...
To improve the accuracy of the sales prediction model, the ML engineer should address the issues seen in the residual plot. The residual plot likely shows patterns (such as a curve or varying spread) that indicate that a linear model is insufficient for modeling the relationship between price and sales. Here's a breakdown of the potential actions:
Option A: Downsample the data uniformly to reduce the amount of data
- Explanation: Downsampling is typically used when dealing with imbalanced datasets or to reduce computational overhead. However, it is unlikely to improve accuracy in this case unless the dataset has extreme class imbalances or a very large volume of irrelevant data. In the context of improving model accuracy based on the residual plot, this does not address the underlying issue.
- Reasoning: Reducing data without addressing the underlying pattern in the residuals does not help to fix the model's shortcomings. This is more of a data reduction technique, which isn't necessarily linked to improving the model's fit.
- Best Use Case: Useful in specific scenarios where data imbalance is an issue, but not in this context.
Option B: Create two different models for different sections of the data
- Explanation: If the data shows different patterns at various ranges of price (e.g., for very low or high prices), it might make sense to fit separate models for different sections. This can be useful if there is evidence of distinct relationships between price and sales in different price ranges.
- Reasoning: If the residual plot suggests that the model does not fit well for certain sections of the data (such as a nonlinear pattern at higher prices), splitting the data and fitting separate models could potentially improve the accuracy. However, this approach may lead to model complexity and overfitting if not handled carefully.
- Best Use Case: This is useful if the relationship between price and sales differs significantly at different price ranges. This would be beneficial if there are clear boundaries where the behavior shifts.
Option C: Downsample the data in sections where Price < 50
- Explanation: Downsampling in a specific price range could be useful if the lower-priced items dominate the dataset and introduce bias. However, this approach ignores the potential underlying non-linearity in the data. Simply downsampling in one range does not address the fundamental problem of model underfitting or poor accuracy in prediction.
- Reasoning: If the issue in the residual plot is a non-linear relationship between price and sales, downsampling one section of the data without transforming or properly modeling the data will not fix the issue.
- Best Use Case: This could be helpful in rare cases of data imbalance, but it is not the best option for improving model accuracy if the model suffers from poor fit or complexity.
Optio...
Author: Ella · Last updated Jul 26, 2026
A data scientist at a food production company wants to use an Amazon SageMaker built-in model to classify different vegetables. The current dataset has many features. The company wants to save on memory costs when the data scientist trains and deploys the model. The company also...
To meet the company's requirements of saving memory costs during training and deployment while being able to find similar data points for each test data point, let's evaluate the different algorithms:
Option A: K-nearest neighbors (k-NN) with dimension reduction
- Explanation: K-nearest neighbors (k-NN) is an algorithm used for classification or regression that classifies data points based on their proximity to other data points. The inclusion of dimension reduction (e.g., via PCA or other methods) helps reduce the number of features, saving memory.
- Strengths: The algorithm's key benefit is that it can efficiently classify data points based on similarity. Additionally, dimension reduction reduces memory costs by lowering the feature space.
- Weaknesses: k-NN can be memory-intensive when dealing with large datasets since it requires storing the entire dataset in memory for real-time classification. The algorithm’s performance also deteriorates with a very large number of features, even if dimension reduction is applied. It may not scale efficiently in production environments unless optimized.
- Best Use Case: Suitable when finding similar data points for each test data point is a critical requirement. However, in large-scale scenarios, using k-NN in combination with dimensionality reduction may not be as memory efficient as other methods.
Option B: Linear learner with early stopping
- Explanation: The Linear Learner algorithm in SageMaker is used for linear classification and regression problems. Early stopping helps prevent overfitting and reduces the time needed for training.
- Strengths: Linear models are generally memory efficient and can handle large datasets with a lower memory footprint compared to algorithms like k-NN or deep learning-based models.
- Weaknesses: While linear models are efficient and simple, they may not perform well on more complex data relationships (e.g., non-linear relationships). For classification of different vegetables, a linear model might struggle to capture the complexity of the data unless the relationships between features are truly linear.
- Best Use Case: Suitable when the relationships between features and target are linear and the dataset is not highly complex, but not ideal for capturing more intricate patterns in the data.
Option C: K-means
- Explanation: K-means is a clustering algorithm that groups similar data points together based on the mean of each cluster. This can be useful...
Author: Carlos Garcia · Last updated Jul 26, 2026
A data scientist is training a large PyTorch model by using Amazon SageMaker. It takes 10 hours on average to train the model on GPU instances. The data scientist suspects that training is not converging and that resource utilization is not optimal.
...
To identify and address training issues with the least development effort, the data scientist should focus on leveraging SageMaker tools that are specifically designed for monitoring training jobs and diagnosing problems related to model training efficiency. Let's review each option:
Option A: Use CPU utilization metrics that are captured in Amazon CloudWatch
- Explanation: This option involves monitoring CPU utilization metrics from CloudWatch and using alarms to stop the training job if low CPU utilization occurs. While this could help identify if the CPU is underutilized, it is not the best metric for diagnosing training issues related to GPU-based models, as the model is likely utilizing the GPU for most of the computation. CPU utilization metrics are not highly relevant for GPU-based training and do not provide much insight into GPU performance or model convergence.
- Reasoning: This is a poor choice because it does not focus on the relevant metrics (GPU utilization or model convergence). Also, it requires setting up alarms manually and may not directly address the issue of model convergence or optimal resource utilization.
- Best Use Case: This would be relevant for CPU-bound tasks but not ideal for GPU-based training, which is likely the case here.
Option B: Use high-resolution custom metrics that are captured in Amazon CloudWatch
- Explanation: This option suggests using high-resolution custom metrics in CloudWatch and analyzing them with an AWS Lambda function. While custom metrics can give insight into specific parts of the model's performance, this approach requires significant development effort to configure and maintain the custom metrics and Lambda functions.
- Reasoning: Although this method could provide detailed insights, it introduces a lot of overhead with respect to metric creation, analysis, and managing the Lambda function. Additionally, it doesn't directly offer solutions or automated interventions like stopping the training when certain conditions are met.
- Best Use Case: Useful if you need highly specific custom metrics but comes with a higher development cost compared to using built-in solutions in SageMaker.
Option C: Use the SageMaker Debugger vanishing_gradient and LowGPUUtilization built-in rules
- Explanation: This option suggests using SageMaker Debugger’s built-in rules for detecting issues such as vanishing gradients and low GPU utilization. Th...
Author: SolarFalcon11 · Last updated Jul 26, 2026
A bank wants to launch a low-rate credit promotion campaign. The bank must identify which customers to target with the promotion and wants to make sure that each customer's full credit history is considered when an approval or denial decision is made.
The bank's data science team used the XGBoost algorithm to train a classification model based on account transaction features. The data science team deployed the model by using the Amazon SageMaker model hosting service. The accuracy of the model is sufficie...
To meet the bank's requirement of explaining why the model denies promotions to some customers, the solution must provide an operationally efficient way to explain individual predictions, ideally after the model has already been deployed. The selected solution should offer interpretability, especially for the credit history used in the classification model, while minimizing the amount of manual intervention.
Evaluating the Options:
Option A: Create a SageMaker notebook instance. Upload the model artifact to the notebook. Use the plot_importance() method in the Python XGBoost interface to create a feature importance chart for individual predictions.
- Reasoning: The `plot_importance()` method generates a feature importance chart, but it is based on the general features used during model training, not on the individual predictions or the specific reasons why a particular prediction was made. This approach is useful for understanding the global feature importance of the model, but does not explain individual decisions or predictions after deployment.
- Rejection: This option does not meet the requirement of explaining why specific customers are denied promotions because it doesn't provide individualized explanations.
Option B: Retrain the model by using SageMaker Debugger. Configure Debugger to calculate and collect Shapley values. Create a chart that shows features and Shapley Additive explanations (SHAP) values to explain how the features affect the model outcomes.
- Reasoning: This option involves retraining the model, which is not necessary since the model is already deployed. Retraining adds overhead and is not the most operationally efficient solution in this case, especially since the model's accuracy is already sufficient.
- Rejection: Retraining the model just for the purpose of explaining individual predictions is not the most operationally efficient approach, and could introduce unnecessary complexity.
Option C: Set up and run an explainability job powered by SageMaker Clarify to analyze the individual customer data, using the training data as a baseline. Create a chart that shows features and Shapley Additive explanations (SHAP) values to explain ho...
Author: SilverBear · Last updated Jul 26, 2026
A company has hired a data scientist to create a loan risk model. The dataset contains loan amounts and variables such as loan type, region, and other demographic variables. The data scientist wants to use Amazon SageMaker to test bias regarding the loan amount distribution with respect to some of these ca...
To address the question of checking bias regarding the loan amount distribution with respect to categorical variables such as loan type, region, and demographic data, it is important to focus on pretraining bias metrics that specifically help measure fairness in relation to these variables. Here’s an analysis of each option:
Option A: Class imbalance
- Reasoning: Class imbalance refers to the unequal distribution of classes in a dataset, typically seen in classification problems. It involves situations where certain categories (e.g., approved vs. denied loans) may be overrepresented or underrepresented. This can affect model performance, especially in terms of bias, as a model may become biased toward the majority class. However, in the context of analyzing bias in loan amount distribution or bias regarding categorical variables (e.g., loan type or region), class imbalance is not directly relevant. It's more applicable to classification tasks rather than regression tasks where loan amounts are being predicted.
- Rejection: This metric is not appropriate for analyzing bias in loan amount distributions or continuous variables such as loan amounts.
Option B: Conditional demographic disparity
- Reasoning: Conditional demographic disparity is a fairness metric used to evaluate if there is a bias or disparity in outcomes across different demographic groups, conditioned on specific features. This would be highly relevant for analyzing bias in loan amount distribution, especially if the goal is to examine how certain categories like region, loan type, or demographic factors (e.g., gender, age, income) are influencing the loan amount distribution. This metric helps to assess if the model is treating individuals from different demographic groups unfairly when it comes to loan amounts.
- Selection: This is a key metric for understanding whether the model's predictions (e.g., loan amounts) exhibit disparity across different demographic groups.
Option C: Difference in proportions of labels
- Reasoning: This metric measures the disparity between the proportions of different labels (e.g., labels in a classification task) between different groups. However, for a regression problem, such as loan amount prediction, where the target is continuous (e.g., loan amounts), this metric is not as relevant because there are no distinct classes or labels to compare across groups. Instead, for continuous outcomes, we need to focus on measures that evaluate how different categorical groups are treated in terms of the predicted values (loan amounts).
- Rejection: This metric is more suited for classification problems and does not directly apply to continuous prediction tasks like loan amount modeling.
Option D: Jensen-Shannon divergence
- Reasoning: Jensen-Shannon divergence is a measure of the similarity between two probability distri...
Author: Madison · Last updated Jul 26, 2026
A retail company wants to use Amazon Forecast to predict daily stock levels of inventory. The cost of running out of items in stock is much higher for the company than the cost of having excess inventory. The company has millions of data samples for multiple years for thousands of items. The company's purchasing department needs to predict demand for 30-day cycles for each item to ensure that restocking occurs.
A machine learning (ML) specialist wants to use item-related features such as "category," "brand," and "safety stock count." The ML specialist also wants to use a binary time series feature that has "promotion applied?" as ...
To address the company's need for predicting daily stock levels of inventory, the solution must consider a few key factors: the cost of running out of stock is much higher than having excess inventory, the company has millions of data points, and the company needs to predict demand over 30-day cycles for each item. Moreover, the model should leverage item-related features and the binary time series feature about promotions, which is available for only the next 5 days.
Let’s break down the key requirements and evaluate the options:
Key Factors to Consider:
1. Cost of Running Out of Stock vs. Excess Inventory: The company wants to avoid stockouts, so the focus should be on predicting the upper quantiles (e.g., P75 or higher) to ensure sufficient stock levels.
2. Time Series and Promotional Data: The binary time series feature ("promotion applied?") can influence demand patterns, so the algorithm must handle this temporal feature and future promotion data effectively.
3. Prediction over 30-Day Cycles: The solution should predict future demand over a 30-day period, incorporating item-related features such as category, brand, and safety stock count, in addition to the promotional feature.
Evaluation of the Options:
Option A: Train a model by using the Autoregressive Integrated Moving Average (ARIMA) algorithm. Evaluate the model by using the Weighted Quantile Loss (wQL) metric at 0.75 (P75).
- Reasoning: ARIMA is a traditional time series model that is good for modeling univariate time series data, especially when historical values influence future values. However, ARIMA is limited in its ability to handle complex multivariate features like "category," "brand," "safety stock count," and time-varying binary features like "promotion applied?". It also doesn't easily accommodate for future external data (like promotions for the next 5 days), which is an essential feature for this case.
- Rejection: ARIMA is not suitable for handling the rich set of features (both categorical and temporal) and future external information like promotions. Therefore, it is not ideal for the task at hand.
Option B: Train a model by using the Autoregressive Integrated Moving Average (ARIMA) algorithm. Evaluate the model by using the Weighted Absolute Percentage Error (WAPE) metric.
- Reasoning: WAPE is a metric used to evaluate forecast accuracy, which measures the absolute percentage error weighted by actual demand. While WAPE can be useful in some cases, the key issue with this option is the same as in Option A: ARIMA is not well-suited for incorporating the categorical features or future external features (such as promotions) effectively. It might not perform well when dealing with complex features or when predicting for multiple i...
Author: Layla · Last updated Jul 26, 2026
An online retail company wants to develop a natural language processing (NLP) model to improve customer service. A machine learning (ML) specialist is setting up distributed training of a Bidirectional Encoder Representations from Transformers (BERT) model on Amazon SageMaker. SageMaker will use eight compute instances for the distributed training.
The ML specialist wants to ensure the security of the data during the distrib...
To ensure the security of the data during distributed training of a BERT model in Amazon SageMaker, we need to focus on protecting the data both in transit and at rest. The goal is to ensure that data is secure during distributed training while also ensuring that all connections are properly controlled and monitored. Let's review each option and its relevance:
A) Run distributed training jobs in a private VPC. Enable inter-container traffic encryption.
- Selection Reasoning: Running the training jobs in a private VPC ensures that the compute instances used for the distributed training are isolated from the public internet, providing a secure environment. Additionally, enabling inter-container traffic encryption ensures that communication between the different compute instances (containers) during the distributed training is encrypted, preventing any unauthorized access to the data while it is in transit between containers.
- Scenario Usefulness: This is a crucial step for ensuring security during distributed training. By using a private VPC, you ensure isolation from the public internet, and inter-container traffic encryption secures communication between instances, which is essential for distributed model training.
B) Run distributed training jobs across multiple VPCs. Enable VPC peering.
- Rejection Reasoning: While running distributed training jobs across multiple VPCs may seem like a way to isolate environments, it introduces unnecessary complexity and overhead. VPC peering enables communication between VPCs but also opens up additional networking configurations that might not be required for training within a single secure network. Additionally, inter-VPC traffic might not be as optimized or secure as traffic within a single private VPC.
- Scenario Usefulness: This option adds unnecessary complexity for this scenario. Since the data is in S3, running the training jobs within a single VPC is sufficient for ensuring security.
C) Create an S3 VPC endpoint. Then configure network routes, endpoint policies, and S3 bucket policies.
- Selection Reasoning: Creating an S3 VPC endpoint ensures that all data transferred between the SageMaker instances and the S3 bucket stays within the AWS network, avoiding exposure to the public internet. By configuring endpoint policies and S3 bucket policies, you can restrict access to the data to only the necessary resources, such as the SageMaker training instances, adding an additional layer of security to protect sensitive data.
- Scenario Usefulness: This step is essential for securing the data stored in S3 during training, ensuring that it’s only accessed via the private VPC and not exposed to the internet. It helps protect the data bot...
Author: RadiantPhoenixX · Last updated Jul 26, 2026
An analytics company has an Amazon SageMaker hosted endpoint for an image classification model. The model is a custom-built convolutional neural network (CNN) and uses the PyTorch deep learning framework. The company wants to increase throughput and decrease ...
To increase throughput and decrease latency for the image classification model hosted on Amazon SageMaker, the solution needs to focus on improving inference performance in a cost-effective manner. Let's analyze each option:
Option A: Use Amazon Elastic Inference on the SageMaker hosted endpoint.
- Reasoning: Amazon Elastic Inference allows you to attach lower-cost GPU-powered inference acceleration to SageMaker instances. This can help reduce the cost of using powerful GPUs for inference while still providing the necessary GPU resources to handle high-throughput requests with low latency. Elastic Inference is highly cost-effective because it enables you to scale the GPU capacity based on the actual need, so you only pay for what you use. For a custom CNN model using PyTorch, adding Elastic Inference to the instance can help handle multiple image classification requests simultaneously without the need for high-cost instances with full GPU capabilities.
- Selection: This option is cost-effective and helps increase throughput and decrease latency by providing GPU acceleration without the need for a full GPU instance.
Option B: Retrain the CNN with more layers and a larger dataset.
- Reasoning: Retraining the CNN with more layers and a larger dataset may improve the model's accuracy, but it will increase the computational complexity of both the training and inference phases. This would require more compute power, more memory, and potentially increase latency during inference, as a more complex model typically takes longer to make predictions. While the model may become more accurate, it would not necessarily address the core requirements of increasing throughput and decreasing latency, and it could increase costs due to the higher demand for computational resources.
- Rejection: This option may improve the model's accuracy but is inefficient for increasing throughput ...
Author: Noah · Last updated Jul 26, 2026
An ecommerce company is collecting structured data and unstructured data from its website, mobile apps, and IoT devices. The data is stored in several databases and Amazon S3 buckets. The company is implementing a scalable repository to store structured data and unstructured data. The company must implement a solution that provides a central data catalog, self-service access to the data, and gra...
To determine the best approach for the company's requirements of a scalable repository with a central data catalog, self-service access, and granular access policies with encryption, let's break down each of the options and evaluate them based on the given criteria.
Key Factors:
1. Central Data Catalog: The company needs a way to manage and organize the data centrally.
2. Self-Service Access: The solution should allow easy access to the data for authorized users.
3. Granular Data Access Policies: Access to the data must be controlled at a granular level.
4. Encryption: Data should be encrypted to protect it.
5. Scalability: The solution should scale efficiently to handle large amounts of data from multiple sources (databases, S3, etc.).
---
Option A: Identify the existing data in the databases and S3 buckets. Link the data to AWS Lake Formation.
- Reasoning: AWS Lake Formation provides a central place for managing data access, governance, and encryption. It allows for building a secure data lake and applying granular access controls.
- Pros:
- It provides a central data catalog for both structured and unstructured data.
- It allows for the application of fine-grained access controls to data.
- Integrates with AWS Glue and other services for managing and querying data.
- Cons: You need to first link data from databases and S3 to Lake Formation, which may require more setup, but the integration and scalability are well supported in the long term.
- Conclusion: A good fit for the needs. Lake Formation provides centralized management and security.
---
Option B: Identify the existing data in the databases and S3 buckets. Link the data to AWS Glue.
- Reasoning: AWS Glue is a fully managed ETL service, primarily used for transforming and preparing data for analytics. While it includes a data catalog, it does not focus on access control as much as Lake Formation does.
- Pros: AWS Glue can create a data catalog and provides the capability to run crawlers to discover and catalog data.
- Cons: Glue alone does not provide the level of data governance and access control that Lake Formation does. It would require additional IAM policies for access control and may not provide the level of integration for encryption out-of-the-box as Lake Formation does.
- Conclusion: While AWS Glue can help organize data, it is not as suited for granular access control and encryption as Lake Formation.
---
Option C: Run AWS Glue crawlers on the linked data sources to create a central data catalog.
- Reasoning: AWS Glue crawlers are used to discover and catalog data. This is an important step to centralize the data catalog.
- Pros: This will create the central data catalog for structured and unstructured d...
Author: Aria · Last updated Jul 26, 2026
A machine learning (ML) specialist is developing a deep learning sentiment analysis model that is based on data from movie reviews. After the ML specialist trains the model and reviews the model results on the validation set, the ML specialist discovers that the model i...
To address the issue of overfitting in the sentiment analysis model, the key goal is to improve the model's generalization ability, which means improving its performance on unseen data (the test set) while preventing it from fitting too closely to the training data (which results in overfitting).
Let’s evaluate each option:
Option A: Shuffle the dataset with a different seed.
- Reasoning: Shuffling the dataset with a different seed could change the order in which data points are presented to the model during training. However, this change typically does not have a significant impact on reducing overfitting. Overfitting is more related to model complexity and regularization techniques than the order of the training data.
- Pros: Shuffling can help with randomization, potentially reducing bias.
- Cons: This does not directly address overfitting, and simply changing the seed is unlikely to have a significant effect.
- Conclusion: Not the most effective solution for overfitting.
Option B: Decrease the learning rate.
- Reasoning: Decreasing the learning rate can help the model converge more slowly, potentially resulting in a better-trained model. However, a lower learning rate does not directly address overfitting. In fact, decreasing the learning rate too much could cause the model to get stuck in local minima, which might make it harder to generalize.
- Pros: A smaller learning rate can prevent the model from overshooting optimal points.
- Cons: It does not directly reduce overfitting. Overfitting is more about the model complexity, training duration, and regularization.
- Conclusion: While it may improve convergence, it is not the best solution for reducing overfitting.
Option C: Increase the number of layers in the network.
- Reasoning: Adding more layers can make the model more complex, which can increase overfitting, especially if the training data is limited. A deeper model is capable of learning more intricate patterns, but it can also fit noise in the data, which leads to overfitting.
- Pros: More layers could capture more complex patterns, potentially improving model performance.
- Cons: It is counterproductive when dealing with overfitting, as adding more layers will likely worsen the overfitting issue.
- Conclusion: Increasing the number of layers is not recommended for overfitting.
Option D: Add L1 regularization and L2 regularization.
- Reasoning: L1 and L2 regularization are widely used to prevent overfitting. L1 regular...
Author: Ishaan · Last updated Jul 26, 2026
An online advertising company is developing a linear model to predict the bid price of advertisements in real time with low-latency predictions. A data scientist has trained the linear model by using many features, but the model is overfitting the training dataset. The data scien...
To address overfitting and reduce the number of features in the linear model, the goal is to implement a method that effectively controls model complexity and removes irrelevant or less useful features. Let's evaluate each option in detail:
Option A: Retrain the model with L1 regularization applied.
- Reasoning: L1 regularization (also known as Lasso regularization) is designed to reduce overfitting by penalizing the absolute value of the coefficients in the model. It has a significant advantage of sparsifying the model, meaning it can set many feature coefficients to zero, effectively removing less important features.
- Pros: L1 regularization is particularly useful when the goal is to reduce the number of features because it can directly lead to a sparse solution, where some feature weights are set to zero. This results in automatic feature selection.
- Cons: It may not work as well if many features are highly correlated with each other.
- Conclusion: L1 regularization is a highly effective choice for both preventing overfitting and reducing the number of features by automatically eliminating non-significant ones.
Option B: Retrain the model with L2 regularization applied.
- Reasoning: L2 regularization (also known as Ridge regularization) penalizes the squared value of the coefficients, discouraging large weights and thus preventing overfitting. However, it does not set coefficients to zero, meaning that all features remain in the model, albeit with smaller weights.
- Pros: L2 regularization helps with overfitting by preventing large model coefficients.
- Cons: It does not perform feature selection since it reduces coefficients without eliminating them completely, so the number of features remains the same.
- Conclusion: While L2 regularization is useful for preventing overfitting, it does not reduce the number of features as L1 regularization does.
Option C: Retrain the model with dropout regularization applied.
- Reasoning: Dropout regularization i...
Author: Manish · Last updated Jul 26, 2026
A credit card company wants to identify fraudulent transactions in real time. A data scientist builds a machine learning model for this purpose. The transactional data is captured and stored in Amazon S3. The historic data is already labeled with two classes: fraud (positive) and fair transactions (negative). The data scientist removes all the missing data and builds a classifier by using the XGBoost algorithm in Amazon SageMaker. The model produces the following results:
* True positive rate (TPR): 0.700
...
To improve the performance of the model, we need to carefully evaluate the current model performance and the best techniques to address potential class imbalance, which is commonly the root cause in fraud detection problems.
Key Factors:
- True Positive Rate (TPR): 0.700 (the percentage of fraudulent transactions correctly identified).
- False Negative Rate (FNR): 0.300 (the percentage of fraudulent transactions incorrectly classified as fair).
- True Negative Rate (TNR): 0.977 (the percentage of fair transactions correctly classified).
- False Positive Rate (FPR): 0.023 (the percentage of fair transactions incorrectly classified as fraud).
- Accuracy: 0.949 (the overall percentage of correct classifications).
While the model seems to perform well in terms of accuracy, the False Negative Rate (FNR) of 0.300 indicates that the model is missing a significant portion of fraudulent transactions. In fraud detection, missing frauds (false negatives) is often a more critical problem than falsely flagging a legitimate transaction as fraud (false positives), especially when the goal is to minimize risk.
Let's evaluate the options:
Option A: Apply the Synthetic Minority Oversampling Technique (SMOTE) on the minority class in the training dataset. Retrain the model with the updated training data.
- Reasoning: SMOTE (Synthetic Minority Oversampling Technique) is a technique used to deal with imbalanced datasets by creating synthetic examples of the minority class. In fraud detection, fraud cases are often the minority class, so oversampling the minority class would help the model learn better and prevent it from being biased toward the majority class (fair transactions).
- Pros: SMOTE increases the representation of the minority class (fraudulent transactions), which should help the model identify fraud more effectively, leading to an improved TPR and a reduced FNR.
- Cons: Careful tuning is necessary to avoid overfitting. Additionally, SMOTE increases the size of the dataset, which can lead to increased training time.
- Conclusion: This option directly addresses the class imbalance and improves the model's ability to identify fraudulent transactions. It is one of the most appropriate strategies for fraud detection.
Option B: Apply the Synthetic Minority Oversampling Technique (SMOTE) on the majority class in the training dataset. Retrain the model with the updated training data.
- Reasoning: Applying SMOTE on the majority class (fair transactions) would generate synthetic data for the majority class, making the dataset more balanced. However, generating synthetic examples of the majority class does not address the core issue of the minority class (fraudulent transactions) being underrepresented.
- Pros: This would balance the datase...
Author: Jack · Last updated Jul 26, 2026
A company is training machine learning (ML) models on Amazon SageMaker by using 200 TB of data that is stored in Amazon S3 buckets. The training data consists of individual files that are each larger than 200 MB in size. The company needs a data access solution that...
To meet the requirements of accessing a large dataset stored in Amazon S3 (200 TB) efficiently with the shortest processing time and minimal setup, let's evaluate each option carefully based on factors like speed, setup complexity, and suitability for large files.
Option A: Use File mode in SageMaker to copy the dataset from the S3 buckets to the ML instance storage.
- Reasoning: File mode involves copying the dataset from S3 to the local storage of the training instances before training starts. This method works well for smaller datasets but can be inefficient for large datasets (200 TB in this case).
- Pros: Simple to implement.
- Cons: Copying 200 TB of data to the local storage of the ML instance is impractical due to time and storage limitations. Additionally, it involves large I/O operations and requires significant disk space on the training instance. This approach is slow and will take a long time to process, especially with large files (larger than 200 MB each).
- Conclusion: This is not ideal for large datasets, as it is time-consuming and involves significant storage overhead.
Option B: Create an Amazon FSx for Lustre file system. Link the file system to the S3 buckets.
- Reasoning: Amazon FSx for Lustre is a high-performance file system that can be linked directly to Amazon S3. It can provide fast data access and is designed for workloads that require high throughput and low latency, like ML training. FSx for Lustre can access data directly from S3 without needing to copy it, improving processing time.
- Pros: High-performance file system designed for large-scale data processing. It can handle large datasets efficiently and offers excellent throughput and low latency. Linking it to S3 allows seamless access to data stored in S3.
- Cons: Setup involves configuring the FSx for Lustre file system, which might require some initial effort. However, once set up, it provides high-speed access to S3 data.
- Conclusion: This is a highly suitable solution for accessing large datasets efficiently. It balances speed with a one-time setup cost.
Option C: Create an Amazon Elastic File System (Amazon EFS) file system. Mount the file system to the training instances.
- Reasoning: Amazon EFS is a scalable file system for cloud-based workloads, b...
Author: Vikram · Last updated Jul 26, 2026
An online store is predicting future book sales by using a linear regression model that is based on past sales data. The data includes duration, a numerical feature that represents the number of days that a book has been listed in the online store. A data scientist performs an exploratory data analysis and discovers that the relationship between book...
To address the issue of a skewed and non-linear relationship between book sales and duration in the linear regression model, the data scientist should apply a data transformation that can make the relationship more linear or better suited for linear regression. Let's evaluate each option:
A) One-hot encoding
One-hot encoding is used to transform categorical variables into a set of binary (0 or 1) variables, representing the presence or absence of each category. Since the problem describes a numerical feature ("duration"), one-hot encoding would not be appropriate here. This technique is irrelevant for this case as it doesn’t address skewness or non-linearity.
B) Cartesian product transformation
Cartesian product transformation is typically used to combine two or more features by creating a new feature based on all possible pairwise combinations. This is often used when dealing with categorical variables. However, this approach does not address the issue of skewness and non-linearity in a numerical feature (like "duration") and would introduce unnecessary complexity without resolving the underlying data issues.
C) Quantile binning
Quantile binning is a technique where the continuous numerical variable is divided into bins based on quantiles (e.g., quartiles or percentiles). This could potentially help to reduce the skewness by grouping values into discrete categories based on their distribution. However, this transformation might discard useful continuous information by turning the numerical variable into categorical data. It might make the model less precise for certain tasks, especially when the actual value of...
Author: Matthew · Last updated Jul 26, 2026
A company's data engineer wants to use Amazon S3 to share datasets with data scientists. The data scientists work in three departments: Finance. Marketing, and Human Resources. Each department has its own IAM user group. Some datasets contain sensitive information and should be accessed on...
The goal here is to share datasets with data scientists from different departments, while ensuring that sensitive datasets are only accessible by the Fice department. The data engineer needs to structure the access control for the datasets in a way that aligns with these requirements. Let's review the options:
A) Create an S3 bucket for each dataset. Create an ACL for each S3 bucket. For each S3 bucket that contains a sensitive dataset, set the ACL to allow access only from the Fice department user group. Allow all three department user groups to access each S3 bucket that contains a non-sensitive dataset.
- Rejection Reasoning: Using Access Control Lists (ACLs) for access control is less flexible and scalable than using IAM policies or bucket policies. ACLs can be difficult to manage, especially with multiple datasets across different departments. It also doesn't scale well for multiple departments, and ACLs are generally considered an older method of controlling access in AWS. This solution requires manually configuring ACLs for each dataset, which can lead to a management overhead.
- Scenario Usefulness: This option is not recommended because of the complexity and limited scalability of using ACLs for managing permissions.
B) Create an S3 bucket for each dataset. For each S3 bucket that contains a sensitive dataset, set the bucket policy to allow access only from the Fice department user group. Allow all three department user groups to access each S3 bucket that contains a non-sensitive dataset.
- Selection Reasoning: This option uses bucket policies, which are more flexible and manageable than ACLs. Bucket policies are easier to apply, especially when different access controls are needed based on dataset sensitivity. By setting specific bucket policies, the data engineer can ensure that the Fice department user group has exclusive access to sensitive datasets, while all three departments can access non-sensitive datasets.
- Scenario Usefulness: This is a valid and effective option as it allows granular control using bucket policies, ensuring that sensitive datasets are protected and only accessible by the required department. However, managing multiple S3 buckets for each dataset may be cumbersome.
C) Create a single S3 bucket that includes two folders to separate the sensitive datasets from the non-sensitive datasets. For the Fice department user group, attach an IAM policy that provides access to both folders. For the Marketi...
Author: Scarlett · Last updated Jul 26, 2026
A company operates an amusement park. The company wants to collect, monitor, and store real-time traffic data at several park entrances by using strategically placed cameras. The company's security team must be able to immediately access the data for viewing. Stored data must be indexed and...
To meet the requirements of collecting, monitoring, storing, and accessing real-time traffic data from cameras at the amusement park entrances, let's break down the options and evaluate which would be most cost-effective and aligned with the company's needs.
Key Requirements:
1. Real-time traffic data collection via cameras.
2. Immediate viewing of the data by the security team.
3. Stored data needs to be indexed and accessible to the data science team for analysis.
4. Cost-effectiveness is emphasized.
Evaluation of Options:
A) Use Amazon Kinesis Video Streams to ingest, index, and store the data. Use the built-in integration with Amazon Rekognition for viewing by the security team.
- Amazon Kinesis Video Streams: Excellent for ingesting real-time video data from cameras. It provides a reliable mechanism for capturing, storing, and streaming video data.
- Amazon Rekognition: Offers advanced video analysis (e.g., object and activity detection) but may be overkill if the primary requirement is simple viewing rather than analysis. It's also relatively more expensive, especially if the primary task is just monitoring and not complex analysis.
- Cost Considerations: While Kinesis Video Streams is suitable for streaming and storing video data, integrating Rekognition could be costly for the real-time viewing use case, unless there is a clear need for video analysis.
Why rejected: The inclusion of Amazon Rekognition for just viewing the data adds unnecessary complexity and cost. Rekognition is more useful for advanced video analysis, not basic streaming or simple viewing.
B) Use Amazon Kinesis Video Streams to ingest, index, and store the data. Use the built-in HTTP live streaming (HLS) capability for viewing by the security team.
- Amazon Kinesis Video Streams: Suitable for real-time video streaming and storage.
- HLS Streaming: Built-in support for streaming video data over HTTP live streaming (HLS). HLS is a widely-used protocol that allows the security team to view the video data on a browser or through a video player in real-time.
- Cost Considerations: This approach avoids unnecessary analysis features (like Rekognition) and focuses on efficient real-time streaming and storage. The security team can view the video without incurring additional costs for advanced video analysis.
Why selected: This ...
Author: Vikram · Last updated Jul 26, 2026
An engraving company wants to automate its quality control process for plaques. The company performs the process before mailing each customized plaque to a customer. The company has created an Amazon S3 bucket that contains images of defects that should cause a plaque to be rejected. Low-confidence predictions must ...
To automate the quality control process for plaques based on image defect detection and send low-confidence predictions to an internal review team, let's evaluate the provided options in terms of their suitability for the task.
Key Requirements:
1. Automatic processing of images to detect defects.
2. Integration with Amazon A2I to handle low-confidence predictions and send them to a human reviewer.
3. The review process must involve an internal team (not external workers like those from Amazon Mechanical Turk, unless it's specified that they are involved in a private workforce context).
Option Analysis:
A) Use Amazon Textract for automatic processing. Use Amazon A2I with Amazon Mechanical Turk for manual review.
- Amazon Textract: This service is primarily designed for extracting text from images, such as scanned documents or forms. It would not be suitable for detecting visual defects in plaques, as it does not specialize in image analysis or defect detection.
- Amazon A2I with Amazon Mechanical Turk: While Amazon Mechanical Turk (MTurk) is suitable for outsourcing tasks to external workers, it doesn't fit the requirement that the review process should be performed by the company’s internal team. MTurk is typically used for crowd-sourced tasks, and this might not meet the internal team requirement.
Why rejected: Amazon Textract is not designed for visual defect detection in images, making it unsuitable for this scenario. Additionally, Mechanical Turk is an external workforce solution and may not fit the company’s internal team requirement.
B) Use Amazon Rekognition for automatic processing. Use Amazon A2I with a private workforce option for manual review.
- Amazon Rekognition: This service is highly suitable for image and video analysis, including defect detection in images, which aligns perfectly with the company's need to identify defects in plaques.
- Amazon A2I with private workforce: Amazon A2I integrates with machine learning models like Rekognition and allows for human review when confidence in the model’s prediction is low. The private workforce option allows the company to use its internal team for manual review, which meets the requirement for using internal resources.
Why selected: Amazon Rekognition is specifically designed for image analysis and d...
Author: Ava · Last updated Jul 26, 2026
A machine learning (ML) engineer at a bank is building a data ingestion solution to provide transaction features to financial ML models. Raw transactional data is available in an Amazon Kinesis data stream.
The solution must compute rolling averages of the ingested data from the data stream and must store the results in Amazon Sa...
The goal is to compute rolling averages on transaction data ingested from an Amazon Kinesis data stream, store the results in Amazon SageMaker Feature Store, and serve the results to models in near real-time. Let's evaluate each solution option to identify which will best meet these requirements:
Key Requirements:
1. Real-time data ingestion from Amazon Kinesis.
2. Rolling averages computation based on the ingested data.
3. Storing the results in Amazon SageMaker Feature Store.
4. The results must be available in near real-time for model consumption.
Option A: Load the data into an Amazon S3 bucket by using Amazon Kinesis Data Firehose. Use a SageMaker Processing job to aggregate the data and load the results into SageMaker Feature Store as an online feature group.
- Amazon Kinesis Data Firehose: This service is great for ingesting and buffering data into destinations like Amazon S3, but it's not directly optimized for real-time streaming processing like computing rolling averages.
- SageMaker Processing job: SageMaker Processing is useful for batch data processing, but it is typically used for batch processing jobs rather than real-time processing. Aggregating data in this manner would introduce latency, making the solution less suited for near real-time use.
- SageMaker Feature Store (online feature group): While this solution would store the results in SageMaker Feature Store, the latency introduced by the batch processing job wouldn't meet the requirement of real-time availability for the models.
Why rejected: This option introduces unnecessary latency with batch processing (via SageMaker Processing) and is not optimal for real-time use. The ingestion into S3 and the need for batch computation make this solution less suited for real-time feature serving.
Option B: Write the data directly from the data stream into SageMaker Feature Store as an online feature group. Calculate the rolling averages in place within SageMaker Feature Store by using the SageMaker GetRecord API operation.
- Direct ingestion into SageMaker Feature Store: While this allows you to store data directly in SageMaker Feature Store, SageMaker Feature Store is not designed to perform complex calculations like rolling averages directly within its structure.
- Rolling averages calculation using SageMaker GetRecord API: The GetRecord API is used to retrieve feature data from the Feature Store, but it is not designed for running computations or transformations on data. Complex calculations like rolling averages would need to be computed beforehand, outside of SageMaker Feature Store.
Why rejected: This option misses the necessary data processing step for calculating the rolling averages. SageMaker Feature Store does not support in-place computations like rolling averages, so this would not meet the real-time computation requirement.
...
Author: GlowingTiger · Last updated Jul 26, 2026
Each morning, a data scientist at a rental car company creates insights about the previous day's rental car reservation demands. The company needs to automate this process by streaming the data to Amazon S3 in near real time. The solution must detect high-demand rental cars at each of the company's locations. The solution also must create a visualiz...
Let's break down the options and select the best one based on the requirements:
Requirements:
- Stream data to Amazon S3 in near real-time.
- Detect high-demand rental cars at each location.
- Visualize the data in a dashboard that automatically refreshes with the most recent data.
- Leverage the least development time (important criterion).
A) Use Amazon Kinesis Data Firehose to stream the reservation data directly to Amazon S3. Detect high-demand outliers by using Amazon QuickSight ML Insights. Visualize the data in QuickSight.
- Pros:
- Amazon Kinesis Data Firehose provides a fully managed service to stream data to S3 with minimal setup and configuration. It’s designed for simple streaming of data without complex stream processing, which saves on development time.
- QuickSight ML Insights can automatically detect outliers in the data without requiring complex model development or training.
- Visualization is handled within QuickSight, which provides automated and interactive dashboards.
- Cons:
- Limited to QuickSight’s built-in capabilities for anomaly detection, which may not be as customizable or precise as a dedicated model.
- May not offer highly sophisticated anomaly detection for complex patterns in rental car demand, but sufficient for general use cases.
B) Use Amazon Kinesis Data Streams to stream the reservation data directly to Amazon S3. Detect high-demand outliers by using the Random Cut Forest (RCF) trained model in Amazon SageMaker. Visualize the data in Amazon QuickSight.
- Pros:
- Kinesis Data Streams provides real-time data streaming but requires additional configuration for processing and managing streams.
- Random Cut Forest (RCF), a machine learning model in SageMaker, is specifically designed for anomaly detection, offering highly customizable and accurate results.
- Visualization in QuickSight is fully integrated and allows for near real-time updates.
- Cons:
- Additional development time is needed for setting up the Kinesis Data Streams, as well as for training and deploying the RCF model in SageMaker. This significantly increases the complexity compared to using Firehose.
- Development overhead for the model’s training and management, especially when compared to the fully managed QuickSight ML Insights.
C) Use Amazon Kinesis Data Firehose to stream the reservation data directly to Amazon S3. Detect high-demand outli...
Author: Ryan · Last updated Jul 26, 2026
A machine learning (ML) engineer is integrating a production model with a customer metadata repository for real-time inference. The repository is hosted in Amazon SageMaker Feature Store. The engineer wants to retrieve only the latest version of th...
To determine the best solution for the machine learning engineer's requirement, let's evaluate each of the options based on the goal of retrieving only the latest version of the customer metadata record for real-time inference:
A) Use the SageMaker Feature Store BatchGetRecord API with the record identifier. Filter to find the latest record.
- Reasoning:
- The `BatchGetRecord` API allows you to retrieve multiple records at once, which is not ideal if you are looking for a real-time inference of a single customer record. The batch operation requires a list of record identifiers, and you would need to filter the response to get the latest version.
- This approach is less efficient because the batch API is typically intended for retrieving multiple records at once, which isn't aligned with the requirement for single-customer inference in real time.
- Rejection Reason: This solution isn't optimal for retrieving a single, real-time customer record.
B) Create an Amazon Athena query to retrieve the data from the feature table.
- Reasoning:
- Athena allows you to run SQL queries against data stored in Amazon S3, but querying the data in a Feature Store requires more specific access methods designed for real-time inference, such as the SageMaker Feature Store APIs.
- Athena can be used for batch processing and analytics, but it may not be the best choice for real-time inference.
- Rejection Reason: Athena is more suitable for large-scale data analysis or batch queries, not for real-time, single-record access.
C) Crea...
Author: Harper · Last updated Jul 26, 2026
A company's data scientist has trained a new machine learning model that performs better on test data than the company's existing model performs in the production environment. The data scientist wants to replace the existing model that runs on an Amazon SageMaker endpoint in the production environment. However, the company is concerned that the new model might not work well on the production environment data.
The data scientist needs to perform A/B testing in the ...
To perform A/B testing in the production environment for evaluating the new machine learning model, the data scientist should consider the following steps:
A) Create a new endpoint configuration that includes a production variant for each of the two models.
- Reasoning:
- In Amazon SageMaker, you can create a new endpoint configuration that includes multiple production variants, each pointing to a different model. By setting up two variants (one for the existing model and one for the new model), SageMaker can serve both models from the same endpoint, allowing for A/B testing. You can control the traffic distribution between these models to evaluate their performance on the production environment data.
- This option is well-suited for A/B testing as it allows easy comparison between models in the production environment.
- Selection Reason: This is a correct step for A/B testing, allowing the data scientist to test both models concurrently under real production conditions.
B) Create a new endpoint configuration that includes two target variants that point to different endpoints.
- Reasoning:
- This approach involves creating an endpoint configuration that points to separate endpoints for each model, rather than within the same endpoint. This is not ideal for A/B testing because it involves multiple endpoints, which would make it harder to control the traffic distribution and evaluate the models against each other simultaneously in the same environment.
- Rejection Reason: This is not an ideal approach for A/B testing as it complicates traffic distribution and does not allow testing both models under the same endpoint.
C) Deploy the new model to the existing endpoint.
- Reasoning:
- Deploying the new model directly to the existin...
Author: RadiantPhoenixX · Last updated Jul 26, 2026
A data scientist is working on a forecast problem by using a dataset that consists of .csv files that are stored in Amazon S3. The files contain a timestamp variable in the following format:
March 1st, 2020, 08:14pm -
There is a hypothesis about seasonal differences in the dependent variable. This number could be higher or lower for weekdays because some days and hours present varying values, so the day of the week, month, or hour could be an important factor. As a result, the data scientist nee...
Let's evaluate each of the options based on the goal of transforming the timestamp variable into weekdays, month, and day as separate variables with the least operational overhead:
A) Create an Amazon EMR cluster. Develop PySpark code that can read the timestamp variable as a string, transform and create the new variables, and save the dataset as a new file in Amazon S3.
- Reasoning:
- Amazon EMR provides a managed cluster environment to run big data frameworks like Apache Spark, and you would need to develop PySpark code for reading, transforming, and saving the dataset. While it’s a powerful tool for large-scale data processing, it requires managing clusters, configuring the environment, and potentially dealing with scaling and resource management.
- This approach involves setting up and managing infrastructure, which leads to more operational overhead compared to other options that abstract infrastructure management.
- Rejection Reason: This approach introduces significant operational overhead due to the need for managing clusters and configurations, especially if the data volume is small or the task doesn't require distributed computing.
B) Create a processing job in Amazon SageMaker. Develop Python code that can read the timestamp variable as a string, transform and create the new variables, and save the dataset as a new file in Amazon S3.
- Reasoning:
- While SageMaker provides an environment for data processing and model training, it requires setting up a processing job, configuring the environment, and potentially writing custom Python code. This option gives flexibility but involves more manual work in terms of environment setup, code writing, and job management compared to other more specialized tools.
- Rejection Reason: It requires more manual setup and coding compared to other options like Amazon SageMaker Data Wrangler, which is designed for easier data transformations with minimal coding.
C) Create a new flow in Amazon SageMaker Data Wrangler. Import the S3 file, use the Featurize date/time transform to generate the new variables, and save the dataset as a new file in Amazon S3.
- Reasoning:
- Amazon SageMaker Data Wrang...
Author: RadiantJaguar56 · Last updated Jul 26, 2026
A manufacturing company has a production line with sensors that collect hundreds of quality metrics. The company has stored sensor data and manual inspection results in a data lake for several months. To automate quality control, the machine learning team must build an automated mechanism that determines whether the produced goods are good quality, replacement mar...
To determine the most accurate approach for predicting product quality in the manufacturing scenario, let's evaluate each of the options:
A) Amazon SageMaker DeepAR forecasting algorithm
- Reasoning:
- DeepAR is designed for time series forecasting and is effective for predicting future values in time series data. It is particularly useful when you have sequential or temporal data and want to forecast numerical values over time.
- In this case, predicting product quality (good quality, replacement market quality, or scrap quality) is a classification problem, not a time series forecasting problem. The task requires classification based on sensor data and manual inspection results, which isn't directly related to forecasting future values.
- Rejection Reason: This is not the right choice because DeepAR is designed for time series forecasting, not classification tasks like the one in this scenario.
B) Amazon SageMaker XGBoost algorithm
- Reasoning:
- XGBoost is an ensemble learning method based on decision trees and is highly effective for classification and regression problems. It is known for being accurate, efficient, and scalable, especially for tabular datasets with structured features (such as sensor data and manual inspection results).
- In this case, the task is to classify the quality of the produced goods based on various sensor data and inspection results. XGBoost is well-suited for this kind of problem, as it can handle both numerical and categorical features and provides high accuracy with relatively low tuning effort.
- Selection Reason: This is the most appropriate choice for a classification problem with structured data. XGBoost has been proven to be highly effective in similar industrial use cases, where classification b...
Author: Vikram · Last updated Jul 26, 2026
A healthcare company wants to create a machine learning (ML) model to predict patient outcomes. A data science team developed an ML model by using a custom ML library. The company wants to use Amazon SageMaker to train this model. The data science team creates a custom SageMaker image to train the model. When the team tries to launch the custom image in SageM...
To determine which service can be used to access the logs for the error that occurs when launching the custom SageMaker image in SageMaker Studio, let's analyze each of the options:
A) Amazon S3
- Reasoning:
- Amazon S3 is a storage service and is often used for storing data, models, and other assets in a variety of formats. While logs can be stored in S3, it is not the service directly responsible for monitoring or accessing logs related to SageMaker.
- S3 does not provide any built-in capability to access or manage logs for application errors or service operations.
- Rejection Reason: S3 is used for storage but does not provide functionality for tracking or accessing logs related to SageMaker applications.
B) Amazon Elastic Block Store (Amazon EBS)
- Reasoning:
- Amazon EBS is a block storage service that provides persistent storage for EC2 instances. It is typically used for attaching storage volumes to EC2 instances but is not focused on log management or monitoring.
- EBS doesn't provide a centralized log repository or monitoring for SageMaker or other AWS services.
- Rejection Reason: EBS is focused on storage, not on log management or error tracking.
C) AWS CloudTrail
- Reasoning:
- AWS CloudTrail is a service that tracks API calls and provides an audit trail for user activities across AWS services. It helps monitor and log activities such as who initiated an action and when it occurred.
- While CloudTrail is valuable for auditing API requests and...
Author: Ishaan · Last updated Jul 26, 2026
A data scientist wants to build a financial trading bot to automate investment decisions. The financial bot should recommend the quantity and price of an asset to buy or sell to maximize long-term profit. The data scientist will continuously stream financial transactions to the bot for training purposes. The data scientist must select ...
To design an effective financial trading bot that can automate investment decisions and maximize long-term profit, we need to select the appropriate machine learning (ML) algorithm. Let's analyze the options based on key factors like decision-making, training data, and how the bot will learn and adjust over time.
A) Supervised Learning
- Scenario: In supervised learning, the algorithm is trained using labeled data (input-output pairs). The bot would learn from historical data (e.g., past transactions and their outcomes) to predict the next action (buy/sell) based on known inputs (price, volume, etc.).
- Limitation: While supervised learning can predict outcomes based on historical data, it doesn't adapt dynamically to the environment. In financial markets, conditions change frequently, and the bot needs to learn continuously and improve over time, which makes supervised learning less ideal for real-time decision-making in trading scenarios.
B) Unsupervised Learning
- Scenario: Unsupervised learning is used when the training data does not include explicit labels, and the algorithm must find patterns or groupings in the data. In trading, this could be used for tasks like clustering assets or identifying hidden structures in market data.
- Limitation: The lack of labeled data makes it unsuitable for the task of making specific buy/sell decisions based on precise objectives like maximizing profit. Trading decisions require actionable predictions (e.g., buy at a specific ...
Author: Zara · Last updated Jul 26, 2026
A manufacturing company wants to create a machine learning (ML) model to predict when equipment is likely to fail. A data science team already constructed a deep learning model by using TensorFlow and a custom Python script in a local environment. The company wants to use Amaz...
To determine the most cost-effective option for training the deep learning model using Amazon SageMaker, let's break down each option and analyze which will provide the best performance-cost balance.
A) Turn on SageMaker Training Compiler by adding compiler_config=3DTrainingCompilerConfig() as a parameter. Pass the script to the estimator in the call to the TensorFlow fit() method.
- Explanation: The SageMaker Training Compiler optimizes the model's performance by compiling the TensorFlow code, which could lead to faster training. However, this option does not take advantage of cost-saving measures such as managed spot instances.
- Limitation: While the Training Compiler improves performance, it does not reduce costs, as it does not utilize spot instances or other cost-saving strategies. It focuses only on optimizing training time.
B) Turn on SageMaker Training Compiler by adding compiler_config=3DTrainingCompilerConfig() as a parameter. Turn on managed spot training by setting the use_spot_instances parameter to True. Pass the script to the estimator in the call to the TensorFlow fit() method.
- Explanation: This option combines the use of SageMaker's Training Compiler with managed spot instances. Spot instances are a significant cost-saving measure in Amazon SageMaker, as they allow you to take advantage of unused EC2 capacity at a lower price. By optimizing performance through the compiler and reducing costs using spot instances, this configuration is a strong candidate for cost-effective training.
- Strength: The use of managed spot instances is key for cost optimization while the Training Compiler enhances the training process. Spot instances can offer substantial savings, making this option highly cost-effective without sacrificing performance.
- Best Fit: This is the most cost-effective option because it combines performance optimization with cost-saving...
Author: Chloe · Last updated Jul 26, 2026
An automotive company uses computer vision in its autonomous cars. The company trained its object detection models successfully by using transfer learning from a convolutional neural network (CNN). The company trained the models by using PyTorch through the Amazon SageMaker SDK.
The vehicles have limited hardware and compute power. The company wants to optimize the model to red...
To optimize the model for limited hardware and compute power while maintaining accuracy, the goal is to reduce the model's memory and computational requirements. Let's examine each option and its suitability for achieving this goal.
A) Use Amazon CloudWatch metrics to gain visibility into the SageMaker training weights, gradients, biases, and activation outputs. Compute the filter ranks based on the training information. Apply pruning to remove the low-ranking filters. Set new weights based on the pruned set of filters. Run a new training job with the pruned model.
- Explanation: CloudWatch provides metrics related to the training job's performance, but it does not directly help with optimizing the model or reducing memory and computation. Although pruning can reduce the size of the model by removing less important weights (filters), CloudWatch is not the tool designed to help in this scenario.
- Limitation: This solution doesn’t leverage any model-specific optimization technique directly. CloudWatch metrics are useful for monitoring, but pruning requires additional steps that aren't provided by CloudWatch.
B) Use Amazon SageMaker Ground Truth to build and run data labeling workflows. Collect a larger labeled dataset with the labeling workflows. Run a new training job that uses the new labeled data with previous training data.
- Explanation: SageMaker Ground Truth is useful for labeling datasets, but adding more data does not necessarily optimize the model for efficiency. In fact, a larger dataset may increase computational load and memory usage, which is contrary to the goal of reducing resource consumption.
- Limitation: While adding more labeled data could improve model accuracy, it does not address the problem of optimizing the model for hardware with limited resources, such as memory and battery.
C) Use Amazon SageMaker Debugger to gain visibility into the training weights, gradients, biases, and activation outputs. Compute the filter ranks based on the training information. Apply pruning ...
Author: Victoria · Last updated Jul 26, 2026
A data scientist wants to improve the fit of a machine learning (ML) model that predicts house prices. The data scientist makes a first attempt to fit the model, but the fitted model has poor accuracy on both the training dataset and th...
In order to improve the accuracy of a machine learning model that predicts house prices and has poor performance on both the training and test datasets, let's review the options and determine the most appropriate actions the data scientist should take:
A) Increase the amount of regularization that the model uses.
- Explanation: Regularization techniques (such as L2 regularization) are used to prevent overfitting by penalizing large model coefficients. However, if the model is already underfitting (which seems likely given the poor accuracy on both training and test datasets), increasing regularization will make it even harder for the model to fit the data properly. This would likely worsen the performance.
- Limitation: Increasing regularization when the model is underfitting would typically make the model more constrained, which is not the correct approach when accuracy is low. This option is rejected.
B) Decrease the amount of regularization that the model uses.
- Explanation: If the model is underfitting, decreasing regularization allows the model to better fit the data by reducing the penalty on large coefficients. This can allow the model to learn more complex patterns, potentially improving accuracy on both the training and test datasets.
- Strength: Decreasing regularization is useful when a model is too simple and cannot capture the underlying patterns in the data (underfitting). This is a good approach to try when the model has poor accuracy.
- Best Fit: This is a viable option to improve model accuracy, especially if the model is underfitting.
C) Increase the number of training examples that the model uses.
- Explanation: Increasing the number of training examples can help improve the model's ability to generalize by exposing it to more diverse examples. If the model is underfitting, adding more data can provide additional insights and help the model capture better patterns in the data.
- Strength: More training data can lead to better model performance, particularly when there are insufficient examples for the model to learn from. This is an effective strategy for improving accuracy.
- Best Fit: This is a solid approach, especially if the model has insufficient data to train on.
...
Author: Sophia · Last updated Jul 26, 2026
A car company is developing a machine learning solution to detect whether a car is present in an image. The image dataset consists of one million images. Each image in the dataset is 200 pixels in height by 200 pixels in width. Each image is labeled as either having a car or not having a car.
W...
To determine which architecture is most likely to produce a model that detects whether a car is present in an image with the highest accuracy, we need to carefully consider the characteristics of the problem and the available architectures.
Key Factors to Consider:
- Image Data: The data consists of images, which are well-suited for convolutional neural networks (CNNs) due to their ability to automatically learn spatial hierarchies in images (i.e., detecting edges, shapes, and objects). CNNs excel at image classification tasks.
- Output Layer: The output of the model needs to be a probability that the image contains a car. For binary classification (car or not car), the appropriate output layer should produce a probability that sums to 1 and is suitable for binary classification.
Now, let's evaluate each option:
A) Use a deep convolutional neural network (CNN) classifier with the images as input. Include a linear output layer that outputs the probability that an image contains a car.
- Selection Reasoning: Using a CNN for image classification is the right approach, as CNNs are specifically designed to extract features from images, which significantly improves the accuracy of image-based models. However, a linear output layer is not the ideal choice for binary classification. A linear output layer would give a continuous value, but for binary classification, we need a function that squashes the output between 0 and 1. This is typically achieved using sigmoid activation. Hence, while the CNN is the correct architecture, the linear output layer is not optimal for this task.
- Scenario Usefulness: This approach is close but still lacks the correct activation function for binary classification.
B) Use a deep convolutional neural network (CNN) classifier with the images as input. Include a softmax output layer that outputs the probability that an image contains a car.
- Selection Reasoning: A CNN is the right architecture for image classification. However, softmax is typically used for multi-class classification (i.e., when there are more than two classes). In this case, since the task is binary classification (car vs. no car), sigmoid activation is a better choice, not softmax....
Author: Aria · Last updated Jul 26, 2026
A company is creating an application to identify, count, and classify animal images that are uploaded to the company's website. The company is using the Amazon SageMaker image classification algorithm with an ImageNetV2 convolutional neural network (CNN). The solution works well for most animal images but does not recognize many animal species that are less common.
The company obtains 10,000 labeled images of less common animal species and stores the images in Amazon S3....
To address the scenario where the company is trying to improve their model's recognition of less common animal species, the key focus is on utilizing the 10,000 labeled images of these less common species and training the model effectively with the Amazon SageMaker image classification algorithm.
Option Analysis:
- A) Use a ResNet model. Initiate full training mode by initializing the network with random weights.
- Rejected: The ResNet model can indeed work well for image classification tasks, but this approach involves full training mode with random weights, which isn't ideal for leveraging the existing knowledge in the ImageNetV2 model. Full training from random weights would require a much larger dataset and extensive computational resources, which isn't necessary given that the company already has a pre-trained model. This step doesn’t align well with the goal of incorporating the less common species data efficiently.
- B) Use an Inception model that is available with the SageMaker image classification algorithm.
- Rejected: The company is already using the SageMaker image classification algorithm with ImageNetV2 CNN, which means the model architecture is already established and works well for most animal images. Switching to a different model (like Inception) might be a valid approach but is unnecessary for the current problem. The goal is to fine-tune the existing model, not to change the architecture entirely. Additionally, switching models could require retraining the entire model on a larger dataset.
- C) Create a .lst file that contains a list of image files and corresponding class labels. Upload the .lst file to Amazon S3.
- Selected: This step is essential when working with the Pipe mode in Amazon SageMaker, as...
Author: MoonlitPantherX · Last updated Jul 26, 2026
A music streaming company is building a pipeline to extract features. The company wants to store the features for offline model training and online inference. The company wants to track feature history and to give the company's data science teams a...
To address the music streaming company's requirements, the solution must be efficient, scalable, and provide the ability to store features for both offline model training and online inference. Additionally, it should allow the company to track feature history and provide easy access to data science teams.
Option Analysis:
- A) Use Amazon SageMaker Feature Store to store features for model training and inference. Create an online store for online inference. Create an offline store for model training. Create an IAM role for data scientists to access and search through feature groups.
- Selected: This is the most efficient and purpose-built solution. Amazon SageMaker Feature Store is designed to manage and store features for machine learning, offering both online and offline storage capabilities. The online store can be used for low-latency inference, while the offline store is ideal for large-scale model training. SageMaker Feature Store also provides automatic tracking of feature history, making it easier for data science teams to access and query features. The ability to create an IAM role for access control ensures that the data science team can securely interact with the feature groups, meeting all the operational and security requirements.
- B) Use Amazon SageMaker Feature Store to store features for model training and inference. Create an online store for both online inference and model training. Create an IAM role for data scientists to access and search through feature groups.
- Rejected: This approach would use a single online store for both inference and model training. While SageMaker Feature Store can handle both use cases, mixing online inference with model training features is not optimal. Model training requires accessing large datasets, which may not be ideal for an online store designed for fast, low-latency access. Having separate stores for online and offline use ensures better optimization for both types of workloads, improving scalability and performance.
- C) Create one Amazon S3 bucket to store online inference features. Create a second S3 bucket to store offline model training features. Turn on versioning for the S3 buckets and use tags to specify which tags are for online inference features and which are for offline model training fea...
Author: Zara1234 · Last updated Jul 26, 2026
A beauty supply store wants to understand some characteristics of visitors to the store. The store has security video recordings from the past several years. The store wants to generate a report of hourly visitors from the recordings. The report should group visi...
Option Analysis:
- A) Use an object detection algorithm to identify a visitor's hair in video frames. Pass the identified hair to a ResNet-50 algorithm to determine hair style and hair color.
- Selected: This is a highly effective solution with minimal effort. Object detection algorithms are designed to identify and localize objects (in this case, hair) in an image or video frame. Once the hair is identified, using a ResNet-50 algorithm (a deep convolutional neural network pre-trained on image data) can be a good fit for recognizing complex attributes like hairstyle and hair color. ResNet-50 has shown excellent performance for image classification tasks, so it's well-suited to distinguishing various hair types and colors. This approach leverages existing powerful models (object detection and ResNet-50) for efficient classification, making it the most straightforward option.
- B) Use an object detection algorithm to identify a visitor's hair in video frames. Pass the identified hair to an XGBoost algorithm to determine hair style and hair color.
- Rejected: While object detection is appropriate for identifying hair in video frames, XGBoost, a decision tree-based model, is not ideal for processing image data, especially when it comes to complex image features like hairstyles and hair color. XGBoost requires structured input, and transforming image data to a form suitable for XGBoost would add unnecessary complexity and likely reduce accuracy. For image classification tasks, deep learning models like ResNet-50 are better suited than tree-based models like XGBoost.
- C) Use a semantic segmentation algorithm to identify a visitor's hair in video frames. Pass the identified hair to a ResNet-50 algorithm to determine h...
Author: Daniel · Last updated Jul 26, 2026
A financial services company wants to automate its loan approval process by building a machine learning (ML) model. Each loan data point contains credit history from a third-party data source and demographic information about the customer. Each loan approval prediction must come with a report that contains an explanation for why the customer was approved for a loan or wa...
Option Analysis:
- A) Use SageMaker Model Debugger to automatically debug the predictions, generate the explanation, and attach the explanation report.
- Rejected: While SageMaker Model Debugger is an excellent tool for debugging machine learning models, it is primarily designed for identifying issues during training, like data quality or model performance problems, and not for generating explanation reports for predictions. It does not provide the functionality needed to generate and attach detailed explanations about why a loan was approved or denied based on the model’s predictions.
- B) Use AWS Lambda to provide feature importance and partial dependence plots. Use the plots to generate and attach the explanation report.
- Rejected: Using AWS Lambda to generate feature importance and partial dependence plots adds unnecessary complexity to the process. While Lambda can be used for various tasks, it requires additional effort to manage and compute the feature importance or generate partial dependence plots manually. It does not inherently provide a model explanation and requires extra steps for integration, making it a more cumbersome solution than needed.
- C) Use SageMaker Clarify to generate the explanation report. Attach the report to the predicted results.
- Selected: SageMaker Clarify is specifically designed to provide model explainability and fairness analysis. It automatically generates explanation reports for model predictions, including feature importance, bia...
Author: Harper · Last updated Jul 26, 2026
A financial company sends special offers to customers through weekly email campaigns. A bulk email marketing system takes the list of email addresses as an input and sends the marketing campaign messages in batches. Few customers use the offers from the campaign messages. The company does not want to send irrelevant offers to customers.
A machine learning (ML) team at the company is using Amazon SageMaker to build a model to recommend specific off...
In this scenario, the goal is to generate personalized offers for customers based on their profiles and past engagement, and feed these recommendations into the bulk email marketing system with operational efficiency. To assess the best solution, let's break down the options considering the following key factors:
Key Considerations:
1. Personalization: The model must be able to recommend specific offers to customers based on historical data, which implies a need for personalized recommendation algorithms.
2. Operational Efficiency: The solution should minimize the overhead of continuous or frequent predictions, especially when dealing with bulk email campaigns. For operational efficiency, we need to avoid high-latency real-time predictions or continuous endpoint calls.
3. Batch vs. Real-Time: Since the bulk email marketing system handles a list of customers at once, it is more efficient to generate recommendations in batch rather than in real-time.
Option Breakdown:
A) Use the Factorization Machines algorithm to build a model that can generate personalized offer recommendations for customers. Deploy a SageMaker endpoint to generate offer recommendations. Feed the offer recommendations into the bulk email marketing system.
- Rejection Reasoning: Although Factorization Machines are a good choice for recommendation tasks, deploying a SageMaker endpoint for real-time inference adds unnecessary complexity and overhead. Real-time inference is not needed for a bulk email campaign because the recommendations can be generated in batch and fed to the email system all at once. Using an endpoint for real-time predictions may lead to higher costs and operational inefficiency in this case.
- Scenario Usefulness: This option is more suitable if the system needed real-time recommendations per customer interaction, but for bulk emails, batch inference is more efficient.
B) Use the Neural Collaborative Filtering algorithm to build a model that can generate personalized offer recommendations for customers. Deploy a SageMaker endpoint to generate offer recommendations. Feed the offer recommendations into the bulk email marketing system.
- Rejection Reasoning: Neural Collaborative Filtering (NCF) is indeed a powerful method for generating personalized recommendations. However, similar to Option A, deploying a SageMaker endpoint for real-time predictions is inefficient for a batch-oriented task like bulk...
Author: StarryEagle42 · Last updated Jul 26, 2026
A social media company wants to develop a machine learning (ML) model to detect inappropriate or offensive content in images. The company has collected a large dataset of labeled images and plans to use the built-in Amazon SageMaker image classification algorithm to train the model. The company also intends to use SageMaker pipe mode to speed up the training.
The company splits the dataset into training, validation, and testing datasets. The company stores the training and validation images in folders that are named Training and Validation, respectively. The folders contain subfolders that correspond to the names of the dataset classes. The company resizes the images to the same size and generates two input manifest files named training....
When preparing data for Amazon SageMaker image classification, especially when using SageMaker Pipe Mode for faster training, the company must ensure that the data is in an efficient and compatible format. Let’s evaluate each option and select the most suitable one.
Option A: Generate two Apache Parquet files, training.parquet and validation.parquet, by reading the images into a Pandas data frame and storing the data frame as a Parquet file. Upload the Parquet files to the training S3 bucket.
- Explanation: Apache Parquet is a columnar data format typically used for structured data. However, images are unstructured data, and using Parquet files to store images is not ideal. Converting image data into a Pandas DataFrame and then storing it in Parquet files would increase unnecessary complexity and is not efficient for training image classification models. Additionally, Parquet is not natively optimized for SageMaker image classification.
- Rejected because: It is not the most efficient way to handle image data in SageMaker, and it requires unnecessary conversions.
- When it could be useful: In cases where you have structured tabular data and need efficient storage and retrieval for large datasets.
Option B: Compress the training and validation directories by using the Snappy compression library. Upload the manifest and compressed files to the training S3 bucket.
- Explanation: Snappy is a compression algorithm commonly used for compressing data in big data frameworks like Hadoop. While it offers fast compression and decompression speeds, it is not a standard compression method for images in machine learning workflows. Additionally, SageMaker does not natively support Snappy compression for image datasets.
- Rejected because: The Snappy compression format is not suitable for image data and is not typically used with SageMaker's built-in image classification algorithms.
- When it could be useful: For data systems that specifically require Snappy-compressed files for big data frameworks but not for image datasets in SageMaker.
Option C: Compress the training and va...
Author: Abigail · Last updated Jul 26, 2026
A media company wants to create a solution that identifies celebrities in pictures that users upload. The company also wants to identify the IP address and the timestamp details from the users so the company can prevent users from uploading pictures...
To meet the requirements of identifying celebrities in pictures and capturing the IP address and timestamp with the least development effort, let's evaluate each option:
Option A: Use AWS Panorama to identify celebrities in the pictures. Use AWS CloudTrail to capture IP address and timestamp details.
- Explanation: AWS Panorama is a service designed for bringing computer vision to on-premises devices to perform tasks like object detection. While it can perform real-time analysis, it requires more setup and custom development, particularly around connecting it to your specific use case of identifying celebrities. AWS CloudTrail, on the other hand, records API calls and activities related to AWS services but doesn't directly capture IP address and timestamp details from user uploads.
- Rejected because: This solution introduces unnecessary complexity. AWS Panorama isn't the best fit for analyzing images from user uploads, as it's intended for edge devices with limited internet connectivity.
- When it could be useful: If the company were processing images from devices on-premises with minimal internet connectivity.
Option B: Use AWS Panorama to identify celebrities in the pictures. Make calls to the AWS Panorama Device SDK to capture IP address and timestamp details.
- Explanation: Again, AWS Panorama is not ideal for processing user-uploaded images directly. The AWS Panorama Device SDK allows developers to build applications on edge devices, but using it for capturing IP addresses and timestamps would add unnecessary complexity and increase development effort.
- Rejected because: Similar to Option A, it requires custom development for a use case that's not a natural fit for AWS Panorama.
- When it could be useful: When you want to perform real-time processing on images from devices located in remote or offline environments, but not for handling uploads from online users.
Option C: Use Amazon Rekognition to identify celebrities in the pictures. Use AWS CloudTrail to capture IP address and timestamp details.
-...
Author: Olivia Johnson · Last updated Jul 26, 2026
A pharmaceutical company performs periodic audits of clinical trial sites to quickly resolve critical findings. The company stores audit documents in text format. Auditors have requested help from a data science team to quickly analyze the documents. The auditors need to discover the 10 main topics within the documents to prioritize and distribute the review work among the auditing team members. Documents that describe adverse events must receive the highest priority.
A data scientist will use statistic...
In this scenario, the goal is to analyze a collection of clinical trial audit documents to identify topics that will help prioritize the review work, particularly highlighting adverse events. The company needs to extract abstract topics from the documents, and the data scientist will use statistical modeling to discover these topics and list relevant words for each topic.
Let’s evaluate the options and determine the most suitable algorithms for this task:
Option A: Latent Dirichlet Allocation (LDA)
- Explanation: LDA is a generative probabilistic model commonly used for topic modeling. It is particularly well-suited for discovering latent (hidden) topics in a collection of documents. LDA assumes that documents are mixtures of topics, and topics are mixtures of words. LDA would identify the 10 main topics in the documents by analyzing the word distributions across them, which is exactly what the auditors need.
- Selected because: LDA is widely used in natural language processing (NLP) tasks, specifically for topic modeling. It fits the requirement of discovering abstract topics and associating them with the relevant words, which will help the auditors understand and prioritize the documents. The model works well with text data and can easily provide interpretable results with the top words for each topic.
- When it could be useful: LDA is ideal for text-based tasks that involve discovering hidden topics in a corpus of documents.
Option B: Random Forest Classifier
- Explanation: Random Forest is an ensemble learning method used for classification and regression tasks. While it can be used to classify documents, it is not ideal for discovering abstract topics or the top words associated with topics. It requires labeled data (supervised learning) and is generally used for tasks like classification or regression rather than unsupervised topic modeling.
- Rejected because: Random Forest is not a topic modeling technique. It does not discover topics in an unsupervised way and would not help in identifying the 10 main topics within the documents. It also doesn’t provide the top words for each category in a way that the auditors need.
- When it could be useful: Random Forest would be useful if the company had labeled data for supervised classification (e.g., classifying documents as "adverse event" or "not adverse event").
Option C: Neural Topic Modeling (NTM)
- Explanation: Neural Topic Modeling (NTM) is a deep learning-based approach for topic modeling. NTM can potentially outperform traditional methods like LDA, as it uses neural networks to discover complex patterns in the data. It also provides a way to extract topics and associated words, much like LDA, but with a more flexible and data-driv...
Author: FrostFalcon88 · Last updated Jul 26, 2026
A company needs to deploy a chatbot to answer common questions from customers. The chatbot must base its answers on company documentation.
Which soluti...
Let's analyze each of the options in terms of the least development effort for deploying a chatbot that answers customer questions based on company documentation.
Option A: Index company documents by using Amazon Kendra. Integrate the chatbot with Amazon Kendra by using the Amazon Kendra Query API operation to answer customer questions.
- Explanation: Amazon Kendra is a fully managed, AI-powered search service specifically designed to index and search unstructured data, such as documents. Kendra can understand natural language queries, making it a great fit for answering customer questions based on company documentation. It also supports integrating with chatbots via its Query API, allowing users to easily get answers from indexed documents.
- Selected because: Amazon Kendra is specifically designed for document search and question answering with minimal setup. This solution leverages a managed service that handles document indexing, search, and natural language queries, significantly reducing development effort. The API integration with the chatbot is straightforward, making it the most efficient and least effort-intensive solution for this use case.
- When it could be useful: Amazon Kendra is ideal when you need a quick, scalable, and accurate solution for searching company documentation based on customer queries without needing to build and train custom models.
Option B: Train a Bidirectional Attention Flow (BiDAF) network based on past customer questions and company documents. Deploy the model as a real-time Amazon SageMaker endpoint. Integrate the model with the chatbot by using the SageMaker Runtime InvokeEndpoint API operation to answer customer questions.
- Explanation: BiDAF is a deep learning-based approach for question answering tasks that requires a custom-trained model. Training a BiDAF model involves significant time and expertise, especially for tasks like fine-tuning it on company-specific documentation. After training, it must be deployed on Amazon SageMaker, and the chatbot would need to interact with the model via the SageMaker API.
- Rejected because: Although BiDAF is a powerful technique for question answering, it requires a lot of custom development, including data preparation, model training, and deployment. This would result in a much higher development effort compared to using a pre-built service like Amazon Kendra.
- When it could be useful: This approach might be suitable for more advanced use cases where highly specific or complex question-answering models are required, but it’s overkill for simple, document-based querying.
Option C: Train an Amazon SageMaker BlazingText model based on past c...
Author: Henry · Last updated Jul 26, 2026
A company wants to conduct targeted marketing to sell solar panels to homeowners. The company wants to use machine learning (ML) technologies to identify which houses already have solar panels. The company has collected 8,000 satellite images as training data and will use Amazon SageMaker Ground Truth to label the data.
The company has a small internal team that is working on the pro...
Key Considerations:
- Internal Team Expertise: The internal team has no machine learning (ML) expertise, so the solution should minimize the amount of effort needed for ML model training and inference.
- Data Labeling: The company has collected 8,000 satellite images and will use Amazon SageMaker Ground Truth for labeling the data. The effort needed for labeling should be minimized.
- Model Training: The solution should use an effective model for detecting solar panels on houses in satellite images. The team needs a simple, low-effort process to train and deploy the model.
Option Breakdown:
A) Set up a private workforce that consists of the internal team. Use the private workforce and the SageMaker Ground Truth active learning feature to label the data. Use Amazon Rekognition Custom Labels for model training and hosting.
- Rejection Reasoning: While Amazon Rekognition Custom Labels is a powerful service for labeling and training models, it may require more involvement from the team in terms of customization and setup, particularly for a specialized task like identifying solar panels. Rekognition Custom Labels might not be optimized for this specific object detection task (solar panels in satellite images). Additionally, relying on the internal team for labeling without ML experience increases the effort, and Rekognition's automated labeling capabilities might not handle this specific problem as well as other more specialized object detection algorithms.
- Scenario Usefulness: This is not the best choice because Rekognition Custom Labels may require more involvement and may not be the most efficient for this problem.
B) Set up a private workforce that consists of the internal team. Use the private workforce to label the data. Use Amazon Rekognition Custom Labels for model training and hosting.
- Rejection Reasoning: This option has the same issues as Option A regarding Rekognition Custom Labels, but it lacks the active learning feature of SageMaker Ground Truth. Active learning would help reduce the amount of manual labeling required by prioritizing uncertain images for labeling, which can significantly improve efficiency, especially with a small internal team. Without active learning, this approach could be more labor-intensive.
- Scenario Usefulness: While Rekognition Custom Labels could work for basic object detection, this option is less efficient compared to using active learning to minimize the amount of labeling effort required from the team...
Author: CrystalWolfX · Last updated Jul 26, 2026
A company hosts a machine learning (ML) dataset repository on Amazon S3. A data scientist is preparing the repository to train a model. The data scientist needs to redact personally identifiable information (PH) from ...
Let's analyze the provided options for redacting personally identifiable information (PII) from a machine learning (ML) dataset in Amazon S3, considering key factors like development effort, simplicity, scalability, and ease of use.
A) Use Amazon SageMaker Data Wrangler with a custom transformation to identify and redact the PII
Analysis:
- Development effort: Medium to high. While Data Wrangler is designed to simplify data processing, creating custom transformations for PII redaction would still require a fair amount of effort, especially to identify PII reliably and redact it properly.
- Simplicity: Data Wrangler has built-in features for data wrangling and preparation, but custom transformations require familiarity with the tool and its APIs.
- Use case suitability: Best for scenarios where the data scientist is already using SageMaker for model training and wants an integrated solution for data wrangling. However, if the goal is purely to redact PII, this might be overkill compared to other simpler solutions.
B) Create a custom AWS Lambda function to read the files, identify the PII, and redact the PII
Analysis:
- Development effort: High. Developing a custom Lambda function would require writing and maintaining the code to detect and redact PII. It may also require additional effort to handle various types of PII across different data formats (e.g., text, images).
- Scalability: Lambda is scalable, but the implementation might become cumbersome for large datasets or complex PII detection rules.
- Use case suitability: Lambda would be useful if a custom solution is required for specific logic, but it introduces a higher development and maintenance burden compared to other options.
C) Use AWS Glue DataBrew to identify and redact the PII
Analysis:
- Development effort: Low. AWS Glue DataBrew provides a no-code interface for data ...
Author: Matthew · Last updated Jul 26, 2026
A company is deploying a new machine learning (ML) model in a production environment. The company is concerned that the ML model will drift over time, so the company creates a script to aggregate all inputs and predictions into a single file at the end of each day. The company stores the file as an object in an Amazon S3 bucket. The total size of the daily file is 100 GB. The daily file size will increase over time.
Four times a year, the company samples the data from the previous 90 days to check the ML model for drift. After the 90-day period, t...
Let's evaluate the given options based on the requirements: minimizing storage costs, maintaining durability, and complying with the need to store the data for compliance after 90 days.
Key Requirements:
1. Minimize storage costs: This indicates that the company is looking for the most cost-effective storage classes for long-term retention.
2. Maintain durability: Amazon S3 provides high durability, but some storage classes (e.g., One Zone-IA) offer lower durability.
3. Compliance and retention for 90 days: The company needs to keep the files for compliance reasons after 90 days, meaning long-term storage is required after that period.
Analysis of Each Option:
A) Store the daily objects in the S3 Standard-Infrequent Access (S3 Standard-IA) storage class. Configure an S3 Lifecycle rule to move the objects to S3 Glacier Flexible Retrieval after 90 days.
- S3 Standard-IA: This is a cost-effective storage class for data that is accessed infrequently but needs to be quickly retrieved. It is highly durable (99.999999999% durability).
- S3 Glacier Flexible Retrieval: This is a good long-term storage option, optimized for data that is rarely accessed but still needs to be preserved with high durability. Retrieval times are slower than Standard-IA.
- Cost Efficiency: Using Standard-IA for 90 days and Glacier Flexible Retrieval for long-term storage is cost-effective for the type of data described (infrequent access and long-term retention).
- Durability: Both Standard-IA and Glacier Flexible Retrieval offer high durability (99.999999999%).
B) Store the daily objects in the S3 One Zone-Infrequent Access (S3 One Zone-IA) storage class. Configure an S3 Lifecycle rule to move the objects to S3 Glacier Flexible Retrieval after 90 days.
- S3 One Zone-IA: This is cheaper than Standard-IA because it stores data in a single availability zone instead of multiple zones. However, it provides lower durability (99.999999% durability) and higher risk of data loss in the event of an availability zone failure.
- S3 Glacier Flexible Retrieval: Like option A, this is a good choice for long-term storage.
- Durability Issue: Using One Zone-IA introduces a risk in durability due to the lack of cross-availabi...
Author: Chloe · Last updated Jul 26, 2026
A company wants to enhance audits for its machine learning (ML) systems. The auditing system must be able to perform metadata analysis on the features that the ML models use. The audit solution must generate a report that analyzes the metadata. The solution also must be able to set the da...
Key Considerations:
1. Metadata Analysis: The solution should be able to perform metadata analysis on features used by the ML models.
2. Setting Data Sensitivity and Authorship: The ability to assign metadata that specifies data sensitivity and authorship is a key requirement.
3. Reporting: The solution should be able to generate reports that summarize the metadata analysis.
4. Development Effort: The company is looking for a solution that minimizes development effort, meaning it should leverage managed services and built-in features wherever possible.
Option Breakdown:
A) Use Amazon SageMaker Feature Store to select the features. Create a data flow to perform feature-level metadata analysis. Create an Amazon DynamoDB table to store feature-level metadata. Use Amazon QuickSight to analyze the metadata.
- Rejection Reasoning: Although SageMaker Feature Store can help with storing and managing features, creating a separate DynamoDB table for feature-level metadata and using Amazon QuickSight for analysis adds unnecessary complexity. The DynamoDB table would require manual effort to manage and synchronize metadata with the feature store, and the solution would need additional custom data flows for analysis, which increases the development effort.
- Scenario Usefulness: This option could be used in custom cases, but it is unnecessarily complex for this use case where there are more straightforward solutions available.
B) Use Amazon SageMaker Feature Store to set feature groups for the current features that the ML models use. Assign the required metadata for each feature. Use SageMaker Studio to analyze the metadata.
- Rejection Reasoning: While SageMaker Feature Store and SageMaker Studio are powerful tools, SageMaker Studio does not provide built-in features for performing specific metadata analysis in a way that generates detailed, structured reports. It’s mainly a development and monitoring environment, but it might not fully meet the requirement for automated metadata analysis and reporting.
- Scenario Usefulness: This solution provides some capabilities but doesn’t quite fulfill the requirement for automa...
Author: Amelia · Last updated Jul 26, 2026
A machine learning (ML) specialist uploads a dataset to an Amazon S3 bucket that is protected by server-side encryption with AWS KMS keys (SSE-KMS). The ML specialist needs to ensure that an Amazon SageMaker notebook inst...
Let's analyze the different solutions to meet the requirement of allowing an Amazon SageMaker notebook instance to read a dataset stored in Amazon S3 with server-side encryption using AWS KMS (SSE-KMS).
Key Requirements:
1. Access to the S3 Dataset: The SageMaker notebook instance must be able to read the encrypted dataset stored in S3.
2. Encryption Consideration: The data is encrypted using KMS keys, so the notebook instance needs permissions to access the KMS key that was used to encrypt the data.
3. Least Permissions and Simplicity: The solution should ensure that only necessary permissions are granted to allow SageMaker to read the S3 dataset.
Analysis of Each Option:
A) Define security groups to allow all HTTP inbound and outbound traffic. Assign the security groups to the SageMaker notebook instance.
- Reasoning: This option is not relevant to the problem. Security groups control network access and are primarily used for controlling traffic between resources in a VPC. However, the requirement here is to access encrypted S3 data, which involves IAM roles and KMS permissions, not network-level traffic.
- Rejected: Security groups are not involved in managing S3 data access or KMS key permissions.
B) Configure the SageMaker notebook instance to have access to the VPC. Grant permission in the AWS Key Management Service (AWS KMS) key policy to the notebook’s VPC.
- Reasoning: While configuring the notebook to access a VPC is a valid configuration for certain use cases (like accessing private resources in the VPC), it does not directly address the issue of accessing the encrypted S3 data. The problem at hand is KMS key access, not VPC access.
- Rejected: This option misses the core requirement of granting the necessary KMS permission...
