Courseiva

CCNA Ml Modeling Questions

75 of 603 questions · Page 8/9 · Ml Modeling topic · Answers revealed

Practice these questionsExam hubAll questions
526
MCQhard

A data scientist is using Amazon SageMaker's built-in BlazingText algorithm for word2vec embeddings. The dataset is a corpus of 10 million documents. After training, the data scientist observes that the learned embeddings do not capture semantic similarity well (e.g., 'king' and 'queen' are not close). Which hyperparameter adjustment is most likely to improve the quality of embeddings?

A.Increase the vector dimensionality
B.Decrease the window size
C.Decrease the number of negative samples
D.Increase the learning rate
AnswerA

Higher dimensionality allows embeddings to capture more fine-grained semantic relationships.

Why this answer

Increasing the vector dimensionality allows the model to capture more nuanced semantic relationships and co-occurrence patterns in the data. With 10 million documents, the default dimensionality (typically 100 or 300) may be insufficient to encode the rich contextual information, so raising it (e.g., to 300 or 500) gives the model more capacity to learn high-quality embeddings where words like 'king' and 'queen' become closer in vector space.

Exam trap

The trap here is that candidates often confuse 'window size' with 'context size' and assume decreasing it helps with similarity, but in reality, a larger window captures broader topical relationships, while a smaller window captures syntactic patterns; for semantic similarity, a moderate to large window is needed.

How to eliminate wrong answers

Option B is wrong because decreasing the window size reduces the context window, making the model focus on very local word co-occurrences, which actually harms the capture of broader semantic similarity like 'king' and 'queen'. Option C is wrong because decreasing the number of negative samples reduces the discriminative training signal, making it harder for the model to separate similar from dissimilar words, thus degrading embedding quality. Option D is wrong because increasing the learning rate can cause the optimization to overshoot minima or diverge, leading to unstable training and poor embeddings; the default learning rate in BlazingText is already tuned for convergence.

Practice this question →
527
MCQmedium

A data scientist is training a neural network for time series forecasting. The training loss decreases initially but then starts to increase after 20 epochs. Which action should the scientist take to address this?

A.Increase the dropout rate
B.Increase the learning rate
C.Implement early stopping based on validation loss
D.Add more layers to the network
AnswerC

Early stopping halts training when validation loss stops improving, preventing overfitting.

Why this answer

Early stopping monitors validation loss and stops training when it starts increasing, preventing overfitting. Option A is wrong because increasing dropout may help with overfitting but the immediate issue of increasing loss is better addressed by early stopping, and dropout alone doesn't stop training. Option B is wrong because increasing the learning rate can cause divergence, making the loss increase worse.

Option D is wrong because adding more layers increases model capacity and typically worsens overfitting.

Practice this question →
528
Multi-Selectmedium

A data scientist is training a model using Amazon SageMaker. The training job is running on GPU instances, but the GPU utilization is low. Which TWO actions could improve GPU utilization?

Select 2 answers
A.Increase the number of epochs
B.Use a larger instance with multiple GPUs
C.Increase the batch size
D.Switch to CPU instances
E.Decrease the batch size
AnswersB, C

Using a larger instance with multiple GPUs provides more parallel compute resources, improving overall GPU utilization.

Why this answer

Using a larger instance with multiple GPUs allows more parallel processing, improving GPU utilization. Option C is correct because increasing the batch size provides more data per step, better utilizing GPU parallelism. Option A is incorrect because increasing epochs does not affect utilization per step.

Option D is incorrect because switching to CPU instances would not utilize GPU. Option E is incorrect because decreasing batch size reduces parallelism and lowers GPU utilization.

Practice this question →
529
MCQmedium

A data scientist is training a text classification model using Amazon SageMaker. The dataset consists of 100,000 labeled documents. The data scientist notices that the model performs well on the training set but poorly on the validation set. Which regularization technique should the data scientist apply to reduce overfitting?

A.Dropout
B.Data augmentation
C.Batch normalization
D.Early stopping
AnswerA

Dropout randomly drops units during training, preventing co-adaptation and reducing overfitting.

Why this answer

Dropout is a regularization technique that randomly drops a fraction of neurons during training, which prevents the model from relying too heavily on any single feature and forces it to learn more robust representations. This directly addresses the overfitting symptom of high training accuracy and low validation accuracy by reducing the model's capacity to memorize noise in the training data.

Exam trap

The trap here is that candidates often confuse batch normalization with regularization, but batch normalization primarily addresses internal covariate shift and training stability, not overfitting, while dropout is the explicit regularization technique for neural networks.

How to eliminate wrong answers

Option B (Data augmentation) is wrong because it is primarily used for image or audio data to artificially expand the dataset by applying transformations, but for text classification, simple augmentation (e.g., synonym replacement) may not be as effective and is not a standard regularization technique for overfitting in this context. Option C (Batch normalization) is wrong because it normalizes layer inputs to stabilize and accelerate training, but it does not directly reduce overfitting; it can even have a slight regularizing effect but is not the primary technique for combating overfitting. Option D (Early stopping) is wrong because while it can prevent overfitting by halting training when validation performance plateaus, the question asks for a regularization technique, and early stopping is an optimization trick rather than a structural regularization method like dropout.

Practice this question →
530
MCQmedium

A data scientist is using Amazon SageMaker to train a model using a built-in algorithm. The training job fails with an error indicating that the algorithm expects the data to be in recordIO-protobuf format, but the input is CSV. What is the most efficient way to resolve this?

A.Change the inference data to recordIO-protobuf format.
B.Use a boto3 script to convert the CSV files locally and upload.
C.Use a SageMaker processing job to convert the CSV data to recordIO-protobuf format.
D.Switch to a different algorithm that accepts CSV format.
AnswerC

Processing jobs can efficiently transform data into the required format.

Why this answer

Using a SageMaker processing job to convert CSV data to recordIO-protobuf format is an efficient, scalable, and fully managed solution within the SageMaker ecosystem. Option A is incorrect because changing the inference data to recordIO-protobuf does not address the training data format issue. Option B is incorrect because using a boto3 script to convert locally is less efficient and not scalable compared to a managed processing job.

Option D is incorrect because switching algorithms may not be desirable and does not solve the underlying data format requirement.

Practice this question →
531
MCQhard

A data scientist runs a training job that fails. The CLI output is shown in the exhibit. What is the MOST likely cause of the failure?

A.The S3 bucket or prefix does not exist.
B.The channel name is misspelled.
C.The instance type ml.m5.large is too small.
D.The IAM role does not have s3:GetObject permission.
AnswerA

The error message explicitly says the S3 URI is not found.

Why this answer

The CLI output shows an error indicating that the S3 bucket or prefix does not exist. This is a common failure when the training job's input data path is incorrect, as SageMaker attempts to read from the specified S3 location and fails if the bucket or prefix is missing. The error message directly points to this issue, making it the most likely cause.

Exam trap

The trap here is that candidates may confuse S3 permission errors (403) with bucket-not-found errors (404), leading them to incorrectly select the IAM role permission option when the actual issue is a missing S3 path.

How to eliminate wrong answers

Option B is wrong because a misspelled channel name would typically result in a different error, such as 'Invalid channel name' or 'Channel not found', not an S3 access error. Option C is wrong because the instance type ml.m5.large is a valid and commonly used instance for training; if it were too small, the job would likely start but fail due to resource exhaustion, not an immediate S3-related error. Option D is wrong because an IAM role lacking s3:GetObject permission would produce an 'Access Denied' or '403 Forbidden' error, not a 'bucket or prefix does not exist' error.

Practice this question →
532
MCQeasy

A data scientist is training a neural network on Amazon SageMaker and wants to automatically stop training if the validation loss does not improve for 5 consecutive epochs. Which feature should they use?

A.Implement early stopping in the training script
B.SageMaker Debugger
C.SageMaker Checkpointing
D.SageMaker Hyperparameter Tuning
AnswerA

Early stopping is implemented in the training code (e.g., Keras EarlyStopping callback).

Why this answer

Early stopping is a technique where training is halted when a monitored metric, such as validation loss, stops improving for a specified number of epochs (patience). In SageMaker, this is implemented within the training script itself, often using framework callbacks like Keras EarlyStopping or PyTorch's ReduceLROnPlateau with early stopping logic. SageMaker Debugger is used for monitoring and profiling but does not automatically stop training; it can emit alerts but requires custom rules or hooks to trigger stopping.

SageMaker Checkpointing saves model state periodically to resume training, not stop it. SageMaker Hyperparameter Tuning launches multiple training jobs to find optimal hyperparameters, not to stop a single job early. Therefore, option A is correct: the data scientist should implement early stopping in the training script.

Practice this question →
533
MCQmedium

Refer to the exhibit. A data scientist is assigned an IAM policy to deploy a SageMaker model. When the scientist tries to create an endpoint, the action fails with an authorization error. What is the missing permission?

A.iam:PassRole
B.sagemaker:ListEndpoints
C.sagemaker:InvokeEndpoint
D.sagemaker:UpdateEndpoint
AnswerA

SageMaker needs iam:PassRole to assume a role for creating endpoints.

Why this answer

The error occurs because the IAM policy does not include the `iam:PassRole` permission. When creating a SageMaker endpoint, the service must assume an IAM role to access resources (e.g., S3 buckets, CloudWatch). The `iam:PassRole` permission allows the user to pass that role to SageMaker.

The other actions listed are either for inference (`InvokeEndpoint`), listing endpoints (`ListEndpoints`), or updating endpoints (`UpdateEndpoint`), which are not relevant to the creation process. Therefore, the missing permission is `iam:PassRole` (Option A).

Practice this question →
534
MCQmedium

A data scientist is using SageMaker to train a deep learning model with a large dataset stored in S3. The training is taking a long time. Which action would most likely reduce training time without sacrificing accuracy?

A.Increase the batch size
B.Use SageMaker Pipe Input mode
C.Use a smaller instance type
D.Reduce the number of epochs
AnswerB

Streams data from S3 directly to the algorithm, reducing I/O time.

Why this answer

SageMaker Pipe Input mode streams training data directly from S3 into the algorithm without first downloading it to the local EBS volume. This eliminates the I/O bottleneck caused by large dataset downloads, significantly reducing training time while preserving accuracy because the model sees the same data.

Exam trap

The trap here is that candidates confuse batch size adjustments (which affect convergence stability) with I/O optimization techniques, overlooking that SageMaker Pipe mode directly addresses the data loading bottleneck without altering the training algorithm.

How to eliminate wrong answers

Option A is wrong because increasing the batch size can reduce training time per epoch but may degrade model accuracy due to convergence to sharper minima or increased generalization error, especially in deep learning. Option C is wrong because using a smaller instance type reduces computational capacity, increasing training time rather than decreasing it. Option D is wrong because reducing the number of epochs directly reduces training time but sacrifices accuracy by underfitting the model.

Practice this question →
535
MCQhard

