CCNA Ml Implementation Operations Questions — Page 3 of 5

151

MCQeasy

Refer to the exhibit. An ML engineer creates a CloudFormation stack with this template. The stack creation succeeds, but when the engineer tries to invoke the endpoint, it returns a ModelError. The CloudWatch logs show that the container exited with error. What is the MOST likely cause?

A.The execution role does not have permissions to pull the Docker image from ECR.

B.The initial instance count is set to 2, which is insufficient for the model size.

C.The endpoint is not deployed in a VPC and cannot access the S3 bucket.

D.The EndpointConfig references the model but the model is not yet created.

AnswerA

The role must have ECR permissions to pull the image; if missing, the container fails to start.

Why this answer

The CloudFormation template likely does not grant the SageMaker execution role the necessary `ecr:GetDownloadUrlForLayer` and `ecr:BatchGetImage` permissions to pull the container image from Amazon ECR. Without these permissions, the SageMaker service cannot download the Docker image to the ML compute instances, causing the container to fail with a ModelError and exit error in CloudWatch logs.

Exam trap

The trap here is that candidates often assume a ModelError is always due to model artifacts or code issues, but in CloudFormation deployments, the most frequent cause is missing ECR permissions for the execution role, especially when the image is in a different account or the role is not explicitly granted pull access.

How to eliminate wrong answers

Option B is wrong because the initial instance count of 2 is not inherently insufficient; SageMaker can scale horizontally, and a ModelError with container exit is not caused by instance count but by the container failing to start. Option C is wrong because the endpoint does not need to be in a VPC to access S3; SageMaker endpoints can access S3 via the internet or VPC endpoints, and the error is a container exit, not a network timeout. Option D is wrong because CloudFormation creates resources in dependency order; the EndpointConfig references the Model, and if the Model were not created, the stack creation would fail, not succeed.

Practice this question →

152

MCQmedium

A company is using Amazon SageMaker to train a deep learning model. The training job uses a script that reads data from Amazon S3 using the SageMaker SDK's `s3_input` method. The training job runs on a single ml.p3.2xlarge instance. The data scientist notices that the GPU utilization is very low during training, often below 20%. The training dataset is large, approximately 50 GB, stored as TFRecord files in S3. What is the MOST likely cause of low GPU utilization?

A.The training script is using a CPU-only version of TensorFlow.

B.The data loading pipeline is not optimized, causing the GPU to wait for data.

C.The batch size is too large, causing the GPU to run out of memory.

D.The instance type does not have enough GPU memory for the model.

AnswerB

Correct: Inefficient data loading leads to GPU starvation.

Why this answer

Low GPU utilization typically indicates that the GPU is waiting for data, which is a classic symptom of a data loading bottleneck. With a large 50 GB TFRecord dataset and a single ml.p3.2xlarge instance, the default SageMaker SDK's s3_input method may not be optimized for high throughput. To fully utilize the GPU, techniques such as using Pipe mode, prefetching, parallel data extraction, and using a data loader like TensorFlow's tf.data API with interleave and prefetch are recommended.

Option B correctly identifies this bottleneck. Option A is incorrect because a CPU-only version of TensorFlow would not run on a GPU at all. Option C is incorrect because a batch size that is too large causes out-of-memory errors, not low utilization.

Option D is incorrect because ml.p3.2xlarge has 8 GB of GPU memory, which is suitable for many models; low memory would cause failures rather than low utilization.

Practice this question →

153

MCQeasy

A company is using SageMaker to train a linear regression model on a dataset that fits into memory on a single instance. The training job is taking longer than expected. The data scientist wants to reduce training time without changing the algorithm. Which approach is most effective?

A.Disable automatic model tuning.

B.Use a larger instance type with more vCPUs.

C.Use SageMaker's distributed training with multiple instances.

D.Reduce the number of epochs.

AnswerC

Parallel processing reduces training time.

Why this answer

SageMaker's distributed training with multiple instances performs data parallelism, splitting the dataset across instances to train concurrently, which reduces training time for data that fits in memory. Option A is wrong because disabling automatic model tuning (hyperparameter tuning) does not speed up training; it only stops searching for optimal hyperparameters. Option B is wrong because while a larger instance with more vCPUs can help, distributed training scales better and is more cost-effective for this scenario.

Option D is wrong because reducing the number of epochs would likely underfit the model, hurting accuracy.

Practice this question →

154

MCQhard

A company deploys a SageMaker model for inference. After a few days, response times increase significantly. CloudWatch metrics show high CPU utilization and memory usage. The model is a large ensemble. What is the most cost-effective solution?

A.Configure SageMaker automatic scaling based on CPU utilization

B.Use CloudWatch alarms to notify the team, who manually launch additional endpoints

C.Migrate the model to AWS Lambda with provisioned concurrency

D.Replace the current instance type with a larger one

AnswerA

Auto scaling dynamically adjusts instance count to handle load cost-effectively.

Why this answer

SageMaker automatic scaling based on CPU utilization is the most cost-effective solution because it dynamically adjusts the number of inference instances in response to real-time demand, adding capacity only when CPU usage is high and removing it when demand drops. This avoids over-provisioning while maintaining performance for the large ensemble model, which is compute-intensive. Other options either introduce manual overhead, are unsuitable for large models, or incur unnecessary cost by permanently using larger instances.

Exam trap

The trap here is that candidates often choose manual scaling (Option B) or vertical scaling (Option D) because they seem simpler, but the exam tests the understanding that automatic horizontal scaling is the most cost-effective and operationally efficient approach for handling variable inference workloads in SageMaker.

How to eliminate wrong answers

Option B is wrong because manually launching additional endpoints via CloudWatch alarms introduces latency and operational overhead, failing to provide the automated, real-time scaling needed to address sudden increases in response times. Option C is wrong because AWS Lambda has a maximum execution timeout of 15 minutes and limited memory (up to 10 GB), making it unsuitable for hosting large ensemble models that require sustained compute and significant memory. Option D is wrong because replacing the current instance type with a larger one is a vertical scaling approach that does not adapt to fluctuating demand, leading to either underutilization during low traffic or continued high costs without addressing the root cause of scaling needs.

Practice this question →

155

MCQhard

A data scientist needs to run a hyperparameter tuning job for a deep learning model. Which SageMaker feature should they use?

A.SageMaker Hyperparameter Tuning Job

B.SageMaker Experiments

C.SageMaker Automatic Model Tuning

D.SageMaker Processing

AnswerA

This is the correct feature for hyperparameter optimization.

Why this answer

SageMaker Hyperparameter Tuning Job (option A) is the correct feature because it is the native SageMaker capability designed specifically to automate the search for optimal hyperparameters for a machine learning model. It launches multiple training jobs with different hyperparameter combinations, evaluates them against a specified objective metric, and uses strategies like Bayesian optimization or random search to converge on the best configuration. This directly matches the requirement to run a hyperparameter tuning job for a deep learning model.

Exam trap

AWS often tests the distinction between the official feature name 'SageMaker Hyperparameter Tuning Job' and the colloquial or older term 'SageMaker Automatic Model Tuning' to catch candidates who memorize synonyms rather than precise service names.

How to eliminate wrong answers

Option B (SageMaker Experiments) is wrong because it is designed for tracking, organizing, and comparing machine learning trials and their metadata, not for automatically searching hyperparameter values. Option C (SageMaker Automatic Model Tuning) is wrong because it is simply an alias or older marketing term for the same SageMaker Hyperparameter Tuning Job feature, not a separate service; the question asks for the feature name, and the official AWS documentation uses 'SageMaker Hyperparameter Tuning Job'. Option D (SageMaker Processing) is wrong because it is a managed service for running data preprocessing, postprocessing, or model evaluation scripts on ephemeral compute, not for hyperparameter optimization.

Practice this question →

156

MCQhard

A team is using Amazon SageMaker Autopilot to automatically build models. The dataset has 50 features and 1 million rows. After training, Autopilot generates multiple candidates. The team wants to deploy the model with the highest accuracy. What is the best practice to select and deploy the model?

A.Deploy all candidates behind a multi-model endpoint and route traffic based on request features

B.Select the model with the highest validation accuracy after performing additional hyperparameter tuning

C.Manually review each candidate's architecture and select the one with the simplest design

D.Deploy the candidate with the highest objective metric value from the Autopilot leaderboard

AnswerD

Autopilot ranks candidates by objective metric.

Why this answer

Amazon SageMaker Autopilot automatically generates a leaderboard ranking candidate models by their objective metric (e.g., accuracy, F1, AUC). The highest-ranked candidate represents the best-performing model based on the validation data, and deploying it directly is the recommended best practice. Autopilot handles preprocessing, algorithm selection, and hyperparameter tuning internally, so manual intervention is unnecessary.

Exam trap

The trap here is that candidates may overthink the process and assume manual review or additional tuning is required, when in fact Autopilot is designed to automate model selection and deployment based on the leaderboard.

How to eliminate wrong answers

Option A is wrong because deploying all candidates behind a multi-model endpoint and routing traffic based on request features is overly complex and not a standard practice for Autopilot; it would require custom routing logic and does not leverage Autopilot's built-in leaderboard. Option B is wrong because Autopilot already performs automated hyperparameter tuning for each candidate; additional manual tuning would duplicate effort and could lead to overfitting or unnecessary complexity. Option C is wrong because manually reviewing each candidate's architecture and selecting the simplest design ignores the objective metric; Autopilot optimizes for performance, not simplicity, and the simplest model may have lower accuracy.

Practice this question →

157

Multi-Selecthard

A data scientist is deploying a model on Amazon SageMaker for real-time inference. The model is a PyTorch model that requires custom inference code. The data scientist needs to handle variable-length inputs and optimize inference latency. Which TWO steps should the data scientist take? (Choose TWO.)

Select 2 answers

A.Enable SageMaker batch transform to process requests in batches.

B.Use the SageMaker PyTorch container without any modifications.

C.Set the endpoint to use multiple variants for A/B testing.

D.Use TorchScript to compile the model for optimized inference.

E.Provide a custom inference script (inference.py) that defines how to load the model and process requests.

AnswersD, E

Correct. TorchScript compiles PyTorch models for optimized inference, reducing execution time and efficiently handling variable-length inputs.

Why this answer

TorchScript compiles PyTorch models for optimized inference, reducing execution time and handling variable-length inputs efficiently. Option E is correct because a custom inference script (inference.py) is required to define preprocessing, prediction, and postprocessing logic for variable-length inputs. Option A is incorrect because SageMaker Batch Transform is designed for offline, asynchronous inference and cannot be used for real-time endpoints with sub-second latency.

Options B and C are also incorrect: using the PyTorch container without modifications would not support custom inference code, and multiple variants are for A/B testing, not latency optimization.

Exam trap

A common trap is assuming that batch transform can be used for real-time inference. However, SageMaker Batch Transform is meant for offline, asynchronous processing and cannot meet real-time latency requirements.

Practice this question →

158

MCQmedium

A company is deploying a real-time inference endpoint using Amazon SageMaker. The model is a large deep learning model that requires GPU inference. The company wants to minimize latency and cost. Which instance type and deployment strategy should be used?

A.Use a serverless inference endpoint with a GPU instance.

B.Use a real-time endpoint with a GPU instance and enable multi-model endpoints.

C.Use a batch transform job with a GPU instance.

D.Use an asynchronous inference endpoint with a GPU instance.

AnswerB

Multi-model endpoints reduce cost by sharing GPU across models.

Why this answer

Using a real-time endpoint with a GPU instance and enabling multi-model endpoints allows the company to serve multiple models on a single GPU instance, reducing cost by sharing the GPU resource while maintaining low latency for real-time inference. Multi-model endpoints load and unload models on demand, minimizing idle GPU time and optimizing cost without sacrificing the low-latency requirement.

Exam trap

The trap here is that candidates often assume serverless inference (Option A) is always the cheapest and simplest option, but they overlook that serverless does not support GPU instances, making it unsuitable for GPU-required deep learning models.

How to eliminate wrong answers

Option A is wrong because SageMaker serverless inference does not support GPU instances; it only supports CPU instances, so it cannot run a large deep learning model that requires GPU inference. Option C is wrong because batch transform jobs are designed for offline, asynchronous processing of large datasets, not for real-time inference, and they do not provide a persistent endpoint with low latency. Option D is wrong because asynchronous inference endpoints are intended for requests with large payloads or long processing times and do not guarantee the low latency required for real-time inference; they also do not minimize cost as effectively as multi-model endpoints for GPU workloads.

Practice this question →

159

MCQeasy

A company uses Amazon SageMaker to deploy a model for real-time inference. The model is a linear regression model that was trained using the SageMaker built-in Linear Learner algorithm. The endpoint is configured with an ml.m5.large instance. After deployment, the company notices that the endpoint returns incorrect predictions. The training data was normalized, but the inference requests send raw feature values without normalization. What should the company do to fix the issue?

A.Retrain the model using raw data without normalization.

B.Change the endpoint instance type to a GPU instance to handle the raw data.

C.Create a SageMaker inference pipeline that includes a preprocessing step to normalize the input data before passing it to the model.

D.Use a batch transform job to preprocess the data before sending it to the endpoint.

