Courseiva

CCNA Machine Learning Implementation and Operations Questions

75 of 338 questions · Page 2/5 · Machine Learning Implementation and Operations · Answers revealed

Practice these questionsDomain overviewAll questions
76
Multi-Selectmedium

A company uses Amazon SageMaker to train models. The data scientist wants to automate the retraining process whenever new data arrives in an S3 bucket. Which THREE services can be used together to achieve this? (Choose THREE.)

Select 3 answers
A.Amazon S3
B.Amazon EC2
C.AWS Lambda
D.Amazon SageMaker
E.AWS Glue
AnswersA, C, D

S3 events can trigger the pipeline.

Why this answer

Amazon S3 is correct because it acts as the event source, emitting notifications (e.g., s3:ObjectCreated:*) when new data arrives. These events can be captured by AWS Lambda, which is correct because it can run a function that invokes Amazon SageMaker to start a retraining job. Amazon SageMaker is correct because it performs the actual model training.

Together, S3 triggers the pipeline, Lambda orchestrates the invocation, and SageMaker executes the retraining. Options B (EC2) and E (Glue) are not directly required for this automated retraining workflow; EC2 is a compute service that would add unnecessary complexity, and Glue (data transformation) is not needed for the core trigger-and-train flow.

Exam trap

The trap here is that candidates often select AWS Glue (Option E) thinking it is needed for data transformation before retraining, but the question asks for services that directly enable the automation of retraining when new data arrives, and Glue is not required for the core trigger-and-train flow.

Practice this question →
77
MCQmedium

A machine learning engineer is responsible for deploying a model that was trained using a custom algorithm in Amazon SageMaker. The engineer has built a Docker container that includes the inference code and has tested it locally. The engineer now wants to deploy the container to a SageMaker endpoint for real-time inference. The engineer has already created the model in SageMaker by specifying the image URI and the model artifacts location in S3. However, when the engineer tries to create an endpoint configuration, the operation fails with an error indicating that the model is not in an 'Active' state. What should the engineer do to resolve this issue?

A.Check the CloudWatch logs for the container to ensure the inference server starts correctly
B.Create the endpoint configuration with a different model name
C.Delete and re-create the model, then wait for a few minutes
D.Re-create the model using a different image URI
AnswerA

The health check requires the container to respond to a ping request. Logs will show if the server failed to start.

Why this answer

When a model is not in 'Active' state after creation, it typically indicates that the container's health check failed. Checking CloudWatch logs for the container helps identify why the inference server is not starting correctly. Option B is incorrect because the issue is with the model's state, not its name.

Option C is incorrect because deleting and recreating the model would not resolve the underlying health check problem without fixing the container. Option D is incorrect because using a different image URI would change the container but not address the health check failure if the root cause is in the inference code or configuration.

Practice this question →
78
MCQeasy

A company is using Amazon SageMaker to build a binary classification model. The dataset is highly imbalanced, with 95% negative class and 5% positive class. Which technique should be used to address the class imbalance?

A.Use a weighted loss function during training.
B.Use accuracy as the primary evaluation metric.
C.Perform random under-sampling of the majority class.
D.Remove all examples from the majority class.
AnswerA

Weighted loss penalizes errors on minority class more heavily.

Why this answer