A data scientist is using Amazon SageMaker to train a large language model with PyTorch. The training job is taking too long. The dataset is stored in S3 and the training script uses the SageMaker PyTorch container. Which change is MOST likely to reduce training time?

A.Use Pipe mode to stream data from S3 instead of downloading.
B.Increase the number of instances in the training job.
C.Change the optimizer to AdamW.
D.Switch to spot instances to reduce cost.
AnswerA

Pipe mode reduces data loading time.

Why this answer

SageMaker Pipe mode streams data directly from S3 to the training algorithm via a Unix FIFO (named pipe), eliminating the need to first download the entire dataset to the training instance's local storage. This reduces I/O wait time and disk usage, which is especially beneficial for large language models where dataset sizes can be in terabytes, thereby significantly cutting total training time.

Exam trap

The trap here is that candidates often confuse cost-saving measures (spot instances) or model-tuning changes (AdamW) with performance improvements, while the actual bottleneck in large-scale training is frequently data I/O, not compute or optimizer choice.

How to eliminate wrong answers

Option B is wrong because simply increasing the number of instances does not address the root cause of slow data loading; it may even introduce communication overhead and increase costs without proportional speedup if the bottleneck is I/O. Option C is wrong because changing the optimizer to AdamW affects convergence behavior and model accuracy, not the data ingestion speed or training job duration directly. Option D is wrong because switching to spot instances reduces cost but does not reduce training time; spot instances can actually increase training time if they are interrupted and require checkpointing and resumption.

Practice this question →
536
MCQhard

A company is using Amazon SageMaker to train a large language model with billions of parameters. The training job uses multiple GPU instances in a distributed fashion. The training is converging but the loss is not decreasing as expected. The data scientist suspects that the learning rate is too high. Which technique should the data scientist use to automatically adjust the learning rate during training?

A.Use a fixed learning rate and train for more epochs
B.Increase the batch size to reduce variance
C.Implement learning rate scheduling with a cosine annealing schedule
D.Use gradient clipping
AnswerC

Cosine annealing reduces the learning rate smoothly, helping convergence.

Why this answer

Learning rate scheduling, such as a cosine annealing schedule, can automatically reduce the learning rate over time. This helps the model converge better. SageMaker's built-in algorithms support learning rate scheduling, or the user can implement it in custom training scripts.

Practice this question →
537
MCQeasy

A company is building a recommendation system using collaborative filtering. The dataset contains implicit feedback (clicks) from users on items. Which algorithm is best suited for this scenario?

A.Linear Regression
B.Alternating Least Squares (ALS)
C.K-means clustering
D.Singular Value Decomposition (SVD)
AnswerB

Alternating Least Squares (ALS) is specifically designed for implicit feedback datasets in collaborative filtering, making it the best choice.

Why this answer

Alternating Least Squares (ALS) is designed for implicit feedback datasets in collaborative filtering. Option A is wrong because Linear Regression is for supervised regression, not recommendation. Option C is wrong because K-means is clustering, not recommendation.

Option D is wrong because SVD is typically used for explicit ratings, while ALS is better suited for implicit feedback.

Practice this question →
538
MCQhard

A data scientist is tuning a gradient boosting model using Amazon SageMaker Automatic Model Tuning. The objective metric is AUC. The training job converges quickly but the final model has low AUC on the validation set. Which hyperparameter should the data scientist adjust to improve validation AUC?

A.Increase the subsample ratio of training data
B.Decrease the learning rate and increase the number of rounds
C.Increase the learning rate
D.Increase the maximum depth of trees
AnswerB

Lower learning rate with more rounds typically improves generalization and AUC.

Why this answer

Decreasing the learning rate and increasing the number of rounds is the correct approach because a low learning rate forces the model to take smaller steps toward the optimum, reducing overfitting and allowing more trees to contribute to the ensemble. This combination often improves generalization and validation AUC when the training job converges too quickly, indicating that the model is overfitting or underfitting due to aggressive learning.

Exam trap

The trap here is that candidates mistakenly think increasing the learning rate will speed up convergence and improve AUC, but in reality it causes overfitting when the model already converges quickly, while decreasing the learning rate with more rounds is the standard remedy for underfitting or overfitting in gradient boosting.

How to eliminate wrong answers

Option A is wrong because increasing the subsample ratio (e.g., from 0.8 to 1.0) actually uses more training data per iteration, which can increase variance and overfitting, not improve validation AUC when the model already converges quickly. Option C is wrong because increasing the learning rate makes the model converge even faster, exacerbating overfitting and further reducing validation AUC. Option D is wrong because increasing the maximum depth of trees makes each tree more complex and prone to overfitting, which typically degrades validation AUC when the model already converges quickly.

Practice this question →
539
MCQhard

A company uses Amazon SageMaker to train a model using the built-in Linear Learner algorithm. The training data contains missing values in some features. What is the best practice for handling missing values with this algorithm?

A.Remove rows with missing values
B.Impute missing values using mean or median imputation
C.Set missing values to zero
D.Use the `handle_missing` parameter in the algorithm
AnswerB

Imputing missing values using mean or median imputation is recommended because it preserves data and avoids bias.

Why this answer

Linear Learner expects dense input; it cannot handle missing values. The best practice is to impute missing values before training, such as using mean or median imputation. Removing rows with missing values (Option A) may lose valuable data.

Setting missing values to zero (Option C) could bias the model. The algorithm does not have a built-in `handle_missing` parameter (Option D). Therefore, Option B (Impute missing values using mean or median imputation) is correct.

Practice this question →
540
MCQhard

A team is training a neural network for image classification using Amazon SageMaker. The training loss decreases rapidly but the validation loss starts increasing after a few epochs. Which action should the team take?

A.Reduce the batch size
B.Add more convolutional layers
C.Increase the learning rate
D.Implement early stopping based on validation loss
AnswerD

Early stopping prevents overfitting.

Why this answer

Early stopping halts training when the validation loss stops improving (or starts increasing), preventing overfitting. Option A is incorrect because reducing batch size does not directly address overfitting; it may add noise to gradients. Option B is incorrect because adding more convolutional layers increases model complexity, likely worsening overfitting.

Option C is incorrect because increasing the learning rate can cause the model to diverge or overshoot minima, not reduce overfitting.

Practice this question →
541
Multi-Selectmedium

A company is using SageMaker to deploy a model for real-time inference. The model requires GPU for low latency. Which THREE configurations should the company consider for high availability and cost optimization? (Choose three.)

Select 3 answers
A.Use Spot instances for the endpoint.
B.Use a multi-model endpoint to share GPU instances among multiple models.
C.Use SageMaker Batch Transform for inference.
D.Use multiple production variants with different instance types.
E.Enable automatic scaling based on invocation count.
AnswersB, D, E

Increases GPU utilization and reduces cost.

Why this answer

A multi-model endpoint allows multiple models to be hosted on the same GPU-backed instance, sharing the GPU resources and reducing idle time. This improves cost efficiency by maximizing GPU utilization while still providing low-latency inference for each model. It is a recommended pattern for serving many models with GPU requirements without provisioning separate endpoints.

Exam trap

The trap here is that candidates often confuse high availability with cost optimization, incorrectly assuming Spot instances (Option A) are suitable for real-time inference despite their interruption risk, or they overlook multi-model endpoints as a GPU-sharing strategy.

Practice this question →
542
MCQeasy

A data scientist is training a Random Forest model on Amazon SageMaker. The model performs well on the training set but poorly on the test set. Which technique should the data scientist use to address this issue?

A.Increase the number of trees in the forest
B.Decrease the maximum depth of each tree
C.Increase the learning rate
D.Increase the maximum depth of each tree
AnswerB

Decreasing the maximum depth of each tree limits the complexity of individual trees, reducing overfitting by preventing them from memorizing noise. This is a standard regularization technique and directly addresses the overfitting issue.

Why this answer

The model is overfitting, as indicated by high training performance and poor test performance. Decreasing the maximum depth of each tree limits the complexity of individual trees, reducing overfitting by preventing them from memorizing noise in the training data. This is a standard regularization technique for Random Forest models in Amazon SageMaker.

Exam trap

AWS often tests the misconception that increasing model complexity (e.g., more trees or deeper trees) always improves performance, when in fact overfitting requires reducing complexity or applying regularization.

How to eliminate wrong answers

Option A is wrong because increasing the number of trees in the forest generally improves model stability and reduces variance without significantly increasing overfitting, but it does not address the root cause of overfitting from overly deep trees. Option C is wrong because learning rate is a hyperparameter for gradient boosting models, not for Random Forest; Random Forest does not use a learning rate. Option D is wrong because increasing the maximum depth of each tree would exacerbate overfitting by allowing trees to capture more noise and specific patterns in the training data, worsening test performance.

Practice this question →
543
MCQhard

A company is building a real-time fraud detection system using Amazon SageMaker. The model is a gradient boosting classifier trained on 500 GB of transactional data. The inference endpoint is deployed as a SageMaker real-time endpoint using an ml.c5.9xlarge instance. The model is serialized using the native format of the framework (XGBoost). The endpoint receives about 100 requests per second with an average payload size of 10 KB. The company observes that the endpoint's latency is around 200 ms, but they need under 100 ms. The data scientist profiles the endpoint and finds that the model inference time is 50 ms, but the remaining time is spent on data preprocessing and serialization/deserialization. The preprocessing involves converting JSON input to a NumPy array and then to a DMatrix. Which action is most likely to reduce latency to meet the requirement?

A.Use a more efficient serialization format such as Apache Arrow or Protocol Buffers for the input data
B.Switch to SageMaker Batch Transform to process requests in batches
C.Use a larger instance type such as ml.c5.18xlarge
D.Reduce the number of trees in the model
AnswerA

Reducing serialization/deserialization overhead directly addresses the bottleneck.

Why this answer

The bottleneck is data preprocessing and serialization/deserialization, not model inference. Using a more efficient serialization format like Apache Arrow or Protocol Buffers reduces the overhead of converting JSON to NumPy arrays and DMatrix, directly cutting the 150 ms spent outside inference. This targets the root cause without changing the model or infrastructure.

Exam trap

The trap here is that candidates often assume latency is due to model complexity or instance size, but the question explicitly states inference is only 50 ms, so the fix must address the preprocessing/serialization bottleneck, not the model or compute resources.

How to eliminate wrong answers

Option B is wrong because SageMaker Batch Transform is designed for offline, asynchronous processing of large datasets, not for real-time sub-100 ms latency requirements; it would increase latency due to queuing and batching delays. Option C is wrong because upgrading to a larger instance (ml.c5.18xlarge) primarily improves compute capacity for inference, but the bottleneck is preprocessing and serialization, not model compute; the inference time is already only 50 ms, so more CPU cores won't fix the serialization overhead. Option D is wrong because reducing the number of trees in the model would decrease inference accuracy and only marginally reduce the 50 ms inference time, leaving the dominant 150 ms preprocessing overhead untouched.