AnswerC

Correct: This ensures real-time raw data is normalized before inference.

Why this answer

The model was trained on normalized data, so it expects normalized input at inference time. Raw feature values will produce incorrect predictions because the model's coefficients are based on normalized data. The correct solution is to create a SageMaker inference pipeline that includes a preprocessing step (e.g., using a scikit-learn container) to normalize the input data before passing it to the model container.

Option A (retrain with raw data) would require retraining and might degrade performance if normalization was necessary for convergence. Option B (changing instance type) does not address the data mismatch. Option D (batch transform job) is for batch inference, not real-time inference via an endpoint.

Practice this question →

160

Multi-Selecteasy

A machine learning engineer is setting up a training job in Amazon SageMaker. Which THREE components are required to define a training job? (Choose three.)

Select 3 answers

A.VPC configuration for network isolation.

B.Hyperparameters for the algorithm.

C.Output data configuration (e.g., model artifact path).

D.An algorithm or custom container image.

E.Input data configuration (e.g., S3 path).

AnswersC, D, E

Specifies where to save output.

Why this answer

Output data configuration (e.g., model artifact path) is required because SageMaker needs to know where to save the trained model artifacts (e.g., the model.tar.gz file) in Amazon S3. Without this path, the training job cannot complete successfully as it has no destination for the output.

Exam trap

AWS commonly tests the distinction between required and optional parameters in SageMaker training jobs, and candidates mistakenly assume that hyperparameters or VPC settings are mandatory when they are actually optional.

Practice this question →

161

MCQmedium

A machine learning engineer is deploying a model using AWS Lambda for real-time inference. The model is a scikit-learn RandomForestClassifier with 100 trees, serialized as a pickle file of 150 MB. The Lambda function has 3 GB memory allocated. However, the inference requests are timing out after 30 seconds. What is the most likely cause?

A.scikit-learn is not compatible with AWS Lambda.

B.The Lambda function does not have enough memory to load the model.

C.The model is loaded from S3 on every invocation, causing high latency.

D.The Lambda function timeout is set too low; increase it to 5 minutes.

AnswerC

Lambda should load the model outside the handler to reuse across invocations, but even then, cold starts with a large model are slow.

Why this answer

The default behavior of loading a model from S3 on every Lambda invocation introduces significant latency. Each invocation must download the 150 MB pickle file from S3 over the network, deserialize it, and then run inference, which easily exceeds the 30-second timeout. The model should be loaded once outside the handler (in global scope) and reused across invocations to avoid this overhead.

Exam trap

The MLS-C01 exam often tests the misconception that Lambda timeouts are always the root cause of slow inference, when in fact the real issue is inefficient resource initialization (like loading large models from S3 on every call) that can be fixed by architectural changes rather than simply increasing the timeout.

How to eliminate wrong answers

Option A is wrong because scikit-learn is fully compatible with AWS Lambda when included in the deployment package or as a Lambda layer. Option B is wrong because 3 GB of memory is more than sufficient to load a 150 MB model; memory is not the bottleneck here. Option D is wrong because increasing the timeout to 5 minutes would mask the underlying issue of inefficient model loading, not solve it; the real problem is the per-invocation S3 download latency, not the timeout value itself.

Practice this question →

162

MCQeasy

A machine learning team is using SageMaker to build a model. They need to track hyperparameter tuning experiments, compare results, and visualize metrics. Which SageMaker feature should they use?

A.SageMaker Experiments

B.SageMaker Ground Truth

C.SageMaker Model Monitor

D.SageMaker Hyperparameter Tuning

E.SageMaker Debugger

AnswerA

Experiments provides tracking, comparison, and visualization.

Why this answer

SageMaker Experiments is the correct answer because it provides experiment tracking, comparison, and visualization capabilities for hyperparameter tuning and other training runs. SageMaker Hyperparameter Tuning (option D) only automates the tuning process but does not track or compare experiments. SageMaker Debugger (option E) is used for debugging training issues, not for experiment tracking.

SageMaker Model Monitor (option C) monitors deployed models for data drift and quality, not for tracking tuning experiments. SageMaker Ground Truth (option B) is for data labeling. Therefore, only SageMaker Experiments meets all the requirements.

Practice this question →

163

MCQmedium

A company is building a recommendation system using Amazon SageMaker. The training data includes user-item interactions stored in a DataFrame with over 100 million rows. The data scientist wants to perform feature engineering, including one-hot encoding of categorical features with high cardinality. Which approach is MOST cost-effective and scalable?

A.Use Amazon EMR with Spark and store the processed data in HDFS.

B.Use SageMaker Processing with a Spark container to distribute the encoding job.

C.Use a SageMaker notebook instance with scikit-learn to perform the encoding in memory.

D.Use AWS Glue ETL jobs to perform the encoding and store the result in S3.

AnswerB

SageMaker Processing with Spark provides distributed processing and is cost-effective for large datasets.

Why this answer

SageMaker Processing with a Spark container allows distributed execution of one-hot encoding on high-cardinality categorical features across a managed cluster, scaling horizontally to handle over 100 million rows without manual infrastructure management. This approach is cost-effective as you pay only for the processing time, and it integrates natively with SageMaker for seamless data pipeline orchestration.

Exam trap

The trap here is that candidates often choose AWS Glue (Option D) assuming it is the most scalable serverless option, but SageMaker Processing with Spark is more cost-effective and purpose-built for ML feature engineering within the SageMaker ecosystem, avoiding Glue's higher per-DPU costs and slower job startup times for large datasets.

How to eliminate wrong answers

Option A is wrong because Amazon EMR with Spark and HDFS introduces additional overhead for cluster management and HDFS storage, which is less cost-effective and scalable compared to SageMaker Processing's serverless-like model, and HDFS is not as durable or cost-efficient as S3 for processed data. Option C is wrong because a SageMaker notebook instance with scikit-learn cannot perform one-hot encoding in memory on over 100 million rows due to memory constraints, leading to out-of-memory errors or excessive costs from a large instance. Option D is wrong because AWS Glue ETL jobs, while serverless, are optimized for schema-on-read and transformations but can be slower and more expensive for large-scale one-hot encoding of high-cardinality features due to its Spark-based runtime overhead and lack of fine-grained control over distributed encoding compared to SageMaker Processing.

Practice this question →

164

MCQhard

A team notices that a SageMaker training job using TensorFlow is running slower than expected. The training data is in S3 in TFRecord format. Which action is most likely to improve training throughput?

A.Use Pipe mode for data ingestion

B.Use distributed training with more instances

C.Increase the batch size in the training script

D.Switch from Pipe mode to File mode

AnswerA

Pipe mode streams data, reducing I/O wait time.

Why this answer

Pipe mode streams data directly from S3 into the training container without writing to disk, eliminating the I/O bottleneck of downloading TFRecord files first. Since TFRecords are already serialized for efficient reading, Pipe mode leverages this by feeding data sequentially, which reduces latency and improves throughput for TensorFlow jobs.

Exam trap

The trap here is that candidates often assume distributed training (Option B) always speeds up training, but the question specifically points to a data ingestion bottleneck, and Pipe mode directly addresses that by reducing I/O wait time.

How to eliminate wrong answers

Option B is wrong because adding more instances introduces network communication overhead (e.g., gradient synchronization) that can actually slow down training if the dataset is small or the model is not embarrassingly parallel; it does not address the data ingestion bottleneck. Option C is wrong because increasing batch size may improve GPU utilization but does not fix the underlying slow data loading from S3; it can even cause out-of-memory errors or require learning rate tuning. Option D is wrong because switching from Pipe mode to File mode would download the entire dataset to the local EBS volume before training, increasing startup time and disk I/O, which would worsen throughput.

Practice this question →

165

Matchingmedium

Match each SageMaker built-in metric to its meaning.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Fraction of correct predictions on validation set

Root mean square error on validation set

Area under ROC curve on validation set

Logistic loss on validation set

Harmonic mean of precision and recall on validation set

Why these pairings

Accuracy measures overall correctness, precision measures positive predictive value, and recall measures sensitivity. Common confusions occur when precision and recall definitions are swapped.

Practice this question →

166

MCQeasy

A machine learning engineer is deploying a model to an Amazon SageMaker endpoint. The model requires GPU for inference. Which instance type should be selected?

A.ml.p3.2xlarge

B.ml.m5.large

C.ml.c5.xlarge

D.ml.r5.large

AnswerA

GPU instance suitable for inference.

Why this answer

Ml.p3.2xlarge is a GPU-enabled instance (part of the P3 family) suitable for inference requiring GPU acceleration. Options B, C, and D (ml.m5.large, ml.c5.xlarge, ml.r5.large) are CPU-only instances and do not provide GPU capabilities.

Practice this question →

167

MCQmedium

A company is using SageMaker to train a linear learner algorithm. The training log shows that the algorithm converges but the final loss is still high. Which change is most likely to improve the model?

A.Reduce the early stopping tolerance

B.Increase the maximum runtime

C.Add feature crosses or polynomial features

D.Increase the number of training instances

AnswerC

Linear models benefit from feature engineering to capture non-linear relationships.

Why this answer

A high final loss despite convergence indicates that the model is underfitting — the linear decision boundary is too simple to capture the underlying patterns in the data. Adding feature crosses or polynomial features increases the model's expressiveness by introducing non-linear interactions, allowing the linear learner to fit more complex relationships and reduce the loss.

Exam trap

The trap here is that candidates confuse convergence (the optimization stopping) with a good model, overlooking that a linear model can converge to a high-loss minimum if the data is non-linear — the fix is feature engineering, not hyperparameter tuning or more data.

How to eliminate wrong answers

Option A is wrong because reducing early stopping tolerance would cause training to stop even sooner, which does not address the fundamental issue of model capacity and would likely worsen the high loss. Option B is wrong because increasing maximum runtime does not help if the model has already converged; the algorithm has reached a plateau and more time will not reduce the loss further. Option D is wrong because increasing the number of training instances does not increase model complexity — it only provides more data for the same linear model, which may actually increase the irreducible error if the data is inherently non-linear.

Practice this question →

168

MCQmedium

A SageMaker training job fails with the failure reason shown in the exhibit. What is the most likely cause?

A.The training instance ran out of memory

B.The S3 bucket with training data is not accessible

C.The SageMaker service limit for the instance type has been exceeded

D.There is an error in the custom training script

AnswerD

ExecuteUserScriptError with ExitCode 1 indicates script error.

Why this answer

The failure reason in the exhibit (not shown here but implied by the question) typically indicates a runtime error such as a Python exception, missing module, or syntax error in the custom training script. SageMaker logs the exact error from the container, and when the script itself fails, the training job terminates with a 'ClientError' or 'AlgorithmError' referencing the script, not infrastructure issues.

Exam trap

The MLS-C01 exam often tests the distinction between infrastructure failures (S3 access, memory, limits) and application-level failures (script errors), and the trap here is that candidates assume any training failure is due to resource limits or data access, ignoring the explicit error message from the script.

How to eliminate wrong answers

Option A is wrong because out-of-memory errors usually manifest as 'ResourceExhaustedError' or container OOM kill signals, not a script-level failure reason. Option B is wrong because inaccessible S3 buckets cause a 'ClientError' with a specific 'AccessDenied' or 'NoSuchBucket' message, not a generic script failure. Option C is wrong because exceeding service limits results in a 'LimitExceededException' during job submission, not during training execution.

Practice this question →

169

MCQeasy

A machine learning engineer needs to store and version datasets for reproducibility. Which AWS service is designed for this purpose?

A.AWS CodeCommit

B.Amazon S3

C.SageMaker Feature Store

D.Amazon Redshift

AnswerC

Feature Store is designed for feature storage, versioning, and retrieval.

Why this answer

SageMaker Feature Store is designed to store, manage, and version features for machine learning, ensuring reproducibility. Option A (CodeCommit) is for version control of code. Option B (S3) is an object store not specialized for ML features.

Option D (Redshift) is a data warehouse. Therefore, Option C is correct.

Practice this question →

170

MCQmedium

An IAM policy attached to a SageMaker execution role is shown in the exhibit. When a data scientist tries to create a training job that writes logs to CloudWatch Logs, the job fails. What is the MOST likely reason?

A.The policy does not specify the SageMaker API version

B.The S3 bucket policy denies access to the training job

C.The policy lacks permissions for CloudWatch Logs actions

D.The policy has an implicit deny for SageMaker actions

AnswerC

Training jobs need logs:CreateLogGroup, logs:CreateLogStream, logs:PutLogEvents.

Why this answer

The IAM policy attached to the SageMaker execution role does not include permissions for CloudWatch Logs actions (e.g., CreateLogGroup, CreateLogStream, PutLogEvents), which are required to write logs during training job execution. Option A is incorrect because the API version is not relevant to permission issues. Option B is incorrect because the problem is not related to S3 bucket policy; the training job fails due to logging, not data access.

Option D is incorrect because the policy does not contain an explicit deny for SageMaker actions, but the lack of CloudWatch Logs permissions causes the failure.

Practice this question →

171

MCQmedium

A company is using Amazon SageMaker to train a deep learning model. The training job is failing with an error 'CUDA out of memory'. The training instance is an ml.p3.2xlarge with 16 GB GPU memory. The model architecture and batch size are appropriate for this instance size. What is the most likely cause of this error?