Using a weighted loss function (e.g., class weights in SageMaker's built-in XGBoost or custom PyTorch loss) assigns a higher penalty to misclassifications of the minority positive class. This directly addresses the 95:5 imbalance by making the model more sensitive to the positive class during gradient updates, without discarding data.

Exam trap

The trap here is that candidates often choose under-sampling (Option C) as a quick fix, but the exam tests understanding that under-sampling discards data and can hurt performance, while weighted loss preserves all data and is the preferred technique in SageMaker for imbalanced classification.

How to eliminate wrong answers

Option B is wrong because accuracy is misleading for imbalanced datasets; a model predicting all negatives would achieve 95% accuracy but fail to identify any positives. Option C is wrong because random under-sampling of the majority class discards valuable data, potentially losing patterns and reducing model generalization, especially when the majority class is 95% of the data. Option D is wrong because removing all majority class examples eliminates most of the training data, making it impossible to learn the negative class distribution and leading to severe overfitting or model failure.

Practice this question →
79
MCQmedium

A data scientist uses SageMaker to train a model and wants to automatically stop the training job if the loss is not improving after a certain number of steps. Which feature should be used?

A.SageMaker Experiments
B.SageMaker Debugger
C.SageMaker Automatic Model Tuning
D.SageMaker Ground Truth
AnswerB

Debugger can monitor and stop jobs based on rules.

Why this answer

SageMaker Debugger provides built-in rules that monitor training metrics (e.g., loss) in real time and can trigger actions such as stopping the training job when the loss stops improving for a specified number of steps. This is done via the `StopTrainingJobOnRuleEvaluation` action, which automatically halts the job when a rule like `loss_not_decreasing` is violated.

Exam trap

The trap here is that candidates confuse SageMaker Debugger's monitoring and auto-stop capability with SageMaker Experiments' tracking features, or mistakenly think hyperparameter tuning (Automatic Model Tuning) can stop individual training jobs based on loss improvement.

How to eliminate wrong answers

Option A is wrong because SageMaker Experiments is designed for tracking, comparing, and managing multiple training runs and their metadata, not for real-time monitoring or automated job termination based on metric thresholds. Option C is wrong because SageMaker Automatic Model Tuning (hyperparameter tuning) optimizes hyperparameters by launching multiple training jobs, but it does not monitor loss within a single training job to stop it early. Option D is wrong because SageMaker Ground Truth is a data labeling service for creating training datasets, not a tool for monitoring or stopping training jobs.

Practice this question →
80
MCQhard

An ML team is using SageMaker Processing jobs to run feature engineering scripts. The scripts require a specific Python package not included in the default SageMaker image. How should the team provide this package?

A.Include 'pip install <package>' in the processing script
B.Use the SageMaker prebuilt deep learning container with the package
C.Place a requirements.txt file in the input data S3 bucket
D.Create a custom Docker image that includes the package and use it for the Processing job
AnswerD

Standard best practice for custom dependencies.

Why this answer

SageMaker Processing jobs run in isolated Docker containers, and the default SageMaker images only include pre-installed packages. To add a custom Python package, the team must create a custom Docker image that includes the package (e.g., via a Dockerfile with 'pip install <package>'), then specify that image URI in the Processing job configuration. This ensures the package is available in the container environment before the script executes.

Exam trap

AWS often tests the misconception that runtime commands (like 'pip install' in the script) or external configuration files (like requirements.txt in S3) can modify the container environment, when in fact SageMaker Processing jobs require all dependencies to be pre-installed in the Docker image.

How to eliminate wrong answers

Option A is wrong because 'pip install <package>' inside the processing script would attempt to install the package at runtime, but the container may lack internet access or sufficient permissions, and it violates the principle of immutable infrastructure — the package should be baked into the image. Option B is wrong because SageMaker prebuilt deep learning containers are optimized for frameworks like TensorFlow, PyTorch, or MXNet, and they do not include arbitrary third-party Python packages; the team would still need to customize the image to add the specific package. Option C is wrong because placing a requirements.txt file in the input data S3 bucket does not automatically install packages; SageMaker Processing jobs do not parse requirements.txt from input data — the container must be pre-configured with dependencies.

Practice this question →
81
MCQmedium

A team is training an XGBoost model using SageMaker with a large dataset in S3 (100 GB). Training is taking too long. Which change will most likely reduce training time without sacrificing accuracy?

A.Reduce the number of training instances
B.Configure Pipe mode for data input
C.Enable SageMaker Managed Spot Training
D.Use a larger instance type with more vCPUs
AnswerB

Pipe mode streams data directly from S3, reducing I/O bottleneck and training time.

Why this answer

Configuring Pipe mode for data input streams data directly from S3 to the training algorithm, significantly reducing I/O overhead and training time without affecting model accuracy. Option A (reducing the number of training instances) would actually increase training time, not reduce it. Option C (enabling SageMaker Managed Spot Training) is primarily for cost savings and does not reduce training time.

Option D (using a larger instance type) may provide some speedup but is less effective than addressing the I/O bottleneck with Pipe mode, and it may increase costs unnecessarily.

Practice this question →
82
MCQhard

A data scientist is training a deep learning model on a large dataset using SageMaker. The training job is taking too long. Upon reviewing the CloudWatch logs, the scientist notices that the GPU utilization is below 10% most of the time. Which change is MOST likely to improve GPU utilization and reduce training time?

A.Increase the batch size in the training script.
B.Use a different optimizer that requires less computation.
C.Switch to a smaller instance type to reduce data transfer overhead.
D.Reduce the size of the training dataset.
AnswerA

Increasing batch size can improve GPU utilization by processing more data per step.

Why this answer

Low GPU utilization (below 10%) indicates that the GPU is idle most of the time, waiting for data to be fed. Increasing the batch size allows each training step to process more samples per forward/backward pass, keeping the GPU busy with larger matrix operations and reducing the relative overhead of data loading and kernel launches. This directly improves GPU throughput and reduces total training time.

Exam trap

The trap here is that candidates mistakenly think reducing instance size or dataset size will speed up training, when in fact the core issue is underutilization of the existing GPU due to insufficient work per step.

How to eliminate wrong answers

Option B is wrong because using a different optimizer that requires less computation (e.g., switching from Adam to SGD) does not address the root cause of low GPU utilization; it may even worsen convergence speed without improving hardware saturation. Option C is wrong because switching to a smaller instance type reduces compute capacity (fewer GPU cores, less memory), which would likely increase training time and further lower utilization due to smaller batch sizes fitting in memory. Option D is wrong because reducing the size of the training dataset would reduce total training time but does not improve GPU utilization per step; the model would still underutilize the GPU during each iteration.

Practice this question →
83
MCQeasy

An ML engineer is troubleshooting why an automated CI/CD pipeline cannot deploy an updated model to an existing SageMaker endpoint. The pipeline uses the IAM role that has the attached policy shown in the exhibit. What is the MOST likely cause of the failure?

A.The pipeline tries to update an existing endpoint, but the sagemaker:UpdateEndpoint action is not allowed.
B.The pipeline tries to create a new endpoint, but the sagemaker:CreateEndpoint action is denied.
C.The pipeline tries to delete the old endpoint, but the sagemaker:DeleteEndpoint action is denied by a Deny statement.
D.The pipeline attempts to invoke the endpoint, but the sagemaker:InvokeEndpoint action is denied.
AnswerA

The policy does not include sagemaker:UpdateEndpoint, which is required to update an existing endpoint. Without this permission, the update fails.

Why this answer

The pipeline is attempting to deploy an updated model to an existing SageMaker endpoint, which requires the sagemaker:UpdateEndpoint action. The IAM policy shown in the exhibit (not provided here but implied) does not include this action, so the API call fails with an access denied error. Without explicit permission to update the endpoint, the CI/CD pipeline cannot modify the deployed configuration.

Exam trap

The trap here is that candidates may confuse the actions required for updating an existing endpoint (UpdateEndpoint) with those for creating a new one (CreateEndpoint), leading them to incorrectly select Option B when the pipeline is actually performing an update.

How to eliminate wrong answers

Option B is wrong because the pipeline is not creating a new endpoint; it is updating an existing one, so sagemaker:CreateEndpoint is not the required action. Option C is wrong because the pipeline does not need to delete the old endpoint; SageMaker endpoints are updated in-place via UpdateEndpoint, which handles traffic shifting automatically. Option D is wrong because the pipeline is not invoking the endpoint during deployment; InvokeEndpoint is used for inference requests, not for model deployment operations.

Practice this question →
84
MCQeasy

An ML engineer needs to store and version training datasets and model artifacts. Which AWS service should they use?

A.Amazon DynamoDB
B.Amazon Simple Storage Service (S3)
C.Amazon Elastic File System (EFS)
D.Amazon Elastic Block Store (EBS)
AnswerB

S3 supports versioning and is commonly used for ML artifacts.

Why this answer

Amazon S3 is the correct choice because it provides scalable, durable, and cost-effective object storage with built-in versioning capabilities, making it ideal for storing and versioning large training datasets and model artifacts. S3's versioning feature allows you to preserve, retrieve, and restore every version of an object, which is essential for reproducibility in ML workflows.

Exam trap

The trap here is that candidates often confuse storage services for ML artifacts with database or file system services, mistakenly choosing DynamoDB for its versioning-like features (e.g., DynamoDB Streams) or EFS for its shared file system access, without recognizing that S3 is the only service that offers native, durable object versioning at scale for ML use cases.

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB is a NoSQL key-value and document database designed for low-latency, high-throughput transactional workloads, not for storing large binary objects like datasets or model artifacts, and it lacks native versioning for such files. Option C is wrong because Amazon EFS is a scalable, elastic NFS file system for use with EC2 instances, but it does not provide built-in object versioning and is less cost-effective for long-term archival of large ML artifacts compared to S3. Option D is wrong because Amazon EBS provides block-level storage volumes for use with EC2 instances, but it lacks native versioning capabilities and is tied to a single Availability Zone, making it unsuitable for durable, versioned storage of datasets and models across regions.

Practice this question →
85
MCQmedium

An IAM policy attached to a SageMaker notebook role is shown in the exhibit. A data scientist is trying to run a training job from the notebook, but the job fails with an access denied error. The training job needs to read data from 'my-bucket' and write output to 'my-bucket'. What is the most likely cause of the failure?

A.The policy does not allow s3:ListBucket
B.The training job execution role does not have the same permissions
C.The policy does not allow sagemaker:CreateTrainingJob
D.The S3 bucket is not specified in the Resource
E.The policy does not allow s3:GetObject
AnswerB

The notebook role is used for the notebook; the training job uses an execution role that may lack permissions.

Why this answer

The IAM policy shown is attached to the SageMaker notebook role, which is used by the data scientist to interact with the notebook. However, when a training job is launched, it runs under a separate execution role (the SageMaker execution role for training jobs), not the notebook role. The training job fails because that execution role lacks the necessary S3 permissions (e.g., s3:GetObject, s3:PutObject) to read from and write to 'my-bucket'.

The notebook role's permissions are irrelevant to the training job's runtime actions.

Exam trap

The trap here is that candidates assume the notebook role's permissions automatically apply to the training job, but SageMaker requires a separate execution role for the training job, and the failure is due to that role lacking S3 permissions.

How to eliminate wrong answers

Option A is wrong because s3:ListBucket is not required for reading or writing objects; it is needed for listing bucket contents, which is not the operation causing the failure. Option C is wrong because the policy does include sagemaker:CreateTrainingJob (as shown in the exhibit), so that permission is not missing. Option D is wrong because the S3 bucket is specified in the Resource field of the policy (e.g., 'arn:aws:s3:::my-bucket/*'), so the resource is correctly defined.

Option E is wrong because the policy does allow s3:GetObject (as shown in the exhibit), so that permission is not the issue.

Practice this question →
86
MCQeasy

A data scientist needs to run a one-time training job on a large dataset using SageMaker. The job requires a specific PyTorch version and custom dependencies. Which approach is MOST efficient?

A.Create a custom Docker container and push to ECR.
B.Launch a SageMaker notebook instance, install dependencies, and run training script.
C.Use the SageMaker PyTorch estimator with a pre-built container.
D.Use the SageMaker generic container and install PyTorch via a lifecycle configuration.
AnswerC

The framework estimator manages the container and allows adding custom dependencies via source_dir.

Why this answer

The SageMaker PyTorch estimator provides a pre-built, optimized container with the specified PyTorch version, eliminating the need to manage custom Docker images or manual dependency installation. For a one-time training job, this approach is the most efficient as it requires minimal setup and leverages SageMaker's managed infrastructure for training.

Exam trap

The MLS-C01 exam often tests the distinction between using a fully managed estimator (like PyTorch) versus manual containerization or notebook-based training, where candidates may overcomplicate the solution by choosing custom Docker (Option A) due to familiarity with containerization, missing that pre-built containers are more efficient for standard frameworks.

How to eliminate wrong answers

Option A is wrong because creating a custom Docker container and pushing it to ECR introduces unnecessary overhead for a one-time job, including Dockerfile creation, image building, and registry management, which is not efficient compared to using a pre-built container. Option B is wrong because launching a SageMaker notebook instance, installing dependencies, and running the training script manually is not a managed training solution; it requires ongoing instance management and does not scale or handle job orchestration as efficiently as the SageMaker training service. Option D is wrong because the SageMaker generic container does not include PyTorch, and installing it via a lifecycle configuration adds complexity and runtime overhead, making it less efficient than using the dedicated PyTorch estimator with a pre-built container.

Practice this question →
87
MCQmedium

A data scientist is performing hyperparameter tuning using Amazon SageMaker Automatic Model Tuning (AMT). The job uses a random search strategy. After 20 training jobs, the best objective metric value has plateaued. The data scientist wants to explore more of the hyperparameter space. Which action should the data scientist take?

A.Change the tuning strategy from Random to Bayesian.
B.Enable early stopping.
C.Decrease the maximum number of training jobs.
D.Increase the number of parallel training jobs.
AnswerA

Bayesian search uses past results to guide exploration.

Why this answer

Changing the tuning strategy from Random to Bayesian allows the tuning job to use previous results to guide the search toward more promising hyperparameter regions, which can explore the space more efficiently after plateauing. Option B is incorrect because enabling early stopping terminates underperforming trials early but does not alter the search strategy itself; it may even reduce exploration. Option C is incorrect because decreasing the maximum number of training jobs reduces the total exploration of the hyperparameter space.

Option D is incorrect because increasing the number of parallel training jobs only speeds up the process but still uses the same random search strategy, which is unlikely to escape the plateau.

Practice this question →
88
MCQeasy

A data scientist is training a model on Amazon SageMaker and notices that the training job is taking much longer than expected. The instance type is ml.m5.xlarge and the dataset is 10 GB in CSV format. Which action is MOST likely to reduce training time without changing the instance type?

A.Change the instance type to ml.p3.2xlarge (GPU) for faster computation.
B.Reduce the number of training epochs to speed up convergence.
C.Convert the dataset to RecordIO or Parquet format before training.
D.Increase the batch size to the maximum supported by the instance memory.
AnswerC

RecordIO and Parquet are columnar formats that reduce I/O and allow faster data loading in SageMaker.

Why this answer

Converting the dataset from CSV to a columnar format like Parquet or RecordIO reduces I/O overhead and improves data throughput during training. SageMaker's built-in algorithms and many deep learning frameworks can read these formats more efficiently, especially for large datasets, because they enable better compression and predicate pushdown, reducing the time spent on data loading.

Exam trap

The trap here is that candidates often assume that changing the instance type (Option A) to a GPU instance is the only way to speed up training on SageMaker, or that hyperparameter tuning (like reducing epochs or increasing batch size) is always effective, but the question specifically tests understanding of data format optimization (e.g., using Parquet or RecordIO) as a cost-effective and instance-agnostic method to reduce I/O bottlenecks in SageMaker.

How to eliminate wrong answers

Option A is wrong because changing the instance type to a GPU instance (ml.p3.2xlarge) violates the constraint of not changing the instance type, and while it could speed up computation, the question explicitly asks for an action without changing the instance type. Option B is wrong because reducing the number of training epochs may harm model convergence and accuracy; it is a hyperparameter change that trades off training time for model quality, not a guaranteed way to reduce time without side effects. Option D is wrong because increasing the batch size to the maximum supported by instance memory can cause out-of-memory errors or degrade model convergence due to larger batch sizes requiring more memory and potentially leading to poor generalization; it does not address the I/O bottleneck that is the primary cause of slow training with large CSV files.

Practice this question →
89
MCQeasy

A data scientist is using Amazon SageMaker to train a model. Training is taking longer than expected. The scientist notices that the training job is using a single instance type with limited GPU memory. Which action will MOST likely reduce training time?

A.Configure the training job to use distributed data parallelism across multiple instances.
B.Use SageMaker Managed Spot Training to lower cost.
C.Use batch normalization layers.
D.Enable SageMaker Debugger for real-time monitoring.
AnswerA

Distributed data parallelism splits the dataset across multiple GPUs/instances, reducing per-worker memory and training time.

Why this answer

The training job is bottlenecked by limited GPU memory on a single instance. Distributed data parallelism splits the dataset across multiple instances, each processing a subset of the data in parallel, which directly reduces wall-clock training time by leveraging aggregate GPU memory and compute. This is the most effective action to address the stated problem of slow training due to limited GPU memory.

Exam trap

The trap here is that candidates often confuse cost optimization (Spot Training) with performance optimization, or they assume that algorithmic improvements (batch normalization) can compensate for hardware limitations, when the real fix is scaling out compute resources.

How to eliminate wrong answers

Option B is wrong because Managed Spot Training reduces cost by using spare EC2 capacity, but it does not increase GPU memory or parallelism, so it will not reduce training time. Option C is wrong because batch normalization layers improve training stability and convergence speed per epoch, but they do not address the fundamental bottleneck of limited GPU memory on a single instance. Option D is wrong because SageMaker Debugger provides real-time monitoring and debugging, but it adds overhead and does not accelerate training; it only helps identify issues.

Practice this question →
90
Multi-Selectmedium

A company is using Amazon SageMaker to build a machine learning pipeline. The pipeline includes data preprocessing, training, and evaluation steps. The company wants to ensure that the pipeline is reproducible and that artifacts are versioned. Which TWO actions should be taken? (Choose TWO.)

Select 2 answers
A.Use a naming convention for training jobs that includes the date.
B.Use SageMaker Pipelines to create the pipeline and enable versioning on the pipeline artifacts.
C.Create a requirements.txt file with specific library versions for the training script.
D.Use AWS CodePipeline to trigger the pipeline on code changes.
E.Store the training dataset in a versioned S3 bucket.
AnswersB, C

SageMaker Pipelines version artifacts automatically.

Why this answer

SageMaker Pipelines provides a native way to define, orchestrate, and version machine learning pipelines. By enabling versioning on pipeline artifacts (e.g., via the `Pipeline` object's `version` parameter or by using SageMaker Model Registry), each pipeline run is tracked with a unique version, ensuring reproducibility. This directly addresses the requirement for reproducible pipelines and versioned artifacts.

Exam trap

The trap here is that candidates often confuse data versioning (Option E) with pipeline versioning, or assume that a naming convention (Option A) or CI/CD trigger (Option D) is sufficient for reproducibility, when in fact only a purpose-built pipeline orchestration service with artifact versioning (Option B) combined with environment pinning (Option C) meets both requirements.

Practice this question →
91
MCQmedium

A data scientist is training a model using Amazon SageMaker and notices that training is taking much longer than expected. The training job uses a single ml.p3.2xlarge instance. The data is stored in S3 and is about 50 GB in size. Which action would MOST likely reduce training time?

A.Enable automatic data sharding in the SageMaker training job.
B.Enable S3 server-side encryption on the training data.
C.Use a larger instance type, such as ml.p3.16xlarge.
D.Change the input mode from File to Pipe.
AnswerD

Pipe mode streams data directly from S3, reducing I/O time.

Why this answer

Changing the input mode from File to Pipe reduces training time by streaming data directly from S3 to the training algorithm without first downloading it to the local disk. In File mode, SageMaker first downloads the entire 50 GB dataset to the instance's Amazon EBS volume, which adds significant I/O latency and storage overhead. Pipe mode uses a Linux FIFO (named pipe) to feed data on-the-fly, eliminating the download step and allowing the GPU to start processing sooner.

Exam trap

The trap here is that candidates often assume upgrading to a larger instance (Option C) is the default solution for slow training, overlooking that the bottleneck is data ingestion (File mode download) rather than compute, and that Pipe mode is a cost-effective alternative that directly addresses the I/O bottleneck.

How to eliminate wrong answers

Option A is wrong because automatic data sharding is not a SageMaker feature; sharding refers to distributing data across multiple instances in distributed training, but this job uses a single instance, so sharding would not apply. Option B is wrong because enabling S3 server-side encryption does not affect data transfer speed or training performance; it only adds encryption at rest, which has negligible impact on I/O. Option C is wrong because while a larger instance like ml.p3.16xlarge provides more GPU and memory, the bottleneck here is the data download time in File mode, not compute capacity; upgrading the instance would still incur the same 50 GB download overhead and is less cost-effective than switching to Pipe mode.

Practice this question →
92
MCQhard

A machine learning engineer is using Amazon SageMaker to train a model. The training job is taking too long. The engineer suspects the data loading is a bottleneck. Which action would MOST effectively diagnose the issue?

A.Monitor CPU utilization in CloudWatch
B.Enable SageMaker Model Monitor
C.Use SageMaker Debugger to profile the training job
D.Increase the instance type to a larger one
AnswerC

Debugger can capture detailed metrics like data loading time.

Why this answer

SageMaker Debugger can profile the training job and identify bottlenecks. Option A may add overhead. Option B is not detailed.

Option D is for inference.

Practice this question →
93
MCQhard

A company is using Amazon SageMaker to train and deploy a fraud detection model. The model is a gradient boosting machine (GBM) trained on a dataset with 10 million rows and 50 features. The training job runs on an ml.m5.2xlarge instance with 8 vCPUs and 32 GB memory. The training completes successfully, and the model is deployed to a real-time endpoint. After deployment, the inference latency is around 200 ms per request, which is acceptable. However, after a week, the company observes that latency increases to over 1 second during peak hours (12:00-13:00 UTC). CloudWatch metrics show CPU utilization on the endpoint instance reaches 95% during these peaks. The endpoint is configured with a single ml.m5.large instance. The company wants to maintain latency under 500 ms during peak hours without incurring unnecessary cost during off-peak hours. Which solution should the company implement?

A.Reduce the number of instances to zero during off-peak hours and manually launch a new endpoint every day at 12:00
B.Switch to SageMaker Batch Transform and have the application send requests in batches
C.Configure SageMaker endpoint auto scaling with a target CPU utilization of 70% and a minimum instance count of 1
D.Replace the endpoint instance type with ml.m5.4xlarge to handle peak load
AnswerC

Auto scaling dynamically adjusts instance count to handle load, keeping latency low and cost efficient.

Why this answer

Configuring auto scaling based on CPU utilization dynamically adds instances during peak hours (when CPU exceeds target) and removes them during off-peak, maintaining latency under 500 ms while minimizing cost. Option A is incorrect because reducing instances to zero and manually launching a new endpoint is not automated, causes downtime, and is impractical. Option B is incorrect because Batch Transform is designed for offline, batch inference, not for real-time requests.

Option D is incorrect because replacing the instance with a larger, always-on type (ml.m5.4xlarge) would handle peak load but incur higher cost during off-peak hours, unlike auto scaling which scales in.

Practice this question →
94
MCQhard

A company is using SageMaker to train a large NLP model. The training job is taking too long due to high I/O wait time. The data is stored as CSV files in S3. Which optimization should the company implement to reduce I/O wait time?

A.Convert CSV files to RecordIO format
B.Use SageMaker Pipe mode to stream data directly from S3
C.Use SageMaker batch transform before training
D.Use SageMaker File mode with larger instance storage
E.Use SageMaker ShardedByS3Key data distribution
AnswerB

Pipe mode avoids disk I/O by streaming data.

Why this answer

SageMaker Pipe mode streams data directly from S3 into the training algorithm without first writing it to the local disk, eliminating the I/O wait time caused by downloading and decompressing CSV files. This is the most effective optimization for high I/O wait during training because it bypasses the bottleneck of writing large datasets to the instance's local storage.

Exam trap

The trap here is that candidates often confuse data format optimizations (like RecordIO) or distribution strategies (like ShardedByS3Key) with the fundamental I/O bottleneck caused by downloading data to disk, leading them to overlook Pipe mode's direct streaming approach.

How to eliminate wrong answers

Option A is wrong because converting CSV to RecordIO format can improve throughput for certain frameworks (e.g., MXNet) but does not address the root cause of high I/O wait time from disk writes; it still requires downloading the data to local storage. Option C is wrong because SageMaker batch transform is used for inference on large datasets, not for training optimization, and does not reduce I/O wait during training. Option D is wrong because SageMaker File mode (the default) downloads the entire dataset to the instance's local disk before training starts, which is the very behavior causing high I/O wait; larger instance storage would not reduce the wait time.

Option E is wrong because ShardedByS3Key is a data distribution strategy for distributed training (splitting data across instances), not a mechanism to reduce I/O wait time on a single instance.

Practice this question →
95
MCQmedium

A data scientist is using Amazon SageMaker Autopilot to automatically build a binary classification model. After the Autopilot job completes, the best model has an accuracy of 0.85 on the validation set. However, the data scientist notices a class imbalance (90% negative, 10% positive). Which metric should the data scientist use to evaluate the model's performance on the positive class?

A.Area Under the ROC Curve (AUC)
B.Recall
C.Accuracy
D.Precision
AnswerA

AUC is robust to class imbalance and evaluates overall ranking performance.

Why this answer

A is correct because Area Under the ROC Curve (AUC) is threshold-independent and evaluates the model's ability to distinguish between positive and negative classes across all classification thresholds. In the presence of severe class imbalance (90% negative, 10% positive), AUC provides a robust measure of model performance on the positive class without being skewed by the majority class, unlike accuracy which would be high even if the model predicts all negatives.

Exam trap

The trap here is that candidates often default to accuracy as the primary metric, failing to recognize that class imbalance renders accuracy misleading, and they overlook AUC's threshold-agnostic property which is specifically designed for evaluating model performance on the minority class in imbalanced datasets.

How to eliminate wrong answers

Option B (Recall) is wrong because recall only measures the proportion of actual positives correctly identified, but it ignores false positives and does not account for the model's performance across different thresholds; it can be misleadingly high if the model predicts positive too often. Option C (Accuracy) is wrong because with 90% negative class, a model that predicts all negatives achieves 90% accuracy, masking poor performance on the positive class; accuracy is not suitable for imbalanced datasets. Option D (Precision) is wrong because precision focuses on the proportion of positive predictions that are correct, but it does not consider false negatives and is highly sensitive to the decision threshold; it does not provide a holistic view of model discrimination ability.

Practice this question →
96
Multi-Selectmedium

An ML team is deploying a model for real-time inference. They require A/B testing to compare a new model against the existing one. Which THREE steps should they take to set up this test?

Select 3 answers
A.Set up a second production variant for the existing model
B.Set up a SageMaker Batch Transform job for each model
C.Configure CloudWatch alarms to trigger variant switching
D.Configure the endpoint to route a percentage of traffic to each variant
E.Create a SageMaker production variant for the new model
AnswersA, D, E

Both models must be variants to split traffic.

Why this answer

To perform A/B testing with SageMaker, you must create a second production variant for the existing model so that both the old and new models are deployed as separate variants under the same endpoint. This allows the endpoint to serve both models simultaneously and compare their performance.

Exam trap

The trap here is that candidates confuse batch inference (Batch Transform) with real-time inference (endpoint variants), or mistakenly think CloudWatch alarms can directly control traffic routing, when in fact traffic weights are set manually or via SDK/CLI updates.

Practice this question →
97
Multi-Selecthard

A company is using Amazon SageMaker to train a machine learning model. The training job is configured to use the File mode to download data from S3 to the training instances. The training data is stored in a single S3 bucket with multiple prefixes. Which TWO actions are required to ensure the training job can access the data? (Choose TWO.)

Select 2 answers
A.Grant the SageMaker execution role s3:GetObject permission for the data bucket.
B.Configure the training job to use Pipe mode.
C.Specify the S3 data channel with the correct prefix.
D.Concatenate all data files into a single file.
E.Convert the data to RecordIO-protobuf format.
AnswersA, C

Needed to read objects.

Why this answer

Options A and C are correct. Option A: The SageMaker execution role must have the s3:GetObject permission for the data bucket to read the training data. Option C: When using File mode, the training job must specify the S3 data channel with the correct prefix to indicate the location of the data.

Option B is incorrect because Pipe mode is not required for File mode. Option D is incorrect because concatenating all data into a single file is unnecessary for File mode. Option E is incorrect because File mode does not require RecordIO-protobuf format.

Practice this question →
98
Multi-Selecthard

Which THREE are valid considerations when deploying a large deep learning model (10 GB) on a SageMaker endpoint? (Choose 3.)

Select 3 answers
A.Enable SageMaker Data Compression for network transfer.
B.Use GPU instances (e.g., p3, inf1) for faster inference.
C.Use SageMaker Multi-Model Endpoints to serve multiple models.
D.Use SageMaker Serverless Inference to avoid managing instances.
E.Attach Elastic Inference accelerators.
AnswersA, B, C

Compression reduces data transfer time.

Why this answer

SageMaker Data Compression uses HTTP compression (e.g., gzip) to reduce the payload size during network transfer between the client and endpoint, which is critical for a 10 GB model to minimize latency and bandwidth consumption. This is especially beneficial when the model is large and inference requests involve substantial input or output data.

Exam trap

The trap here is that candidates may assume Serverless Inference or Elastic Inference can handle any model size, but both have hard limits (1 GB for Elastic Inference, 1 GB model size and 6 MB payload for Serverless) that make them invalid for a 10 GB model.

Practice this question →
99
MCQhard

A media company uses Amazon SageMaker to train a deep learning model for video classification. The training job uses a single ml.p3.2xlarge instance and processes 50 GB of labeled video data stored in Amazon S3. The training completes successfully in 12 hours. However, the data scientists report that the model’s accuracy is lower than expected. They suspect the training data contains labeling errors. To improve model accuracy without incurring significant additional cost, they want to identify and remove mislabeled training examples before retraining. They have a small budget of $50 and need to complete the analysis within 2 hours. Which approach should the data scientists take?

A.Use SageMaker Ground Truth to create a new labeling job for the entire dataset, then compare the new labels with the original labels to identify discrepancies.
B.Use SageMaker Clarify to generate a bias report for the training data and remove instances that contribute to bias.
C.Train a small, fast model on a random sample of the data (e.g., 1 GB) using a cheaper instance like ml.m5.xlarge, then use the model's prediction confidence to flag low-confidence examples as potential mislabels for manual review.
D.Manually review all 50 GB of video data to correct labels.
AnswerC

This approach is cost-effective (within $50) and fast (under 2 hours). The small model can identify likely mislabeled examples by low confidence, allowing targeted manual review.

Why this answer

Training a small, fast model on a 1 GB random sample using a cheaper instance (ml.m5.xlarge) allows the team to quickly identify low-confidence predictions, which are strong indicators of mislabeled examples. This approach fits within the $50 budget and 2-hour time constraint, as it avoids processing the full 50 GB dataset and leverages a lightweight model for rapid iteration. By flagging only suspicious samples for manual review, the team can efficiently clean the training data without incurring the cost of re-labeling the entire dataset.

Exam trap

The trap here is that candidates may choose SageMaker Ground Truth (Option A) assuming it is the standard tool for label correction, but they overlook the strict budget and time constraints that make it infeasible for the full dataset.

How to eliminate wrong answers

Option A is wrong because using SageMaker Ground Truth to create a new labeling job for the entire 50 GB dataset would exceed the $50 budget and 2-hour time limit, as labeling large video datasets is expensive and time-consuming. Option B is wrong because SageMaker Clarify is designed for detecting bias in data and models, not for identifying individual mislabeled examples; it generates bias reports but cannot pinpoint which specific labels are erroneous. Option D is wrong because manually reviewing all 50 GB of video data is impractical within the 2-hour window and would far exceed the $50 budget, requiring significant human effort and cost.

Practice this question →
100
Multi-Selecthard

A company is deploying a machine learning model to a SageMaker endpoint and wants to ensure that the endpoint is resilient to instance failures. Which THREE steps should the company take to achieve high availability? (Choose THREE.)

Select 3 answers
A.Deploy the endpoint in a VPC with subnets in at least two Availability Zones.
B.Use a single instance type with the largest size to handle capacity.
C.Configure the endpoint with an initial instance count of at least 2.
D.Use a single Availability Zone for simplicity.
E.Enable auto-scaling to automatically replace unhealthy instances.
AnswersA, C, E

Provides AZ redundancy.

Why this answer

Deploying the endpoint in a VPC with subnets in at least two Availability Zones ensures that if one Availability Zone fails, the endpoint can still serve traffic from the other zone. SageMaker endpoints distribute instances across the specified subnets, so multi-AZ deployment provides fault isolation and high availability at the infrastructure level.

Exam trap

The trap here is that candidates often think a single large instance or a single Availability Zone is sufficient for high availability, but AWS's shared responsibility model requires you to architect for failure across multiple AZs and use auto-scaling to replace unhealthy instances automatically.

Practice this question →
101
Multi-Selecthard

A data scientist is using Amazon SageMaker to train a model using a custom Docker container. The training job fails with an error message indicating that the container exited with a non-zero code. Which THREE steps should the data scientist take to diagnose the issue? (Choose THREE.)

Select 3 answers
A.Retry the training job with the same configuration; the error might be transient.
B.Use the SageMaker Debugger to capture system metrics and output tensors for analysis.
C.Check the CloudWatch Logs for the training job to see the container's stdout and stderr.
D.Increase the number of training instances to distribute the workload.
E.Run the container locally using SageMaker Local Mode to simulate the training environment.
AnswersB, C, E

Debugger can capture detailed metrics that help identify why the container exited.

Why this answer

SageMaker Debugger can capture system metrics (e.g., CPU/GPU utilization, memory) and output tensors during training, which helps identify issues like resource exhaustion or problematic gradients that cause non-zero exit codes. It provides deep visibility into the training process without requiring code changes, making it a powerful diagnostic tool for custom container failures.

Exam trap

The trap here is that candidates may think retrying the job (Option A) is a valid first step for transient errors, but the MLS-C01 exam emphasizes systematic debugging using tools like CloudWatch Logs and SageMaker Debugger rather than guesswork.

Practice this question →
102
MCQeasy

A data scientist is trying to create a SageMaker training job using an execution role with the attached IAM policy. The training job fails with an access denied error when trying to read training data from the S3 bucket 'my-bucket'. What is the most likely cause?

A.The S3 bucket policy explicitly denies access to the role.
B.The IAM policy does not include s3:ListBucket permission.
C.The S3 bucket is in a different AWS account.
D.The sagemaker:CreateTrainingJob action is not allowed.
AnswerA

Even if IAM allows, bucket policy can deny.

Why this answer

The most likely cause is that the S3 bucket policy explicitly denies access to the SageMaker execution role. Even if the IAM policy grants the necessary permissions, an explicit deny in the bucket policy overrides any allow, resulting in an access denied error when the training job attempts to read training data from the S3 bucket.

Exam trap

The trap here is that candidates often assume the IAM policy is insufficient (e.g., missing ListBucket) or that cross-account issues are the cause, but the most likely cause is an explicit deny in the bucket policy, which is a classic AWS IAM evaluation logic trick.

How to eliminate wrong answers

Option B is wrong because the s3:ListBucket permission is not required to read objects from S3; the s3:GetObject permission is sufficient for reading training data, and the error is about reading data, not listing. Option C is wrong because if the bucket is in a different AWS account, the error would typically be an access denied due to cross-account permissions, but the question does not indicate cross-account access, and the most likely cause is an explicit deny in the bucket policy. Option D is wrong because the error occurs when reading training data from S3, not when creating the training job; the sagemaker:CreateTrainingJob action is likely allowed since the training job was created but failed during data access.

Practice this question →
103
MCQhard

A machine learning engineer is deploying a model on Amazon SageMaker that was trained using a custom Docker container. The container is stored in Amazon ECR. The engineer creates a SageMaker model and endpoint configuration, but when creating the endpoint, it fails with an error: 'Could not find the inference code at the expected path.' The engineer verified that the container image is correct and the model artifacts are in S3. What is the most likely cause?

A.The container is not compatible with the SageMaker inference environment.
B.The SageMaker execution role does not have ECR pull permissions.
C.The model artifacts are not in the correct format.
D.The inference code is not placed in the /opt/ml/model directory inside the container.
AnswerD

SageMaker expects code in /opt/ml/model for custom containers.

Why this answer

The error 'Could not find the inference code at the expected path' indicates that SageMaker cannot locate the inference script (e.g., serve.py, inference.py) inside the container. SageMaker expects the inference code to be placed in the /opt/ml/model/ directory within the container. Option D correctly identifies that the inference code is not placed in /opt/ml/model.

Option A is incorrect because container compatibility would cause a different error (e.g., unsupported base image). Option B is incorrect because ECR pull permissions typically result in an 'Unauthorized' error when pulling the image. Option C is incorrect because model artifacts being in the wrong format would cause loading errors, not inference code path errors.

Practice this question →
104
MCQhard

A company deploys a real-time inference endpoint using Amazon SageMaker with an ML model that has strict latency requirements. The endpoint currently uses a single ml.c5.xlarge instance. During a load test, the p99 latency exceeds the 100ms threshold. The team adds more instances but latency does not improve because the model is heavily CPU-bound. What is the MOST cost-effective change to meet the latency requirement?

A.Change the instance type to a GPU instance such as ml.g4dn.xlarge.
B.Use a multi-model endpoint to serve multiple models on the same instance.
C.Enable automatic scaling based on inference latency.
D.Increase the number of instances and use a target tracking scaling policy.
AnswerA

GPU instances accelerate model inference, reducing per-request latency.

Why this answer

The model is CPU-bound, meaning the bottleneck is compute capacity, not throughput. GPU instances like ml.g4dn.xlarge offload parallel computation from the CPU, significantly reducing per-inference latency. This directly addresses the root cause without over-provisioning, making it the most cost-effective solution.

Exam trap

The trap here is that candidates assume adding more instances (horizontal scaling) always reduces latency, but for CPU-bound models, the bottleneck is per-instance compute, not request queuing, so vertical scaling with GPU instances is required.

How to eliminate wrong answers

Option B is wrong because a multi-model endpoint reduces memory overhead for multiple models but does not accelerate a single CPU-bound model's inference. Option C is wrong because automatic scaling based on latency only adds more instances, which does not help when the model is CPU-bound and each instance is already saturated. Option D is wrong because increasing instances and using target tracking scaling does not resolve the CPU bottleneck; it only distributes load across more instances, each still suffering high latency.

Practice this question →
105
MCQeasy

A data scientist needs to deploy a trained model to Amazon SageMaker for real-time inference. The model is stored as a .tar.gz file in Amazon S3. Which AWS service is used to create a SageMaker endpoint?

A.SageMaker Model and Endpoint Configuration
B.AWS Lambda
C.AWS CloudFormation
D.Amazon ECS
AnswerA

You create a Model, then EndpointConfig, then Endpoint.

Why this answer

To create a SageMaker endpoint, you must first create a SageMaker Model (which points to the model artifact in S3 and the inference code) and then create an Endpoint Configuration (which specifies the model variant, instance type, and initial instance count). These are done using the SageMaker Model and Endpoint Configuration services. AWS Lambda, CloudFormation, and ECS are not directly used for creating the endpoint; they could be part of deployment automation but are not required.

Practice this question →
106
MCQeasy

A data scientist trains a model using Amazon SageMaker's built-in XGBoost algorithm. The model overfits on the training data. Which hyperparameter adjustment is MOST likely to reduce overfitting?

A.Increase the value of the max_depth hyperparameter.
B.Increase the value of the subsample hyperparameter to 1.0.
C.Increase the value of the lambda (L2 regularization) hyperparameter.
D.Increase the value of the num_round hyperparameter.
AnswerC

L2 regularization penalizes large coefficients, reducing model complexity and overfitting.

Why this answer

Increasing the lambda (L2 regularization) hyperparameter adds a penalty on the squared magnitude of the model weights, which discourages the model from fitting noise in the training data. This directly reduces overfitting by shrinking the influence of individual features, a standard regularization technique in XGBoost.

Exam trap

AWS exam candidates often mistakenly think that increasing any hyperparameter that adds complexity (like max_depth or num_round) can reduce overfitting, when in fact only regularization parameters or those that reduce model capacity are effective.

How to eliminate wrong answers

Option A is wrong because increasing max_depth makes trees deeper, allowing the model to capture more complex patterns and noise, which exacerbates overfitting rather than reducing it. Option B is wrong because increasing subsample to 1.0 means using 100% of the training data for each tree, removing the stochasticity that helps prevent overfitting; lower subsample values (e.g., 0.5–0.8) are typically used to introduce randomness. Option D is wrong because increasing num_round (the number of boosting rounds) allows the model to continue fitting the training data more closely, increasing the risk of overfitting; early stopping or reducing num_round is a common countermeasure.

Practice this question →
107
Multi-Selecthard

A company is using Amazon SageMaker to build a custom model. The training job is failing with a 'ResourceLimitExceeded' error. Which TWO actions should the company take to resolve this issue?

Select 2 answers
A.Request a service quota increase for SageMaker training instances.
B.Use spot instances for training.
C.Use Amazon EFS for training data.
D.Reduce the size of the training dataset.
E.Use a smaller instance type.
AnswersA, B

Increases the maximum number of instances.

Why this answer

The 'ResourceLimitExceeded' error indicates that the AWS account has reached its service quota for SageMaker training instances. Requesting a service quota increase through the AWS Service Quotas console or API allows the account to launch additional instances of the required type, directly resolving the limit issue.

Exam trap

The trap here is that candidates may confuse a resource limit error with a performance or storage issue, leading them to choose dataset reduction or storage changes instead of addressing the actual AWS service quota.

Practice this question →
108
MCQeasy

A data science team is deploying a machine learning model to production using Amazon SageMaker. The model requires real-time inference with low latency. Which SageMaker feature should they use to deploy the model?

A.SageMaker Notebook Instance
B.SageMaker Batch Transform
C.SageMaker Autopilot
D.SageMaker Realtime Endpoint
AnswerD

Provides low-latency, real-time inference.

Why this answer

SageMaker Realtime Endpoints are designed for low-latency, synchronous inference, making them the correct choice for serving predictions in real time. They keep the model loaded and ready to respond to individual requests, which is essential for applications requiring immediate responses.

Exam trap

The trap here is that candidates often confuse SageMaker Batch Transform (designed for batch processing) with real-time inference, or they mistakenly think SageMaker Notebook Instances can serve as production endpoints because they can run code interactively.

How to eliminate wrong answers

Option A is wrong because SageMaker Notebook Instances are interactive development environments for building and testing models, not for serving production inference. Option B is wrong because SageMaker Batch Transform is designed for asynchronous, offline inference on large datasets, not for real-time, low-latency requests. Option C is wrong because SageMaker Autopilot automates the process of building, training, and tuning machine learning models, but it does not provide a mechanism for deploying models to real-time endpoints.

Practice this question →
109
MCQhard

A machine learning team is using Amazon SageMaker Experiments to track multiple training runs. They need to compare the performance of different models based on metrics like accuracy and F1 score. However, when they view the experiment list in SageMaker Studio, the metrics are not displayed. What is the MOST likely cause?

A.The training job did not define metric definitions in the algorithm specification.
B.The training script did not use the SageMaker SDK to log the metrics.
C.The training job is running on an instance type that does not support Experiments.
D.The IAM role used by SageMaker does not have permission to write to the Experiments table.
AnswerB

Metrics must be logged using experiment.log_metric() or automatically if using frameworks with SageMaker integration.

Why this answer

SageMaker Experiments automatically tracks parameters and metrics only when the training script explicitly logs them using the SageMaker SDK's `log_metric` function or the `sagemaker.experiments.run.Run` class. Without these SDK calls, the metrics are never recorded in the experiment's trial components, so they will not appear in the Studio experiment list. The team must instrument their training code to emit metrics for Experiments to capture them.

Exam trap

The trap here is that candidates confuse CloudWatch metric definitions (used for hyperparameter tuning or console monitoring) with SageMaker Experiments metric logging, assuming that defining metrics in the algorithm specification is sufficient for Experiments to display them.

How to eliminate wrong answers

Option A is wrong because metric definitions in the algorithm specification are used for CloudWatch metric emission and automatic model tuning, not for SageMaker Experiments; Experiments relies on SDK-based logging, not algorithm specification definitions. Option C is wrong because SageMaker Experiments is supported on all SageMaker training instance types; there is no instance type restriction for Experiments functionality. Option D is wrong because the IAM role's permission to write to the Experiments table is not the issue; the Experiments table is an internal SageMaker resource, and the role typically has sufficient permissions if it can launch training jobs; the core problem is the absence of metric logging in the training script.

Practice this question →
110
MCQhard

A training job log shows this error. The training instance is an ml.m5.large with 8 GB EBS storage. The training data is 500 MB, and the model size is expected to be 200 MB. What is the most likely cause?

A.The training data is not fully downloaded from S3 before processing
B.The S3 bucket does not have write permissions
C.The training instance does not have enough RAM
D.The training process is generating large temporary files that fill the instance's local storage
AnswerD

Correct. The training process is generating large temporary files that fill the instance's local storage, causing a 'No space left on device' error.

Why this answer

The training job runs on an ml.m5.large instance with only 8 GB of EBS storage. Given that the training data is 500 MB and the model size is 200 MB, there is ample space for those, but the error indicates a lack of storage space. This is most likely caused by temporary files (e.g., checkpoints, logs, or intermediate data) generated during training that fill up the remaining storage.

Option A is incorrect because a download issue would show errors like 'Download failed' or 'NoSuchKey', not a storage error. Option B is incorrect because S3 permission issues would result in 'AccessDenied' errors. Option C is incorrect because insufficient RAM would cause a 'MemoryError' or out-of-memory kill, not a storage space error.

Practice this question →
111
Multi-Selecteasy

A data scientist needs to select a model training infrastructure that supports distributed training across multiple GPUs and provides automatic model parallelism. Which TWO AWS services should the scientist consider?

Select 2 answers
A.AWS Glue
B.AWS Lambda
C.Amazon Redshift
D.Amazon EMR
E.Amazon SageMaker
AnswersD, E

EMR with Spark MLlib can perform distributed training.

Why this answer

Amazon EMR is correct because it supports distributed training across multiple GPUs using frameworks like TensorFlow, PyTorch, and Apache Spark, and it can automatically handle model parallelism through its integration with Horovod or custom distributed training scripts. Amazon SageMaker is correct because it provides built-in distributed training libraries (e.g., SageMaker Distributed Data Parallel and Model Parallel) that automatically partition model layers across multiple GPUs, enabling efficient training of large models.

Exam trap

The trap here is that candidates often confuse data processing services (Glue, Redshift) or serverless compute (Lambda) with GPU-accelerated training infrastructure, overlooking that only services explicitly supporting distributed GPU training and model parallelism (SageMaker and EMR) are correct.

Practice this question →
112
MCQmedium

A data scientist is using Amazon SageMaker to train a model using the built-in XGBoost algorithm. The training job uses a hyperparameter tuning job to optimize hyperparameters. The tuning job has been running for 3 hours and has completed 20 training jobs. The data scientist wants to stop the tuning job early if it is not making progress. What should the data scientist do to accomplish this?

A.Configure the tuning job with early stopping enabled.
B.Set up a CloudWatch alarm to stop the tuning job if a metric does not improve.
C.Use SageMaker Experiments to monitor and manually stop the tuning job.
D.Use SageMaker Debugger to stop training jobs that are not improving.
AnswerA

Built-in early stopping stops underperforming training jobs.

Why this answer

SageMaker's automatic model tuning supports early stopping. When enabled, the tuning job stops automatically if no significant improvement is observed. Option B is incorrect because CloudWatch alarms can monitor metrics but cannot directly stop a tuning job; they can trigger actions like notifications but not stop the tuning.

Option C is incorrect because SageMaker Experiments is for tracking experiments, not for stopping tuning jobs. Option D is incorrect because SageMaker Debugger stops individual training jobs, not the hyperparameter tuning job itself; early stopping is a built-in feature of the tuning job.

Practice this question →
113
MCQeasy

A company is using SageMaker to train a model. The training data includes personally identifiable information (PII). The company must ensure that the data is encrypted at rest and in transit. Which combination of actions meets these requirements?

A.Use S3 server-side encryption with S3 managed keys (SSE-S3)
B.Enable SSL for data in transit and use VPC endpoints
C.Place all resources in a private VPC subnets with no internet access
D.Use S3 server-side encryption and enable SageMaker inter-container traffic encryption
AnswerD

S3 SSE encrypts at rest; SageMaker inter-container encryption uses TLS for in-transit.

Why this answer

It combines S3 server-side encryption (SSE-S3) to protect data at rest in the training dataset with SageMaker inter-container traffic encryption, which encrypts data in transit between training containers using TLS. This dual approach satisfies the requirement for encryption both at rest and in transit within the SageMaker training environment.

Exam trap

The trap here is that candidates often assume VPC isolation or SSL alone satisfies both encryption requirements, but they overlook the need for explicit encryption of inter-container traffic within SageMaker's distributed training environment.

How to eliminate wrong answers

Option A is wrong because SSE-S3 only encrypts data at rest in S3, but does not address encryption of data in transit during model training. Option B is wrong because enabling SSL for data in transit and using VPC endpoints secures network traffic but does not encrypt data at rest in S3 or within SageMaker containers. Option C is wrong because placing resources in private VPC subnets with no internet access prevents network exposure but does not provide encryption of data at rest or in transit between containers.

Practice this question →
114
MCQmedium

A research lab is using SageMaker to train deep learning models on a custom dataset stored in S3. Each training job uses a single ml.p3.2xlarge instance. Recently, training jobs have been failing intermittently with 'NetworkError: Connection reset by peer' during the data download phase. The data scientist notices that the dataset is 50GB and the network throughput is low. The training script uses the default S3 download method (boto3) to copy data from S3 to the local instance storage. Which solution should the data scientist implement to resolve the issue?

A.Mount an EBS volume to the instance and copy data there before training.
B.Use SageMaker Pipe mode to stream data directly from S3.
C.Add retry logic in the training script to handle network errors.
D.Use a larger instance type like p3.8xlarge for better network bandwidth.
AnswerB

Pipe mode avoids large local file downloads and is more resilient.

Why this answer

SageMaker Pipe mode streams training data directly from S3 without writing to local disk, avoiding the large download that causes network timeouts. Option A (mount EBS) does not eliminate the need to download 50GB, so it does not resolve the network reset. Option C (retry logic) may help but does not address the root cause of low throughput and large downloads.

Option D (larger instance) increases bandwidth but does not guarantee connection stability and costs more.

Practice this question →
115
MCQeasy

An ML engineer needs to run a hyperparameter tuning job on Amazon SageMaker. The training algorithm supports distributed training across multiple GPUs. The engineer wants to minimize the total time to find the best hyperparameters. Which strategy should be used?

A.Use random search to explore a wide range.
B.Use grid search to cover all combinations.
C.Use Hyperband which is designed for distributed training.
D.Use Bayesian optimization as the tuning strategy.
AnswerD

Bayesian optimization adaptively selects hyperparameters, reducing total tuning time.

Why this answer

Bayesian optimization is the correct choice because it builds a probabilistic model of the objective function and uses an acquisition function to select the most promising hyperparameters to evaluate next. This approach converges to optimal hyperparameters in far fewer trials than random or grid search, minimizing total tuning time. SageMaker's built-in hyperparameter tuning jobs natively support Bayesian optimization and can leverage distributed training across multiple GPUs without any additional configuration.

Exam trap

The trap here is that candidates may assume Hyperband is the best choice because it is explicitly designed for distributed training and early stopping, but the question asks to minimize total time to find the best hyperparameters, and Bayesian optimization is more sample-efficient and converges faster than Hyperband when the objective function is expensive to evaluate.

How to eliminate wrong answers

Option A is wrong because random search, while better than grid search, does not use past evaluation results to guide future trials, so it wastes time exploring unpromising regions and does not minimize total tuning time. Option B is wrong because grid search exhaustively evaluates all combinations of a predefined set of hyperparameter values, which is computationally expensive and scales poorly with the number of hyperparameters, making it the slowest strategy for minimizing total time. Option C is wrong because Hyperband is an early-stopping strategy that allocates resources to promising configurations and terminates poor ones early, but it is not specifically designed for distributed training; it can be used with distributed training but does not inherently minimize total tuning time better than Bayesian optimization when the goal is to find the best hyperparameters with minimal wall-clock time.

Practice this question →
116
MCQmedium

A company is using Amazon SageMaker to host a model for real-time inference. The model was trained using SageMaker's built-in Linear Learner algorithm. The endpoint has been running for a week, and the operations team notices that the endpoint's latency has increased from 50 ms to 150 ms over the past few days. The number of requests per second has remained steady at about 200. The team suspects a memory leak in the inference container. What should the team do to diagnose the issue?

A.Enable CloudWatch Logs and use Container Insights to view memory utilization.
B.Use Amazon CloudWatch to monitor the endpoint's latency metric.
C.Use SageMaker Debugger to inspect the inference container.
D.Use SageMaker Model Monitor to detect data drift.
AnswerA

Container Insights shows memory usage trends, helping diagnose leaks.

Why this answer

CloudWatch Container Insights provides metrics for containerized applications, including memory utilization. This can help diagnose a memory leak by showing memory usage trends over time. Option B is incorrect because CloudWatch latency metrics only show endpoint response time, not memory usage.

Option C is incorrect because SageMaker Debugger is designed for debugging training jobs, not inference containers. Option D is incorrect because SageMaker Model Monitor detects data and model drift, not memory leaks.

Practice this question →
117
Multi-Selectmedium

A company is using Amazon SageMaker to train and deploy machine learning models. The data science team wants to track and compare model versions, hyperparameters, and metrics across multiple training jobs. Which TWO AWS services should they use together to achieve this? (Choose TWO.)

Select 2 answers
A.Amazon RDS
B.Amazon CloudWatch Logs
C.AWS Glue
D.Amazon S3
E.Amazon SageMaker Experiments
AnswersD, E

S3 stores experiment artifacts and outputs.

Why this answer

Amazon S3 is correct because it serves as the central repository for storing model artifacts, training data, and output files from SageMaker training jobs. By default, SageMaker saves model artifacts and training results to S3, enabling version tracking and reproducibility across experiments.

Exam trap

The trap here is that candidates may confuse CloudWatch Logs (which only stores raw logs) with a proper experiment tracking solution, or assume a database like RDS is needed for metadata storage, when SageMaker Experiments natively handles this with S3 as the artifact store.

Practice this question →
118
Multi-Selectmedium

Which TWO configuration steps are necessary to deploy a custom Docker container for training in Amazon SageMaker? (Choose two.)

Select 2 answers
A.Expose a REST API endpoint for inference
B.Implement the train function in the container that saves model artifacts to /opt/ml/model
C.Define a Docker Compose file to manage multi-container training
D.Include a training script that reads hyperparameters from /opt/ml/input/config/hyperparameters.json
E.Push the container image to Docker Hub
AnswersB, D

SageMaker expects the model to be saved in /opt/ml/model.

Why this answer

Amazon SageMaker expects the training container to save model artifacts to the `/opt/ml/model` directory, which SageMaker automatically copies to Amazon S3 after training completes. This is a required contract for any custom training container used with SageMaker.

Exam trap

The trap here is that candidates confuse the requirements for a training container versus an inference container, thinking that exposing an API endpoint or pushing to Docker Hub is necessary for training, when SageMaker strictly enforces the `/opt/ml` directory contract and uses Amazon ECR for image storage.

Practice this question →
119
Multi-Selecthard

A machine learning team is using Amazon SageMaker to train a deep learning model on a large dataset stored in Amazon S3. The training job is taking too long. The team wants to reduce training time without modifying the model architecture. Which THREE actions should the team take? (Choose 3.)

Select 3 answers
A.Enable SageMaker Managed Spot Training to use cheaper spot instances.
B.Use a larger instance type with more vCPUs and memory.
C.Use distributed training with multiple GPU instances.
D.Use Pipe input mode to stream data from S3 instead of downloading it.
E.Use SageMaker Processing to preprocess the data.
AnswersA, C, D

SageMaker Managed Spot Training leverages spare AWS EC2 compute capacity at a significantly reduced cost, but the primary mechanism that reduces training time is the ability to scale horizontally across more instances for the same budget. Since the stem prohibits modifying the model architecture, this option satisfies the constraint by allowing the team to allocate the saved cost towards provisioning additional GPU instances, thereby decreasing wall-clock training duration through increased parallelism.

Why this answer

SageMaker Managed Spot Training enables the use of spot instances at a reduced cost, allowing the team to allocate more resources (e.g., more or larger instances) within the same budget, which can directly reduce training time. Option C is correct because distributed training across multiple GPU instances parallelizes the workload, significantly reducing training duration. Option D is correct because Pipe input mode streams data from Amazon S3 directly to the training algorithm, minimizing I/O bottlenecks and reducing time spent waiting for data to load.

Option B is not one of the three best choices because simply using a larger instance may not fully address I/O or parallelism bottlenecks and can be more expensive. Option E is incorrect because SageMaker Processing is designed for data preprocessing, not for accelerating training itself.

Exam trap

The trap here is that candidates often confuse cost-saving techniques (like Spot Training) with performance-optimization techniques, and they may overlook that Pipe input mode and distributed training directly address I/O and compute bottlenecks, respectively, while Spot Training primarily saves money.

Practice this question →
120
Multi-Selecthard

Which THREE factors should be considered when choosing an instance type for a SageMaker training job?

Select 3 answers
A.The number of vCPUs needed for parallel processing
B.The memory requirements of the model
C.The endpoint latency requirement
D.The AWS region where the instance is launched
E.The GPU requirements for model training
AnswersA, B, E

More vCPUs can speed up training.

Why this answer

The number of vCPUs directly determines the parallel processing capability of the training job. SageMaker training instances with more vCPUs can handle larger batch sizes and more concurrent data loading, which is critical for CPU-bound preprocessing or model training that does not rely on GPUs. Choosing an instance with insufficient vCPUs can lead to underutilization of other resources or excessive training time.

Exam trap

The trap here is that candidates confuse training job requirements with inference endpoint requirements, incorrectly selecting endpoint latency (Option C) as a factor for training, when it only applies to SageMaker hosting endpoints.

Practice this question →
121
MCQmedium

A company is deploying a machine learning model using SageMaker. The model is a PyTorch model that requires GPU for inference. The company wants to minimize costs while ensuring low latency. Which instance type should be used for the SageMaker endpoint?

A.ml.m5.large
B.ml.p3.2xlarge
C.ml.c5.2xlarge
D.ml.g4dn.xlarge
AnswerD

Correct. ml.g4dn.xlarge provides a cost-effective GPU instance (NVIDIA T4) suitable for PyTorch inference with low latency, balancing cost and performance.

Why this answer

Ml.g4dn.xlarge is a GPU instance with an NVIDIA T4, optimized for inference, and is more cost-effective than ml.p3.2xlarge while still providing low latency for PyTorch models. Option A (ml.m5.large) is wrong as it is a CPU instance without GPU support. Option B (ml.p3.2xlarge) is wrong because although it has a GPU, it is more expensive and not necessary for low-latency inference; ml.g4dn.xlarge offers similar performance at lower cost.

Option C (ml.c5.2xlarge) is also a CPU instance and unsuitable.

Practice this question →
122
MCQhard

A company operates a real-time fraud detection system using SageMaker. The model is deployed on an ml.c5.xlarge instance behind an Application Load Balancer (ALB). Recently, during a sales event, traffic spiked and the endpoint returned HTTP 503 errors. The team scaled the instance count from 2 to 5, but errors persisted. CloudWatch metrics show low CPU utilization (~30%) and high memory usage (~90%). The model loads a large dictionary file (2GB) into memory at startup. Which action should resolve the issue?

A.Enable auto-scaling with Spot instances.
B.Switch to a compute-optimized instance type like c5.2xlarge.
C.Increase the number of instances further to 10.
D.Use a memory-optimized instance type like r5.large.
AnswerB

Switching to c5.2xlarge doubles memory (16 GB) and increases CPU cores, directly addressing the memory exhaustion and providing headroom for concurrent requests.

Why this answer

The high memory usage (~90%) with low CPU (~30%) indicates the instance is memory-constrained under load. The ml.c5.xlarge has 8 GB memory, and the model's 2 GB dictionary plus overhead exhausts memory, causing 503 errors. Scaling out doesn't help because each instance is individually memory-bound.

Option B switches to c5.2xlarge, which provides 16 GB memory (doubling capacity) and more CPU cores, addressing both memory exhaustion and ensuring sufficient compute for concurrent requests. Option A (Spot instances) does not increase per-instance memory. Option C (scaling to 10 instances) still uses c5.xlarge instances with 8 GB each, so each remains memory-limited.

Option D (r5.large) offers 16 GB memory but reduces vCPUs to 2, which could create a CPU bottleneck for the inference workload, making B the better choice.

Practice this question →
123
MCQeasy

A data scientist wants to deploy a PyTorch model for real-time inference with low latency. Which AWS service should they use?

A.Amazon Elastic Container Service (ECS)
B.Amazon SageMaker batch transform
C.Amazon SageMaker real-time endpoint
D.AWS Lambda
AnswerC

Designed for low-latency inference.

Why this answer

Amazon SageMaker real-time endpoints are specifically designed for low-latency inference on deployed models, including PyTorch models. They provide persistent HTTPS endpoints that autoscale and support custom containers, making them ideal for real-time prediction workloads.

Exam trap

The trap here is that candidates often confuse batch transform (asynchronous, offline) with real-time endpoints (synchronous, low-latency), or assume that any container service like ECS is sufficient without considering the specialized model hosting and scaling capabilities of SageMaker endpoints.

How to eliminate wrong answers

Option A is wrong because Amazon ECS is a container orchestration service that requires manual setup of load balancing, scaling, and monitoring, adding operational overhead and not providing built-in model hosting features like SageMaker endpoints. Option B is wrong because Amazon SageMaker batch transform is designed for asynchronous, offline inference on large datasets, not for real-time, low-latency predictions. Option D is wrong because AWS Lambda has a maximum execution timeout of 15 minutes and is better suited for short-lived, event-driven tasks, not for hosting a PyTorch model that requires persistent, low-latency inference.

Practice this question →
124
MCQmedium

A company is using Amazon SageMaker to train a deep learning model on a large dataset stored in S3. The training job is failing with an OutOfMemory error. The data scientist wants to minimize cost while resolving the issue. Which action should the data scientist take?

A.Increase the instance type to one with more memory.
B.Use the 'auto' setting for the input mode.
C.Reduce the batch size hyperparameter.
D.Change the input mode from 'File' to 'Pipe'.
AnswerD

Pipe mode streams data, reducing memory footprint.

Why this answer

The OutOfMemory error occurs because the 'File' input mode downloads the entire training dataset to the instance's local storage before training begins, consuming significant memory. Switching to 'Pipe' mode streams data directly from S3 to the training algorithm, reducing memory footprint and avoiding the need for larger instances. This minimizes cost by using the existing instance type while resolving the memory issue.

Exam trap

The trap here is that candidates may assume reducing the batch size (Option C) is the standard fix for memory issues, but they overlook that the 'File' input mode's full dataset download is the primary cause, and 'Pipe' mode directly addresses this without additional cost.

How to eliminate wrong answers

Option A is wrong because increasing the instance type to one with more memory would resolve the error but at a higher cost, contradicting the goal to minimize cost. Option B is wrong because the 'auto' setting for input mode does not exist in SageMaker; the valid input modes are 'File' and 'Pipe', and 'auto' is not a recognized configuration. Option C is wrong because reducing the batch size hyperparameter may reduce memory usage per step but does not address the root cause of the dataset being fully loaded into memory in 'File' mode, and it could negatively impact model convergence or training time.

Practice this question →
125
MCQmedium

Refer to the exhibit. An administrator has attached this IAM policy to a user. The user tries to start a SageMaker training job that uses a custom Docker image from Amazon ECR. The training job fails with an access denied error. What is the MOST likely reason?

A.The s3:* action is too permissive and should be scoped.
B.The policy is missing ecr:GetDownloadUrlForLayer and ecr:BatchGetImage.
C.The iam:PassRole permission is missing the SageMaker service principal.
D.The sagemaker:* action should be restricted to specific resources.
AnswerB

ECR permissions are required to pull the custom image.

Why this answer

The IAM policy grants sagemaker:* and s3:* actions but does not include the specific ECR permissions required to pull a custom Docker image. When SageMaker launches a training job with a custom image, it needs ecr:GetDownloadUrlForLayer and ecr:BatchGetImage to authenticate and download the image layers from Amazon ECR. Without these permissions, the training job fails with an access denied error.

Exam trap

The trap here is that candidates assume full sagemaker:* and s3:* permissions are sufficient, overlooking the specific ECR permissions required when using a custom Docker image from a private repository.

How to eliminate wrong answers

Option A is wrong because the s3:* action being too permissive would not cause an access denied error for starting a training job; overly permissive policies do not block actions. Option C is wrong because the iam:PassRole permission is not missing the SageMaker service principal; the policy includes 'iam:PassRole' with 'Service': ['sagemaker.amazonaws.com'], which is correctly scoped. Option D is wrong because restricting sagemaker:* to specific resources is a best practice for least privilege but is not required for the job to start; the broad sagemaker:* action does not cause an access denied error.

Practice this question →
126
MCQeasy

A data scientist runs the AWS CLI command shown in the exhibit. The output shows that job-2 failed. Which action should the data scientist take to diagnose the failure?

A.Check the CloudWatch Logs log group for job-2
B.Check the S3 bucket for any error logs uploaded by the training job
C.Run `aws sagemaker list-training-jobs --name-contains job-2` to get more details
D.Run `aws sagemaker describe-training-job --training-job-name job-2` to see the failure reason
AnswerD

DescribeTrainingJob includes a FailureReason field.

Why this answer

The `describe-training-job` API call returns a `FailureReason` field that provides the specific error message for a failed SageMaker training job. This is the most direct and efficient way to diagnose why job-2 failed, as it retrieves the exact failure reason from the SageMaker service without requiring additional log parsing or bucket inspection.

Exam trap

The trap here is that candidates assume CloudWatch Logs are always available for failed jobs, but SageMaker only writes to CloudWatch after the training container starts, so a pre-start failure (e.g., insufficient instance capacity) will have no logs, making `describe-training-job` the correct first diagnostic step.

How to eliminate wrong answers

Option A is wrong because CloudWatch Logs log groups for SageMaker training jobs are only created if the training job successfully starts and begins writing logs; if the job failed before that point (e.g., due to a resource limit or invalid input), no log group exists. Option B is wrong because SageMaker does not automatically upload error logs to an S3 bucket; only training output artifacts (like model artifacts) are uploaded, and error logs are not stored there by default. Option C is wrong because `list-training-jobs --name-contains job-2` only returns a list of training jobs matching the name filter with basic status information, not the detailed failure reason needed for diagnosis.

Practice this question →
127
MCQhard

A data scientist is training a deep learning model on SageMaker using a custom Docker container. The training job fails with an error indicating that the container exited with a non-zero status. The CloudWatch logs show 'FileNotFoundError: [Errno 2] No such file or directory: '/opt/ml/input/data/training/data.csv''. What is the most likely cause?

A.The container's Docker entry point is misconfigured.
B.The S3 data source path is incorrect or the data has not been uploaded.
C.The training script has a syntax error.
D.The model output path in the training job configuration is wrong.
AnswerB

Missing training data leads to FileNotFoundError.

Why this answer

The error indicates that the training data file 'data.csv' is missing at the expected container path '/opt/ml/input/data/training/'. This typically occurs when the S3 data source path specified in the training job configuration is incorrect or the data has not been uploaded to that S3 location. Option A is wrong because the error is about missing data, not the container entry point.

Option C is wrong because the error does not relate to training script syntax. Option D is wrong because the error does not mention model artifacts.

Practice this question →
128
MCQhard

A data scientist attempts to create a SageMaker training job using the IAM policy shown in the exhibit. The training job fails with an access denied error. What is the most likely cause?

A.The S3 bucket policy does not grant access to the SageMaker service principal
B.The IAM policy is missing the sagemaker:DescribeTrainingJob permission
C.The IAM policy is missing the s3:ListBucket action
D.The IAM policy is missing the s3:PutObject permission
AnswerC

SageMaker needs ListBucket to read objects from the bucket.

Why this answer

The IAM policy shown in the exhibit grants s3:GetObject and s3:PutObject actions but is missing the s3:ListBucket action. When SageMaker attempts to read or write objects in an S3 bucket, it first needs to list the bucket's contents to verify the object's existence and path. Without s3:ListBucket, the training job fails with an access denied error during the initial S3 operation.

Exam trap

The trap here is that candidates assume only GetObject and PutObject are needed for S3 read/write operations, overlooking that SageMaker's S3 client implicitly calls ListBucket to verify object existence and path resolution before performing data transfers.

How to eliminate wrong answers

Option A is wrong because the S3 bucket policy is not mentioned in the question; the error is due to the IAM policy, not a bucket policy, and SageMaker service principal access is typically handled via IAM roles, not bucket policies. Option B is wrong because sagemaker:DescribeTrainingJob is a read-only action used to retrieve training job status, not required for creating or running a training job; the error occurs during S3 access, not SageMaker API calls. Option D is wrong because s3:PutObject is already present in the IAM policy (as shown in the exhibit), so missing it is not the cause of the access denied error.

Practice this question →
129
MCQhard

A company is using Amazon SageMaker to train a model using a custom Docker container. The training script writes model artifacts to the `/opt/ml/model` directory. The training job completes successfully, but the model artifacts are not uploaded to the S3 output path specified in the training job. The company has verified that the SageMaker execution role has the necessary S3 permissions. The Docker container is built using a base image that is not one of the official SageMaker Docker images. What is the MOST likely reason for the failure to upload model artifacts?

A.The training script's entry point is not correctly specified in the container.
B.The custom container does not include the SageMaker training toolkit, which handles artifact uploads.
C.The output path in the training job configuration is incorrectly formatted.
D.The SageMaker execution role does not have s3:PutObject permission on the output bucket.
AnswerB

Correct: Without the toolkit, SageMaker does not automatically upload artifacts.

Why this answer

The SageMaker training toolkit is required in custom containers to handle the automatic upload of model artifacts to S3. Without it, even if the script writes to /opt/ml/model and has correct permissions, SageMaker cannot perform the upload. Option B is correct because the container lacks the toolkit.

Option A is incorrect because the entry point is unrelated to the upload failure. Option C is incorrect as the output path formatting would cause a different error. Option D is incorrect because permissions were already verified.

Practice this question →
130
MCQmedium

A company has a SageMaker endpoint that serves predictions for a mobile app. The endpoint is deployed on a single ml.m5.large instance. Recently, users have reported that the app sometimes returns outdated predictions. The data science team has confirmed that the model is updated daily by retraining with new data and creating a new endpoint configuration. However, the endpoint still returns predictions from the old model for some requests. The team has verified that the new endpoint configuration is associated with the endpoint and that the endpoint is in service. What is the most likely cause of this issue?

A.The old model artifacts are still being cached by the endpoint
B.The endpoint has multiple variants and the old variant still has a weight assigned
C.The mobile app is using a CDN that caches the predictions
D.The new endpoint configuration has not been deployed to the endpoint
AnswerB

If the old variant has a weight, it will continue to serve traffic. The new variant should get a weight of 1 and the old variant weight should be set to 0.

Why this answer

When a SageMaker endpoint has multiple variants with assigned weights, traffic is distributed proportionally. If the old variant still has a weight greater than zero, some requests will continue to be served by the old model, causing outdated predictions. Option A is incorrect because SageMaker endpoints do not cache model artifacts; they load the model from S3 into memory.

Option C is incorrect because the mobile app's CDN caching is unrelated to the SageMaker endpoint's model selection. Option D is incorrect because the team confirmed that the new endpoint configuration is associated with the endpoint and the endpoint is in service, meaning the configuration is deployed.

Practice this question →
131
MCQeasy

A data scientist is training a deep learning model on a large dataset using Amazon SageMaker. The training job is taking too long and the scientist wants to reduce the training time by distributing the workload across multiple GPUs. Which SageMaker feature should be used to achieve this?

A.Use SageMaker's distributed training libraries
B.Use Amazon EMR to distribute the training
C.Use SageMaker Automatic Model Tuning
D.Use SageMaker Hyperparameter Tuning
AnswerA

SageMaker provides built-in distributed training libraries that can split the workload across multiple GPUs.

Why this answer

SageMaker's distributed training libraries provide built-in optimized implementations of data parallelism and model parallelism, enabling efficient distribution of deep learning workloads across multiple GPUs with minimal code changes. This directly addresses the need to reduce training time by leveraging multiple GPUs in a SageMaker training job.

Exam trap

The trap here is that candidates confuse hyperparameter tuning (which runs multiple independent training jobs) with distributed training (which splits a single training job across multiple GPUs), leading them to select options C or D.

How to eliminate wrong answers

Option B is wrong because Amazon EMR is a big data processing service for Apache Hadoop/Spark workloads, not designed for deep learning model training with GPU distribution. Option C is wrong because SageMaker Automatic Model Tuning is a hyperparameter optimization feature that runs multiple training jobs with different hyperparameters, not a method to distribute a single training job across multiple GPUs. Option D is wrong because SageMaker Hyperparameter Tuning is the same as Automatic Model Tuning (just a different name) and does not distribute a single training job across GPUs.

Practice this question →
132
MCQhard

A company uses SageMaker Pipelines to automate model retraining. The pipeline fails intermittently at the Preprocess step with a 'ResourceLimitExceeded' error. The team uses a ml.m5.xlarge instance. What is the most likely cause?

A.The account has reached the limit for concurrent ml.m5.xlarge instances
B.The preprocessing script has a memory leak
C.The S3 bucket has insufficient permissions
D.The pipeline execution role is missing the PassRole permission
AnswerA

ResourceLimitExceeded typically means hitting a service limit like concurrent instances.

Why this answer

The error indicates reaching a service quota. SageMaker has a default limit of concurrent training jobs per account. Option A is correct.

Option B would cause different errors. Option C is unrelated. Option D would cause a SageMaker service error, not a resource limit.

Practice this question →
133
MCQmedium

A company uses Amazon SageMaker to train a model using a custom Docker container. The training job fails with an error: "Unable to write to /opt/ml/output/data". The data scientist checks the container and finds that the /opt/ml directory is not writable. What is the MOST likely cause?

A.The Docker image is built from a base image that does not have the required libraries.
B.The container runs as a non-root user that lacks write permissions to /opt/ml.
C.The SageMaker training job is configured with insufficient memory.
D.The training script is not copying the model to /opt/ml/model.
AnswerB

SageMaker mounts volumes as root by default; if the container runs as a different user, it may not have write access.

Why this answer

The error 'Unable to write to /opt/ml/output/data' indicates a permission issue. By default, SageMaker training containers run as a non-root user (uid 1000) for security reasons. If the Docker image is built with /opt/ml owned by root and without world-writable permissions, the non-root user cannot write to that directory, causing the failure.

Exam trap

The trap here is that candidates may confuse a permission error with a missing library or resource constraint, but the specific 'not writable' message directly points to filesystem permissions, not dependencies or memory.

How to eliminate wrong answers

Option A is wrong because missing libraries would cause import or runtime errors, not a 'not writable' filesystem error. Option C is wrong because insufficient memory would cause an out-of-memory (OOM) kill or swap thrashing, not a permission-denied write error. Option D is wrong because failing to copy the model to /opt/ml/model would result in a missing model artifact error, not a write failure to /opt/ml/output/data.

Practice this question →
134
MCQmedium

An IAM policy is attached to a SageMaker execution role. A data scientist tries to create a training job using a custom algorithm stored in an ECR repository. The training job fails with an 'AccessDenied' error when pulling the Docker image from ECR. What is the missing permission?

A.ecr:GetDownloadUrlForLayer and ecr:BatchGetImage on the ECR repository
B.ecr:PutImage on the ECR repository
C.s3:GetObject on the ECR repository
D.sagemaker:CreateTrainingJob on the ECR resource
AnswerA

These permissions are required to pull a Docker image from ECR.

Why this answer

When SageMaker pulls a custom Docker image from ECR during training job creation, the execution role needs permissions to download the image layers. The required actions are ecr:GetDownloadUrlForLayer (to generate pre-signed URLs for each layer) and ecr:BatchGetImage (to retrieve image metadata and layer manifests). Without these, the 'AccessDenied' error occurs because SageMaker cannot authenticate or fetch the container image from the ECR repository.

Exam trap

The trap here is that candidates often confuse ECR pull permissions with S3 permissions (option C) or assume that the SageMaker CreateTrainingJob permission (option D) implicitly covers the ECR pull, when in fact the IAM role must explicitly grant the specific ECR read actions for image retrieval.

How to eliminate wrong answers

Option B is wrong because ecr:PutImage is used to push images into ECR, not to pull them; the training job only needs read access. Option C is wrong because s3:GetObject is an S3 permission, not an ECR permission; ECR uses its own API actions for image retrieval, not S3. Option D is wrong because sagemaker:CreateTrainingJob is a SageMaker API action that allows creating the training job itself, not the ECR pull operation; the error occurs at the ECR layer, not at the SageMaker API level.

Practice this question →
135
MCQhard

A company is using Amazon SageMaker to deploy a model for real-time inference. The endpoint receives variable traffic and the company wants to optimize cost while maintaining responsiveness. Which scaling policy should be used?

A.Target tracking scaling based on invocation count
B.Simple scaling with a cooldown period
C.Scheduled scaling
D.Manual scaling
AnswerA

Automatically adjusts to traffic.

Why this answer

Target tracking scaling based on invocation count is the correct choice because it automatically adjusts the number of instances in real-time based on a predefined metric (e.g., InvocationsPerInstance), maintaining responsiveness during variable traffic while optimizing cost by scaling down during low demand. This policy uses a target value (e.g., 1000 invocations per instance) and SageMaker Application Auto Scaling continuously monitors CloudWatch metrics to add or remove instances as needed, eliminating manual intervention.

Exam trap

The trap here is that candidates often confuse 'simple scaling' with 'dynamic scaling' and assume a cooldown period alone can handle variable traffic, but simple scaling lacks the continuous metric tracking and automatic adjustment that target tracking provides.

How to eliminate wrong answers

Option B is wrong because simple scaling with a cooldown period requires manual definition of step adjustments and cooldown timers, which can lead to over-provisioning or under-provisioning under variable traffic due to its rigid, non-adaptive nature. Option C is wrong because scheduled scaling only adjusts capacity at predetermined times, making it unsuitable for unpredictable, variable traffic patterns that do not follow a fixed schedule. Option D is wrong because manual scaling requires human intervention to change instance count, which cannot react quickly to variable traffic and defeats the purpose of cost optimization and responsiveness.

Practice this question →
136
MCQeasy

A company wants to use Amazon SageMaker to train a model using data that is updated daily. The training data is stored in an S3 bucket, and the team wants to automate the training process whenever new data arrives. Which AWS service should be used to trigger the SageMaker training job?

A.AWS Lambda triggered by S3 event notifications
B.Amazon CloudWatch Events
C.Amazon Simple Queue Service (SQS)
D.AWS Step Functions with a scheduled trigger
AnswerA

Lambda can be triggered by S3 events to start the training job.

Why this answer

AWS Lambda can be triggered by S3 event notifications (e.g., object creation). The Lambda function can then start the SageMaker training job using the AWS SDK, automating the process when new data arrives. Option B (Amazon CloudWatch Events) is incorrect because CloudWatch Events can schedule events based on time or AWS API calls but cannot directly react to S3 object creation without additional services.

Option C (Amazon SQS) is incorrect because SQS is a message queue service; it does not natively trigger from S3 events without an intermediary like Lambda, which would still be the trigger. Option D (AWS Step Functions with a scheduled trigger) is incorrect because a scheduled trigger is time-based, not event-driven; Step Functions would need an S3 event to start, and that event would typically come via Lambda.

Practice this question →
137
Multi-Selecteasy

A data engineer is building a data pipeline for a machine learning project using Amazon SageMaker. The raw data is stored in Amazon S3. Which TWO steps are essential to ensure data privacy and security before training? (Choose TWO.)

Select 2 answers
A.Create a bucket policy that restricts access to the data scientist's IAM role only
B.Enable versioning on the S3 bucket
C.Encrypt the data at rest using S3 server-side encryption
D.Use S3 Transfer Acceleration for faster uploads
E.Use Amazon SageMaker in a VPC and configure VPC endpoints to access S3 securely
AnswersC, E

Encryption protects data at rest.

Why this answer

Options C and E are correct because data privacy and security require encryption at rest (e.g., S3 server-side encryption) and secure network access (e.g., using SageMaker in a VPC with VPC endpoints). Option C ensures data is encrypted when stored in S3. Option E prevents data from traversing the public internet and allows fine-grained access control.

Options A, B, and D are not essential for privacy/security: A (bucket policy) is a means of access control but not as fundamental as encryption; B (versioning) protects against accidental deletion, not privacy; D (Transfer Acceleration) is a performance feature, not a security measure.

Practice this question →
138
MCQeasy

A data scientist is training a linear regression model on a dataset with 100 features. The model shows high variance on the test set. Which action is MOST likely to reduce overfitting?

A.Use a more complex model like XGBoost
B.Increase the number of training iterations
C.Apply L2 regularization (Ridge regression)
D.Add more feature engineering to increase model complexity
AnswerC

L2 regularization penalizes large coefficients, reducing overfitting.

Why this answer

High variance (overfitting) means the model is too complex and fits noise in the training data. L2 regularization (Ridge regression) adds a penalty proportional to the square of the coefficients, shrinking them toward zero and reducing model complexity. This directly counteracts overfitting by preventing the model from relying too heavily on any single feature.

Exam trap

The MLS-C01 exam often tests the misconception that adding complexity (more features, more iterations, or more powerful models) always improves performance, when in fact overfitting requires reducing model complexity through regularization or simpler models.

How to eliminate wrong answers

Option A is wrong because using a more complex model like XGBoost (which can capture non-linear interactions and often has high variance) would likely increase overfitting, not reduce it. Option B is wrong because increasing the number of training iterations does not address model complexity; for linear regression, more iterations simply mean more gradient descent steps, which can lead to overfitting if the model is already too flexible. Option D is wrong because adding more feature engineering to increase model complexity would introduce additional parameters and interactions, exacerbating the high variance problem rather than solving it.

Practice this question →
139
Multi-Selecteasy

Which TWO AWS services can be used to deploy a machine learning model for serverless inference? (Choose 2.)

Select 2 answers
A.Amazon SageMaker Serverless Inference
B.AWS Lambda
C.Amazon EMR
D.Amazon ECS with Fargate
E.AWS Batch
AnswersA, B

Serverless inference option.

Why this answer

Amazon SageMaker Serverless Inference automatically provisions, scales, and manages compute resources to run inference requests without requiring you to manage any underlying infrastructure. It scales down to zero when not in use and charges only for the compute time consumed, making it a fully serverless option for deploying ML models. AWS Lambda can also be used for serverless inference by packaging the model and inference code as a Lambda function.

Lambda scales automatically, charges per invocation, and can be triggered by various AWS services, making it suitable for lightweight, event-driven inference workloads. Both services provide pay-per-request, auto-scaling-to-zero inference without requiring management of compute resources or container orchestration.

Exam trap

The trap here is that candidates often confuse 'serverless' with any managed service (like ECS Fargate or AWS Batch) that abstracts servers, but only SageMaker Serverless Inference and AWS Lambda provide true pay-per-request, auto-scaling-to-zero inference without requiring you to manage compute resources or container orchestration.

Practice this question →
140
MCQmedium

A team is deploying a machine learning model to production using Amazon SageMaker. They want to automatically scale the endpoint based on the incoming request volume, and they also need to ensure that the endpoint can handle sudden bursts of traffic without dropping requests. Which scaling policy should they use?

A.Scheduled scaling policy for peak hours
B.Target tracking scaling policy based on the number of invocations
C.Simple scaling policy based on average latency
D.Manual scaling by monitoring CloudWatch alarms
AnswerB

Target tracking automatically adjusts capacity to maintain a target metric and can handle bursts.

Why this answer

A target tracking scaling policy based on the number of invocations allows the endpoint to automatically adjust the number of instances to maintain a target metric value (e.g., invocations per instance). This policy can proactively scale out to handle sudden bursts by adding instances before the request queue grows, preventing dropped requests. SageMaker's built-in scaling metric, 'SageMakerVariantInvocationsPerInstance', is ideal for this use case as it directly correlates with traffic volume.

Exam trap

The trap here is that candidates confuse 'target tracking' with 'scheduled scaling' or 'simple scaling', assuming any scaling policy works for bursts, but only target tracking (or step scaling with proper alarms) can dynamically adjust to sudden, unpredictable spikes without dropping requests.

How to eliminate wrong answers

Option A is wrong because scheduled scaling is based on predictable traffic patterns (e.g., peak hours) and cannot react to sudden, unplanned bursts of traffic, which may cause request drops. Option C is wrong because a simple scaling policy based on average latency is reactive—it only scales after latency has already increased, which can lead to dropped requests during the scaling delay. Option D is wrong because manual scaling requires human intervention and cannot automatically handle sudden traffic bursts, making it unsuitable for real-time, dynamic workloads.

Practice this question →
141
Multi-Selecteasy

A company is building a machine learning pipeline on AWS. The pipeline includes data ingestion, preprocessing, training, and deployment. Which THREE AWS services can be used to orchestrate the pipeline? (Choose THREE.)

Select 3 answers
A.AWS Glue Workflows
B.Amazon CloudWatch
C.Amazon SageMaker Pipelines
D.AWS Lambda
E.AWS Step Functions
AnswersA, C, E

Glue Workflows can orchestrate ETL jobs.

Why this answer

AWS Glue Workflows is correct because it provides a visual orchestration tool for designing and managing complex ETL pipelines, including data ingestion and preprocessing steps. It allows you to define dependencies, triggers, and job sequences, making it suitable for orchestrating the data preparation stages of a machine learning pipeline.

Exam trap

The trap here is that candidates often confuse monitoring services (CloudWatch) or compute triggers (Lambda) with orchestration, but orchestration requires managing sequential/parallel task execution and state management across multiple services.

Practice this question →
142
MCQhard

A data scientist is using Amazon SageMaker Debugger to monitor training jobs. The training loss is decreasing but then suddenly spikes. What is the most likely cause and how should it be addressed?

A.Gradient explosion; apply gradient clipping.
B.Overfitting; apply regularization.
C.Learning rate too low; increase learning rate.
D.Vanishing gradients; use ReLU activation.
AnswerA

Gradient clipping limits the gradient magnitude.

Why this answer

A sudden spike in training loss after a period of decreasing loss is a classic symptom of gradient explosion, where gradients become excessively large during backpropagation, causing the model parameters to update erratically. Amazon SageMaker Debugger can monitor tensors and gradients in real time, and applying gradient clipping (e.g., via `max_grad_norm` in PyTorch or `clip_by_global_norm` in TensorFlow) directly addresses this by capping the gradient norm to prevent destabilizing updates.

Exam trap

The trap here is that candidates confuse a sudden loss spike with overfitting or learning rate issues, but the key differentiator is the abrupt, non-monotonic increase in training loss (not validation loss), which points to numerical instability from exploding gradients.

How to eliminate wrong answers

Option B is wrong because overfitting typically manifests as a divergence between training and validation loss (training loss continues to decrease while validation loss increases), not a sudden spike in training loss itself. Option C is wrong because a learning rate that is too low would cause the loss to decrease very slowly or plateau, not suddenly spike upward. Option D is wrong because vanishing gradients cause the loss to stagnate or decrease extremely slowly, not a sudden spike; ReLU activation helps mitigate vanishing gradients but does not address gradient explosion.

Practice this question →
143
MCQeasy

A company is training a deep learning model on Amazon SageMaker. The training job is failing with an out-of-memory error. Which SageMaker feature should the company use to resolve this issue without changing the instance type?

A.Use SageMaker distributed training with model parallelism
B.Use SageMaker Savings Plans
C.Enable SageMaker Managed Spot Training
D.Use SageMaker Debugger to monitor memory usage
E.Enable SageMaker Profiler to profile memory
AnswerA

Model parallelism splits the model across multiple instances, reducing memory per instance.

Why this answer

SageMaker's distributed training with model parallelism splits the model's layers across multiple GPUs, reducing the memory footprint per GPU. This allows the company to train a large model that exceeds a single GPU's memory without changing the instance type. Model parallelism is specifically designed to handle out-of-memory errors by distributing the model parameters, gradients, and optimizer states across devices.

Exam trap

The trap here is that candidates confuse diagnostic tools (Debugger, Profiler) with solutions, or mistakenly think cost-saving features (Savings Plans, Spot Training) can fix memory errors, when the correct answer requires understanding that model parallelism directly addresses GPU memory limits by distributing the model.

How to eliminate wrong answers

Option B is wrong because SageMaker Savings Plans are a pricing model that offers discounted rates in exchange for a commitment to a consistent amount of compute usage; they do not resolve out-of-memory errors. Option C is wrong because Managed Spot Training uses spare EC2 capacity to reduce costs but does not change the memory available per instance; it can even cause interruptions that exacerbate memory issues. Option D is wrong because SageMaker Debugger monitors training metrics and system bottlenecks but cannot increase memory or redistribute model components; it only helps diagnose the problem.

Option E is wrong because SageMaker Profiler profiles CPU/GPU utilization and memory usage but does not provide a mechanism to reduce memory consumption; it is a diagnostic tool, not a solution.

Practice this question →
144
MCQmedium

A data scientist is using Amazon SageMaker to train a custom image classification model using a PyTorch script. The training job runs successfully but the model accuracy is lower than expected. The scientist wants to debug the training process by inspecting gradients and layer outputs. Which SageMaker feature should be used to capture this internal state during training?

A.Use SageMaker Experiments to track hyperparameters and metrics.
B.Use SageMaker Debugger to capture tensors and gradients.
C.Use SageMaker Profiler to profile system bottlenecks.
D.Use SageMaker Model Monitor to detect data drift.
AnswerB

SageMaker Debugger provides real-time monitoring of training metrics and internal state like gradients.

Why this answer

SageMaker Debugger is specifically designed to capture internal model state such as tensors, gradients, and weights during training. It allows you to set rules to monitor for issues like vanishing gradients or overfitting, and to save these tensors for later analysis. This directly addresses the need to inspect gradients and layer outputs to diagnose low accuracy.

Exam trap

The trap here is that candidates confuse SageMaker Debugger (for internal state like gradients) with SageMaker Experiments (for external metrics) or SageMaker Profiler (for system performance), because all three are debugging tools but serve distinct purposes.

How to eliminate wrong answers

Option A is wrong because SageMaker Experiments tracks hyperparameters and metrics (e.g., accuracy, loss) at the trial level, but does not capture internal tensor or gradient values from the model. Option C is wrong because SageMaker Profiler focuses on system-level bottlenecks like CPU/GPU utilization and I/O, not on model internals such as gradients or layer outputs. Option D is wrong because SageMaker Model Monitor detects data drift in production inference data, not during training, and does not inspect gradients or layer activations.

Practice this question →
145
MCQhard

A data scientist submits a SageMaker training job with the provided configuration. The job fails immediately with the error 'Algorithm not found: 382416733822.dkr.ecr.us-west-2.amazonaws.com/sagemaker-xgboost:1.2-1'. What is the most likely cause?

A.The training region is different from the image region.
B.The ECR repository URI is incorrect or the image does not exist.
C.The input data format is incorrect.
D.The IAM role does not have permission to pull the image.
AnswerB

The URI may have wrong account ID or tag.

Why this answer

The error 'Algorithm not found' indicates that the ECR repository URI specified in the training job configuration does not point to an existing image. The URI '382416733822.dkr.ecr.us-west-2.amazonaws.com/sagemaker-xgboost:1.2-1' is the standard SageMaker built-in XGBoost image for the us-west-2 region, but the version '1.2-1' may not exist or the URI is malformed. SageMaker training jobs require a valid ECR image URI to launch the container; if the image is not found in the registry, the job fails immediately with this error.

Exam trap

The trap here is that candidates may confuse an 'Algorithm not found' error with a permissions issue (Option D) or a region mismatch (Option A), but the error message is specific to the image URI not existing in ECR, not to access or region problems.

How to eliminate wrong answers

Option A is wrong because the error message explicitly states 'Algorithm not found', not a region mismatch; if the region were different, SageMaker would attempt to pull from the specified URI and fail with a different error (e.g., 'CannotPullContainerError' or 'AccessDeniedException'). Option C is wrong because input data format issues cause failures during the training phase (e.g., 'AlgorithmError' or 'ClientError'), not at job submission with an 'Algorithm not found' error. Option D is wrong because IAM permission errors (e.g., 'AccessDeniedException') would occur when SageMaker tries to pull the image, but the error message here is 'Algorithm not found', which indicates the image does not exist in the registry, not a permissions issue.

Practice this question →
146
MCQmedium

A media company uses SageMaker to train a recommendation model. The training data is stored in an S3 bucket with versioning enabled. The data pipeline updates the training data daily by overwriting objects with new data. Recently, the model's performance degraded, and the team suspects that the training data was corrupted on a specific day. They want to train the model using the data from a previous version. How can the team retrieve the previous version of the training data?

A.Restore the bucket from S3 Glacier, which contains the previous version.
B.Use the S3 GET Object Version API to download the specific version of each object.
C.Use S3 Select to query the previous version of the data.
D.Enable S3 replication to a different bucket and use the replicated data.
AnswerB

S3 versioning stores multiple versions; GET Object with version ID retrieves the desired version.

Why this answer

S3 versioning allows retrieval of any previous version of an object by using the GET Object Version API with the specific version ID. Option A is incorrect because S3 Glacier is an archival storage class, not a feature for accessing previous versions of current objects. Option C is incorrect because S3 Select is used to query data within an object, not for version retrieval.

Option D is incorrect because S3 replication copies objects to another bucket but does not provide access to previous versions in the source bucket.

Practice this question →
147
Multi-Selecthard

A data scientist is deploying a model on Amazon SageMaker. The model requires inference on images, and the data scientist wants to use a GPU instance for low latency. However, the data scientist is unsure about the instance type to choose for the endpoint. Which TWO factors should the data scientist consider when selecting the instance type? (Choose TWO.)

Select 2 answers
A.The time taken to train the model
B.The number of vCPUs on the instance
C.The cost per inference for the instance type
D.The AWS Region of the S3 bucket storing the model
E.The GPU memory available on the instance
AnswersC, E

Cost is a key consideration.

Why this answer

Cost per inference directly impacts operational budget, especially with GPU instances that have higher hourly costs; data scientists must balance low latency with cost efficiency. Option E is correct because GPU memory limits the size of models and batch sizes that can be processed in a single inference call, directly affecting latency and throughput. Both factors are critical when selecting an instance type for real-time inference on SageMaker.

Exam trap

The trap here is that candidates often focus on training-related metrics (like vCPUs or training time) instead of inference-specific factors, or they mistakenly think regional proximity of the S3 bucket affects instance performance, when in fact the endpoint must be in the same Region but the Region itself does not constrain instance type selection.

Practice this question →
148
MCQhard

A company is using Amazon SageMaker Ground Truth to build a training dataset for an image classification model. The company has a large number of unlabeled images stored in Amazon S3. The data science team wants to use a private workforce consisting of internal employees to label the images. The team creates a labeling job with a private workforce. After starting the job, the team notices that the labeling tasks are not being assigned to any workers. The workers have been added to the private workforce and have received their login credentials. What is the MOST likely cause of this issue?

A.The labeling job is configured for a different task type than image classification.
B.The S3 bucket containing the images has incorrect permissions, preventing workers from viewing the images.
C.The workers do not have the required IAM permissions to access the labeling portal.
D.The workers have not been added to the work team that is assigned to the labeling job.
AnswerD

Correct: Workers must be part of the work team to receive tasks.

Why this answer

For a private workforce, workers must be added to a work team that is associated with the labeling job. If workers are not added to the work team, the labeling tasks will not be assigned to them. Option D correctly identifies that the workers have not been added to the work team.

Option A (different task type) would affect the labeling interface, not task assignment. Option B (S3 bucket permissions) would prevent workers from viewing images but not from receiving tasks. Option C (IAM permissions) would prevent login, not task assignment.

Practice this question →
149
MCQhard

A data scientist is deploying a real-time inference endpoint using SageMaker. The model is a large NLP model requiring GPU for low latency. The endpoint must be highly available across two Availability Zones. Which deployment configuration meets these requirements?

A.Deploy a single model endpoint on an ml.c5.xlarge instance with auto-scaling
B.Use SageMaker batch transform on GPU instances
C.Deploy a multi-model endpoint on an ml.p3.2xlarge instance with auto-scaling and at least two instances in different AZs
D.Deploy a single model endpoint on an ml.p3.2xlarge instance with one instance
AnswerC

GPU, auto-scaling, and multi-AZ provide low latency and high availability.

Why this answer

It uses a GPU instance (ml.p3.2xlarge) to meet the low-latency requirement for a large NLP model, and it deploys at least two instances across different Availability Zones (AZs) to achieve high availability. SageMaker multi-model endpoints allow hosting multiple models on the same endpoint, but here the key is the instance type and the multi-instance, multi-AZ deployment for fault tolerance.

Exam trap

The trap here is that candidates may overlook the GPU requirement and choose a cheaper CPU instance (Option A), or confuse batch transform with real-time inference (Option B), or forget that a single instance cannot provide high availability (Option D).

How to eliminate wrong answers

Option A is wrong because ml.c5.xlarge is a CPU instance, which cannot provide the GPU acceleration needed for low-latency inference on a large NLP model. Option B is wrong because SageMaker batch transform is designed for asynchronous, offline inference on large datasets, not for real-time inference endpoints. Option D is wrong because a single instance in a single AZ provides no high availability; if that instance or AZ fails, the endpoint becomes unavailable.

Practice this question →
150
MCQmedium

A company's ML model training on Amazon SageMaker is taking longer than expected. The training job uses a single ml.p3.2xlarge instance. Which change is most likely to reduce training time?

A.Increase the instance's EBS volume size
B.Use distributed training with multiple GPU instances
C.Enable Managed Spot Training
D.Switch to a compute-optimized instance with more vCPUs
AnswerB

Parallelizes work across GPUs.

Why this answer

The training job is bottlenecked by compute capacity, as a single ml.p3.2xlarge instance provides only one NVIDIA V100 GPU. Distributed training with multiple GPU instances (e.g., multiple ml.p3.2xlarge instances) enables data parallelism, splitting the workload across GPUs and significantly reducing wall-clock training time for large models or datasets.

Exam trap

The trap here is that candidates often confuse cost-saving techniques (like Spot Instances) with performance improvements, or mistakenly think that increasing storage or CPU cores will accelerate GPU-bound deep learning training.

How to eliminate wrong answers

Option A is wrong because increasing the EBS volume size does not improve compute performance; it only provides more storage, which does not address the GPU compute bottleneck. Option C is wrong because Managed Spot Training reduces cost by using spare EC2 capacity, but it does not inherently reduce training time—it may even increase time if instances are interrupted. Option D is wrong because switching to a compute-optimized instance with more vCPUs does not leverage GPU acceleration; for deep learning workloads, GPU instances are far more effective than CPU-based compute-optimized instances.

Practice this question →
← PreviousPage 2 of 5 · 338 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Machine Learning Implementation and Operations questions.

Start 20-question session