Practice this question →
544
MCQeasy

A data scientist is building a regression model to predict house prices. The dataset includes features such as square footage, number of bedrooms, year built, and location. After training a linear regression model, the data scientist notices that the residuals have a clear pattern when plotted against predicted values: they increase with predicted values. The model also has high RMSE. Which action should the data scientist take to improve the model?

A.Remove outliers from the dataset.
B.Use L1 regularization (Lasso) to reduce overfitting.
C.Apply a log transformation to the target variable.
D.Add interaction terms between features.
AnswerC

Log transformation can stabilize variance and linearize the relationship, reducing the residual pattern.

Why this answer

A pattern in residuals indicates non-linearity, and transforming the target variable (e.g., log transformation) can stabilize variance and linearize relationships. Option A is wrong because removing outliers does not address the underlying non-linearity or heteroscedasticity; it may even discard useful data. Option B is wrong because L1 regularization helps reduce overfitting by penalizing large coefficients, but it does not fix non-constant variance or non-linearity.

Option D is wrong because while interaction terms can model relationships between features, they do not directly address the pattern of increasing residuals (heteroscedasticity) and may not resolve the non-linearity in the target.

Practice this question →
545
MCQmedium

A company has a time series dataset of daily sales for the past 5 years. They want to forecast sales for the next 30 days. The data shows weekly seasonality and a slight upward trend. Which Amazon SageMaker algorithm is most appropriate for this task?

A.DeepAR
B.Linear Learner
C.XGBoost
D.K-Means
AnswerA

DeepAR is a built-in SageMaker algorithm for time series forecasting that handles seasonality and trends.

Why this answer

DeepAR is purpose-built for time series forecasting with seasonal patterns and trends. It uses a recurrent neural network (RNN) to model the conditional distribution of future values given past observations, and it natively handles multiple time series, missing data, and known seasonal periods (e.g., weekly). The weekly seasonality and upward trend in the daily sales data are exactly the kind of patterns DeepAR is designed to capture.

Exam trap

The trap here is that candidates often pick XGBoost (Option C) because it is a powerful tree-based model, but they overlook that it lacks native time series capabilities and requires manual feature engineering to capture seasonality and trend, whereas DeepAR is the only option specifically designed for this forecasting task.

How to eliminate wrong answers

Option B (Linear Learner) is wrong because it is a general-purpose linear regression or classification algorithm that cannot model seasonality or temporal dependencies without extensive manual feature engineering (e.g., lag variables, Fourier terms). Option C (XGBoost) is wrong because while it can be used for time series via feature engineering, it is not a dedicated forecasting algorithm and does not natively handle temporal order, autocorrelation, or seasonality; it treats each prediction as an independent regression task. Option D (K-Means) is wrong because it is an unsupervised clustering algorithm that groups data points by similarity and has no mechanism for forecasting future values in a time series.

Practice this question →
546
MCQmedium

A machine learning team is deploying a model for real-time fraud detection. The model must make predictions with less than 100ms latency. The team uses SageMaker and the model is a large ensemble of decision trees. Which SageMaker hosting option is MOST suitable?

A.SageMaker Multi-model endpoint
B.SageMaker Serverless Inference
C.SageMaker Elastic Inference
D.SageMaker Batch Transform
AnswerB

Correct. SageMaker Serverless Inference provides automatic scaling and is ideal for real-time inference with low latency. For a constantly used model, cold starts are minimal, and the service handles the large ensemble efficiently.

Why this answer

SageMaker Serverless Inference is the most suitable option because it automatically scales to handle variable traffic and does not require managing underlying infrastructure. Although it may incur cold starts, for a constantly invoked fraud detection model the endpoint remains warm, achieving sub-100ms latency. The large ensemble of decision trees can be deployed as a single model on a Serverless endpoint, which is optimized for real-time inference with low latency and automatic scaling.

Exam trap

Candidates often select SageMaker Multi-model endpoint (Option A) thinking it is the only real-time option, but it is designed for hosting multiple independent models, not a single large ensemble. A regular real-time endpoint or Serverless Inference is more appropriate. Serverless avoids the overhead of managing instances and can achieve low latency when the endpoint is continuously invoked.

How to eliminate wrong answers

Option B (SageMaker Serverless Inference) is wrong because it has a cold start latency that can exceed 100ms, making it unsuitable for real-time fraud detection requiring consistent sub-100ms responses. Option C (SageMaker Elastic Inference) is wrong because it accelerates deep learning models by attaching GPU accelerators, but it does not benefit decision tree ensembles which are CPU-bound and do not leverage GPU acceleration. Option D (SageMaker Batch Transform) is wrong because it is designed for offline, asynchronous batch predictions on large datasets, not for real-time inference with low latency requirements.

Practice this question →
547
MCQmedium

A company uses Amazon SageMaker to train a linear regression model. After training, the model shows high bias on the training set. Which action is MOST likely to reduce bias?

A.Add more features
B.Collect more training data
C.Apply L2 regularization
D.Deploy the model to a larger instance
AnswerA

More features can capture patterns better.

Why this answer

High bias indicates that the model is underfitting the training data, meaning it is too simple to capture the underlying patterns. Adding more features increases the model's capacity to learn complex relationships, directly addressing underfitting by reducing bias. In SageMaker, this can be done by engineering additional input columns or using feature transformations before training.

Exam trap

The trap here is that candidates confuse high bias with high variance and incorrectly choose regularization or more data, which are solutions for overfitting, not underfitting.

How to eliminate wrong answers

Option B is wrong because collecting more training data does not reduce bias; it primarily helps with high variance (overfitting) by providing more examples to generalize from. Option C is wrong because L2 regularization (ridge regression) penalizes large coefficients, which increases bias to reduce variance, making bias worse in an already underfit model. Option D is wrong because deploying the model to a larger instance affects inference performance (latency/throughput) but does not change the model's learned parameters or its bias-variance tradeoff.

Practice this question →
548
Multi-Selecthard

Which THREE techniques can help reduce overfitting in a neural network? (Select THREE.)

Select 3 answers
A.Increase training epochs
B.Dropout
C.Early stopping
D.Increase the number of layers
E.L2 regularization
AnswersB, C, E

Dropout randomly drops units.

Why this answer

Dropout is correct because it randomly deactivates a fraction of neurons during training, forcing the network to learn redundant representations and preventing co-adaptation of features. This reduces overfitting by acting as an ensemble method without increasing computational cost at inference time.

Exam trap

AWS often tests the misconception that adding more capacity (layers/epochs) always improves performance, when in fact it increases overfitting without proper regularization.

Practice this question →
549
MCQeasy

A company uses Amazon SageMaker to deploy a model that predicts customer churn. The model is retrained weekly. The data scientist notices that the model's accuracy remains high, but the business reports that the model is not capturing new churn patterns. What is the most likely cause?

A.The model is underfitting the data
B.The model has data leakage from future data
C.The model is overfitting to the training data
D.The model is experiencing concept drift
AnswerD

Concept drift means the underlying data distribution changes, so the model's accuracy on old patterns remains high but it misses new patterns.

Why this answer

Concept drift occurs when the statistical properties of the target variable change over time, causing the model's predictions to become less relevant even if accuracy metrics remain high. In this scenario, the model is retrained weekly but still fails to capture new churn patterns because the underlying customer behavior has shifted—a classic sign of concept drift rather than a data or overfitting issue. Amazon SageMaker's built-in Model Monitor can detect such drift by comparing inference data distributions against a baseline.

Exam trap

The trap here is that candidates see 'accuracy remains high' and assume the model is overfitting or underfitting, but the key clue is 'not capturing new churn patterns'—which points to a shift in the underlying data distribution (concept drift), not a static model fit issue.

How to eliminate wrong answers

Option A is wrong because underfitting would manifest as consistently low accuracy on both training and test data, not as high accuracy with missed new patterns. Option B is wrong because data leakage from future data would cause unrealistically high performance during training and evaluation, not a failure to capture new churn patterns after deployment. Option C is wrong because overfitting would show high training accuracy but poor generalization on unseen data from the same distribution, whereas the problem here is that the data distribution itself has changed over time.

Practice this question →
550
MCQhard

A data scientist is using SageMaker to train a random forest model. The dataset has 100 features and 1 million rows. The training job fails with a 'ResourceLimitExceeded' error. What is the MOST likely cause?

A.The S3 bucket containing the training data is not in the same region.
B.The instance type selected does not have enough GPU memory.
C.The wrong algorithm was specified for the training job.
D.The account has reached its limit on the number of SageMaker training instances.
AnswerD

ResourceLimitExceeded indicates a service quota limit.

Why this answer

The 'ResourceLimitExceeded' error indicates that the account has reached its limit on the number of SageMaker training instances or vCPUs. Option A (S3 bucket region) would cause a different error, not a resource limit. Option B (GPU memory) is unlikely because random forest models typically use CPU instances.

Option C (wrong algorithm) would result in an algorithm-specific error, not a resource limit. Option D correctly identifies that the account limit has been exceeded.

Practice this question →
551
MCQmedium

A data scientist is training a deep learning model on Amazon SageMaker for image classification. The training is taking a long time and the GPU utilization is consistently below 30%. What should the data scientist do to improve GPU utilization and reduce training time?

A.Use early stopping to stop training earlier.
B.Increase the batch size.
C.Switch to a CPU-only instance.
D.Reduce the number of layers in the model.
AnswerB

Larger batches use GPU memory more efficiently and increase utilization.

Why this answer

Low GPU utilization (below 30%) indicates that the GPU is spending most of its time waiting for data to process, often due to small batch sizes that underutilize the GPU's parallel compute capacity. Increasing the batch size allows the GPU to process more samples per forward/backward pass, improving arithmetic intensity and hardware utilization, which directly reduces total training time on SageMaker.

Exam trap

The trap here is that candidates confuse 'low GPU utilization' with 'overfitting' or 'model complexity,' leading them to choose early stopping or reducing layers, when the real issue is insufficient data parallelism per batch.

How to eliminate wrong answers

Option A is wrong because early stopping halts training based on validation performance, but it does not address the root cause of low GPU utilization or improve hardware efficiency during each training step. Option C is wrong because switching to a CPU-only instance would drastically reduce computational throughput, making training even slower and further underutilizing resources. Option D is wrong because reducing the number of layers decreases model capacity and may harm accuracy, but it does not directly improve GPU utilization; the bottleneck is data throughput, not model depth.

Practice this question →
552
MCQmedium

A data scientist is training a binary classification model on a dataset with 100 features and 10,000 samples. The model achieves 99% accuracy on the training set but only 65% on the test set. Which technique should be applied first to address this issue?

A.Reduce the size of the training dataset
B.Increase the number of trees in a random forest
C.Apply L2 regularization to the model
D.Add more features to the model
AnswerC

L2 regularization penalizes large weights, reducing overfitting.

Why this answer