A.Reduce the number of epochs.

B.Increase the number of GPUs by using a distributed training instance type.

C.Enable automatic mixed precision (AMP) training to reduce memory usage.

D.Use a smaller instance type to force lower memory usage.

AnswerC

AMP uses FP16 where possible, cutting memory usage roughly in half, which often resolves out-of-memory errors.

Why this answer

Enabling automatic mixed precision (AMP) training reduces GPU memory usage by storing tensors in half-precision (FP16) where possible, while keeping critical operations in full precision (FP32). This directly addresses the 'CUDA out of memory' error on an ml.p3.2xlarge instance (16 GB GPU memory) without changing the model architecture or batch size, which are already appropriate.

Exam trap

The trap here is that candidates may incorrectly assume the solution is to reduce epochs (Option A) or scale out to more GPUs (Option B), when the root cause is memory exhaustion per GPU, which is best addressed by mixed precision training to halve the memory footprint without altering the model or batch size.

How to eliminate wrong answers

Option A is wrong because reducing the number of epochs does not affect peak GPU memory usage during training; it only changes the total training time, not the memory footprint per batch. Option B is wrong because increasing the number of GPUs via distributed training (e.g., ml.p3.16xlarge) does not reduce per-GPU memory consumption; it distributes the model across GPUs but each GPU still needs to hold its portion of the data and gradients, and the error is on a single GPU instance. Option D is wrong because using a smaller instance type would reduce available GPU memory (e.g., ml.p3.xlarge has only 8 GB), making the out-of-memory error worse, not better.

Practice this question →

172

MCQhard

A company uses Amazon SageMaker to train a text classification model. The training data is stored in S3 and contains sensitive personally identifiable information (PII). The company must ensure that the data is encrypted at rest in S3 and that the encryption key is managed by the company's own hardware security module (HSM). Which configuration should be used?

A.Use S3 server-side encryption with S3-managed keys (SSE-S3)

B.Use client-side encryption with the encryption key stored in the HSM

C.Use S3 server-side encryption with customer-provided keys (SSE-C) and store the keys in the HSM

D.Use S3 server-side encryption with AWS KMS managed keys (SSE-KMS) with a customer managed key

AnswerC

SSE-C allows customers to provide their own keys, which can be stored in an HSM.

Why this answer

SSE-C allows you to provide your own encryption key, which can be stored in your own HSM, and Amazon S3 manages the encryption/decryption process using that key. This satisfies the requirement for server-side encryption with a key managed by the company's HSM, ensuring data at rest is encrypted without exposing the key to AWS.

Exam trap

The trap here is that candidates confuse SSE-KMS with customer managed keys as meeting the 'customer-managed' requirement, but the question specifically requires the key to be managed by the company's own HSM, not by AWS KMS, which still stores the key in AWS's infrastructure.

How to eliminate wrong answers

Option A is wrong because SSE-S3 uses AWS-managed keys, not the company's own HSM-managed keys, violating the requirement for customer-controlled key management. Option B is wrong because client-side encryption encrypts data before it reaches S3, but the requirement specifies 'encrypted at rest in S3' and server-side encryption; client-side encryption also places the burden of key management on the client, but the key must be stored in the HSM, not used for client-side encryption. Option D is wrong because SSE-KMS with a customer managed key still relies on AWS KMS to manage the key, not the company's own HSM, and the key is not stored or managed directly in the company's HSM.

Practice this question →

173

MCQmedium

A machine learning team is deploying a model using Amazon SageMaker. The model inference code runs on GPUs and requires a custom container. The team wants to minimize cold start latency. Which SageMaker hosting option should they use?

A.Use a multi-model endpoint with GPU instances.

B.Use a serverless inference endpoint.

C.Use a real-time endpoint with multiple production variants for redundancy.

D.Use a real-time endpoint with a single production variant using a GPU instance.

AnswerD

Real-time endpoints with GPU instances minimize cold start latency for custom containers.

Why this answer

A real-time endpoint with a single production variant using a GPU instance provides a persistent, always-on inference environment. This eliminates cold start latency entirely, as the container and GPU resources are pre-warmed and ready to serve requests immediately, which is critical for minimizing latency in GPU-based custom containers.

Exam trap

The trap here is that candidates often confuse 'minimizing cold start latency' with 'scalability' or 'cost optimization,' leading them to choose serverless (Option B) or multi-model (Option A) options, which actually increase cold start latency due to their on-demand scaling behavior.

How to eliminate wrong answers

Option A is wrong because multi-model endpoints do not support GPU instances; they are designed for CPU-based hosting where multiple models share the same endpoint to reduce costs, not for minimizing cold start latency. Option B is wrong because serverless inference endpoints automatically scale to zero when idle, incurring cold start latency when a request arrives, which contradicts the goal of minimizing cold start latency. Option C is wrong because multiple production variants are used for A/B testing or gradual rollout, not for reducing cold start latency; they do not change the underlying cold start behavior of the endpoint.

Practice this question →

174

MCQeasy

A company wants to use SageMaker to host multiple models behind a single endpoint to reduce costs. Which SageMaker feature should they use?

A.SageMaker Elastic Inference

B.SageMaker inference pipeline

C.SageMaker batch transform

D.SageMaker multi-container endpoints

E.SageMaker Multi-Model Endpoints

AnswerE

Multi-Model Endpoints host multiple models on the same endpoint.

Why this answer

SageMaker Multi-Model Endpoints allow you to deploy multiple models behind a single endpoint, each loaded dynamically from Amazon S3 based on the inference request. This reduces hosting costs by sharing a single instance across many models, as only the models that are actively invoked consume memory. The correct answer is E because this feature is specifically designed for cost-efficient multi-model hosting.

Exam trap

The trap here is confusing SageMaker Multi-Model Endpoints with multi-container endpoints, but multi-container endpoints run multiple containers per instance for a single pipeline, not independently serving different models on demand.

How to eliminate wrong answers

Option A is wrong because SageMaker Elastic Inference attaches a fixed acceleration resource to a single model endpoint, not enabling multiple models behind one endpoint. Option B is wrong because SageMaker inference pipeline chains multiple containers (e.g., pre-processing, prediction, post-processing) for a single model workflow, not for hosting multiple independent models. Option C is wrong because SageMaker batch transform processes entire datasets offline in batches, not real-time inference with multiple models behind a single endpoint.

Option D is wrong because SageMaker multi-container endpoints run multiple containers per instance but they are part of a single inference pipeline or ensemble, not independently serving different models on demand.

Practice this question →

175

MCQhard

A data scientist is training a model using Amazon SageMaker. The training dataset is 500 GB and is stored in S3. The data scientist wants to use Pipe input mode to stream data directly from S3 to the training container. However, the training job fails with an error indicating that the container cannot read the data. What is the most likely cause?

A.The training instance does not have enough memory

B.The IAM role does not have s3:GetObject permission

C.The data is compressed and Pipe mode cannot handle compressed data

D.The S3 bucket is in a different Region

E.The training algorithm does not support Pipe mode

AnswerE

Not all algorithms support Pipe input; they need to read from a pipe.

Why this answer

Pipe mode in SageMaker streams data directly from S3 to the training container via a FIFO pipe, but the training algorithm must be specifically designed to read from a pipe (e.g., via stdin or a named pipe). If the algorithm expects random access to files or uses libraries that require seekable file handles (like many image-processing or custom Python scripts using `open()`), it will fail because a pipe is a sequential, non-seekable stream. SageMaker’s built-in algorithms like BlazingText and XGBoost support Pipe mode, but custom algorithms often do not unless explicitly coded for it.

Exam trap

The trap here is that candidates confuse Pipe mode with File mode and assume all algorithms can use Pipe mode, but SageMaker explicitly requires the algorithm to support streaming input, and many custom containers do not.

How to eliminate wrong answers

Option A is wrong because insufficient memory would cause an out-of-memory error, not a 'cannot read the data' error, and Pipe mode actually reduces memory usage by streaming data. Option B is wrong because missing s3:GetObject permission would cause an S3 access denied error, not a container read failure, and SageMaker would report a different error message. Option C is wrong because Pipe mode can handle compressed data (e.g., .gzip) as long as the algorithm supports decompression on the fly; SageMaker automatically decompresses for supported algorithms.

Option D is wrong because cross-Region S3 access is fully supported by SageMaker; the training job would still be able to read the data, though latency may increase.

Practice this question →

176

Multi-Selecthard

A company is training a deep learning model on SageMaker using multiple GPUs. The training is slow due to inefficient data loading. Which TWO actions can improve I/O performance?

Select 2 answers

A.Use instance store volumes for data.

B.Increase the instance count to a single large instance.

C.Use Pipe mode input for training data.

D.Use Amazon EBS volumes attached to training instances.

E.Use Amazon EFS as a shared file system.

AnswersC, E

Pipe mode streams data directly from Amazon S3 to the GPU instances without writing to disk, bypassing the filesystem bottleneck that slows I/O in multi-GPU training. This satisfies the constraint of inefficient data loading by eliminating disk-based staging, allowing GPUs to remain saturated with data during each epoch.

Why this answer

Pipe mode streams training data directly from Amazon S3 to the training algorithm, bypassing the need to download data to disk before training begins. This eliminates disk I/O bottlenecks and reduces data loading latency, which is critical for GPU-intensive training where GPUs may otherwise idle waiting for data.

Exam trap

The trap here is that candidates often confuse 'increasing instance size' with 'improving I/O performance,' but the real bottleneck is data loading latency, not compute capacity, and Pipe mode directly addresses this by streaming data without disk writes.

Practice this question →

177

MCQmedium

Refer to the exhibit. An IAM policy is attached to an IAM role used by a SageMaker training job. The training job fails with an access denied error when trying to write model artifacts to an S3 bucket. What is the most likely cause?

A.The IAM role does not have permission to write to the S3 bucket

B.The training job is trying to write to a different S3 bucket

C.The IAM role does not have permission to read the training data

D.The IAM role does not have permission to create training jobs

AnswerA

The policy lacks s3:PutObject, so writing model artifacts is denied.

Why this answer

The IAM role attached to the SageMaker training job must have an IAM policy that grants s3:PutObject permission on the S3 bucket where model artifacts are written. The access denied error indicates that the role lacks the necessary write permissions for that specific bucket, causing the training job to fail when it attempts to upload the model output.

Exam trap

The trap in this question is that candidates may confuse a write failure with a read failure, or assume the role is missing a broader permission like creating training jobs, when the error is specifically about missing s3:PutObject permission for the model artifacts bucket.

How to eliminate wrong answers

Option B is wrong because if the training job were trying to write to a different S3 bucket, the error would still be an access denied error unless the role had permissions for that bucket, but the question states the job fails when trying to write to the specified bucket, not a different one. Option C is wrong because the error occurs during the write of model artifacts, not during reading training data; a read permission issue would cause a different error (e.g., during data loading). Option D is wrong because the training job is already running, meaning the role has permission to create training jobs; the error is specifically about writing to S3, not about job creation.

Practice this question →

178

MCQeasy

A machine learning engineer needs to deploy a TensorFlow model to a SageMaker endpoint. The model expects a specific input format. The engineer has the model artifacts stored in an S3 bucket. Which step is REQUIRED to deploy the model?

A.Register the model in SageMaker Model Registry.

B.Create a SageMaker training job to re-train the model.

C.Save the model as a SavedModel format.

D.Create a SageMaker Model object using the TensorFlow serving image.

AnswerD

A SageMaker Model object is required to specify the container and artifact location for deployment.

Why this answer

To deploy a TensorFlow model to a SageMaker endpoint, you must create a SageMaker Model object that references the model artifacts in S3 and specifies the appropriate TensorFlow Serving container image. This image handles loading the model and exposing a RESTful or gRPC inference endpoint. Without this step, SageMaker cannot associate the artifacts with a serving container to start the endpoint.

Exam trap

A common misconception is that model artifacts must be in a specific format (like SavedModel) before deployment, but the question explicitly states the artifacts are already stored, so the required step is the SageMaker Model object creation, not the format conversion.

How to eliminate wrong answers

Option A is wrong because registering the model in SageMaker Model Registry is optional for deployment; it is used for model versioning and governance, not a required step to deploy an endpoint. Option B is wrong because creating a training job to re-train the model is unnecessary if the model artifacts already exist; deployment only requires the artifacts and a serving container. Option C is wrong because while TensorFlow models are often saved as SavedModel format, the question states the artifacts are already stored in S3, and the required step is to create the Model object with the serving image, not to save the model again.

Practice this question →

179

MCQhard

A SageMaker endpoint creation fails with the above CloudWatch Logs excerpt. What is the MOST likely cause?

A.The S3 bucket containing the model artifacts has incorrect permissions

B.The inference script has a syntax error

C.The instance type does not have enough memory to load the model

D.The model file is too large and takes longer than 300 seconds to load

AnswerD

The timeout indicates the model loading exceeds the default 300 seconds.

Why this answer

The CloudWatch Logs excerpt shows a timeout error during model loading. SageMaker has a default 300-second timeout for downloading and loading model artifacts from S3 into the inference container. If the model file is too large or the network is slow, the container fails to start within this window, causing the endpoint creation to fail with a timeout error.

Exam trap

The MLS-C01 exam often tests the distinction between timeout errors (which indicate slow download/extraction) and permission errors (which indicate access issues), leading candidates to incorrectly blame S3 permissions when the actual cause is a timeout.

How to eliminate wrong answers

Option A is wrong because incorrect S3 bucket permissions would result in an AccessDenied error, not a timeout. Option B is wrong because a syntax error in the inference script would cause a Python runtime error during invocation, not a timeout during model loading. Option C is wrong because insufficient memory would cause an OutOfMemory error or container crash, not a timeout; the instance type's memory is checked at container start, not via a timeout.

Practice this question →

180

MCQhard

A company is deploying a real-time inference endpoint using SageMaker. The model has a high memory footprint and requires GPU acceleration. Which instance type and configuration should be used to minimize cost while meeting latency requirements?

A.ml.p3.2xlarge with 1 GPU

B.ml.g4dn.xlarge with 1 GPU

C.ml.c5.xlarge with no GPU

D.ml.p3.16xlarge with 8 GPUs

AnswerA

Good balance of GPU and memory for high-memory models at reasonable cost.

Why this answer

(ml.p3.2xlarge with 1 GPU) is correct because it provides the required GPU acceleration for the high-memory-footprint model while using the smallest instance in the P3 family, which minimizes cost. The P3 instances use NVIDIA V100 GPUs with high memory bandwidth, suitable for real-time inference with low latency, and the 2xlarge size offers sufficient GPU memory without over-provisioning.

Exam trap

The trap here is that candidates often assume a larger instance with more GPUs (like ml.p3.16xlarge) is needed for high-memory models, but the question specifically asks to minimize cost while meeting latency, so the smallest GPU instance that fits the model is optimal.

How to eliminate wrong answers

Option B is wrong because the ml.g4dn.xlarge uses a T4 GPU with less memory and lower compute performance compared to the V100 in P3 instances, which may not meet the latency requirements for a high-memory-footprint model. Option C is wrong because ml.c5.xlarge has no GPU, making it incapable of GPU acceleration required by the model. Option D is wrong because ml.p3.16xlarge with 8 GPUs is over-provisioned for a single model endpoint, leading to unnecessary cost without latency benefit for a single inference request.

Practice this question →

181

Multi-Selecteasy

Which TWO AWS services can be used to deploy a trained model for serverless inference? (Select TWO.)

Select 2 answers

A.AWS Lambda with a container image

B.Amazon SageMaker Serverless Inference

C.Amazon SageMaker batch transform

D.Amazon Elastic Container Service (ECS) with Fargate

E.Amazon EC2 instances

AnswersA, B

Serverless compute for small models.

Why this answer

AWS Lambda with a container image allows you to package a trained model and its dependencies into a Docker container and deploy it as a serverless function. Lambda automatically scales the inference endpoint in response to incoming requests, and you pay only for the compute time consumed during inference, with no idle infrastructure costs.

Exam trap

The trap here is that candidates often confuse serverless inference with batch processing or managed container services, mistakenly selecting SageMaker batch transform or ECS with Fargate because they think 'serverless' means any managed service, but the key requirement is automatic scaling to zero and pay-per-request billing.

Practice this question →

182

MCQhard

A company is using SageMaker to train a model with a large dataset that is stored in S3. The training job is taking a long time due to high I/O latency. The team has already converted the data to RecordIO format. What should they do next to reduce I/O latency?

A.Use SageMaker fast file mode

B.Use multiple training instances

C.Use Amazon FSx for Lustre as the training data source

D.Shuffle the data before training

E.Use Pipe mode to stream the RecordIO data

AnswerE

Pipe mode avoids disk I/O by streaming data directly from S3.

Why this answer

Pipe mode streams data directly from S3 to the training algorithm in a sequential manner, eliminating the need to download files to the local disk. Since the data is already in RecordIO format, Pipe mode can efficiently read the serialized records, significantly reducing I/O latency compared to File mode.

Exam trap

The trap here is that candidates often confuse reducing I/O latency with improving data throughput or model performance, leading them to choose options like multiple instances or shuffling, which address different problems.

How to eliminate wrong answers

Option A is wrong because SageMaker fast file mode downloads files to the local disk, which still incurs I/O overhead and does not eliminate the latency from reading large datasets. Option B is wrong because using multiple training instances distributes the compute workload but does not reduce per-instance I/O latency; it may even increase overall data transfer time. Option C is wrong because Amazon FSx for Lustre is a high-performance file system that can reduce latency, but it requires additional setup and cost, and the question specifically asks for the next step after converting to RecordIO, where Pipe mode is the simplest and most direct solution.

Option D is wrong because shuffling data before training improves model convergence but does not address I/O latency during training.

Practice this question →

183

MCQmedium

A company runs a machine learning pipeline on Amazon SageMaker. The pipeline consists of three steps: data preprocessing (using a custom container), training (using a built-in algorithm), and model evaluation (using a custom container). The pipeline is orchestrated using AWS Step Functions. Recently, the pipeline has been failing intermittently at the model evaluation step with a 'TimeoutError'. The evaluation step runs a Python script that loads the trained model and a test dataset from S3, computes metrics, and writes results back to S3. The step is configured with a timeout of 600 seconds. The test dataset size has grown over time. The data science team suspects that the timeout is due to the increased data size. They want a solution that minimizes changes to the existing infrastructure and avoids increasing the timeout arbitrarily. Which approach should the team take?

A.Increase the timeout to 1200 seconds and use a larger instance type for the evaluation step.

B.Increase the timeout to 1800 seconds to accommodate the larger dataset.

C.Modify the evaluation script to process the test dataset in parallel batches, and use multiprocessing to distribute the workload within the same container.

D.Switch the evaluation step to use the 'ml.m5.4xlarge' instance type for more memory and compute.

AnswerC

Reduces wall-clock time without increasing timeout or instance size.

Why this answer

It addresses the root cause—the evaluation script's inability to process the growing dataset within the 600-second timeout—by parallelizing the workload within the same container. This approach minimizes infrastructure changes (no instance type or timeout increase) and leverages Python's multiprocessing to reduce wall-clock time, directly tackling the 'TimeoutError' without arbitrary timeout extensions.

Exam trap

The trap here is that candidates often default to scaling up infrastructure (larger instances or higher timeouts) instead of optimizing the code, which is a classic 'throw hardware at the problem' misconception that the MLS-C01 exam tests by rewarding efficient, cost-conscious solutions.

How to eliminate wrong answers

Option A is wrong because increasing both timeout and instance type is an over-engineered solution that introduces unnecessary cost and complexity, and it does not address the underlying inefficiency in processing the dataset sequentially. Option B is wrong because simply increasing the timeout to 1800 seconds is a temporary band-aid that does not fix the performance bottleneck; as the dataset continues to grow, the timeout will need to be increased again, leading to an unsustainable pattern. Option D is wrong because switching to a larger instance type (ml.m5.4xlarge) only provides more memory and compute but does not change the sequential processing logic; the script will still take the same amount of time (or only marginally less) and may still hit the timeout if the dataset is large enough.

Practice this question →

184

MCQeasy

A startup is using SageMaker to train a model using the built-in XGBoost algorithm. The training job runs successfully but the resulting model performs poorly on the test data. The data scientist suspects overfitting. The training data is relatively small (10,000 rows). Which action should be taken to reduce overfitting?

A.Decrease the number of trees (num_round) to 50

B.Increase the learning rate to 0.3

C.Increase the number of trees (num_round) to 500

D.Use a larger instance type

AnswerA

Fewer trees reduce overfitting.

Why this answer

Overfitting occurs when the model learns noise in the training data. Decreasing the number of trees (num_round) reduces model complexity, which helps prevent overfitting, especially with a small dataset (10,000 rows). Option B (increasing learning rate) can cause the model to converge too quickly to a suboptimal solution, potentially increasing overfitting.

Option C (increasing trees) increases complexity and overfitting. Option D (larger instance) does not affect overfitting as it only changes compute resources.

Practice this question →

185

MCQmedium

Refer to the exhibit. An IAM policy is attached to a SageMaker notebook instance. Which action will the notebook be able to perform?

A.Create a training job

B.Create a model

C.Read data from S3

D.Invoke a SageMaker endpoint

AnswerD

The policy explicitly allows sagemaker:InvokeEndpoint.

Why this answer

The IAM policy attached to the SageMaker notebook instance grants only the `sagemaker:InvokeEndpoint` action. This action allows the notebook to send inference requests to a deployed SageMaker endpoint. No other SageMaker or S3 actions are permitted, so the notebook can only invoke the endpoint.

Exam trap

The trap here is that candidates may assume a SageMaker notebook instance automatically has broad permissions to perform all SageMaker actions, but the IAM policy explicitly limits the notebook to only `InvokeEndpoint`, so only endpoint invocation is allowed.

How to eliminate wrong answers

Option A is wrong because the policy does not include `sagemaker:CreateTrainingJob`, which is required to create a training job. Option B is wrong because the policy lacks `sagemaker:CreateModel`, which is necessary to create a SageMaker model. Option C is wrong because the policy does not grant any S3 actions (e.g., `s3:GetObject`), so the notebook cannot read data from S3.

Practice this question →

186

MCQmedium

A data scientist is using Amazon SageMaker to train a model and wants to use a custom Docker container for training. The container requires access to a private Amazon ECR repository. Which IAM role configuration is needed?

A.Attach an IAM policy to the SageMaker execution role that allows ecr:GetDownloadUrlForLayer, ecr:BatchGetImage, and ecr:GetAuthorizationToken for the ECR repository.

B.Use the AWS account owner's IAM role as the SageMaker execution role.

C.Create a new IAM user with ECR access and store credentials in SageMaker.

D.Add a bucket policy to the ECR repository allowing access from the SageMaker execution role.

AnswerA

These permissions allow SageMaker to pull the container image.

Why this answer

The SageMaker execution role must have an IAM policy that includes ecr:GetDownloadUrlForLayer, ecr:BatchGetImage, and ecr:GetAuthorizationToken for the ECR repository. This is achieved by attaching an IAM policy to the SageMaker execution role, as described in Option A. Option B is incorrect because using the AWS account owner's role is not appropriate and would grant excessive permissions.

Option C is incorrect because IAM users are not used for SageMaker execution roles; roles are used instead. Option D is incorrect because bucket policies apply to S3 buckets, not ECR repositories; ECR uses resource-based policies on the repository itself.

Practice this question →

187

MCQmedium

A machine learning engineer is deploying a custom XGBoost model for real-time inference on Amazon SageMaker. The model was trained using the SageMaker XGBoost built-in algorithm. The endpoint is deployed with an ml.m5.large instance and is receiving around 50 requests per second. The engineer notices that the endpoint's latency is around 200 ms, but the requirement is under 100 ms. The model's serialized format is a .tar.gz file. The engineer wants to reduce inference latency without modifying the model or retraining. What should the engineer do?

A.Configure SageMaker Debugger to optimize the inference code.

B.Use SageMaker Elastic Inference to attach an accelerator.

C.Use SageMaker Neo to compile the model for the target instance.

D.Use SageMaker Batch Transform instead of a real-time endpoint.

AnswerC

SageMaker Neo compiles the trained model to optimize it for the target hardware (ml.m5.large), which can improve inference speed and reduce latency without modifying the model.

Why this answer

SageMaker Neo compiles trained models to optimize them for target hardware, reducing inference latency without modifying the model. Option A is wrong because SageMaker Debugger is used for monitoring training jobs and debugging, not for optimizing inference code. Option B is wrong because SageMaker Elastic Inference attaches GPU acceleration, which is beneficial for deep learning models but not for XGBoost (a tree-based model).

Option D is wrong because SageMaker Batch Transform is designed for batch predictions on large datasets, not for real-time inference with low latency requirements.

Exam trap

Candidates may incorrectly choose Elastic Inference (B) thinking it speeds up all models, but it is only useful for deep learning models, not tree-based XGBoost.

Practice this question →

188

Multi-Selecthard

A company is deploying a machine learning model using Amazon SageMaker. The model must be updated frequently without downtime. Which TWO strategies can achieve this? (Choose two.)

Select 2 answers

A.Update the model artifact on the existing endpoint.

B.Delete the existing endpoint and create a new one.

C.Use blue/green deployment with endpoint variants.

D.Use rolling update with multiple instances.

E.Use canary deployment by gradually shifting traffic.

AnswersC, E

Traffic is shifted gradually.

Why this answer

Amazon SageMaker supports blue/green deployment using endpoint variants, where you can deploy a new model version alongside the current one and then shift all traffic to the new variant once validated. This approach ensures zero downtime because the existing endpoint remains active during the transition, and traffic is switched atomically. Option E is correct because canary deployment with SageMaker allows you to gradually shift a small percentage of traffic to a new model variant, monitor its performance, and then ramp up to 100% if successful, all without interrupting the service.

Exam trap

The trap here is that candidates confuse the concept of 'updating' a model with the ability to directly modify an existing endpoint, but SageMaker requires immutable deployments, and only traffic-shifting strategies like blue/green or canary deployments achieve zero-downtime updates.