The symptoms indicate overfitting. Regularization (L1/L2) is a direct method to reduce overfitting by penalizing large coefficients. Option A is wrong because reducing the size of the training dataset would worsen overfitting.

Option B is wrong because increasing the number of trees in a random forest could help reduce overfitting in some cases, but it's not the first technique to apply; regularization is more direct. Option D is wrong because adding more features would increase model complexity and worsen overfitting.

Practice this question →
553
Multi-Selectmedium

A data scientist is building a text classification model using a bag-of-words approach. The dataset contains 100,000 documents with a vocabulary of 50,000 unique words. The model is overfitting. Which THREE techniques can help reduce overfitting? (Choose THREE.)

Select 3 answers
A.Increase max_features to include more words
B.Apply L1 or L2 regularization
C.Reduce the n-gram range to unigrams only
D.Use feature selection to remove rare words
E.Use TF-IDF instead of raw counts
AnswersB, C, D

Regularization penalizes large coefficients, reducing overfitting.

Why this answer

Regularization (L1/L2), reducing n-gram range to unigrams, and feature selection (removing rare words) all reduce model complexity and help prevent overfitting. Option A (increasing max_features) increases complexity and can worsen overfitting. Option E (TF-IDF) is a weighting scheme, not a regularization technique.

Practice this question →
554
Multi-Selectmedium

Which TWO of the following are valid techniques to handle missing data in a dataset?

Select 2 answers
A.Normalizing the data
B.Adding a constant value of 0
C.Mean imputation
D.Synthetic Minority Over-sampling (SMOTE)
E.Deleting rows with missing values
AnswersC, E

Replacing missing values with the mean is a standard technique.

Why this answer

Mean imputation (Option C) is a valid technique for handling missing data because it replaces missing values with the mean of the observed values for that feature, preserving the overall mean of the dataset. This approach is simple and effective for numerical data that is missing completely at random (MCAR), as it does not introduce bias in the mean estimate.

Exam trap

The MLS-C01 exam often tests the distinction between data preprocessing techniques (like imputation) and other unrelated techniques (like normalization or SMOTE), so the trap here is that candidates may confuse SMOTE or normalization as valid missing data handling methods because they are common preprocessing steps, but they serve entirely different purposes.

Practice this question →
555
Multi-Selectmedium

A company uses Amazon SageMaker to train a linear regression model. During evaluation, they observe that the model has high bias (underfitting). Which THREE actions can reduce bias?

Select 3 answers
A.Increase L2 regularization.
B.Add polynomial features.
C.Reduce the regularization strength.
D.Use a smaller training dataset.
E.Use a random forest model instead of linear regression.
AnswersB, C, E

Polynomial features increase model capacity, reducing bias.

Why this answer

Options B, C, and E are correct. Bias (underfitting) occurs when the model is too simple to capture patterns in the data. Adding polynomial features (B) increases model complexity, allowing the linear regression to fit non-linear relationships.

Reducing regularization strength (C) reduces the penalty on large coefficients, letting the model fit the training data more closely. Using a random forest model (E) is a more complex algorithm capable of capturing non-linear patterns, thus reducing bias. Option A (increasing L2 regularization) increases bias by penalizing large weights.

Option D (using a smaller training dataset) typically increases bias due to less data.

Practice this question →
556
MCQmedium

A data scientist is training a text classification model using Amazon SageMaker's BlazingText algorithm. The dataset consists of 1 million documents, each labeled with one of 10 categories. The model achieves 92% accuracy on a held-out test set. However, when deployed, the model performs poorly on documents containing slang and typos. What should the data scientist do to improve model robustness?

A.Remove all documents with slang or typos from the training set.
B.Augment the training data by introducing common slang replacements and typos.
C.Increase the embedding dimension from 100 to 300.
D.Increase the number of training epochs.
AnswerB

Data augmentation exposes the model to realistic noise, improving robustness.

Why this answer

Data augmentation by introducing common slang replacements and typos into the training data increases the model's robustness to such variations, helping it generalize better to real-world text that contains slang and typos. Removing such documents (Option A) reduces the training data and does not teach the model to handle these variations. Increasing the embedding dimension (Option C) or number of epochs (Option D) does not directly address the issue of slang and typos.

Practice this question →
557
MCQeasy

A team is building a product recommendation system using matrix factorization in Amazon SageMaker. They notice that the model's training loss decreases steadily but validation loss starts increasing after 5 epochs. What is the most likely cause?

A.Underfitting
B.Not enough training data
C.Learning rate too high
D.Overfitting
AnswerD

The model is memorizing the training data.

Why this answer

In matrix factorization for recommendation systems, a decreasing training loss with an increasing validation loss after several epochs is a classic sign of overfitting. The model is memorizing the training data (including noise) rather than learning generalizable patterns, which degrades its performance on unseen validation data.

Exam trap

The trap here is that candidates may confuse the symptom of overfitting (training loss decreasing, validation loss increasing) with underfitting or a learning rate issue, but the key is the divergence between the two loss curves after a period of convergence.

How to eliminate wrong answers

Option A is wrong because underfitting would show high training loss that does not decrease sufficiently, not a diverging gap between training and validation loss. Option B is wrong because insufficient training data can contribute to overfitting, but the direct symptom described—training loss decreasing while validation loss increases—is the hallmark of overfitting, not a data quantity issue alone. Option C is wrong because a learning rate that is too high typically causes the loss to oscillate or diverge entirely, not a steady decrease in training loss with a later increase in validation loss.

Practice this question →
558
Multi-Selecthard

A company is deploying a machine learning model for real-time fraud detection. The model must have extremely low latency (<10 ms) and high throughput. Which THREE design choices meet these requirements? (Choose 3.)

Select 3 answers
A.Use GPU instances (e.g., ml.p3) for the endpoint.
B.Use one endpoint per model to avoid interference.
C.Use SageMaker Batch Transform for real-time predictions.
D.Use SageMaker multi-model endpoints to host multiple models on the same instance.
E.Use SageMaker Elastic Inference to attach GPU acceleration to a CPU instance.
AnswersA, D, E

GPU accelerates inference, reducing latency.

Why this answer

GPU instances like ml.p3 provide massively parallel compute capability that accelerates matrix operations common in deep learning models, enabling inference latencies under 10 ms. For real-time fraud detection, the GPU's high throughput and low latency are essential for processing thousands of transactions per second without bottlenecks.

Exam trap

The MLS-C01 exam often tests the misconception that batch processing services like Batch Transform can be used for real-time inference, but the key distinction is that Batch Transform is designed for offline, asynchronous workloads and cannot meet low-latency requirements.

Practice this question →
559
Multi-Selecthard

Which TWO of the following are techniques used to reduce overfitting in a neural network?

Select 2 answers
A.Increase the number of layers
B.Batch normalization
C.L2 regularization
D.Dropout
E.Increase the learning rate
AnswersC, D

L2 regularization penalizes large weights.

Why this answer

Options C and D are correct. C (L2 regularization) is correct because it penalizes large weights, reducing model complexity and overfitting. D (dropout) is correct because it randomly drops units during training, preventing co-adaptation.

A is wrong because increasing the number of layers increases model complexity, which can worsen overfitting. B is wrong because batch normalization helps training stability but does not primarily reduce overfitting. E is wrong because increasing the learning rate may cause divergence, not reduce overfitting.

Practice this question →
560
MCQeasy

A data scientist is training a binary classification model on an imbalanced dataset where the positive class represents only 1% of the data. The model achieves 99% accuracy but fails to identify most positive cases. Which metric should the data scientist use to evaluate model performance?

A.R-squared
B.F1 score
C.Accuracy
D.RMSE
AnswerB

F1 score balances precision and recall, suitable for imbalanced data.

Why this answer

The F1 score is the harmonic mean of precision and recall, making it ideal for imbalanced datasets where accuracy is misleading. Since the model achieves 99% accuracy by simply predicting the majority class (negative), it fails to capture positive cases; F1 score penalizes this by balancing false positives and false negatives, providing a more truthful performance measure.

Exam trap

The trap here is that candidates often default to accuracy as the primary metric, overlooking how imbalanced data can inflate accuracy while hiding poor positive class detection, which the F1 score directly addresses.

How to eliminate wrong answers

Option A is wrong because R-squared is a regression metric that measures the proportion of variance explained by the model, not applicable to binary classification. Option C is wrong because accuracy is misleading on imbalanced datasets; a model predicting all negatives achieves 99% accuracy but fails to identify any positives, so it does not reflect true performance. Option D is wrong because RMSE is a regression metric that measures the square root of the average squared differences between predicted and actual values, not suitable for binary classification outcomes.

Practice this question →
561
MCQeasy

A company is building a binary classifier to predict customer churn. The dataset has 10,000 samples with 500 churners (5% positive class). After training a logistic regression model, the precision is 0.8 and recall is 0.2. Which metric should the data scientist focus on to improve the model's ability to identify churners while minimizing false positives?

A.Increase accuracy
B.Increase precision
C.Increase recall
D.Increase F1 score
AnswerC

Recall is low (0.2), so improving it will capture more churners.

Why this answer

The model's recall is very low (0.2), meaning it misses most churners. Since the goal is to identify churners (positive class), improving recall should be the primary focus. Option A (accuracy) is misleading due to class imbalance.

Option B (precision) is already high (0.8), so further improvement would likely reduce recall. Option D (F1 score) balances precision and recall, but the immediate need is to address the low recall, not to balance both.

Practice this question →
562
MCQmedium

A machine learning engineer is deploying a PyTorch model on SageMaker for real-time inference. The model requires GPU for low latency. Which instance type and configuration should the engineer choose?

A.Deploy to an ml.c5.4xlarge instance with SageMaker batch transform.
B.Deploy to an ml.m5.large instance with a SageMaker model endpoint.
C.Deploy to an ml.p3.2xlarge instance with a SageMaker endpoint.
D.Deploy to an ml.p3.2xlarge instance with SageMaker batch transform.
AnswerC

p3 provides GPU; endpoint enables real-time inference.

Why this answer

SageMaker real-time endpoints support GPU instances like ml.p3.2xlarge. Option A (ml.c5.4xlarge with batch transform) is a CPU instance and batch transform is for offline inference, not real-time. Option B (ml.m5.large with endpoint) is a CPU instance and not suitable for GPU-accelerated inference.

Option D (ml.p3.2xlarge with batch transform) uses a GPU instance but batch transform is not real-time; a SageMaker endpoint is required for real-time inference.

Practice this question →
563
MCQhard

A company uses Amazon SageMaker to train a custom TensorFlow model for image classification. The training job runs on a single ml.p3.2xlarge instance. The dataset contains 500,000 images stored in S3. The training time is too long (over 24 hours). The data scientist wants to reduce training time without changing the model architecture. The dataset is already in TFRecord format. The training script uses the default TensorFlow data pipeline. Which change will MOST significantly reduce training time?