Practice this question →

189

MCQhard

A company is using Amazon SageMaker to train a model on data stored in S3. The training job needs to access data from an S3 bucket in a different AWS account. The data owner has granted cross-account access via a bucket policy. However, the training job fails with an AccessDenied error. What is the MOST likely cause?

A.The data is encrypted with SSE-KMS and the SageMaker role lacks KMS permissions.

B.The SageMaker execution role does not have the necessary permissions to access the S3 bucket.

C.The S3 bucket is not configured with public access.

D.The S3 bucket is in a different region and requires a VPC endpoint.

AnswerB

The SageMaker execution role must have an IAM policy that grants access to the S3 bucket. Without it, even with a bucket policy, the training job will fail.

Why this answer

Even with a bucket policy granting cross-account access, the SageMaker execution role must have an IAM policy that allows s3:GetObject (and any other required actions) on the S3 bucket. Without these permissions, the training job will fail with AccessDenied. Option A is incorrect because SSE-KMS encryption would require KMS permissions, but the issue is specifically about access permissions, not encryption.

Option C is incorrect because the data does not need to be public; cross-account access via bucket policy is sufficient. Option D is incorrect because cross-account access does not require a VPC endpoint.

Practice this question →

190

MCQhard

A company uses SageMaker Ground Truth to label images for object detection. After labeling, they notice that the bounding boxes are often misaligned with the objects. Which action should they take to improve label quality?

A.Use a pre-built annotation tool that enforces bounding box alignment

B.Use automated labeling with a pre-trained model

C.Increase the number of workers per task

D.Adjust the confidence threshold for the model

AnswerA

Tool constraints improve consistency.

Why this answer

SageMaker Ground Truth offers pre-built annotation tools, such as the bounding box tool, which includes features like snap-to-grid or edge alignment that enforce precise bounding box placement. Using this tool directly improves label quality by reducing human error in manual drawing, ensuring boxes tightly fit objects without manual guesswork.

Exam trap

The trap here is that candidates often confuse label quality improvement strategies (e.g., using consensus voting or automated labeling) with the specific need to enforce geometric precision in bounding box annotations, leading them to select options that address general accuracy rather than alignment accuracy.

How to eliminate wrong answers

Option B is wrong because automated labeling with a pre-trained model would generate bounding boxes based on the model's predictions, which may also be misaligned if the model is not fine-tuned or if the objects differ from the training data; it does not address the root cause of misalignment in human-drawn boxes. Option C is wrong because increasing the number of workers per task (using a consensus-based approach) can reduce random errors but does not fix systematic misalignment caused by imprecise manual drawing; workers may still produce misaligned boxes if the tool lacks alignment enforcement. Option D is wrong because adjusting the confidence threshold for the model is relevant only when using automated labeling or model inference, not for improving the quality of human-annotated bounding boxes in Ground Truth.

Practice this question →

191

MCQhard

Refer to the exhibit. A SageMaker endpoint is returning 5xx errors. The logs show the above error. Which change will most likely resolve the issue?

A.Reduce the batch size in the inference script

B.Enable Auto Scaling on the endpoint

C.Compress the model artifact

D.Use a larger instance type with more memory

AnswerD

More memory solves OutOfMemoryError.

Why this answer

5xx errors from a SageMaker endpoint typically indicate that the inference container is running out of memory (OOM) or crashing under load. The error log suggests the model or inference process requires more memory than the current instance type provides. Upgrading to a larger instance type with more memory directly addresses the resource exhaustion, allowing the model to load and inference to complete without failure.

Exam trap

The MLS-C01 exam often tests the misconception that Auto Scaling or batch size adjustments can fix resource exhaustion errors, when in fact only vertical scaling (larger instance) addresses the root cause of insufficient memory per instance.

How to eliminate wrong answers

Option A is wrong because reducing the batch size might reduce memory usage per request, but if the model itself is too large for the instance (e.g., cannot even load), batch size changes won't fix the underlying memory exhaustion. Option B is wrong because Auto Scaling adds more instances to handle increased traffic, but it does not increase the memory per instance; if each instance is already OOM, adding more instances will just replicate the failure. Option C is wrong because compressing the model artifact only reduces storage and download time, not the runtime memory footprint; the model must still be decompressed and loaded into memory, so the OOM error persists.

Practice this question →

192

MCQeasy

Refer to the exhibit. A data scientist runs the AWS CLI command to create a SageMaker training job. The training job fails because the input data is not accessible. Which step should the data scientist take to fix the issue?

A.Attach an IAM policy to SageMakerRole that grants s3:GetObject on the bucket

B.Add a VpcConfig to the training job

C.Modify the bucket policy to allow s3:GetObject for any principal

D.Increase VolumeSizeInGB to 50

AnswerA

The role needs explicit S3 read permissions.

Why this answer

The training job fails because the SageMaker execution role (SageMakerRole) lacks the necessary IAM permissions to read the input data from the S3 bucket. By attaching an IAM policy that grants s3:GetObject on the specific bucket, the role gains the required access. SageMaker uses the execution role to access S3 data, so the role's permissions must explicitly allow the GetObject action.

Exam trap

The trap here is that candidates may confuse IAM role permissions with bucket policies or network configurations, thinking that VPC settings or storage size can fix an S3 access denied error, when the root cause is always a missing IAM action on the execution role.

How to eliminate wrong answers

Option B is wrong because adding a VpcConfig configures the training job to run within a VPC, which addresses network isolation or private subnet access, but does not resolve missing S3 read permissions. Option C is wrong because modifying the bucket policy to allow s3:GetObject for any principal is a security risk and unnecessary; the correct approach is to grant permissions to the specific IAM role used by SageMaker. Option D is wrong because increasing VolumeSizeInGB increases the size of the local training instance storage, which does not affect the ability to read input data from S3.

Practice this question →

193

Multi-Selectmedium

A data scientist is using SageMaker to train a model and wants to track experiments, including hyperparameters and metrics. Which TWO actions should the scientist take to set up experiment tracking? (Choose TWO.)

Select 2 answers

A.Use the SageMaker Experiments Python SDK to create an experiment and log runs.

B.Enable SageMaker Model Monitor to track training metrics.

C.Configure CloudWatch Logs to store experiment data.

D.Create a trial component in the experiment to log hyperparameters and metrics.

E.Enable SageMaker Studio to automatically capture experiments.

AnswersA, D

Directly supports experiment tracking.

Why this answer

The SageMaker Experiments Python SDK provides the primary interface for creating and managing experiments, allowing the data scientist to log runs, hyperparameters, and metrics in a structured way. This SDK directly integrates with SageMaker training jobs and notebook executions to capture experiment metadata.

Exam trap

The MLS-C01 exam often tests the distinction between monitoring (Model Monitor) and experiment tracking (Experiments SDK), and the trap here is that candidates confuse CloudWatch Logs or Model Monitor as valid tools for structured experiment metadata capture when they are not designed for that purpose.

Practice this question →

194

MCQeasy

A data scientist is using Amazon SageMaker to train a model using a built-in algorithm. The training job is taking a long time, and the data scientist wants to improve performance by using a larger instance type with more vCPUs. The training job is currently using an ml.m5.large instance. The data scientist changes the instance type to ml.m5.4xlarge and resubmits the training job. However, the training time does not decrease significantly. What is the MOST likely reason?

A.The algorithm is single-threaded and cannot use multiple vCPUs.

B.The built-in algorithm is not designed to scale with additional vCPUs.

C.The training job is I/O bound, and increasing vCPUs does not help.

D.The training dataset is too small to benefit from more vCPUs.

AnswerB

The built-in algorithm may not be able to utilize additional vCPUs effectively if it is not parallelized. This is the most likely reason.

Why this answer

The most likely reason the training time did not decrease significantly is that the built-in algorithm may not be designed to scale effectively with additional vCPUs. Option B correctly identifies this. Option A is less likely because, while single-threaded algorithms cannot use multiple vCPUs, many SageMaker built-in algorithms are parallelized but still have limited scalability due to overhead.

Option C is possible but less common; the question's most likely reason is inherent scalability limitations. Option D is incorrect because if the dataset were too small, training time would already be low, and increasing vCPUs could still help, but the lack of improvement here points to scalability issues, not dataset size.

Practice this question →

195

MCQmedium

A company has deployed a model on SageMaker for real-time inference. The endpoint is experiencing high latency during traffic spikes. Which action should the company take to reduce latency?

A.Use a larger instance type for the endpoint

B.Attach SageMaker Elastic Inference to the endpoint

C.Enable SageMaker endpoint auto-scaling

D.Use SageMaker Neo to compile the model

E.Switch to SageMaker batch transform

AnswerC

Auto-scaling adds instances during spikes, reducing latency.

Why this answer

Enabling SageMaker endpoint auto-scaling allows the endpoint to dynamically adjust the number of instances based on incoming traffic, which directly reduces latency during spikes by ensuring sufficient compute capacity is available. Auto-scaling uses CloudWatch metrics (e.g., InvocationsPerInstance or latency) to trigger scale-out events, preventing queue buildup and response time degradation.

Exam trap

AWS often tests the misconception that improving per-request performance (e.g., via larger instances, Elastic Inference, or Neo compilation) is the solution for handling traffic spikes, when the actual need is horizontal scaling to increase request throughput capacity.

How to eliminate wrong answers

Option A is wrong because using a larger instance type increases per-instance compute capacity but does not address the root cause of traffic spikes—it only shifts the bottleneck and may still result in high latency if the single instance is overwhelmed; it also increases cost without elasticity. Option B is wrong because SageMaker Elastic Inference accelerates model inference by attaching a GPU accelerator, but it does not help with traffic spikes—it only reduces per-request latency for a fixed number of requests, not handle increased request volume. Option D is wrong because SageMaker Neo compiles models to optimize inference performance on specific hardware, which can reduce per-request latency but does not scale the endpoint to handle traffic spikes.

Option E is wrong because switching to batch transform is for offline, asynchronous processing of large datasets and is not suitable for real-time inference; it would increase latency for real-time use cases.

Practice this question →

196

Multi-Selecteasy

A company wants to monitor SageMaker endpoints for data drift. Which TWO services can be used together to detect and alert on drift?

Select 2 answers

A.SageMaker Data Wrangler

B.SageMaker Model Monitor

C.AWS CodePipeline

D.Amazon CloudWatch Alarms

E.Amazon CloudWatch Logs

AnswersB, D

Model Monitor detects drift in real-time.

Why this answer

SageMaker Model Monitor (option B) continuously monitors models for data and quality drift. Amazon CloudWatch Alarms (option D) can be set up on Model Monitor's metrics to trigger alerts when drift is detected. SageMaker Data Wrangler (option A) is for data preparation, not monitoring.

AWS CodePipeline (option C) is for CI/CD. Amazon CloudWatch Logs (option E) is for log storage and analysis, not for alerting on drift.

Practice this question →

197

MCQhard

A company is using SageMaker to host a model that performs real-time fraud detection. The model receives high request volumes with occasional spikes. The company wants to ensure that the endpoint can handle spikes without throttling while minimizing cost. Which scaling strategy should be used?

A.Use a target tracking scaling policy with a target value of 70% for the SageMakerVariantInvocationsPerInstance metric.

B.Use a simple scaling policy with a step adjustment based on the InvocationsPerInstance metric.

C.Manually adjust the instance count based on monitoring dashboards.

D.Use a scheduled scaling action to add instances during peak hours.

AnswerA

Automatically scales based on utilization.

Why this answer

A target tracking scaling policy with the SageMakerVariantInvocationsPerInstance metric is the correct choice because it automatically adjusts the instance count to maintain a target utilization (e.g., 70%), handling spikes without manual intervention while minimizing cost by scaling down during low traffic. This is the recommended approach for real-time endpoints with variable traffic, as it aligns with AWS best practices for dynamic scaling.

Exam trap

The trap here is that candidates often confuse simple scaling (step adjustments) with target tracking, assuming any metric-based policy works, but target tracking is specifically designed for maintaining a utilization target and is the only option that handles irregular spikes without manual or scheduled intervention.

How to eliminate wrong answers

Option B is wrong because simple scaling policies with step adjustments require predefined thresholds and cooldown periods, which can lead to over-provisioning or under-provisioning during sudden spikes, lacking the smooth, proportional response of target tracking. Option C is wrong because manually adjusting instance count based on dashboards is reactive, error-prone, and cannot handle rapid spikes without causing throttling or waste, defeating the goal of cost minimization. Option D is wrong because scheduled scaling only works for predictable traffic patterns, not for occasional spikes that occur at irregular times, leading to either throttling during unscheduled surges or unnecessary cost during off-peak hours.

Practice this question →

198

Multi-Selecteasy

Which TWO actions are best practices for securing a SageMaker notebook instance? (Select TWO.)

Select 2 answers

A.Disable direct internet access for the notebook instance.

B.Enable root access for users to install packages.

C.Launch the notebook instance in a private subnet in a VPC.

D.Store data in the notebook's local storage for performance.

E.Use a shared IAM user for all data scientists.

AnswersA, C

Disabling internet access prevents data exfiltration.

Why this answer

Disabling direct internet access for a SageMaker notebook instance (Option A) is a best practice because it prevents the instance from reaching the public internet, reducing the attack surface. This forces all outbound traffic through a VPC, allowing you to control egress via NAT gateways or VPC endpoints, and ensures data does not traverse the public internet. It is a fundamental security hardening step for sensitive workloads.

Exam trap

The trap here is that candidates often confuse 'disabling direct internet access' with 'blocking all internet access' and think it will break SageMaker's ability to download libraries, not realizing that VPC endpoints or a NAT gateway can still provide controlled access to AWS services and the internet.

Practice this question →

199

MCQhard

A data scientist is trying to create a training job named 'test-model' using an IAM role with the attached policy. The creation fails with an AccessDenied error. What is the most likely cause?

A.The Resource is set to '*' and should be specific.

B.The Deny statement uses 'StringNotEquals' which should be 'StringEquals'.

C.The IAM role does not have permission to assume the SageMaker execution role.

D.The Deny statement uses a wildcard '*' in the condition value, which is not supported for StringNotEquals.

AnswerD

Wildcards are not supported in StringNotEquals conditions, causing unexpected denial.

Why this answer

The Deny statement uses 'StringNotEquals' with a wildcard '*' in the condition value, which is not supported for the 'StringNotEquals' condition operator in IAM policies. The 'StringNotEquals' operator requires exact string matching and does not support wildcards; using '*' will cause the condition to never match, effectively making the Deny statement non-functional or causing unexpected behavior. This mismatch leads to an AccessDenied error because the policy evaluation fails to properly deny or allow the action.

Exam trap

The trap here is that candidates may assume 'StringNotEquals' supports wildcards like 'StringNotLike' does, or they may focus on the Resource wildcard (Option A) as the obvious cause, missing the subtle condition operator mismatch.

How to eliminate wrong answers

Option A is wrong because setting the Resource to '*' is generally acceptable for service-linked roles or broad permissions, and the error is specifically about an AccessDenied due to a policy condition issue, not resource specificity. Option B is wrong because 'StringNotEquals' is a valid condition operator; the issue is not the operator itself but the use of a wildcard in its value, which is unsupported. Option C is wrong because the IAM role's ability to assume the SageMaker execution role is a separate permission (sts:AssumeRole) and not directly related to the training job creation failure caused by the Deny statement's condition syntax.

Practice this question →

200

MCQeasy

A machine learning engineer is deploying a model that was trained on a large dataset stored in Amazon S3. The model needs to be retrained daily with new data. Which approach is the MOST cost-effective for storing the training data while allowing quick access for retraining?

A.Store all data in S3 Standard

B.Use S3 Glacier Deep Archive

C.Use S3 Intelligent-Tiering

D.Use S3 One Zone-IA

AnswerC

Intelligent-Tiering automatically optimizes costs for data with changing access patterns.

Why this answer

S3 Intelligent-Tiering is the most cost-effective choice because it automatically moves data between access tiers (frequent, infrequent, and archive instant access) based on changing access patterns. Since the model is retrained daily, the training data will be accessed frequently during retraining but may have low access at other times, and Intelligent-Tiering optimizes storage costs without performance impact by charging a small monitoring fee per object.

Exam trap

The trap here is that candidates often choose S3 Standard assuming daily access justifies it, but they overlook that Intelligent-Tiering provides the same low-latency access for frequently used data while automatically reducing costs for data that becomes less active over time.

How to eliminate wrong answers

Option A is wrong because S3 Standard is designed for frequently accessed data and would be more expensive for data that is not accessed daily outside of retraining windows, leading to higher storage costs over time. Option B is wrong because S3 Glacier Deep Archive is intended for long-term archival with retrieval times of 12 hours or more, making it unsuitable for daily retraining that requires quick access. Option D is wrong because S3 One Zone-IA stores data in a single Availability Zone, which risks data loss if that zone fails, and it incurs retrieval costs that can add up with daily access, making it less cost-effective than Intelligent-Tiering for this mixed access pattern.

Practice this question →

201

Multi-Selectmedium

A data scientist is using Amazon SageMaker to train a model and wants to track experiments, including parameters and metrics. Which THREE actions should be taken? (Choose three.)

Select 3 answers

A.Use SageMaker Studio to manually record experiments.

B.Use Amazon CloudWatch Logs to store experiment data.

C.Create an experiment in SageMaker Experiments.

D.Use the SageMaker SDK to log parameters and metrics in the training script.

E.Use the SageMaker SDK to create a trial and trial component.

AnswersC, D, E

Experiments organize runs.

Why this answer

SageMaker Experiments is the native service for organizing, tracking, and comparing machine learning training runs. It provides a structured way to create experiments, trials, and trial components, enabling systematic tracking of parameters and metrics without manual overhead.

Exam trap

The trap here is that candidates confuse logging to CloudWatch (which is for raw logs) with structured experiment tracking, or assume SageMaker Studio provides a manual recording interface, when in fact all experiment tracking must be done programmatically via the SDK or console API.

Practice this question →

202

MCQhard

A machine learning team is using SageMaker Processing jobs to run feature engineering on large datasets. The job takes a long time to complete. Which change would most likely reduce the processing time?

A.Increase the number of instances in the processing cluster

B.Switch to local mode to avoid network overhead

C.Change the processing script from Python to PySpark

D.Use a larger instance type, e.g., from r5.xlarge to r5.24xlarge

AnswerA

More instances allow parallel processing, reducing overall time.

Why this answer

Increasing the number of instances in the processing cluster enables SageMaker Processing to distribute the workload across multiple nodes, leveraging parallel processing to reduce the overall execution time. SageMaker Processing uses a distributed computing model where each instance processes a subset of the data, so adding more instances directly increases parallelism and throughput for embarrassingly parallel tasks like feature engineering.

Exam trap

The trap here is that candidates often confuse scaling up (larger instance type) with scaling out (more instances), assuming that a bigger instance always yields faster processing, but for distributed data processing, horizontal scaling is usually more effective for large datasets.

How to eliminate wrong answers

Option B is wrong because local mode runs the job on a single local machine, which eliminates network overhead but does not scale; it would likely increase processing time for large datasets due to limited compute resources. Option C is wrong because simply changing the script from Python to PySpark does not inherently reduce processing time unless the job is already configured to run on a distributed cluster; PySpark requires a Spark runtime and cluster setup, and without that, it may even add overhead. Option D is wrong because using a larger instance type (e.g., r5.xlarge to r5.24xlarge) provides more vCPUs and memory per instance but does not increase parallelism beyond a single node; for large datasets, the bottleneck is often I/O and data shuffling, which a single larger instance cannot address as effectively as multiple instances.

Practice this question →

203

MCQmedium

A company uses SageMaker to host a model for real-time predictions. The model is updated weekly. To minimize downtime during model updates, what should the company do?

A.Create a new endpoint configuration with the new model and update the endpoint to use the new configuration

B.Create a second endpoint with the new model and use an Application Load Balancer to route traffic

C.Update the existing endpoint configuration with the new model URL

D.Delete the existing endpoint and create a new one with the updated model

AnswerA

SageMaker supports blue/green deployment by updating endpoint to new configuration, minimizing downtime.

Why this answer

SageMaker allows you to create a new endpoint configuration with the updated model and then update the existing endpoint to use this new configuration. This triggers a rolling update where SageMaker gradually shifts traffic from the old model to the new one, ensuring zero downtime during the transition. The endpoint remains available throughout the process, and you can roll back quickly if needed by reverting to the previous configuration.

Exam trap

The trap here is that candidates often assume that updating the endpoint configuration directly (Option C) is sufficient, but they miss that SageMaker requires a new endpoint configuration object to trigger a safe, rolling update rather than an in-place replacement that can cause downtime.

How to eliminate wrong answers

Option B is wrong because using a second endpoint with an Application Load Balancer introduces unnecessary complexity and cost, and SageMaker does not natively integrate with ALB for endpoint traffic routing; instead, SageMaker’s built-in endpoint update mechanism already handles zero-downtime deployments. Option C is wrong because updating the existing endpoint configuration with a new model URL does not trigger a rolling update; it immediately replaces the model behind the endpoint, which can cause downtime or errors during the transition. Option D is wrong because deleting the existing endpoint and creating a new one results in a period where the endpoint is unavailable, causing downtime until the new endpoint is fully provisioned and traffic is redirected.

Practice this question →

204

MCQhard

A company is using Amazon SageMaker Ground Truth to create a labeled dataset for object detection. The labeling job is taking longer than expected. The team notices that many workers are spending a lot of time on images with no objects. Which labeling strategy should they use to reduce costs and time?

A.Use a private workforce instead of public.

B.Create a pre-labeling task where workers only identify if an object exists, then send only positive images for full labeling.

C.Use automated data labeling with a pre-trained model to filter empty images.

D.Increase the number of workers per dataset object.

AnswerB

This two-stage approach reduces work on empty images.

Why this answer

It introduces a two-stage labeling workflow: first, workers perform a quick binary classification to identify images containing objects, and only those positive images proceed to the expensive, time-consuming bounding box annotation. This directly reduces the cost and time spent on empty images, which is the root cause of the delay.

Exam trap

The trap here is that candidates may assume 'automated data labeling' (Option C) is the fastest solution, but they overlook that it requires a pre-trained model and labeled data to start, making it impractical for a new labeling project where the goal is to create the initial labeled dataset.

How to eliminate wrong answers

Option A is wrong because switching to a private workforce does not address the core issue of workers wasting time on empty images; it only changes the pool of workers, potentially increasing cost without improving efficiency. Option C is wrong because automated data labeling with a pre-trained model requires a labeled dataset to train or fine-tune, which is the very problem the team is trying to solve, and it may introduce bias or errors in filtering empty images without ground truth validation. Option D is wrong because increasing the number of workers per dataset object (using annotation consolidation) does not reduce the time spent on empty images; it only adds redundancy and cost, as each empty image would still be labeled by multiple workers.

Practice this question →

205

Multi-Selectmedium

Which TWO actions can reduce inference latency for a SageMaker real-time endpoint? (Choose 2.)

Select 2 answers

A.Choose a larger instance type with more compute capacity.

B.Add more instances behind the endpoint.

C.Use batch transform instead.

D.Compile the model using SageMaker Neo.

E.Switch to asynchronous inference.

AnswersA, D

More compute reduces per-request latency.

Why this answer

Choosing a larger instance type with more compute capacity (Option A) reduces inference latency because it provides more CPU/GPU and memory resources, enabling the model to process each request faster. This directly decreases the time per inference, which is the primary driver of latency for real-time endpoints.

Exam trap

A common trap in AWS exams is the distinction between scaling for throughput (adding instances) vs. scaling for latency (increasing instance size or optimizing the model). Candidates mistakenly choose 'add more instances' thinking it reduces per-request latency.

Practice this question →

206

MCQmedium

A company is building a recommendation system using Amazon SageMaker. The data is stored in a large S3 bucket with millions of small CSV files. The team wants to train a factorization machines model. Which data ingestion strategy will be MOST efficient?

A.Use a SageMaker Processing job with a Spark container to read the files and write a single RecordIO file.

B.Use Amazon Athena to query the data and output to a single CSV.

C.Point the training job directly to the S3 bucket containing the CSV files.

D.Use SageMaker Data Wrangler to create a data flow and export to a training dataset.

AnswerA

Spark can efficiently combine many small files into a single format optimized for training.

Why this answer

SageMaker's factorization machines algorithm requires data in RecordIO-wrapped protobuf format for optimal performance, especially with high-dimensional sparse data. Using a SageMaker Processing job with Spark efficiently reads millions of small CSV files from S3, coalesces them into a single or few large RecordIO files, and avoids the overhead of many small S3 GET requests during training, which would otherwise cause severe I/O bottlenecks.

Exam trap

The trap here is that candidates often assume SageMaker can efficiently handle any data format directly from S3, overlooking that factorization machines specifically require RecordIO-wrapped protobuf input for optimal performance with sparse, high-dimensional data.

How to eliminate wrong answers

Option B is wrong because Amazon Athena outputs query results as a single CSV file, which does not convert the data into the RecordIO-wrapped protobuf format required by SageMaker's factorization machines, and the single CSV file still suffers from inefficient row-based parsing during training. Option C is wrong because pointing the training job directly to the S3 bucket with millions of small CSV files causes excessive S3 GET requests and network overhead, leading to poor training performance and potential throttling, and the CSV format is not optimized for the sparse, high-dimensional data typical of factorization machines. Option D is wrong because SageMaker Data Wrangler is designed for data preparation and feature engineering, not for converting data into the specific RecordIO protobuf format required by factorization machines, and it does not natively output to that format.

Practice this question →

207

MCQeasy

A company wants to serve predictions from a model using a REST API with low latency. Which SageMaker deployment option is most appropriate?

A.SageMaker Notebook instance

B.SageMaker real-time endpoint

C.SageMaker Processing job

D.SageMaker Batch Transform

AnswerB

Real-time endpoints provide low-latency REST API.

Why this answer

SageMaker real-time endpoints are designed for low-latency inference, deploying the model behind an HTTPS endpoint that autoscales to handle request traffic. This directly meets the requirement for serving predictions via a REST API with minimal latency, as the endpoint keeps the model loaded and ready to respond to individual requests in milliseconds.