A.Use SageMaker Pipe mode and increase the number of data files.
B.Use SageMaker's distributed data parallelism with multiple instances.
C.Switch the input mode from File to Pipe.
D.Optimize the data pipeline using tf.data.Dataset.prefetch and cache.
AnswerB

Distributed training across multiple GPUs significantly reduces wall-clock training time.

Why this answer

Using SageMaker's distributed data parallelism with multiple instances increases the number of GPUs and splits the training data across them, directly reducing the compute time. Option A is incorrect because simply increasing the number of data files does not reduce the computational workload, and Pipe mode primarily helps with streaming data but does not accelerate model training. Option C is incorrect because switching from File to Pipe mode improves data loading but does not address the core compute bottleneck.

Option D is incorrect because optimizing the data pipeline with tf.data.Dataset.prefetch and cache can improve I/O efficiency, but the most significant performance gain comes from scaling out the training across multiple GPUs.

Practice this question →
564
MCQhard

A media company uses SageMaker to train a neural network for content recommendation. The model uses embeddings for users and items. Training is slow and they want to reduce time. The dataset has 10 million users and 1 million items. They have a cluster of 8 p3.16xlarge instances. Which strategy is most likely to reduce training time?

A.Use data parallelism to replicate the model on each GPU and synchronize gradients
B.Reduce the embedding dimension from 256 to 64
C.Use SageMaker's model parallelism to split the embedding layers across GPUs
D.Use a smaller batch size to fit on each GPU
AnswerC

Model parallelism distributes large embedding tables across devices, reducing memory and enabling larger batches.

Why this answer

SageMaker's model parallelism splits the embedding layers across GPUs, which is essential when the embedding table is too large to fit into the memory of a single GPU. With 10 million users and 1 million items, even with a modest embedding dimension of 256, the embedding layer alone can exceed 10 GB, causing memory bottlenecks that slow training. Model parallelism distributes these large parameters across multiple GPUs, reducing per-GPU memory pressure and enabling larger batch sizes, which directly reduces training time.

Exam trap

The trap here is that candidates often default to data parallelism as the standard approach for distributed training, failing to recognize that when the model itself (especially embedding layers) exceeds GPU memory, model parallelism is required to scale out effectively.

How to eliminate wrong answers

Option A is wrong because data parallelism replicates the entire model on each GPU, which does not solve the memory bottleneck caused by the massive embedding table; it actually increases memory usage per GPU and can lead to out-of-memory errors. Option B is wrong because reducing the embedding dimension from 256 to 64 would degrade recommendation quality by losing representational capacity, and while it might reduce memory, it does not address the fundamental issue of scaling training across the cluster efficiently. Option D is wrong because using a smaller batch size reduces throughput and increases the number of gradient updates needed, which actually increases total training time, not reduces it.

Practice this question →
565
Multi-Selecthard

A machine learning team is deploying a real-time inference endpoint for a fraud detection model using Amazon SageMaker. The model is a LightGBM classifier trained on 1 GB of tabular data. The endpoint must respond within 100 ms for 99% of requests, with a throughput of 10 requests per second. During load testing, the team observes that the 99th percentile latency is 250 ms and the endpoint CPU utilization is consistently above 90%. The team has already selected an ml.c5.xlarge instance with auto scaling enabled. Which combination of actions should the team take to meet the latency requirement? (Choose 3.)

Select 3 answers
A.Upgrade the instance type to ml.c5.2xlarge to increase CPU resources per instance.
B.Reduce the number of trees in the LightGBM model to decrease inference time.
C.Enable SageMaker's data compression for endpoint input payloads.
D.Switch to using SageMaker Batch Transform instead of a real-time endpoint.
AnswersA, B, C

More CPU reduces per-request processing time, lowering latency.

Why this answer