Exam trap

The trap here is that candidates confuse batch inference (Batch Transform) with real-time inference, or mistakenly think a Notebook instance can serve as a production API, when only the real-time endpoint provides the persistent, low-latency REST API required.

How to eliminate wrong answers

Option A is wrong because a SageMaker Notebook instance is an interactive development environment for building and testing models, not a deployment option for serving predictions via an API. Option C is wrong because a SageMaker Processing job is a transient compute resource for data processing or model evaluation, not for hosting a persistent REST API with low-latency inference. Option D is wrong because SageMaker Batch Transform is designed for asynchronous, batch predictions on large datasets, not for real-time, low-latency serving of individual requests via a REST API.

Practice this question →

208

MCQhard

A financial services company is deploying a machine learning model for credit risk assessment. The model must have an inference latency under 200ms and must be able to handle up to 1000 transactions per second (TPS). The company wants to minimize costs. The model is a gradient boosting model implemented in XGBoost. Which SageMaker deployment option should the team choose?

A.Use SageMaker Batch Transform to process transactions in batches.

B.Use SageMaker asynchronous inference for queued requests.

C.Deploy the model on a SageMaker real-time endpoint with multiple instances behind a load balancer.

D.Use SageMaker Serverless Inference for automatic scaling.

AnswerC

Real-time endpoints provide sub-second latency and can scale to 1000 TPS.

Why this answer

A SageMaker real-time endpoint with multiple instances behind a load balancer provides the sub-200ms inference latency and 1000 TPS throughput required for synchronous, low-latency predictions. XGBoost models are well-suited for real-time endpoints, and horizontal scaling with multiple instances ensures high availability and cost efficiency by matching capacity to demand.

Exam trap

The trap here is that candidates often choose Serverless Inference (Option D) thinking it automatically scales to any load, but they overlook the cold start latency and concurrency limits that prevent it from meeting strict sub-200ms latency and 1000 TPS requirements.

How to eliminate wrong answers

Option A is wrong because SageMaker Batch Transform is designed for offline, asynchronous processing of large datasets and does not meet the sub-200ms latency requirement for real-time transactions. Option B is wrong because SageMaker asynchronous inference is intended for requests with larger payloads or longer processing times (typically seconds to minutes), not for sub-200ms latency or high TPS synchronous workloads. Option D is wrong because SageMaker Serverless Inference auto-scales from zero but incurs cold start latency (often >1 second) and has a maximum concurrency limit (default 200) that cannot guarantee 1000 TPS with sub-200ms latency, making it unsuitable for this throughput and latency requirement.

Practice this question →

209

MCQmedium

A company is using Amazon SageMaker to host a real-time inference endpoint for a natural language processing model. The endpoint is configured with an ml.m5.large instance. After deployment, the company observes that the inference latency is higher than expected, and the endpoint is experiencing CPU utilization near 100% during peak hours. The model is a PyTorch model that uses a transformer architecture. The company wants to reduce latency without increasing cost significantly. Which approach should the company take?

A.Configure the endpoint with Auto Scaling to add more instances during peak hours.

B.Switch to batch transform for inference.

C.Attach an Elastic Inference accelerator to the existing instance.

D.Change the endpoint instance type to ml.g4dn.xlarge to use GPU acceleration.

AnswerD

Correct: GPU instances accelerate transformer inference, reducing latency.

Why this answer

The issue is high CPU utilization causing latency for a PyTorch transformer model. GPU instances like ml.g4dn.xlarge can significantly accelerate inference through parallel processing, reducing latency. Option D is correct.

Elastic Inference (C) may provide some acceleration but is less effective for transformer models and adds complexity. Auto Scaling (A) helps with traffic spikes but does not reduce per-request latency. Batch Transform (B) is for offline inference, not real-time.

Practice this question →

210

MCQhard

A machine learning engineer is deploying a model to an Amazon SageMaker endpoint. The model is a PyTorch model that requires a custom inference script. The engineer notices that the endpoint is returning 500 errors after deployment. Which step should the engineer take to debug the issue?

A.Redeploy the endpoint with a different instance type.

B.Check the CloudWatch metrics for the endpoint.

C.Modify the inference script and update the endpoint.

D.View the CloudWatch Logs for the endpoint.

AnswerD

Logs contain stack traces and error messages.

Why this answer

When a SageMaker endpoint returns 500 errors, it typically indicates an application-level failure in the inference container, such as an unhandled exception in the custom inference script. CloudWatch Logs capture the stdout and stderr of the container, including Python tracebacks, which directly reveal the root cause. Option D is correct because viewing these logs is the first and most effective step to diagnose the specific error.

Exam trap

The trap here is that candidates confuse CloudWatch Metrics (aggregate data) with CloudWatch Logs (detailed output), and mistakenly choose metrics thinking they will show error details, when in fact only logs contain the actual error messages and stack traces.

How to eliminate wrong answers

Option A is wrong because changing the instance type addresses resource constraints (e.g., memory or CPU), not application logic errors that cause 500 errors. Option B is wrong because CloudWatch metrics (e.g., Invocations, ModelLatency) show aggregate performance and error counts but do not provide the detailed error messages or stack traces needed to debug a custom inference script. Option C is wrong because modifying the inference script without first understanding the error is speculative; the engineer must first view the logs to identify the specific failure before making changes.

Practice this question →

211

MCQmedium

A company is using Amazon SageMaker to train a model on a large dataset stored in S3. The training job is taking a long time due to slow data loading. Which action can the data scientist take to reduce data loading time?

A.Use Pipe mode to stream data from S3.

B.Use File mode and copy data to Amazon EBS.

C.Use a larger instance type with more memory.

D.Enable data augmentation during training.

AnswerA

Pipe mode streams data directly, reducing load time.

Why this answer

Pipe mode streams data directly from S3 into the training algorithm without first downloading it to the local storage, eliminating the bottleneck of disk I/O and reducing data loading time. This is especially effective for large datasets where the time to copy data to EBS (File mode) dominates the training job duration.

Exam trap

The MLS-C01 exam often tests the misconception that increasing instance size (Option C) solves all performance issues, but the trap here is that data loading latency is I/O-bound, not compute-bound, so Pipe mode directly mitigates the bottleneck by streaming instead of downloading.

How to eliminate wrong answers

Option B is wrong because File mode copies the entire dataset from S3 to the Amazon EBS volume attached to the training instance, which adds significant data transfer time before training can start, making it slower than Pipe mode for large datasets. Option C is wrong because using a larger instance type with more memory does not address the data loading bottleneck; it only speeds up computation after data is loaded, and the data transfer from S3 remains the limiting factor. Option D is wrong because data augmentation is a technique to artificially expand the training dataset by applying transformations, which would increase the data loading time and not reduce it.

Practice this question →

212

MCQmedium

A team is using SageMaker to train a model using the built-in XGBoost algorithm. The training job is taking longer than expected. The team suspects that the data is not being loaded efficiently. Which data format should they use to minimize training time?

A.Pipe mode with CSV

B.File mode with Parquet

C.Pipe mode with RecordIO-Protobuf

D.File mode with CSV

AnswerC

Streaming with efficient binary format.

Why this answer

Pipe mode with RecordIO-Protobuf is correct because it streams data directly from Amazon S3 to the training container without writing to disk, reducing I/O overhead. RecordIO-Protobuf also stores data in a binary, columnar format that XGBoost can parse more efficiently than CSV, especially for large datasets, leading to faster training times.

Exam trap

The trap here is that candidates often assume CSV is universally efficient due to its simplicity, overlooking that binary formats like RecordIO-Protobuf combined with streaming (Pipe mode) drastically reduce I/O latency and parsing overhead in SageMaker's distributed training environment.

How to eliminate wrong answers

Option A is wrong because Pipe mode with CSV still requires parsing text-based CSV records on the fly, which is slower than binary formats due to string-to-numeric conversion overhead. Option B is wrong because File mode downloads the entire dataset to the training instance's local storage before training begins, causing significant startup delays for large datasets. Option D is wrong because File mode with CSV combines the worst of both: full data download and slow text parsing, making it the least efficient choice for minimizing training time.

Practice this question →

213

Multi-Selecthard

A company is deploying a machine learning model to an Amazon SageMaker endpoint. The model receives requests with sensitive data that must be encrypted in transit and at rest. Additionally, the company needs to control access to the endpoint using AWS IAM. Which THREE steps should the company take to meet these requirements? (Choose THREE.)

Select 3 answers

A.Enable HTTPS for the endpoint

B.Configure the endpoint to use a VPC

C.Store the model artifacts in Amazon S3 with SSE-S3 encryption

D.Enable encryption at rest for the endpoint's ML storage volume

E.Attach an IAM policy to the endpoint to allow only authorized principals

AnswersA, D, E

HTTPS encrypts data in transit.

Why this answer

Enabling HTTPS for the SageMaker endpoint encrypts data in transit using TLS/SSL. SageMaker endpoints support HTTPS by default when using the InvokeEndpoint API, and you can enforce HTTPS by configuring a custom VPC and security group to only allow HTTPS traffic. Option D is correct because encryption at rest for the endpoint's ML storage volume can be enabled by specifying an AWS KMS key when creating the endpoint configuration.

This encrypts the temporary storage used during inference. Option E is correct by attaching a resource-based IAM policy to the endpoint to control which IAM principals (users, roles) can invoke the endpoint, meeting access control requirements. Option B is incorrect because using a VPC is not required for encryption or access control; it provides network isolation but does not directly enforce HTTPS or IAM access.

Option C is incorrect because SSE-S3 encrypts model artifacts in S3, not the endpoint's ML storage volume; encryption at rest for the endpoint must be configured at the endpoint level.

Exam trap

The trap here is that candidates often confuse encryption at rest for model artifacts in S3 (Option C) with encryption at rest for the endpoint's ML storage volume, which is a separate requirement; the exam tests whether you know that the endpoint's storage volume encryption is configured at the endpoint level, not via S3 SSE-S3.

Practice this question →

214

MCQeasy

A company is deploying a PyTorch model on a SageMaker endpoint for real-time inference. The model is stored as a .pth file in an S3 bucket. The data scientist wants to use the SageMaker PyTorch inference toolkit. Which file is REQUIRED in the model artifacts to serve the model?

A.A file named model.tar.gz that contains the model and any dependencies.

B.A file named inference.py that defines the model loading and prediction logic.

C.A file named model.pth containing the model state dictionary.

D.A file named requirements.txt listing the dependencies.

AnswerC

The PyTorch inference toolkit loads model.pth by default.

Why this answer

The SageMaker PyTorch inference toolkit expects the model artifact to be a single file named model.pth containing the model's state dictionary. When using the default inference handler, the toolkit automatically loads this file into the PyTorch model for serving. No additional inference script is required if the default behavior is sufficient.

Exam trap

The trap here is that candidates often assume a custom inference script (inference.py) is always required, but the SageMaker PyTorch inference toolkit provides a default handler that works with a simple model.pth file, making inference.py optional for basic use cases.

How to eliminate wrong answers

Option A is wrong because model.tar.gz is the standard SageMaker model artifact format for frameworks like XGBoost or Scikit-learn, but the PyTorch inference toolkit specifically expects a .pth file, not a tarball. Option B is wrong because inference.py is only required if you need custom inference logic; the PyTorch inference toolkit provides a default handler that loads model.pth automatically, so inference.py is optional, not required. Option D is wrong because requirements.txt is used to install additional dependencies during deployment, but it is not mandatory for serving the model; the PyTorch inference toolkit already includes PyTorch and its dependencies.

Practice this question →

215

MCQmedium

A data scientist is using SageMaker to train a model. The training job is failing with a 'ResourceLimitExceeded' error. Which action should be taken to resolve this issue?

A.Use a different AWS Region.

B.Request a service limit increase for the instance type.

C.Reduce the training dataset size.

D.Switch to a different instance type with lower resource requirements.

AnswerB

The error indicates the instance limit is reached; requesting an increase resolves it.

Why this answer

The 'ResourceLimitExceeded' error in SageMaker indicates that the AWS account has reached the maximum number of allowed resources (e.g., instances, vCPUs, or storage) for a given instance type in the current region. Requesting a service limit increase via the AWS Service Quotas console or API directly resolves this by raising the cap for that specific instance type, allowing the training job to proceed.

Exam trap

The trap here is that candidates may confuse 'ResourceLimitExceeded' with an out-of-memory or insufficient capacity error, leading them to choose dataset reduction or instance type changes instead of recognizing it as a quota-based limit that requires a service limit increase.

How to eliminate wrong answers

Option A is wrong because using a different AWS Region does not resolve the underlying resource limit issue; it only moves the problem to another region where limits may also be exceeded or where the required instance type may not be available. Option C is wrong because reducing the training dataset size does not affect the resource limit error; it might reduce training time or memory usage but does not change the account-level quota on instance count or vCPUs. Option D is wrong because switching to a different instance type with lower resource requirements may avoid the limit for the original type but does not address the root cause—the account's overall resource quota—and could still hit limits for the new type if it is also constrained.

Practice this question →

216

Multi-Selecteasy

Which TWO SageMaker features can be used to monitor and debug training jobs? (Choose 2.)

Select 2 answers

A.SageMaker Debugger

B.SageMaker Model Monitor

C.SageMaker Ground Truth

D.Amazon CloudWatch Logs

E.SageMaker Clarify

AnswersA, D

Debugger captures real-time training metrics and tensors.

Why this answer

SageMaker Debugger (A) is correct because it provides real-time monitoring and debugging of training jobs by capturing tensors, gradients, and other metrics during training, allowing you to detect issues like vanishing gradients or overfitting. Amazon CloudWatch Logs (D) is correct because it automatically collects and stores logs from SageMaker training jobs, including algorithm output and framework logs, which you can monitor for errors or anomalies.

Exam trap

AWS often tests the distinction between monitoring training jobs (Debugger, CloudWatch) versus monitoring inference endpoints (Model Monitor) or data preparation (Ground Truth), leading candidates to confuse Model Monitor as a training debugger.

Practice this question →

217

MCQhard

A machine learning team is using Amazon SageMaker to train a model with a custom algorithm packaged in a Docker container. The training job fails with the error 'Error: Unable to locate sagemaker-training toolkit.' What is the MOST likely cause?

A.The container does not have internet access to download dependencies

B.The instance type is incompatible with the container

C.The training role does not have permissions to access the container repository

D.The container does not include the SageMaker Training Toolkit

AnswerD

The toolkit must be installed in the Docker image.

Why this answer

The SageMaker Training Toolkit is a required library that provides the interface between SageMaker and custom Docker containers for training jobs. When a custom container does not include this toolkit, SageMaker cannot execute the training script or communicate with the container, resulting in the 'Unable to locate sagemaker-training toolkit' error. This is a mandatory dependency for any custom training container used with SageMaker.

Exam trap

The trap here is that candidates often confuse missing dependencies with network or permission issues, but the specific error message 'Unable to locate sagemaker-training toolkit' directly points to the absence of the required SageMaker Training Toolkit package inside the container.

How to eliminate wrong answers

Option A is wrong because the error is specifically about the missing toolkit, not about internet access; SageMaker containers can pull dependencies from Amazon ECR or S3 without internet access if configured correctly. Option B is wrong because instance type compatibility issues typically manifest as hardware or driver errors (e.g., CUDA mismatch), not a missing Python package error. Option C is wrong because permissions to access the container repository would cause an authentication or authorization error (e.g., 'AccessDenied' or 'Unauthorized'), not a missing toolkit error within the container itself.

Practice this question →

218

Multi-Selecthard

A machine learning team is building a real-time inference pipeline using Amazon SageMaker. The team has multiple models that need to be served, but usage patterns are unpredictable and traffic spikes occur several times a day. The team wants to minimize costs while maintaining low latency. Which THREE actions should the team take?

Select 3 answers

A.Enable provisioned concurrency on the endpoint to reduce cold starts.

B.Use SageMaker inference with Spot Instances to reduce cost.

C.Use a SageMaker multi-model endpoint to serve multiple models on the same instance.

D.Configure automatic scaling on the endpoint to handle traffic spikes.

E.Use SageMaker Batch Transform for all inference requests.

AnswersB, C, D

Spot Instances are cheaper but can be interrupted; for cost savings, sometimes acceptable.

Why this answer

Using Spot Instances for SageMaker inference can significantly reduce costs (up to 60-90% compared to On-Demand) while still providing the compute needed for real-time inference. Spot Instances are suitable when the workload can tolerate interruptions, and with SageMaker's managed Spot support, the endpoint can automatically fall back to On-Demand capacity if Spot capacity is reclaimed, ensuring availability during traffic spikes.

Exam trap

The trap here is that candidates often confuse provisioned concurrency (a Lambda feature) with SageMaker endpoint warm-up strategies, leading them to select Option A, which is not applicable to SageMaker inference endpoints.

Practice this question →

219

MCQmedium

A company wants to monitor a deployed model for data drift. Which AWS service should they use?

A.Amazon SageMaker Ground Truth

B.Amazon CloudWatch Logs

C.Amazon SageMaker Clarify

D.Amazon SageMaker Model Monitor

AnswerD

Model Monitor checks for data and model drift.

Why this answer

Amazon SageMaker Model Monitor is the correct service because it is specifically designed to continuously monitor deployed machine learning models for data drift and quality issues. It automatically detects deviations in the input data distribution compared to a baseline, triggering alerts when drift exceeds defined thresholds, which directly addresses the company's requirement.

Exam trap

The trap here is that candidates confuse SageMaker Clarify (bias/explainability) with Model Monitor (drift/quality), as both involve analyzing model behavior but serve fundamentally different purposes.

How to eliminate wrong answers

Option A is wrong because Amazon SageMaker Ground Truth is a data labeling service for creating training datasets, not for monitoring deployed models for drift. Option B is wrong because Amazon CloudWatch Logs is a log aggregation and monitoring service for infrastructure and application logs, but it lacks built-in capabilities to detect statistical data drift in ML model inputs. Option C is wrong because Amazon SageMaker Clarify is designed for bias detection and explainability of model predictions, not for continuous monitoring of data drift in production.

Practice this question →

220

MCQhard

A company is using AWS Glue to run ETL jobs that transform data for machine learning. The jobs are failing with 'Out of Memory' errors. The data size is growing, and the company needs a cost-effective solution. Which approach should be taken?

A.Switch to Spark on Amazon EMR.

B.Increase the number of workers in the job configuration.

C.Optimize the job by filtering data earlier.

D.Use a larger worker type like G.2X.

AnswerB

Increases parallelism, reducing memory per worker.

Why this answer

Increasing the number of workers in the AWS Glue job configuration distributes the data processing load across more Spark executors, directly addressing the 'Out of Memory' error by providing more aggregate memory without changing the worker type. This is a cost-effective approach because it scales horizontally, often at a lower cost than moving to a larger worker type, and it leverages the existing Glue infrastructure without migrating to EMR.

Exam trap

The trap here is that candidates often assume 'Out of Memory' errors must be solved by increasing memory per worker (vertical scaling) or by switching to a more powerful service, but the most cost-effective and direct solution in AWS Glue is to increase the number of workers (horizontal scaling) to distribute the memory load.

How to eliminate wrong answers

Option A is wrong because switching to Spark on Amazon EMR would require significant architectural changes and operational overhead, and it is not inherently more cost-effective than adjusting Glue worker count for the same memory issue. Option C is wrong because filtering data earlier is a best practice for performance optimization but does not directly resolve an 'Out of Memory' error caused by insufficient total memory across workers; it reduces data volume but may not prevent memory exhaustion if the cluster is undersized. Option D is wrong because using a larger worker type like G.2X increases memory per worker but is typically more expensive than adding more workers of the same type, and it may not be the most cost-effective horizontal scaling solution for growing data.

Practice this question →

221

MCQhard

A machine learning engineer is deploying a model on SageMaker and needs to ensure that the endpoint can handle a sudden spike in traffic. The engineer expects traffic to increase by 10x during a promotional event. Which scaling strategy should be used?

A.Use a single large instance type instead of multiple smaller instances.

B.Manually increase the instance count before the event.

C.Use only dynamic scaling based on the average latency metric.

D.Use scheduled scaling to add instances before the event, combined with dynamic scaling for the remaining duration.

AnswerD

Scheduled scaling pre-warms the endpoint to handle the spike.

Why this answer

The correct answer. Scheduled scaling allows you to add instances before the expected traffic spike, ensuring capacity is ready when needed. Combined with dynamic scaling (e.g., based on CPU utilization or request count), you can handle unexpected additional load during the event.

Option A is wrong because a single large instance is a single point of failure and may not provide sufficient throughput for a 10x spike. Option B is wrong because manual scaling requires human intervention and may not react fast enough. Option C is wrong because relying solely on dynamic scaling may not scale up quickly enough for a sudden 10x increase, as there is a lag in metrics and scaling actions.

Practice this question →

222

MCQhard

A company operates a real-time fraud detection system using an Amazon SageMaker endpoint. The model is a gradient boosting model trained on historical transaction data. The endpoint is deployed on an ml.c5.2xlarge instance with auto-scaling enabled based on average latency. Recently, during a flash sale event, the endpoint started returning HTTP 503 errors. The CloudWatch metrics show that the CPU utilization is at 70%, and the average latency has increased from 50 ms to 200 ms. The auto-scaling policy is configured to add one instance when average latency exceeds 100 ms for 5 consecutive minutes, and remove one instance when latency drops below 50 ms for 5 minutes. The current number of instances is 2. The flash sale lasted 30 minutes. What should the company do to prevent this issue in future flash sales?

A.Enable request throttling to drop excess requests

B.Change the instance type to ml.c5.4xlarge to handle higher load

C.Pre-warm the endpoint by setting a minimum number of instances that can handle the expected peak load before the flash sale

D.Change the model to a simpler model with lower latency

AnswerC

This ensures capacity is available from the start.

Why this answer

The auto-scaling policy is reactive and requires a 5-minute evaluation period, which is too slow to handle the rapid traffic spike during a flash sale. Pre-warming the endpoint by setting a minimum number of instances to handle the expected peak load ensures capacity is available immediately. Option A (request throttling) would reject excess requests and cause errors, not prevent them.

Option B (changing instance type) may help handle more load per instance but still suffers from the same reactive scaling delay, and it may be more expensive. Option D (simpler model) could reduce latency but may compromise model accuracy and does not address the scaling issue directly.

Practice this question →

223

Multi-Selecthard

Which THREE steps should be taken to secure a SageMaker notebook instance that accesses sensitive data? (Select THREE.)

Select 3 answers

A.Enable encryption at rest for the notebook's EBS volume

B.Grant root access to the notebook instance for flexibility

C.Place the notebook instance inside a VPC with no internet access

D.Allow direct internet access from the notebook for downloading packages

E.Use an IAM role with least privilege permissions for the notebook

AnswersA, C, E

Protects stored data.

Why this answer

SageMaker notebook instances use an Amazon EBS volume for storage, and enabling encryption at rest for this volume ensures that sensitive data stored on the notebook (e.g., datasets, model artifacts) is encrypted using AWS KMS-managed keys. This protects data at the storage layer, which is a fundamental security requirement for compliance with standards like HIPAA or PCI DSS.

Exam trap

The trap here is that candidates often confuse 'root access' with necessary administrative flexibility, not realizing that SageMaker notebook instances already provide sufficient permissions via IAM roles, and root access introduces security vulnerabilities without any operational benefit.

Practice this question →

224

MCQhard

A data scientist is using Amazon SageMaker for hyperparameter tuning. The tuning job uses a Bayesian optimization strategy. After 10 training jobs, the objective metric (validation accuracy) has plateaued at 0.85. The data scientist wants to explore more diverse hyperparameter combinations. What should the data scientist do?

A.Decrease the exploration weight in the tuning job configuration.

B.Switch to random search strategy.

C.Increase the exploration weight in the tuning job configuration.

D.Increase the number of parallel training jobs.

AnswerC

Increasing exploration weight prompts the algorithm to try more diverse combinations.

Why this answer

In Bayesian optimization, the exploration weight controls the trade-off between exploring new hyperparameter regions and exploiting known good regions. Increasing this weight encourages the acquisition function to sample more diverse combinations, which can help escape a plateau. Option C is correct because it directly addresses the need for greater diversity in the search space.

Exam trap

The MLS-C01 exam often tests the misconception that increasing parallel jobs or switching to random search is the best way to increase diversity, when in fact Bayesian optimization's exploration weight is the precise control for this purpose.

How to eliminate wrong answers

Option A is wrong because decreasing the exploration weight would make the tuning job more exploitative, focusing on known good regions and reducing diversity, which is the opposite of what is needed. Option B is wrong because switching to random search would abandon the benefits of Bayesian optimization's informed sampling, potentially wasting resources on random trials without leveraging prior results. Option D is wrong because increasing the number of parallel training jobs does not inherently increase exploration diversity; it only speeds up the tuning process but may lead to less informed decisions if the Bayesian model cannot keep up with parallel evaluations.

Practice this question →

225

MCQeasy

A company is using SageMaker to deploy a model for real-time inference. The model requires low latency, and the company wants to test the endpoint before production. Which approach should be used to validate endpoint performance?

A.Use CloudWatch Synthetics to create a canary.

B.Perform offline batch evaluation on a test dataset.

C.Deploy to production and monitor using CloudWatch.

D.Use SageMaker's built-in shadow testing or load testing features.

AnswerD

Allows traffic simulation and latency measurement.

Why this answer

SageMaker provides features like shadow testing, which allows you to test a new variant alongside the existing production variant without impacting live traffic, and integration with load testing tools to simulate traffic and measure latency before full production deployment. Option A is incorrect because CloudWatch Synthetics is used for monitoring endpoint health and availability, not for pre-production load or performance testing. Option B is incorrect because offline batch evaluation assesses model accuracy on a static dataset, but does not test real-time inference performance metrics such as latency and throughput.

Option C is incorrect because deploying directly to production and monitoring exposes users to potential performance issues; pre-production validation should be conducted first.

Practice this question →