(upgrading to ml.c5.2xlarge) provides more CPU resources per instance, reducing CPU utilization and thus latency. Option B (reducing the number of trees in the LightGBM model) decreases the computational complexity of inference, directly lowering inference time. Option C (enabling SageMaker's data compression for endpoint input payloads) reduces the data transfer size, which can lower I/O overhead and network latency.

Option D (switching to SageMaker Batch Transform) is unsuitable because it is not designed for real-time inference and would not meet the low-latency requirement. Together, options A, B, and C address the latency issue by improving compute capacity, reducing model complexity, and minimizing data transfer time.

Practice this question →
566
MCQeasy

A data scientist is using Amazon SageMaker to train a linear regression model. The training data contains 100 features and 1 million rows. The scientist notices that the model is overfitting, with training R² of 0.99 and validation R² of 0.65. The scientist has already tried adding L2 regularization and reducing the number of features. Which additional technique should the scientist try to reduce overfitting?

A.Increase the amount of training data
B.Increase the batch size
C.Increase the learning rate
D.Add more features
AnswerA

More data helps the model generalize better.

Why this answer

Increasing the amount of training data provides the model with more examples of the underlying distribution, which helps reduce variance and combat overfitting. With 1 million rows and 100 features, the model may still be memorizing noise; adding more diverse data forces the linear regression to generalize better, improving validation R² without changing the model's capacity.

Exam trap

The trap here is that candidates often confuse techniques that improve optimization (batch size, learning rate) with techniques that improve generalization (more data, stronger regularization), leading them to pick B or C instead of A.

How to eliminate wrong answers

Option B is wrong because increasing batch size stabilizes gradient estimates and can speed up training, but it does not directly reduce overfitting—it may even lead to sharper minima that generalize worse. Option C is wrong because increasing the learning rate can cause training to diverge or oscillate, and it does not address the fundamental bias-variance tradeoff; it may actually worsen overfitting by preventing convergence to a good solution. Option D is wrong because adding more features increases model complexity and the risk of overfitting, which is the opposite of what is needed when the model already has high variance.

Practice this question →
567
MCQeasy

A data scientist is using SageMaker to train a linear learner algorithm. After training, the evaluation shows that the model has high bias. Which action is most likely to reduce bias?

A.Increase the L2 regularization strength
B.Reduce the amount of training data
C.Add feature crosses for categorical variables
D.Remove some features that have low variance
AnswerC

Adding feature crosses increases model capacity to capture interactions, reducing bias.

Why this answer

High bias indicates that the model is underfitting the data, meaning it is too simple to capture the underlying patterns. Adding feature crosses for categorical variables creates interaction features that allow the linear learner to model non-linear relationships, increasing model complexity and reducing bias. This is a standard technique in linear models to address underfitting without switching to a non-linear algorithm.

Exam trap

The trap here is that candidates often confuse bias with variance and incorrectly choose regularization (Option A) to fix underfitting, when regularization actually increases bias and is used to combat overfitting (high variance).

How to eliminate wrong answers

Option A is wrong because increasing L2 regularization strength penalizes large weights, which simplifies the model further and increases bias, not reduces it. Option B is wrong because reducing the amount of training data typically worsens underfitting by providing fewer examples for the model to learn from, increasing bias. Option D is wrong because removing low-variance features reduces the information available to the model, which can increase bias by discarding potentially useful signals.

Practice this question →
568
MCQmedium

A data science team is using Amazon SageMaker to train a deep learning model for object detection using the built-in SSD algorithm. The dataset consists of 100,000 labeled images stored in a SageMaker Pipe Mode input. The training job uses a single ml.p3.2xlarge instance. After 2 hours, the training job fails with the error 'ResourceLimitExceeded: The account-level service limit for ml.p3.2xlarge for training job usage is 1. Contact AWS Support to request a limit increase'. However, the team has already submitted a limit increase request and it was approved for 5 instances. What is the most likely cause of the error?

A.The instance is running out of GPU memory
B.The built-in SSD algorithm requires a GPU instance type with at least 16 GB of GPU memory
C.The service limit increase has not yet been applied to the account in the current region
D.The IAM role does not have permission to access the S3 bucket for model artifacts
AnswerC

The limit increase may not have been applied yet in the region, causing the 'ResourceLimitExceeded' error even though the increase was approved.

Why this answer

The error 'ResourceLimitExceeded' indicates that the account's service limit for ml.p3.2xlarge training instances has been exceeded. Even though the team requested and received approval for a limit increase to 5 instances, the increase may not have taken effect yet in the current region. AWS service limit increases are applied per region, and there can be a propagation delay after approval.

Option A (GPU memory) would cause a different error such as 'OutOfMemory'. Option B (algorithm requirement) is unrelated because the SSD algorithm does run on the chosen instance. Option D (S3 permissions) would result in an 'AccessDenied' error, not a limit error.

Therefore, option C is the correct answer.

Practice this question →
569
MCQmedium

A data scientist is using Amazon SageMaker to train a deep learning model on a large dataset stored in S3. The training job is taking too long. The data scientist wants to reduce training time without changing the model architecture. Which action should they take?

A.Use Pipe mode for data input
B.Use a smaller instance type
C.Increase the number of epochs
D.Decrease the batch size
AnswerA

Pipe mode streams data, reducing download time.

Why this answer

Using Pipe mode streams training data directly from S3 without first downloading it to the instance's local storage, significantly reducing I/O time and therefore overall training time. Option A is correct. Option B is incorrect because using a smaller instance type reduces compute capacity, which would likely increase training time.

Option C is incorrect because increasing the number of epochs would increase training time, not decrease it. Option D is incorrect because decreasing the batch size typically results in more gradient updates per epoch, which can increase training time.

Practice this question →
570
MCQmedium

A training job fails with the error shown. The training script expects a file named 'train.csv' in the 'training' channel. What is the most likely cause?

A.The 'train.csv' file is located inside a subfolder within 's3://my-bucket/data/', and the script expects it directly in the channel path.
B.The S3 bucket policy denies access to the 'train.csv' file.
C.The channel name in the input data configuration does not match the script's expected channel name.
D.The training script has a bug that prevents it from reading the file.
AnswerA

SageMaker downloads the entire S3 prefix; if the file is nested, it may not be at the expected location.

Why this answer

The error indicates that the training script cannot find 'train.csv' in the expected location. When SageMaker copies data from an S3 channel path (e.g., 's3://my-bucket/data/') to the training instance, it places the contents of that S3 prefix directly into the channel directory (e.g., '/opt/ml/input/data/training/'). If the CSV file is inside a subfolder (e.g., 's3://my-bucket/data/subfolder/train.csv'), the script will not find it at the top level of the channel path, causing a 'file not found' error.

Exam trap

The MLS-C01 exam often tests the distinction between S3 prefix behavior and file location expectations, trapping candidates who assume SageMaker automatically searches subdirectories or flattens the S3 structure.

How to eliminate wrong answers

Option B is wrong because an S3 bucket policy denying access would produce a different error (e.g., 'AccessDenied' or '403 Forbidden'), not a 'file not found' error from the training script. Option C is wrong because the error message does not mention a channel name mismatch; such a mismatch would cause SageMaker to fail to mount the channel, resulting in a different error during the job setup phase. Option D is wrong because the error is specifically about a missing file, not a runtime bug in the script's reading logic; a bug would typically produce a Python traceback or parsing error, not a 'file not found' error.

Practice this question →
571
MCQmedium

A company is using Amazon SageMaker to deploy a model for real-time inference. The model has a latency requirement of less than 100 milliseconds. During testing, the latency is around 150 milliseconds. Which action can most likely reduce the latency to meet the requirement?

A.Reduce the batch size for inference.
B.Enable data capture for the endpoint.
C.Increase the initial variant weight for the production variant.
D.Use a larger instance type for the endpoint.
AnswerD

A larger instance type provides more compute resources, reducing inference latency.

Why this answer

Enabling data capture adds overhead and increases latency. Using a larger instance type would provide more compute and reduce latency, but may increase cost. Reducing the batch size for inference (if batching is used) can reduce latency because the model processes fewer requests at once.

However, the question implies a real-time endpoint which typically processes one request at a time; batch size might be 1. Increasing the variant weight for the production variant is for traffic routing, not latency. The most direct is to use a more powerful instance type.

But also consider that increasing batch size (if using multi-record) increases latency. Reducing batch size reduces latency. However, for a real-time endpoint, the instance type is key.

I'll go with using a larger instance type.

Practice this question →
572
MCQhard

A company is deploying a machine learning model for real-time fraud detection. The model must have low latency (under 100 ms) and high throughput. The data scientist trains a gradient boosting model and deploys it to a SageMaker endpoint with a single ml.c5.xlarge instance. During load testing, the endpoint exceeds the latency threshold. Which change is MOST likely to reduce latency?

A.Replace the model with a simpler model, such as logistic regression
B.Use a larger instance type, such as ml.c5.4xlarge
C.Switch to batch transform for inference
D.Enable automatic scaling on the endpoint
AnswerA

A simpler model has lower inference latency, meeting the 100 ms requirement.

Why this answer

Replacing the gradient boosting model with a simpler model like logistic regression reduces the computational complexity per inference. Gradient boosting involves traversing many decision trees, each requiring multiple conditional checks and arithmetic operations, while logistic regression is a single linear transformation. This directly lowers CPU utilization per request, reducing latency under the same instance resources.

Exam trap

The trap here is that candidates often assume scaling up instance size or adding automatic scaling will fix latency, but latency is a per-request metric that depends on model complexity, not just infrastructure parallelism or throughput.

How to eliminate wrong answers

Option B is wrong because using a larger instance type (ml.c5.4xlarge) increases available vCPUs and memory, but the bottleneck is likely per-request computation time, not parallelism; a larger instance may improve throughput but does not guarantee per-request latency drops below 100 ms if the model itself is computationally heavy. Option C is wrong because batch transform is designed for offline, asynchronous inference on large datasets, not real-time low-latency serving; switching to batch transform would increase latency dramatically (minutes vs milliseconds) and violate the real-time requirement. Option D is wrong because automatic scaling adjusts the number of instances based on traffic, which helps with throughput under varying load but does not reduce the per-request latency of a single inference; scaling adds more endpoints but each individual request still faces the same model computation time.

Practice this question →
573
MCQeasy

A data scientist needs to evaluate a binary classification model. The dataset is balanced. Which metric is most appropriate to compare model performance?

A.Recall
B.F1 score
C.Precision
D.Accuracy
AnswerD

For balanced classes, accuracy is a straightforward metric.

Why this answer

For a balanced binary classification dataset, accuracy is the most appropriate metric because it directly measures the proportion of correct predictions (true positives and true negatives) out of all predictions. Since the class distribution is equal, accuracy is not misleadingly high due to class imbalance, making it a reliable and straightforward measure of overall model performance.

Exam trap

AWS often tests the misconception that F1 score or precision-recall metrics are always superior, but for balanced datasets, accuracy is the simplest and most appropriate metric, and candidates may overlook this by defaulting to imbalance-focused metrics.

How to eliminate wrong answers

Option A is wrong because recall focuses only on true positives relative to actual positives, ignoring true negatives and thus not capturing overall performance on a balanced dataset. Option B is wrong because the F1 score is the harmonic mean of precision and recall, which is more useful when there is class imbalance; for a balanced dataset, accuracy is simpler and equally informative. Option C is wrong because precision only considers true positives relative to predicted positives, neglecting true negatives and overall correctness, which is insufficient for balanced data.

Practice this question →
574
Multi-Selectmedium

Which TWO options are best practices for training machine learning models using SageMaker? (Choose TWO.)

Select 2 answers
A.Train the final model on the combined training and test sets to maximize data usage
B.Use incremental training when you have new data that is similar to the original training data
C.Use SageMaker Managed Spot Training to reduce training costs
D.Always use the largest possible instance type to minimize training time
E.Always enable checkpointing to save the model after every epoch
AnswersB, C

Incremental training saves time by starting from an existing model.

Why this answer

SageMaker's incremental training allows you to continue training an existing model with new data that shares the same schema and feature space, without retraining from scratch. This is a best practice when you have a steady stream of similar data, as it saves time and compute resources while preserving previously learned patterns.

Exam trap

The MLS-C01 exam often tests the misconception that 'more data is always better' (Option A) or that 'bigger instances are always faster' (Option D), when in reality best practices prioritize data integrity, cost efficiency, and appropriate resource scaling.

Practice this question →
575
MCQmedium

A company is using Amazon SageMaker to train a model. The training job is using a large dataset stored in S3. The data scientist notices that the training job is spending a significant amount of time reading data from S3. Which approach would BEST reduce data loading time?

A.Use the Pipe mode input for the training data
B.Use the File mode input with a larger instance
C.Use a larger training instance with more CPU
D.Increase the batch size to reduce the number of batches
AnswerA

Pipe mode streams data directly from S3 into the training container without first downloading it to the local disk, eliminating the I/O bottleneck caused by reading large datasets into memory before training begins. This satisfies the stem’s constraint of reducing the significant time spent on data loading, as the model processes data on-the-fly rather than waiting for full file downloads.

Why this answer

Pipe mode streams data directly from S3 into the training algorithm without first downloading it to the training instance's local storage. This eliminates the I/O bottleneck of writing large datasets to disk, significantly reducing data loading time compared to File mode, which downloads the entire dataset before training begins.

Exam trap

The trap here is that candidates often confuse 'batch size' with data loading performance, or assume that more CPU/instance size will speed up S3 reads, when in fact the bottleneck is the network and disk I/O, not compute.

How to eliminate wrong answers

Option B is wrong because File mode requires the entire dataset to be downloaded to the instance's local disk before training starts, which adds significant latency and does not address the root cause of slow S3 reads. Option C is wrong because a larger instance with more CPU does not reduce the time spent reading data from S3; the bottleneck is network I/O and S3 request latency, not compute capacity. Option D is wrong because increasing batch size only affects the number of forward/backward passes per epoch, not the time spent loading data from S3; the data must still be read in its entirety.

Practice this question →
576
MCQhard

A data scientist is using SageMaker to train an XGBoost model for regression. The training data contains categorical features with high cardinality (e.g., zip code with over 10,000 unique values). Which feature engineering approach is MOST appropriate to avoid overfitting while preserving predictive power?

A.Use target encoding with smoothing
B.One-hot encode the categorical features
C.Apply frequency encoding based on category occurrence
D.Label encode the categorical features
AnswerA

Target encoding captures category-target relationship with regularization to avoid overfitting.

Why this answer

Target encoding with smoothing is the most appropriate approach because it replaces each high-cardinality category with the mean of the target variable for that category, regularized by a smoothing factor that pulls estimates toward the global mean. This preserves predictive power by capturing the relationship between the category and the target while preventing overfitting on rare categories that have few samples. In SageMaker XGBoost, this avoids the curse of dimensionality from one-hot encoding and the arbitrary ordering from label encoding.

Exam trap

The trap here is that candidates often default to one-hot encoding for categorical features, not realizing that high cardinality makes it computationally infeasible and prone to overfitting, while target encoding with smoothing offers a compact and powerful alternative.

How to eliminate wrong answers

Option B is wrong because one-hot encoding a feature with over 10,000 unique values would create over 10,000 binary columns, drastically increasing dimensionality and memory usage, which leads to overfitting and poor generalization in tree-based models like XGBoost. Option C is wrong because frequency encoding replaces categories with their occurrence counts, which loses the relationship between the category and the target variable, often reducing predictive power and introducing bias toward frequent categories. Option D is wrong because label encoding assigns arbitrary integer labels to categories, which implies an ordinal relationship that does not exist, misleading the XGBoost model into treating the feature as ordered and potentially causing poor splits.

Practice this question →
577
MCQhard

A machine learning engineer is deploying a model for real-time inference using Amazon SageMaker. The model is a large ensemble that requires 8 GB of memory and 4 vCPUs. The expected traffic is 100 requests per second with a 200 ms latency requirement. Which instance configuration should they choose?

A.ml.t2.medium (2 vCPU, 4 GB)
B.ml.c5.2xlarge (8 vCPU, 16 GB)
C.ml.p3.2xlarge (8 vCPU, 61 GB GPU)
D.ml.m5.large (2 vCPU, 8 GB)
AnswerB

Adequate memory and vCPUs for the workload.

Why this answer

(ml.c5.2xlarge) is correct because it offers 8 vCPUs and 16 GB memory, meeting both the compute and memory requirements while being cost-effective for CPU-based inference. Option A (ml.t2.medium) is wrong because it has only 2 vCPUs and 4 GB, insufficient for the 8 GB memory need. Option C (ml.p3.2xlarge) is wrong because it includes a GPU, which is unnecessary and overkill for this CPU-bound workload, and costs more.

Option D (ml.m5.large) is wrong because it has only 2 vCPUs and 8 GB memory, lacking the required vCPUs and barely meeting memory.

Practice this question →
578
MCQhard

A machine learning engineer is training a model using Amazon SageMaker. The training data is stored in S3 and is 10 TB. The engineer wants to use Pipe input mode to stream data from S3. Which algorithms support Pipe mode? (Select all that apply)

A.Amazon SageMaker Linear Learner
B.Amazon SageMaker K-Means
C.Amazon SageMaker XGBoost
D.Amazon SageMaker PCA
AnswerA, B, C, D

Amazon SageMaker Linear Learner supports Pipe mode for streaming training data.

Why this answer

Amazon SageMaker's built-in algorithms, including Linear Learner, K-Means, XGBoost, and PCA, all support Pipe mode for streaming training data from S3. Therefore, all the listed options (A, B, C, D) are correct.

Practice this question →
579
Multi-Selecthard

A company uses Amazon SageMaker to train a deep learning model using TensorFlow. The training job is failing with an 'OutOfMemory' error. The instance type is ml.p3.2xlarge with 16 GB GPU memory. The model has 10 million parameters. Which THREE actions should be taken to resolve the memory issue? (Choose THREE.)

Select 3 answers
A.Reduce the batch size
B.Increase the number of epochs
C.Enable mixed precision training
D.Increase the batch size
E.Use gradient accumulation
AnswersA, C, E

Smaller batch size directly reduces memory usage.

Why this answer

Reducing the batch size directly decreases the memory footprint per training step because fewer samples are loaded into GPU memory simultaneously. With 10 million parameters and 16 GB GPU memory, the default batch size may exceed available memory for activations and gradients. This is the most straightforward fix for an OutOfMemory error in TensorFlow on SageMaker.

Exam trap

The trap here is that candidates may confuse 'increasing epochs' with reducing memory load, or think that increasing batch size helps convergence, when in fact it exacerbates the memory issue.

Practice this question →
580
Multi-Selectmedium

A machine learning engineer is training a deep learning model on Amazon SageMaker. The training job is taking a long time. Which THREE actions can reduce training time? (Choose 3.)

Select 3 answers
A.Use SageMaker managed spot training
B.Use SageMaker managed warm pools to reuse the training environment
C.Use SageMaker distributed training (data parallelism)
D.Use a smaller batch size
E.Use SageMaker hyperparameter tuning jobs
AnswersA, B, C

Spot instances can reduce cost and training time if interruptions are tolerated.

Why this answer

A is correct because SageMaker managed spot training leverages spare AWS EC2 capacity at a significantly lower cost, but more importantly, it can reduce training time by allowing you to use larger or more instances for the same budget. Spot instances can be interrupted, but SageMaker automatically resumes training from the last checkpoint, making this a viable speed-up strategy for fault-tolerant deep learning jobs.

Exam trap

The trap here is that candidates often confuse hyperparameter tuning (which runs many jobs) with a technique that speeds up a single training job, or they mistakenly think reducing batch size always improves speed, ignoring the negative impact on convergence and hardware utilization.

Practice this question →
581
MCQhard

A company is building a recommendation system using Amazon SageMaker Factorization Machines. The dataset includes user IDs, item IDs, and implicit feedback (clicks). The data is sparse with millions of users and items. The model needs to capture interactions between users and items. Which hyperparameter tuning strategy should be used to improve model performance?

A.Increase L2 regularization to prevent overfitting.
B.Increase the batch size to speed up training.
C.Decrease the learning rate to improve convergence.
D.Change the activation function to ReLU.
E.Increase the number of factors (num_factors) to capture more latent features.
AnswerE

More factors increase model capacity to learn interactions.

Why this answer

(increase number of factors) is correct because increasing num_factors increases the dimensionality of the latent feature vectors, allowing the model to capture more complex interactions between users and items. Option A (L2 regularization) helps prevent overfitting but does not increase the model's capacity to capture interactions. Option B (batch size) affects training speed and stability, not the expressiveness of the model.

Option C (learning rate) influences convergence but not the complexity of interactions. Option D (activation function) is not applicable since Factorization Machines are linear models and do not use activation functions like ReLU.

Practice this question →
582
Multi-Selectmedium

A data scientist is training a deep learning model on SageMaker using a custom container. The training job fails with an 'OutOfMemory' error. Which THREE actions could resolve this issue? (Choose 3.)

Select 3 answers
A.Use gradient accumulation to simulate larger batch sizes.
B.Reduce the number of training epochs.
C.Reduce the batch size.
D.Use an instance type with more memory, such as ml.p3.16xlarge.
E.Increase the learning rate.
AnswersA, C, D

Gradient accumulation divides the desired batch into micro-batches, performing a forward pass on each and accumulating gradients, then updating weights once. This simulates a larger batch without increasing memory per step.

Why this answer

An OutOfMemory error occurs when the model and data exceed the GPU memory. Reducing batch size (C) directly lowers memory per iteration. Gradient accumulation (A) allows using a larger effective batch size without increasing memory by splitting it into micro-batches.

Using an instance with more memory (D) provides additional capacity. Reducing epochs (B) does not affect per-batch memory; it only shortens training. Increasing learning rate (E) can cause instability but does not reduce memory usage.

Practice this question →
583
MCQhard

Refer to the exhibit. A custom training job using Pipe input mode fails. The logs indicate the algorithm cannot read the data. What is the most likely issue?

A.The algorithm expects File mode but Pipe mode is specified
B.The instance type is too small for the data
C.The training data is compressed
D.The training image is not accessible
AnswerA

Pipe mode sends data via pipe; algorithms expecting files will fail.

Why this answer

Pipe mode streams data from S3 via stdin, but the algorithm must be designed to read from a pipe rather than a file. Many custom algorithms expect file input, causing a failure. Option A is correct because Pipe mode is incompatible with algorithms expecting File mode.

Option B is incorrect because instance size does not affect data reading. Option C is incorrect because the data is not compressed. Option D is incorrect because the training image is accessible.

Practice this question →
584
MCQmedium

A company wants to use Amazon SageMaker to train a model using a custom algorithm packaged in a Docker container. Which approach should they use?

A.Use SageMaker Ground Truth
B.Use SageMaker Autopilot
C.Use the SageMaker SDK to create an Estimator with the image URI of the custom container
D.Select one of the built-in algorithms in SageMaker
AnswerC

The Estimator can accept a custom Docker image for training.

Why this answer

The correct approach is to use the SageMaker SDK to create an Estimator with the image URI of the custom container, as SageMaker supports bring-your-own-container for custom algorithms. Option A is incorrect because SageMaker Ground Truth is a labeling service, not for training custom algorithms. Option B is incorrect because SageMaker Autopilot automates model selection and tuning, but it does not support custom containers.

Option D is incorrect because built-in algorithms are predefined and do not allow custom code.

Practice this question →
585
MCQmedium

A company is deploying a fraud detection model using Amazon SageMaker. The model is a linear learner trained on 100 GB of data. For inference, the model receives individual transactions and must return a prediction within 100 ms. Which endpoint configuration should the team use to meet the latency requirement?

A.Use a multi-model endpoint with CPU instances.
B.Deploy a single model endpoint using a GPU instance and enable autoscaling.
C.Use a batch transform job scheduled every minute.
D.Deploy using SageMaker Serverless Inference.
AnswerB

GPU instance can process individual transactions fast, autoscaling handles traffic.

Why this answer

A single-model endpoint on a GPU instance provides the low-latency, high-throughput inference required for real-time fraud detection. GPU instances accelerate linear learner inference by parallelizing matrix operations, enabling sub-100 ms predictions for individual transactions. Autoscaling ensures the endpoint can handle traffic spikes without degrading latency.

Exam trap

The trap here is that candidates often choose multi-model endpoints (Option A) thinking they reduce cost, but they overlook the cold-start latency penalty for large models, which violates the strict 100 ms requirement.

How to eliminate wrong answers

Option A is wrong because multi-model endpoints share a single container and load models on demand, which adds cold-start latency that can exceed 100 ms for individual transactions, especially with a 100 GB model. Option C is wrong because batch transform jobs are designed for offline, asynchronous processing of large datasets, not real-time inference with a 100 ms latency requirement. Option D is wrong because SageMaker Serverless Inference has a maximum concurrency limit and cold-start latency that can exceed 100 ms, making it unsuitable for sub-100 ms real-time predictions.

Practice this question →
586
MCQeasy

A healthcare company needs to predict patient readmission risk using clinical notes. Which AWS service can be used to preprocess the text data into numerical features for a machine learning model?

A.Amazon SageMaker Ground Truth
B.Amazon Comprehend
C.Amazon Translate
D.Amazon Rekognition
AnswerB

Comprehend provides NLP capabilities for text feature extraction.

Why this answer

Amazon Comprehend is a natural language processing (NLP) service that can extract entities, key phrases, and sentiment. It is suitable for preprocessing clinical notes into features. SageMaker Ground Truth is for data labeling.

Rekognition is for images. Translate is for translation.

Practice this question →
587
Multi-Selectmedium

Which TWO of the following are valid approaches to handle missing values in a dataset for a machine learning model?

Select 2 answers
A.Use a neural network to predict missing values
B.Impute missing values with the mean of the column
C.Remove rows with missing values
D.Standardize the features to handle missing values
E.Apply one-hot encoding to convert missing values
AnswersB, C

Mean imputation is a standard technique for numerical features.

Why this answer

Removing rows with missing values is a valid approach (listwise deletion). Imputing with the mean is also valid. Using a neural network to predict missing values is possible but not standard.

Standardization does not handle missing values. One-hot encoding is for categorical variables.

Practice this question →
588
MCQmedium

A machine learning engineer is using Amazon SageMaker to train a model. The training data is stored in an S3 bucket encrypted with AWS KMS. The SageMaker training job fails with an AccessDenied error when trying to read the data. Which IAM policy addition should resolve the issue?

A.Add kms:Decrypt permission for the KMS key.
B.Add s3:GetObject permission for the bucket.
C.Add kms:GenerateDataKey permission for the key.
D.Attach the AmazonSageMakerFullAccess policy.
AnswerA

Decrypt is required to read encrypted objects.

Why this answer

When an S3 bucket is encrypted with AWS KMS, the SageMaker training job's execution role must have the `kms:Decrypt` permission for the specific KMS key to read the encrypted objects. Without this permission, the job fails with an AccessDenied error, even if `s3:GetObject` is granted, because SageMaker must decrypt the data before reading it.

Exam trap

The trap here is that candidates often assume `s3:GetObject` is sufficient for reading encrypted objects, overlooking that KMS-encrypted S3 data requires explicit `kms:Decrypt` permissions on the execution role.

How to eliminate wrong answers

Option B is wrong because `s3:GetObject` alone is insufficient; the error occurs specifically due to KMS encryption, so the missing permission is for KMS decryption, not S3 read access. Option C is wrong because `kms:GenerateDataKey` is used for creating new data keys for encryption, not for decrypting existing objects; the required permission for reading encrypted data is `kms:Decrypt`. Option D is wrong because attaching the `AmazonSageMakerFullAccess` managed policy does not automatically grant permissions for customer-managed KMS keys; it only provides basic SageMaker permissions, and explicit KMS key permissions must be added to the role.

Practice this question →
589
MCQmedium

A data scientist is training a binary classifier on an imbalanced dataset where the positive class represents 1% of the data. The model currently achieves 99% accuracy but a recall of only 10% on the positive class. Which metric combination should the data scientist prioritize to evaluate model improvements?

A.F1 score and AUC-ROC
B.Precision and recall at 90% precision
C.Accuracy and RMSE
D.Precision and RMSE
AnswerA

F1 score balances precision and recall; AUC-ROC is robust to imbalance.

Why this answer

With a highly imbalanced dataset (1% positive class), 99% accuracy is misleading because the model can achieve it by simply predicting the majority class. The low recall (10%) indicates the model fails to identify most positive instances. The F1 score balances precision and recall, providing a single metric for minority class performance, while AUC-ROC evaluates the model's ability to distinguish between classes across all thresholds, making it robust to class imbalance.

Exam trap

The trap here is that candidates see 99% accuracy and assume the model is good, failing to recognize that accuracy is a poor metric for imbalanced datasets, and that metrics like RMSE are for regression, not classification.

How to eliminate wrong answers

Option B is wrong because 'precision and recall at 90% precision' is not a standard metric combination; it fixes precision arbitrarily, which may not be achievable or relevant for evaluating overall model improvements, and it ignores the trade-off with recall. Option C is wrong because accuracy is misleading on imbalanced data (as shown) and RMSE is a regression metric, not suitable for binary classification evaluation. Option D is wrong because RMSE is inappropriate for classification tasks; it measures continuous error, not classification performance, and precision alone does not capture recall or threshold behavior.

Practice this question →
590
MCQmedium

Refer to the exhibit. A data scientist creates a SageMaker model using the configuration above. When deploying the model to an endpoint, the endpoint status remains 'Creating' for a long time and then fails. What is the most likely cause?

A.The S3 model artifact does not exist
B.The environment variable SAGEMAKER_REGION is incorrect
C.The model name is already in use
D.The IAM role lacks permission to pull the Docker image from ECR
AnswerD

The image is in a different account; the role needs ecr:GetDownloadUrlForLayer and BatchGetImage permissions.

Why this answer

The image URI points to an ECR repository in account 382416733822, which is not the customer's account. SageMaker expects the image to be in the same account or accessible via cross-account permissions. This URI is likely the AWS account for built-in algorithms, but if the region or repository is incorrect, it may fail.

The most likely issue is that the image does not exist in that account or the role lacks permissions to pull it.

Practice this question →
591
MCQeasy

A data scientist needs to implement a recommendation system for an e-commerce website. Which Amazon service is specifically designed for building and deploying recommendation models?

A.Amazon SageMaker
B.Amazon Rekognition
C.Amazon Forecast
D.Amazon Personalize
AnswerD

Personalize is specifically for building and deploying recommendation models.

Why this answer

Amazon Personalize is a fully managed machine learning service that provides real-time personalized recommendations. It is purpose-built for recommendation systems. SageMaker is a general-purpose ML platform, but Personalize is specialized for recommendations.

Practice this question →
592
MCQmedium

A data scientist is using Amazon SageMaker to train a linear regression model. The training data has 10 features and 100,000 observations. The model's training loss is decreasing, but the validation loss starts increasing after a few epochs. Which step should the data scientist take first to address this issue?

A.Add more features to the model
B.Reduce the learning rate
C.Increase the batch size
D.Increase the number of epochs
AnswerB

Reducing the learning rate can help the model converge more stably and reduce overfitting.

Why this answer

The increasing validation loss while training loss decreases is a classic sign of overfitting. Reducing the learning rate (Option B) is the first step to stabilize training by allowing the optimizer to take smaller, more controlled steps, which can help the model converge to a better local minimum and reduce validation loss. In SageMaker, this is typically adjusted via the `learning_rate` hyperparameter in the estimator.

Exam trap

The trap here is that candidates often confuse overfitting with underfitting and incorrectly choose to add more features or increase epochs, not realizing that the validation loss increase is a direct sign of overfitting that requires reducing model capacity or learning rate.

How to eliminate wrong answers

Option A is wrong because adding more features increases model complexity, which typically worsens overfitting by giving the model more capacity to memorize noise. Option C is wrong because increasing batch size provides a more accurate gradient estimate but does not directly address overfitting; it may even lead to sharper minima and worse generalization. Option D is wrong because increasing the number of epochs gives the model more iterations to overfit, which will further increase validation loss.

Practice this question →
593
MCQhard

Refer to the exhibit. A data scientist runs the above AWS CLI command to create a SageMaker training job using the built-in Linear Learner algorithm. The training job fails with an error. What is the most likely cause?

A.The S3 data type is AugmentedManifestFile, but Linear Learner requires RecordIO or CSV
B.The IAM role does not have sufficient permissions
C.The instance type ml.m5.large does not support the Linear Learner algorithm
D.The MaxRuntimeInSeconds is too short
AnswerA

Linear Learner does not support augmented manifest.

Why this answer

The command uses `S3DataType` as `AugmentedManifestFile`, but the Linear Learner algorithm only supports `RecordIO` or `CSV` as the S3 data type. AugmentedManifestFile is used for algorithms like object detection that require additional labels. The content type `application/x-recordio` is correct for RecordIO, but since the data type is set to AugmentedManifestFile, the training job fails.

The IAM role, instance type, and MaxRuntimeInSeconds are all valid and would not cause this specific error. Therefore, the most likely cause is the incorrect S3 data type, which corresponds to option A.

Practice this question →
594
Multi-Selecteasy

A machine learning engineer is deploying a model using Amazon SageMaker. The model requires preprocessing steps (e.g., scaling, encoding) that were applied during training. Which TWO options can ensure the same preprocessing is applied at inference?

Select 2 answers
A.Implement preprocessing as an AWS Lambda function invoked before inference.
B.Deploy a separate preprocessing endpoint and call it before the model endpoint.
C.Retrain the model in each inference request with the preprocessing applied.
D.Create a Scikit-learn pipeline that includes preprocessing and the model, then deploy it.
E.Use SageMaker Inference Pipeline to chain a preprocessing container with the model container.
AnswersD, E

The pipeline ensures consistent transformation during training and inference.

Why this answer

Options D and E are correct. A Scikit-learn pipeline bundles preprocessing and the model into a single object, ensuring consistent preprocessing during training and inference. SageMaker Inference Pipeline chains a preprocessing container with the model container, allowing separate preprocessing steps to be applied consistently at inference time.

Option A is wrong because using a Lambda function can introduce inconsistencies if not carefully managed, and it adds latency. Option B is wrong because a separate preprocessing endpoint adds complexity and may not guarantee identical preprocessing logic. Option C is wrong because retraining the model per inference request is impractical and computationally expensive.

Practice this question →
595
Multi-Selecteasy

Which TWO of the following are true about the bias-variance tradeoff?

Select 2 answers
A.Ensemble methods like bagging increase variance
B.Simple models tend to have high variance
C.High variance can cause overfitting
D.High bias can cause underfitting
E.High variance models are typically too simple
AnswersC, D

High variance means the model is very sensitive to training data, leading to overfitting.

Why this answer

The bias-variance tradeoff describes the balance between underfitting (high bias) and overfitting (high variance). Simple models have high bias and low variance, leading to underfitting. Complex models have low bias and high variance, leading to overfitting. Ensemble methods like bagging reduce variance by averaging multiple models. Therefore:

A is false: Bagging reduces variance, not increases.

B is false: Simple models have low variance, not high.

C is true: High variance causes the model to fit noise, i.e., overfitting.

D is true: High bias causes the model to miss relevant patterns, i.e., underfitting.

E is false: High variance models are typically too complex, not too simple.

Practice this question →
596
MCQhard

A team is building a model to predict customer churn. They have 50 features, including categorical variables with high cardinality (e.g., zip code with 10,000 unique values). Which feature engineering technique is most appropriate?

A.Binning zip codes into regions
B.Target encoding
C.Label encoding
D.One-hot encoding
AnswerB

Target encoding condenses high cardinality into one numeric feature.

Why this answer

Target encoding replaces each category with the mean of the target variable, which handles high cardinality well. Option A (binning) reduces cardinality but loses information. Option B is correct because target encoding is specifically designed for high-cardinality categorical features.

Option C (label encoding) implies ordinality and can introduce misleading relationships. Option D (one-hot encoding) would create 10,000 binary columns, causing high dimensionality.

Practice this question →
597
MCQmedium

A data scientist is training a deep learning model on a GPU instance. The training loss is decreasing, but the validation loss starts increasing after a few epochs. Which action should the data scientist take to address this?

A.Reduce the batch size
B.Implement early stopping
C.Increase the learning rate
D.Add more layers to the model
AnswerB

Early stopping halts training when validation loss increases.

Why this answer

Early stopping monitors validation loss and stops training when it starts to increase, which directly addresses overfitting. Option A (reduce batch size) is not the best action; while it can affect training dynamics, it does not directly prevent validation loss increase due to overfitting. Option C (increase learning rate) is incorrect as it may cause the model to diverge or overshoot optimal minima.

Option D (add more layers) is incorrect because adding layers increases model complexity, which typically worsens overfitting.

Practice this question →
598
MCQeasy

A company is using Amazon SageMaker to train a linear learner model for predicting customer lifetime value. The target variable is right-skewed with a long tail. The data scientist applies a log transformation to the target variable and trains the model. The model achieves a low root mean squared error (RMSE) on the log scale. However, when the predictions are exponentiated back to the original scale, the RMSE is much higher. Which step should the data scientist take to improve the model's performance on the original scale?

A.Increase the regularization strength
B.Remove outliers from the training data
C.Use a loss function that models the original distribution, such as Poisson or Tweedie
D.Use a deep learning model instead of linear learner
AnswerC

These loss functions handle skewed distributions better.

Why this answer

Using a loss function like Poisson or Tweedie directly models the non-negative, skewed distribution of the target variable in its original scale, which avoids the bias introduced by log transformation when predicting on the original scale. Option A (increase regularization) may not address the scale mismatch. Option B (remove outliers) could discard valuable data.

Option D (use a deep learning model) might not solve the fundamental issue of loss function selection.

Practice this question →
599
Multi-Selecthard

Which THREE of the following are valid strategies to reduce overfitting in a deep neural network? (Choose 3)

Select 3 answers
A.Increase the number of layers.
B.Use early stopping.
C.Increase the learning rate.
D.Add L2 regularization to the loss function.
E.Use dropout layers.
AnswersB, D, E

Early stopping prevents overfitting.

Why this answer

Early stopping halts training when validation performance degrades, preventing overfitting. Option D is correct because L2 regularization adds a penalty on large weights, discouraging complexity. Option E is correct because dropout randomly drops neurons during training, reducing co-adaptation.

Option A is wrong because adding more layers increases model capacity, which exacerbates overfitting. Option C is wrong because a higher learning rate can cause the loss to diverge and does not directly address overfitting.

Practice this question →
600
Multi-Selecteasy

Which TWO of the following are appropriate use cases for using Amazon SageMaker BlazingText? (Choose 2)

Select 2 answers
A.Text classification using supervised learning.
B.Time series forecasting.
C.Learning word embeddings from a large text corpus.
D.Classifying images.
E.Sequence-to-sequence translation.
AnswersA, C

BlazingText has supervised mode.

Why this answer

Amazon SageMaker BlazingText supports text classification using supervised learning. Option C is correct because BlazingText can learn word embeddings (e.g., Word2Vec) from large text corpora. Option B is incorrect because time series forecasting is not a capability of BlazingText; it is suited for NLP tasks.

Option D is incorrect because BlazingText does not support image classification—that would require a different service or algorithm. Option E is incorrect because sequence-to-sequence translation is not supported by BlazingText; it is designed for word-level embeddings and text classification.

Practice this question →
← PreviousPage 8 of 9 · 603 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Ml Modeling questions.

Start 20-question session