Courseiva

AWS Certified Machine Learning Specialty MLS-C01 (MLS-C01) — Questions 676–750

1672 questions total · 23pages · All types, answers revealed

Take a mock examExam hub
Page 9

Page 10 of 23

Page 11
676
MCQeasy

A data scientist is training a random forest model on a dataset with 50 features. After training, the model achieves 98% accuracy on the training set but only 85% on the test set. Which technique is most appropriate to reduce the generalization error?

A.Apply Principal Component Analysis (PCA) to reduce dimensionality
B.Add more training data
C.Increase the number of trees in the forest
D.Reduce the maximum depth of each tree
AnswerD

Shallow trees are simpler and less likely to overfit, thus improving test accuracy.

Why this answer

The gap indicates overfitting. Random forest can overfit if trees are too deep or if the number of trees is too high. Reducing the maximum depth of trees limits model complexity and helps generalization.

Increasing the number of trees typically reduces overfitting but can also increase computational cost; however, reducing depth is more direct. Feature selection or PCA might help but are less direct than controlling tree complexity.

Full explanation →
677
MCQhard

A financial services company is building a fraud detection model that requires joining real-time transaction data with a reference dataset of known fraudulent accounts stored in Amazon DynamoDB. The solution must minimize latency and be highly available. The reference dataset is updated frequently (every few minutes). Which architecture should the team use?

A.Use Amazon Athena to query the DynamoDB table and join with streaming data.
B.Use Amazon Kinesis Data Analytics to process the stream and join with a DynamoDB table.
C.Use AWS Glue streaming ETL to read from Kinesis and join with DynamoDB.
D.Use Amazon SageMaker to host a model that queries DynamoDB for each inference.
AnswerB

Kinesis Data Analytics supports real-time joins with DynamoDB using reference data.

Why this answer

Amazon Kinesis Data Analytics (now managed Apache Flink) can directly reference a DynamoDB table as a reference source via the Flink Table API or SQL JOINs, enabling low-latency, stateful stream enrichment without external query overhead. This architecture minimizes latency by performing the join in-memory within the streaming application, and it supports high availability through Kinesis Data Analytics' automatic checkpointing and failover.

Exam trap

The trap here is that candidates often choose AWS Glue streaming ETL (Option C) because they associate Glue with ETL and DynamoDB, but Glue streaming ETL lacks native DynamoDB reference join support, making Kinesis Data Analytics the correct low-latency streaming join service.

How to eliminate wrong answers

Option A is wrong because Amazon Athena is an interactive query service designed for ad-hoc analytics on data in S3, not for real-time stream processing; querying DynamoDB via Athena would introduce high latency and cannot continuously join with streaming data. Option C is wrong because AWS Glue streaming ETL reads from Kinesis but does not natively support joining with a DynamoDB table as a reference source; it would require custom workarounds like reading DynamoDB into a Spark DataFrame, adding latency and complexity. Option D is wrong because hosting a model on SageMaker and querying DynamoDB for each inference introduces network round-trip latency per request, which is unacceptable for real-time fraud detection at high throughput, and SageMaker endpoints are not designed for frequent external database lookups.

Full explanation →
678
MCQeasy

Refer to the exhibit. The log shows the end of a successful SageMaker training job. However, the ML engineer cannot find the model artifacts in the specified S3 bucket. What is the most likely cause?

A.The IAM role used by the training job does not have permission to write to the S3 bucket.
B.The S3 bucket does not exist.
C.The model artifacts were uploaded to a different S3 path.
D.The training job did not have network access to S3.
AnswerA

Without s3:PutObject, the upload fails.

Why this answer

The training job completed successfully, meaning the SageMaker training container executed without errors. However, if the model artifacts are not found in the specified S3 bucket, the most likely cause is that the IAM role associated with the training job lacks the necessary s3:PutObject permission for that bucket. SageMaker uses the role's credentials to write the output; without write access, the artifacts are silently dropped or fail to upload, even though the training code itself may have run to completion.

Exam trap

AWS often tests the misconception that a successful training job log implies the model artifacts were successfully uploaded, when in fact the IAM role permissions are the gatekeeper for S3 write operations, and a missing permission can cause silent failures.

How to eliminate wrong answers

Option B is wrong because if the S3 bucket did not exist, SageMaker would raise a bucket-not-found error during the training job initialization, and the job would fail, not complete successfully. Option C is wrong because the model artifacts are written to the exact S3 path specified in the OutputDataConfig parameter of the training job; SageMaker does not randomly choose a different path. Option D is wrong because if the training job lacked network access to S3, it would fail to download training data or upload output, resulting in a job failure, not a successful completion with missing artifacts.

Full explanation →
679
MCQhard

A data scientist is trying to read a CSV file from S3 bucket 'my-bucket' with key 'training/data.csv' using an IAM role with the attached policy shown in the exhibit. The read operation fails with an Access Denied error. What is the most likely cause?

A.The policy does not include the s3:ListBucket permission, which is required to access the object.
B.The object is encrypted with SSE-KMS and the role does not have kms:Decrypt permission.
C.The resource ARN in the first statement should be 'arn:aws:s3:::my-bucket/training' without the wildcard.
D.The policy explicitly denies s3:GetObject because of the second statement with the trailing slash.
AnswerA

To read an S3 object, the principal needs both s3:GetObject on the object and s3:ListBucket on the bucket (or at least the bucket-level permission to allow access). The policy only grants object-level permissions, not bucket-level ListBucket.

Why this answer

The s3:GetObject permission alone is sufficient for direct object retrieval using the object's full key (e.g., via AWS CLI `aws s3api get-object`). However, many AWS services and tools (such as the S3 console, Amazon Athena, or AWS Glue) implicitly invoke a ListObjects API call to resolve the object path or display the bucket contents, which requires the s3:ListBucket permission. Without it, these operations fail with an Access Denied error even though GetObject is granted.

In this scenario, the error likely occurs because the tool or service used to read the file performs a ListObjects call first.

Exam trap

The MLS-C01 exam often tests the nuanced distinction between object-level permissions (GetObject) and bucket-level permissions (ListBucket). A common pitfall is assuming that GetObject alone is sufficient for all read operations, ignoring the fact that many S3 interactions (e.g., via the console or certain SDK methods) implicitly require ListBucket to navigate the bucket hierarchy. This question highlights that even with GetObject allowed, the absence of ListBucket can cause an Access Denied error.

How to eliminate wrong answers

Option B is wrong because the question does not mention any encryption settings on the object, and the error is Access Denied, not a KMS-related permission error (which would typically return a 400 Bad Request with a KMS-specific message). Option C is wrong because the resource ARN 'arn:aws:s3:::my-bucket/training/*' correctly grants access to all objects under the 'training/' prefix; removing the wildcard would restrict access to a single object named 'training' (without a trailing slash), which is not the intended scope. Option D is wrong because the second statement with a trailing slash ('arn:aws:s3:::my-bucket/training/') does not explicitly deny s3:GetObject; it only grants s3:GetObject on objects with keys starting with 'training/' (the trailing slash is part of the prefix pattern, not a denial).

Full explanation →
680
Multi-Selectmedium

Which THREE of the following are valid techniques for detecting outliers in a dataset during exploratory data analysis? (Select THREE.)

Select 3 answers
A.Z-score method: flag points with absolute Z-score > 3.
B.Linear regression residuals.
C.Isolation Forest algorithm.
D.K-means clustering.
E.Interquartile Range (IQR) method: flag points outside 1.5*IQR from quartiles.
AnswersA, C, E

Z-score is a standard outlier detection technique.

Why this answer

Z-score, IQR, and Isolation Forest are all common outlier detection methods. Option B (Linear regression) is not for outlier detection; it models relationships between variables. Option D (K-means) is a clustering algorithm, not primarily for outlier detection.

Full explanation →
681
MCQhard

A company is deploying a machine learning model for real-time fraud detection. The model must have low latency (under 100 ms) and high throughput. The model is an ensemble of 5 gradient boosted trees (XGBoost), each 200 MB. Which deployment strategy is MOST suitable?

A.Use AWS Lambda to invoke each model sequentially.
B.Deploy each model as a separate SageMaker endpoint and use a load balancer.
C.Deploy the ensemble on a single GPU instance with large batch processing.
D.Use SageMaker multi-model endpoint on a compute-optimized instance.
AnswerD

A multi-model endpoint on a compute-optimized instance allows loading multiple models dynamically, reducing cost and latency compared to separate endpoints.

Why this answer

A multi-model endpoint on a compute-optimized instance allows loading multiple models dynamically, reducing cost and latency compared to separate endpoints. Option A is wrong because invoking each model sequentially with Lambda would incur overhead and cold start latency, exceeding the 100 ms requirement. Option B is wrong because deploying each model as a separate SageMaker endpoint would require managing multiple endpoints, increasing cost and complexity without benefiting from model sharing on a single instance.

Option C is wrong because batch processing is not suitable for real-time inference; GPU instances are overkill for tree-based models and add latency.

Full explanation →
682
MCQeasy

A data scientist is reviewing the training logs from a SageMaker training job. The logs show training and validation loss per epoch. Based on the exhibited logs, which statement is correct?

A.The model is not learning because the loss is not decreasing
B.The model is underfitting because both losses are high
C.The model is performing well because validation loss is stable
D.The model is overfitting because training loss decreases while validation loss does not
AnswerD

Classic overfitting: training loss improves, validation loss stagnates.

Why this answer

The training logs show a classic overfitting pattern: training loss consistently decreases across epochs, indicating the model is memorizing the training data, while validation loss does not decrease (or may even increase), indicating poor generalization to unseen data. In SageMaker, monitoring both losses during training is critical to detect overfitting early, often prompting regularization or early stopping.

Exam trap

The trap here is that candidates see decreasing training loss and assume the model is learning well, ignoring the validation loss plateau or increase, which is the hallmark of overfitting.

How to eliminate wrong answers

Option A is wrong because the loss is decreasing (training loss goes down), so the model is learning; the issue is not lack of learning but divergence between training and validation performance. Option B is wrong because underfitting would show both training and validation losses remaining high and not decreasing, whereas here training loss decreases significantly. Option C is wrong because a stable validation loss alone does not indicate good performance if training loss is decreasing while validation loss is not improving—this divergence signals overfitting, not good generalization.

Full explanation →
683
MCQhard

A data engineer runs the CLI command to download an object from S3. The bucket owner is 123456789012, and the engineer's IAM user has s3:GetObject permission on the bucket. The object was uploaded by a different AWS account. What is the MOST likely reason for the AccessDenied error?

A.The --expected-bucket-owner parameter is incorrect
B.The object is owned by a different AWS account, and the bucket owner has not been granted access
C.The bucket policy denies access to the engineer's IAM user
D.The IAM policy does not allow s3:GetObject for that specific key
AnswerB

Object ACLs or bucket policy must grant access to bucket owner.

Why this answer

When an object is uploaded to S3 by a different AWS account, the object is owned by the uploading account, not the bucket owner. By default, the bucket owner does not have access to objects uploaded by other accounts, even if the bucket owner has a policy granting s3:GetObject to their IAM users. The engineer's IAM user has permission on the bucket, but the object itself is not owned by the bucket owner, so the bucket owner cannot delegate access to it unless the object owner explicitly grants read access via an object ACL or a bucket policy that the object owner accepts.

Exam trap

The trap here is that candidates assume bucket-level permissions (like s3:GetObject on the bucket) automatically grant access to all objects in the bucket, but S3's object ownership model requires explicit permission from the object owner for objects uploaded by other accounts.

How to eliminate wrong answers

Option A is wrong because the --expected-bucket-owner parameter is used to ensure the bucket owner matches the expected account ID, but it does not cause an AccessDenied error; it would cause a different error (e.g., 'BucketOwnerMismatch') if the bucket owner does not match. Option C is wrong because the bucket policy does not deny access; the error arises from the object ownership model, not from an explicit deny in the bucket policy. Option D is wrong because the IAM policy does allow s3:GetObject for the bucket, but the issue is that the object is owned by a different account, and the bucket owner (and thus the engineer) lacks access rights to that specific object.

Full explanation →
684
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.

Full explanation →
685
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.

Full explanation →
686
MCQhard

A data scientist is granted the IAM policy shown in the exhibit. The data scientist can query the 'data-lake-bucket' using Athena and get results. However, when the data scientist tries to run a CTAS (CREATE TABLE AS SELECT) query in Athena to write results to a new S3 location, the query fails. What is the most likely reason?

A.The policy does not grant athena:CreateTable permission.
B.The policy does not grant s3:PutObject permission on the bucket.
C.The policy does not grant permissions to the Glue Data Catalog.
D.The policy uses a wildcard for Athena actions, which is not allowed.
AnswerB

CTAS queries write output to S3, requiring s3:PutObject.

Why this answer

The policy allows s3:GetObject and s3:ListBucket, but not s3:PutObject, which is required for CTAS queries. Option A is wrong because the policy uses resource-level permissions for S3. Option C is wrong because Athena does not require Glue Data Catalog permissions for CTAS if the table metadata is already stored.

Option D is wrong because the policy does not restrict Athena resource ARNs.

Full explanation →
687
MCQmedium

During EDA, a data scientist finds that a numeric feature has many outliers. The feature will be used in a linear regression model. Which approach should the scientist take to handle the outliers?

A.Remove all rows with outlier values.
B.Apply a logarithmic transformation to the feature.
C.Standardize the feature using Z-score normalization.
D.Cap the feature values at the 1st and 99th percentiles.
AnswerD

Correct. Capping at percentiles limits extreme values, reducing their impact while preserving data size.

Why this answer

Capping (winsorizing) the feature values at the 1st and 99th percentiles limits the influence of extreme outliers while retaining all data points. This is particularly important for linear regression, which is sensitive to outliers. Option A is wrong because removing all rows with outliers can lead to significant data loss and bias.

Option B is wrong because a logarithmic transformation reduces skew but does not eliminate the impact of outliers; it only compresses their range. Option C is wrong because Z-score normalization standardizes the data but does not reduce the influence of outliers; extreme values remain extreme relative to the distribution.

Exam trap

Candidates often confuse capping (winsorization) with standardization or transformation. Standardization does not mitigate outliers; it only rescales the data. The key is to limit extreme values using percentile-based capping.

Full explanation →
688
MCQhard

A data engineer is designing a data lake on Amazon S3 that must support both batch and streaming analytics. The data comes in Parquet format and needs to be queryable by Amazon Athena. Which partitioning strategy will optimize query performance and reduce costs?

A.Partition by date and hour for time-based queries
B.Store data as CSV without partitioning for simplicity
C.Partition by device_id for granular access
D.Use a single partition for all data to simplify management
AnswerA

Common query patterns are time-filtered; this reduces data scanned.

Why this answer

Partitioning by date and hour is optimal for time-series data in Parquet format queried by Athena because it leverages Hive-style partitioning to prune partitions during query execution, drastically reducing the amount of data scanned. This minimizes Athena's cost (which is based on data scanned) and improves query performance by limiting I/O to only the relevant partitions. Parquet's columnar storage further reduces scan volume when queries select only specific columns, making this combination highly efficient for both batch and streaming ingestion patterns.

Exam trap

AWS often tests the misconception that high-cardinality partitions (like device_id) improve query performance, but in Athena and Presto, they actually degrade performance due to excessive partition metadata and small file overhead, whereas coarse-grained time partitions are the recommended pattern.

How to eliminate wrong answers

Option B is wrong because storing data as CSV without partitioning forces full-table scans for every query, increasing Athena's cost (data scanned) and degrading performance, while CSV lacks the compression and columnar benefits of Parquet. Option C is wrong because partitioning by device_id creates an excessive number of small partitions (high cardinality), leading to metadata overhead, slow partition discovery, and poor query performance in Athena, which is optimized for coarse-grained, time-based partitioning. Option D is wrong because using a single partition for all data eliminates the benefits of partition pruning, causing Athena to scan the entire dataset for every query, which is both expensive and slow.

Full explanation →
689
Multi-Selecthard

A data scientist is analyzing a dataset with missing values. Which THREE methods are appropriate for handling missing data during EDA and preprocessing?

Select 3 answers
A.Remove rows with any missing values
B.Impute missing values with the mean of the column
C.Replace missing values with 0
D.Ignore missing values and proceed with modeling
E.Impute missing values with the median of the column
AnswersA, B, E

Listwise deletion is acceptable if missing is MCAR and few rows.

Why this answer

(remove rows with any missing values) is appropriate if missing data is random and limited. Option B (impute with mean) is commonly used for numeric features without outliers. Option E (impute with median) is robust to outliers.

Option C (replace missing values with 0) is generally not recommended as it can introduce bias unless 0 is a valid value. Option D (ignore missing values and proceed with modeling) is problematic because most algorithms cannot handle missing values and will raise errors.

Full explanation →
690
MCQeasy

A machine learning team is using Amazon SageMaker to build a regression model. The target variable is heavily right-skewed with a long tail. Which data transformation should the team apply to the target variable before training?

A.One-hot encoding
B.Min-max scaling
C.Log transformation
D.Standardization (z-score)
AnswerC

Log transform reduces right skew and makes distribution more normal.

Why this answer

A log transformation compresses the range of the target and makes the distribution more symmetric, improving model performance.

Full explanation →
691
MCQeasy

A data scientist is analyzing a dataset with numerical features and a binary target variable. The data scientist creates a pairplot and notices that one feature has a bimodal distribution when colored by the target class. What does this observation suggest?

A.The feature is irrelevant and should be removed.
B.The feature is likely predictive of the target.
C.The feature contains outliers that need to be removed.
D.The feature has missing values that need to be imputed.
AnswerB

Different distributions for each class indicate the feature can separate the classes.

Why this answer

A bimodal distribution separated by class indicates the feature can help distinguish between the classes, making it predictive. Option A is wrong because bimodality separated by class suggests the feature is useful, not irrelevant. Option C is wrong because bimodality is not an indication of outliers; it shows a pattern related to the target.

Option D is wrong because bimodality does not imply missing values.

Full explanation →
692
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.

Full explanation →
693
MCQeasy

A company uses Amazon Kinesis Data Streams to collect clickstream data. The data is consumed by a Lambda function that writes to DynamoDB. Occasionally, the Lambda function fails due to throttling from DynamoDB. How can the company resolve this issue without losing data?

A.Ignore the throttling errors and let Lambda retry.
B.Increase the number of shards in the Kinesis stream.
C.Use an Amazon SQS queue as a buffer between Kinesis and Lambda.
D.Decrease the batch size in the Lambda event source mapping.
AnswerD

Smaller batches reduce the write rate, avoiding throttling.

Why this answer

Decreasing the batch size in the Lambda event source mapping reduces the number of records sent to each Lambda invocation. This lowers the write throughput demand on DynamoDB per invocation, mitigating throttling while still allowing Lambda to retry failed records individually. The Kinesis stream retains data for up to 365 days, so no data is lost as long as the Lambda function eventually processes all records.

Exam trap

The trap here is that candidates often assume increasing shards or adding a buffer will solve throttling, but the real issue is the downstream write volume per invocation, which is directly controlled by the batch size in the event source mapping.

How to eliminate wrong answers

Option A is wrong because ignoring throttling errors and relying solely on Lambda retries can lead to repeated failures, increased latency, and potential data loss if the retry policy is exhausted or the event source mapping discards records after a maximum retry count. Option B is wrong because increasing the number of shards in the Kinesis stream increases the parallelism and throughput of data ingestion, but it does not address the downstream DynamoDB throttling; it may actually worsen the problem by sending more data to Lambda faster. Option C is wrong because using an SQS queue as a buffer between Kinesis and Lambda adds unnecessary complexity and latency, and Kinesis Data Streams already provides durable storage with per-record retry logic; SQS does not solve the root cause of DynamoDB throttling.

Full explanation →
694
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.

Full explanation →
695
MCQhard

A data scientist is working on a binary classification problem with a highly imbalanced dataset (1% positive class). They have applied oversampling using SMOTE and trained a logistic regression model. The model achieves 99% accuracy on the test set, but the recall for the positive class is only 5%. What is the most likely cause?

A.SMOTE was applied before splitting the data into training and test sets
B.The model is overfitting due to lack of regularization
C.Accuracy is not a suitable metric for imbalanced data
D.Logistic regression is inappropriate for imbalanced datasets
AnswerA

Applying SMOTE before splitting the data causes data leakage, artificially inflating training accuracy but not improving generalization, leading to poor recall.

Why this answer

Applying SMOTE before splitting the data causes data leakage. SMOTE generates synthetic samples based on the entire dataset, including the test set, so synthetic versions of test samples can appear in the training set. This inflates training accuracy artificially but does not improve the model's ability to generalize to unseen data, leading to poor recall on the true test set.

Option B is incorrect because while overfitting due to lack of regularization can cause poor generalization, the specific pattern of high accuracy but very low recall is characteristic of data leakage from preprocessing before splitting. Option C is incorrect because accuracy is indeed a poor metric for imbalanced data, but the low recall (5%) indicates a fundamental issue with the model's ability to detect positives, which goes beyond metric choice. Option D is incorrect because logistic regression can be effective for imbalanced datasets when properly handled (e.g., with class weights or resampling); the problem here stems from the improper application of SMOTE, not the algorithm itself.

Full explanation →
696
MCQmedium

A healthcare company is building a model to predict patient readmission within 30 days of discharge. The dataset includes 10,000 patient records with 200 features, including lab results, demographics, and historical admissions. The target variable is highly imbalanced: only 8% of patients are readmitted. The data scientist splits the data into 80% training and 20% test sets, ensuring the same proportion of readmissions in each. The scientist trains a logistic regression model and a random forest model. The logistic regression achieves 92% accuracy but recall of 10% for the readmitted class. The random forest achieves 90% accuracy but recall of 25%. The business requirement is to achieve at least 60% recall for readmissions while maintaining reasonable precision. The scientist also has access to a large collection of unlabeled patient records from other hospitals. Which strategy should the data scientist use to meet the business requirement?

A.Collect more labeled data from other hospitals.
B.Use SMOTE to oversample the minority class in the training set.
C.Use random undersampling of the majority class in the training set.
D.Switch to a deep neural network with more layers.
AnswerB

SMOTE creates synthetic samples to balance classes.

Why this answer

Using SMOTE (Synthetic Minority Over-sampling Technique) generates synthetic samples for the minority class, which can improve recall. Option A is wrong because collecting more data may not be feasible and may not help if imbalance persists. Option C is wrong because undersampling reduces data and may lose information.

Option D is wrong because changing to a deep learning model may not help with limited data.

Full explanation →
697
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.

Full explanation →
698
MCQmedium

A data scientist is training a deep learning model on a large dataset using Amazon SageMaker. The training job is taking too long. Which action would MOST likely reduce training time without sacrificing model accuracy?

A.Use a smaller instance type for training
B.Implement early stopping with a low patience value
C.Enable data parallelism across multiple GPUs
D.Reduce the number of epochs by half
AnswerC

Data parallelism distributes data across GPUs, reducing training time while preserving accuracy.

Why this answer

Enabling data parallelism across multiple GPUs distributes the training workload across several devices, allowing larger batch sizes and faster gradient computation per epoch. Amazon SageMaker's distributed training libraries (e.g., SageMaker Data Parallelism) use all-reduce algorithms to synchronize gradients efficiently, which reduces wall-clock training time without altering the model architecture or loss function, thus preserving accuracy.

Exam trap

The trap here is that candidates may confuse reducing training time with reducing computational load (e.g., smaller instance or fewer epochs), but the question specifically requires maintaining accuracy, which distributed parallelism achieves by leveraging more hardware rather than cutting corners in the training process.

How to eliminate wrong answers

Option A is wrong because using a smaller instance type reduces computational resources (CPU/GPU memory and throughput), which increases per-iteration time and may force smaller batch sizes, potentially slowing convergence or even degrading accuracy due to underfitting. Option B is wrong because implementing early stopping with a low patience value risks halting training prematurely before the model has converged, which can sacrifice accuracy by underfitting the data. Option D is wrong because reducing the number of epochs by half arbitrarily cuts training short without regard to convergence criteria, likely resulting in an underfit model with lower accuracy.

Full explanation →
699
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.

Full explanation →
700
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.

Full explanation →
701
MCQmedium

Refer to the exhibit. A data scientist runs the AWS CLI command to create a SageMaker training job. The job fails immediately with 'ValidationException: Invalid instance type'. What is the most likely issue?

A.The IAM role ARN is invalid
B.The S3 bucket 'my-bucket' does not exist or the role lacks permissions
C.The instance type ml.m5.large does not support the XGBoost image
D.The training image URI is for a different AWS region
AnswerD

The account ID corresponds to us-east-1, but the CLI command is running in us-west-2.

Why this answer

The error 'ValidationException: Invalid instance type' occurs because the training image URI specified in the command points to an Amazon ECR repository in a different AWS region than where the SageMaker training job is being created. SageMaker validates that the image URI is accessible from the current region; if the URI references a region that does not contain the XGBoost image or the instance type is not supported in that region's ECR, the validation fails. The instance type itself (ml.m5.large) is valid for XGBoost, but the mismatch between the image's region and the job's region triggers the exception.

Exam trap

The trap here is that candidates assume 'Invalid instance type' always means the instance is unsupported by the algorithm, when in reality SageMaker uses this generic error for any validation failure related to the training job's resource configuration, including regional mismatches in the image URI.

How to eliminate wrong answers

Option A is wrong because an invalid IAM role ARN would cause an 'AccessDeniedException' or 'InvalidParameterValue' error, not a 'ValidationException' specifically about the instance type. Option B is wrong because a missing S3 bucket or insufficient permissions would result in a 'ClientError: 404 Not Found' or 'AccessDenied' during data download, not a validation error at job creation. Option C is wrong because ml.m5.large is a supported instance type for the XGBoost algorithm in SageMaker; the error is not about instance type compatibility with the image but about the image URI's regional mismatch.

Full explanation →
702
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.

Full explanation →
703
MCQeasy

A data scientist is training a binary classifier using logistic regression. The dataset has 100 features and 1 million samples. After training, the model achieves AUC of 0.85 on the test set. The business wants to understand which features contribute most to predictions. Which technique should the data scientist use?

A.Use t-SNE to visualize feature importance
B.Use the coefficients of the logistic regression model as feature importance
C.Use a random forest model and its feature importance attribute
D.Use Principal Component Analysis (PCA) to find important components
AnswerB

Logistic regression coefficients indicate direction and magnitude of feature impact.

Why this answer

Coefficients of logistic regression are natural measures of feature importance.

Full explanation →
704
MCQmedium

A company is building a recommendation system for an e-commerce platform. They have user-item interaction data (clicks, purchases) and want to use matrix factorization. They plan to use Amazon SageMaker to train the model. Which dataset format is MOST appropriate for the built-in Factorization Machines algorithm?

A.Libsvm format with user_id and item_id as features
B.CSV file with user_id, item_id, and label columns
C.RecordIO-protobuf with user_id, item_id, and label fields
D.JSON lines file with user_id, item_id, and label fields
AnswerC

RecordIO-protobuf is the required format for SageMaker's built-in Factorization Machines.

Why this answer

The built-in Factorization Machines algorithm in Amazon SageMaker requires the RecordIO-protobuf format for optimal performance, as it allows efficient binary serialization and direct integration with SageMaker's distributed training infrastructure. This format supports sparse data representation, which is critical for high-dimensional user-item interaction data, and enables faster I/O and reduced memory overhead compared to text-based formats.

Exam trap

The trap here is that candidates often assume libsvm or CSV are universally optimal for sparse data, but SageMaker's built-in Factorization Machines specifically requires RecordIO-protobuf for native sparse tensor support and maximum performance, not just any text-based sparse format.

How to eliminate wrong answers

Option A is wrong because libsvm format, while common for linear models and SVM, is not natively supported by SageMaker's built-in Factorization Machines algorithm; the algorithm expects RecordIO-protobuf or CSV, but libsvm lacks the protobuf efficiency and sparse tensor handling required for optimal training. Option B is wrong because CSV format, though supported, is less efficient for large-scale sparse data due to text parsing overhead and lack of native sparse encoding, making it suboptimal for matrix factorization tasks with millions of user-item pairs. Option D is wrong because JSON lines format is not supported by the built-in Factorization Machines algorithm; SageMaker's built-in algorithms require either RecordIO-protobuf or CSV for training, and JSON lines would require custom preprocessing or a custom container.

Full explanation →
705
MCQhard

A data scientist is performing exploratory data analysis on a dataset with mixed data types: numerical, categorical, and text. They want to use Amazon SageMaker Data Wrangler to create a quick visualization dashboard. Which set of transformations should they apply in Data Wrangler to handle all data types appropriately?

A.Use the built-in analysis: summary statistics for numerical, word cloud for text, and frequency for categorical.
B.Convert all features to numerical using one-hot encoding and then create a scatter matrix.
C.Apply TF-IDF vectorization to text and then run k-means clustering.
D.Use PCA to reduce dimensionality and then visualize the first two components.
AnswerA

These are appropriate EDA visualizations for different data types.

Why this answer

Amazon SageMaker Data Wrangler provides built-in analysis types that are appropriate for EDA with mixed data types: summary statistics for numerical features, word clouds for text, and frequency counts for categorical features. These allow quick visualization without complex transformations. Option B is incorrect because one-hot encoding and scatter matrix are not suitable for mixed types, and Data Wrangler does not offer a scatter matrix as a built-in analysis.

Option C is incorrect because TF-IDF vectorization and k-means clustering are feature engineering and modeling steps, not EDA. Option D is incorrect because PCA is for dimensionality reduction and not a standard EDA visualization technique.

Full explanation →
706
MCQmedium

A research institution is building a data lake to store genomics data. Each experiment generates multiple files totaling about 500 GB. The data is stored in Amazon S3 and needs to be processed by multiple machine learning (ML) training jobs running on Amazon SageMaker. The data has a high churn rate; after 30 days, most data becomes irrelevant and should be moved to Amazon S3 Glacier Deep Archive. The institution wants to minimize storage costs while maintaining data durability. Which S3 storage class should they use for the first 30 days?

A.Use S3 Intelligent-Tiering for all data, and set a lifecycle policy to transition to S3 Glacier Deep Archive after 30 days.
B.Use S3 One Zone-IA for all data, and set a lifecycle policy to transition to S3 Glacier Deep Archive after 30 days.
C.Use S3 Standard for all data, and set a lifecycle policy to transition to S3 Glacier Deep Archive after 30 days.
D.Use S3 Glacier Instant Retrieval for all data, and set a lifecycle policy to transition to S3 Glacier Deep Archive after 30 days.
AnswerA

Intelligent-Tiering automatically optimizes costs by moving data to lower-cost tiers when not accessed, and it provides high durability.

Why this answer

S3 Intelligent-Tiering is the most cost-effective storage class for the first 30 days because it automatically moves data between frequent and infrequent access tiers based on usage, without any retrieval fees. This is ideal for genomics data that may have unknown or changing access patterns during the initial processing period. After 30 days, a lifecycle rule transitions the data to S3 Glacier Deep Archive for long-term storage, minimizing costs.

S3 Standard is more expensive for data that may not be accessed frequently, S3 One Zone-IA lacks durability across Availability Zones, and S3 Glacier Instant Retrieval is designed for long-lived, rarely accessed data and is not cost-effective for the first 30 days.

Full explanation →
707
MCQeasy

A data engineer is designing a data lake on Amazon S3. The data comes from various sources, including IoT devices, web logs, and transactional databases. The engineer needs to organize the data in a way that supports efficient querying using Amazon Athena and allows for easy management of access permissions. Which S3 bucket structure is the most appropriate?

A.Store all data in a single prefix without any partitioning.
B.Use a prefix structure like s3://bucket/source/year/month/day/.
C.Store all data in separate S3 buckets for each source and date.
D.Use a prefix structure like s3://bucket/date/source/.
AnswerB

This structure enables partition pruning by source and time, optimizing Athena queries and allowing granular access control at the source level.

Why this answer

Partitioning by source, year, month, day allows Athena to prune partitions, reducing scan costs and improving performance. Option A is wrong because storing all data in a flat structure forces full scans. Option C is wrong because prefix-based access controls can be applied at the source level within the partitioned structure.

Option D is wrong because using date as the first partition level is less intuitive for managing permissions by source.

Full explanation →
708
MCQhard

A team is training a large deep learning model on Amazon SageMaker. The training job is taking too long and they want to reduce training time without changing the model architecture. Which action is MOST effective?

A.Switch to a compute-optimized instance like c5.4xlarge
B.Use a GPU instance (e.g., p3.2xlarge) for training
C.Increase the batch size and learning rate proportionally
D.Use SageMaker Automatic Model Tuning with hyperparameter optimization
AnswerB

GPUs dramatically speed up matrix operations common in deep learning.

Why this answer

Using a SageMaker managed training instance with GPU (e.g., p3.2xlarge) provides significant acceleration for deep learning models due to parallel processing.

Full explanation →
709
Multi-Selecteasy

Which TWO of the following are common techniques for handling missing values in a dataset during exploratory data analysis? (Select TWO.)

Select 2 answers
A.Apply feature scaling to normalize the data.
B.Remove rows or columns with missing values if they are few.
C.Use Principal Component Analysis (PCA) to reduce dimensionality.
D.Apply one-hot encoding to the missing values.
E.Impute missing values with the mean or median of the column.
AnswersB, E

Deletion is a valid approach when missing data is minimal.

Why this answer

The correct techniques for handling missing values are removing rows/columns with missing values (if the proportion is small) and imputing missing values with statistical measures like the mean or median. Options A (feature scaling), C (PCA), and D (one-hot encoding) are not methods for dealing with missing data; they serve other purposes such as normalization, dimensionality reduction, and encoding categorical variables.

Full explanation →
710
MCQmedium

A machine learning engineer is analyzing a dataset and observes that the distribution of a continuous feature is heavily right-skewed. Which transformation is most likely to make the distribution approximately normal?

A.Square root transformation
B.Exponential transformation
C.Log transformation
D.Box-Cox transformation with lambda = 0
AnswerC

Log transformation is standard for right-skewed data.

Why this answer

A log transformation (C) is most appropriate for heavily right-skewed continuous data because it compresses the long right tail and can make the distribution approximately normal. Square root (A) is less effective for severe skewness. Exponential (B) would amplify the skewness.

Box-Cox with lambda = 0 (D) is equivalent to log, but since log is explicitly given and commonly known, option C is the direct and correct choice.

Full explanation →
711
MCQmedium

A team is exploring a dataset with missing values in multiple columns. They want to decide whether to drop rows or impute values. Which approach is most appropriate for exploratory data analysis?

A.Impute missing values with the mean of each column
B.Analyze the missing data pattern using visualizations and summary statistics
C.Drop all rows with missing values to ensure data quality
D.Use Amazon SageMaker Data Wrangler to automatically impute missing values
AnswerB

Understanding the missing data pattern is crucial before deciding on imputation or deletion.

Why this answer

During EDA, the first step is to understand the pattern and extent of missing data using visualizations and summary statistics. This helps determine whether missingness is random or systematic, and guides the choice of imputation or deletion. Option A is wrong because imputing with the mean without understanding the missing mechanism can introduce bias.

Option C is wrong because dropping rows may discard valuable data and reduce sample size unnecessarily. Option D is wrong because using SageMaker Data Wrangler is a specific tool and may not be necessary; EDA focuses on understanding data, not automated imputation.

Full explanation →
712
MCQhard

Refer to the exhibit. A data scientist ran an S3 Select query on a large CSV file stored in Amazon S3. The output shows only 2 records returned, but the data scientist expected thousands. The file size is 10 GB. What is the MOST likely reason for the small result set?

A.The file needs to be indexed by S3 Select before querying.
B.The city column may have leading/trailing spaces or case differences.
C.The CSV file contains nested arrays that S3 Select cannot parse.
D.S3 Select does not support the WHERE clause on CSV files.
AnswerB

String comparison is exact; variations cause mismatches, reducing results.

Why this answer

S3 Select performs exact string matching by default, so if the WHERE clause filters on the city column, any leading/trailing spaces or case differences will cause mismatches, returning far fewer rows than expected. The query likely used a literal like 'New York' while the data contains ' New York ' or 'new york', resulting in only 2 matches instead of thousands.

Exam trap

The MLS-C01 exam often tests the nuance that S3 Select does not automatically trim or normalize string data, so candidates mistakenly assume the query engine handles such common data quality issues.

How to eliminate wrong answers

Option A is wrong because S3 Select does not require indexing; it scans the entire file and applies the query on the fly. Option C is wrong because S3 Select can parse CSV files with nested arrays as long as the CSV is well-formed (e.g., quoted fields), and nested arrays are not inherently unsupported. Option D is wrong because S3 Select fully supports the WHERE clause on CSV files, including standard SQL predicates.

Full explanation →
713
Multi-Selectmedium

A data scientist is training a neural network for image classification. The training loss decreases but validation loss increases after a few epochs. Which TWO actions should be taken to address this?

Select 2 answers
A.Implement early stopping based on validation loss.
B.Increase the learning rate.
C.Increase the dropout rate.
D.Increase the number of epochs.
E.Add more convolutional layers.
AnswersA, C

Early stopping prevents overfitting by halting training when validation loss stops improving.

Why this answer

Early stopping monitors validation loss and halts training when it stops improving, preventing overfitting. This directly addresses the symptom of decreasing training loss with increasing validation loss, which is a classic sign of overfitting.

Exam trap

AWS often tests the distinction between underfitting and overfitting solutions, where candidates mistakenly choose capacity-increasing options (like more layers or epochs) when the problem is overfitting, not underfitting.

Full explanation →
714
MCQhard

A machine learning team is using Amazon SageMaker to train a large language model. The training script uses PyTorch and the model requires significant memory. The team wants to use model parallelism across multiple GPUs. Which SageMaker feature should they use?

A.SageMaker Distributed Training
B.SageMaker model parallelism library
C.SageMaker Horovod
D.SageMaker Debugger
AnswerB

SMP is specifically designed for model parallelism.

Why this answer

SageMaker's model parallelism library (SMP) is designed for distributed training of large models across GPUs. Horovod is for data parallelism, not model parallelism. SageMaker Debugger is for monitoring training.

Distributed Training is a generic term; the specific library is SMP.

Full explanation →
715
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.

Full explanation →
716
MCQmedium

An e-commerce company uses Amazon Kinesis Data Firehose to deliver clickstream data to an Amazon S3 bucket. The data is then queried using Amazon Athena. The marketing team wants to run daily reports that aggregate click events by product ID. However, the reports are slow because Athena scans the entire dataset each time. The data is partitioned by date (e.g., s3://bucket/clickstream/2023/01/01/). The product ID is a column within the data. The data engineering team wants to improve query performance without moving the data to another service. Which approach should the team take?

A.Convert the data from JSON to Parquet format
B.Use Amazon Redshift Spectrum to query the data
C.Create a view in Athena that filters by product ID
D.Repartition the data by product ID in addition to date
AnswerD

Partitioning by product ID allows Athena to skip irrelevant partitions.

Why this answer

Repartition the data by product ID in addition to date. This adds a partition level for product ID, so queries that filter on product ID will only scan the relevant partitions. Option A (convert to Parquet) reduces data scanned due to columnar storage and compression, but without partition pruning on product ID, Athena would still scan all partitions for each query.

Option B (Redshift Spectrum) would still require scanning data, and involves additional service complexity. Option C (create a view) does not change physical storage; it only provides a logical filter, but Athena still scans all underlying data. Therefore, repartitioning by product ID provides the most direct improvement for queries filtering by product ID.

Full explanation →
717
MCQeasy

A data scientist is training a neural network for image classification. The training loss is decreasing steadily, but the validation loss starts increasing after a few epochs. What is the MOST likely cause?

A.The learning rate is too high
B.The gradients are vanishing
C.The model is underfitting
D.The model is overfitting to the training data
AnswerD

Overfitting causes validation loss to increase.

Why this answer

The validation loss increasing while the training loss continues to decrease is the classic signature of overfitting. The model is memorizing the training data (including noise) rather than learning generalizable patterns, causing it to perform poorly on unseen validation data.

Exam trap

AWS often tests the distinction between overfitting and underfitting by describing a scenario where training loss decreases but validation loss increases, and the trap is that candidates may mistakenly attribute this to a high learning rate or vanishing gradients instead of recognizing it as the hallmark of overfitting.

How to eliminate wrong answers

Option A is wrong because a learning rate that is too high typically causes the training loss to oscillate or diverge, not steadily decrease while validation loss increases. Option B is wrong because vanishing gradients prevent the model from learning at all, resulting in stagnant training loss, not a decreasing training loss with increasing validation loss. Option C is wrong because underfitting means the model fails to capture patterns in the training data, leading to high training loss that does not decrease adequately, which contradicts the described steady decrease in training loss.

Full explanation →
718
MCQmedium

Refer to the exhibit. An IAM policy is attached to a SageMaker execution role. A data scientist tries to create a training job that reads training data from s3://my-bucket/confidential/data.csv. What will happen?

A.The training job will succeed because there is an Allow on my-bucket/*
B.The training job will succeed because the Deny statement is invalid
C.The training job will fail because the role lacks sagemaker:CreateTrainingJob
D.The training job will fail with an access denied error
AnswerD

The Deny statement blocks access to the confidential prefix.

Why this answer

The policy allows s3:GetObject on my-bucket/* but explicitly denies s3:GetObject on my-bucket/confidential/*. Since explicit Deny overrides any Allow, the training job will fail with an access denied error.

Full explanation →
719
MCQhard

A company uses Amazon Redshift for its data warehouse. The data engineering team needs to load 10 TB of data from Amazon S3 into Redshift every night. The team wants to minimize the load time and use the fewest number of COPY commands. The data is in CSV format and is partitioned by date in S3. Which approach should the team take?

A.Use a manifest file with a single COPY command.
B.Use multiple COPY commands, one per partition.
C.Concatenate all data into a single large file before loading.
D.Use AWS Glue to transform the data and then load into Redshift.
AnswerA

A manifest file allows Redshift to load from multiple files in parallel efficiently.

Why this answer

Using a manifest file with a single COPY command is the most efficient approach because it allows Redshift to load data from multiple S3 objects (partitioned by date) in parallel, automatically splitting the workload across cluster nodes. This minimizes load time by leveraging Redshift's parallel processing without requiring multiple COPY commands or manual concatenation, and it avoids the overhead of additional services like AWS Glue for a straightforward bulk load.

Exam trap

The trap here is that candidates assume multiple COPY commands (one per partition) are needed for partitioned data, but Redshift's manifest file allows a single COPY command to load from many S3 objects in parallel, which is faster and simpler.

How to eliminate wrong answers

Option B is wrong because using multiple COPY commands (one per partition) introduces sequential overhead and requires managing multiple statements, which increases load time and complexity compared to a single manifest-based COPY that handles parallelism natively. Option C is wrong because concatenating all data into a single large file eliminates parallelism, forcing Redshift to process the file sequentially on a single slice, which dramatically increases load time for 10 TB of data. Option D is wrong because AWS Glue adds unnecessary transformation overhead and cost for a simple CSV load; Redshift's COPY command can directly load CSV from S3 without an intermediate ETL service, and Glue does not reduce the number of COPY commands or improve load time for this use case.

Full explanation →
720
MCQmedium

A data engineer is performing EDA on a dataset containing user activity logs from a mobile app. The dataset has 10 million rows and includes columns: 'user_id', 'event_type', 'timestamp', 'device_type', and 'session_duration'. The engineer uses Amazon Athena to query the data stored in S3 as CSV files. The engineer runs a query to find the average session_duration per device_type, but the query takes over 5 minutes and scans 100 GB of data. The engineer wants to reduce query cost and improve performance for future EDA. The dataset is not partitioned, and the engineer anticipates frequent queries filtering on 'timestamp' and 'device_type'. Which action will most effectively reduce data scanned?

A.Partition the table by date derived from timestamp and convert to Parquet.
B.Use random sampling to query a subset of data.
C.Convert the data to Parquet format and use columnar storage.
D.Partition the table by device_type.
AnswerA

Combining partitioning and columnar storage maximizes reduction in scanned data.

Why this answer

The most effective because it combines partitioning by date (derived from timestamp) and converting to Parquet format. Partitioning by date enables partition pruning for queries filtering on 'timestamp', drastically reducing the amount of data scanned. Parquet provides columnar storage and compression, further minimizing I/O and cost.

Option C (Parquet without partitioning) still requires full file scans when filters are applied. Option B (random sampling) sacrifices accuracy for speed, which is undesirable for accurate EDA. Option D (partitioning by device_type) helps only for device_type filters, not for the common timestamp filters mentioned in the scenario.

Full explanation →
721
MCQmedium

A team is using Amazon SageMaker to train a model on a dataset that is 500 GB in size, stored as CSV files in S3. The training job takes 2 hours using a single ml.p3.2xlarge instance. The team wants to reduce training time to under 30 minutes. The model architecture supports distributed training. Which solution will achieve this goal with the LEAST amount of code changes?

A.Use managed spot training to reduce cost and then use cost savings to train with a larger instance.
B.Use a single ml.p3.16xlarge instance with more GPUs and memory.
C.Use multiple ml.p3.2xlarge instances with SageMaker's distributed data parallelism library, enabling automatic sharding of the training data.
D.Change the input mode to Pipe mode to stream data from S3 directly, reducing I/O wait time.
AnswerC

Distributed training across multiple instances reduces time proportionally; minimal code changes with SageMaker's SDK.

Why this answer

SageMaker's distributed data parallelism library automatically shards the training data across multiple ml.p3.2xlarge instances, enabling parallel gradient computation and reducing wall-clock training time from 2 hours to under 30 minutes without requiring manual code changes to the training script. The model architecture already supports distributed training, so the library handles the communication and synchronization (e.g., AllReduce) transparently.

Exam trap

The trap here is that candidates often confuse 'larger instance' (Option B) with 'distributed training' (Option C), failing to realize that a single large instance cannot parallelize data loading and gradient computation across multiple nodes, while distributed data parallelism with multiple smaller instances can achieve the required speedup with minimal code changes.

How to eliminate wrong answers

Option A is wrong because managed spot training reduces cost but does not inherently reduce training time; using a larger instance with spot training still requires code changes for distributed training and may not achieve the sub-30-minute goal. Option B is wrong because a single ml.p3.16xlarge instance, while having more GPUs and memory, still processes data sequentially on one node and cannot scale training time linearly to under 30 minutes for a 500 GB dataset without distributed data parallelism across multiple instances. Option D is wrong because Pipe mode streams data directly from S3 to reduce I/O wait time, but it does not parallelize computation across multiple GPUs or instances, so the training time remains bound by the single-instance compute capacity.

Full explanation →
722
MCQeasy

A data scientist is using Amazon SageMaker to train a linear regression model. The dataset has 500 features and 50,000 observations. The model converges but has high bias. Which technique should the data scientist use to reduce bias?

A.Apply L2 regularization (Ridge) to penalize large coefficients.
B.Add polynomial features or interaction terms to the feature set.
C.Decrease the learning rate.
D.Use feature selection to remove irrelevant features.
E.Increase the number of training epochs.
AnswerB

Increasing model complexity reduces bias.

Why this answer

Adding interaction features or polynomial features allows the linear model to capture non-linear relationships, reducing bias. Option A (L2 regularization/ridge) penalizes large coefficients, which primarily reduces variance, not bias. Option C (decreasing the learning rate) affects the step size during gradient descent, influencing convergence speed and stability, but does not directly reduce bias.

Option D (feature selection) removes irrelevant features, which can reduce overfitting (variance) and may increase bias if important features are removed. Option E (increasing the number of training epochs) gives the model more iterations to converge, but if the model already converges, more epochs won't reduce bias; it might reduce underfitting if the model hasn't fully converged, but typically bias is addressed by model complexity.

Full explanation →
723
MCQeasy

A company uses Amazon S3 to store log files from various applications. The logs are in JSON format and are appended to existing files every few minutes. A data analyst wants to run SQL queries on the logs using Amazon Athena. However, queries return incomplete results because Athena does not support modifying data. The team needs to enable querying of the latest log data with minimal changes to the existing ingestion process. Which solution should the team implement?

A.Convert the logs to Parquet format using a scheduled AWS Glue job and store them in a separate S3 bucket.
B.Stream the logs to Amazon Kinesis Data Firehose, which writes the data to S3 in Parquet format.
C.Create an Athena table using the Hive JSON SerDe that reads the logs directly from the existing S3 bucket.
D.Use AWS Glue to load the JSON logs into Amazon Redshift and query using Redshift.
AnswerC

Athena can query JSON logs with the correct SerDe without changing the ingestion.

Why this answer

Athena supports reading JSON data with the Hive JSON SerDe. By creating a table with the appropriate SerDe, the analyst can query the JSON logs directly without modifying the ingestion process. Option A is incorrect because converting to Parquet would require changing the ingestion process.

Option B is incorrect because using Kinesis Data Firehose would require altering the ingestion pipeline. Option D is incorrect because loading into Redshift adds complexity and latency.

Full explanation →
724
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.

Full explanation →
725
MCQhard

A company uses AWS Glue ETL jobs to process data from an Amazon RDS for MySQL database into Amazon S3. The job runs daily and takes 6 hours to complete. The team wants to reduce runtime and cost. The source table has 50 million rows and is updated continuously. Which combination of changes would be MOST effective?

A.Use a single worker with a larger instance type.
B.Increase the number of DPUs and enable job bookmarking.
C.Use JDBC connections with pushdown predicates and increase the number of DPUs.
D.Change the job trigger from time-based to event-based.
AnswerC

Pushdown predicates filter data at source, reducing data transfer; more DPUs parallelize the work.

Why this answer

Using JDBC pushdown predicates filters data at the source database, reducing the volume of data transferred over the network and processed by Glue. Increasing the number of DPUs (data processing units) adds parallelism, which directly reduces runtime. Together, these changes minimize both execution time and cost by optimizing data movement and compute resources.

Exam trap

The trap here is that candidates assume simply adding more compute (DPUs) or using job bookmarking will solve performance issues, without realizing that the primary bottleneck is data transfer from the source database, which requires predicate pushdown to reduce the data volume.

How to eliminate wrong answers

Option A is wrong because using a single worker with a larger instance type does not address the bottleneck of reading 50 million rows from RDS; Glue's single-worker architecture cannot parallelize the JDBC read, so runtime remains high and cost may increase due to a more expensive instance. Option B is wrong because increasing DPUs without pushdown predicates still forces Glue to pull all 50 million rows over the network, and job bookmarking only helps with incremental processing on subsequent runs, not the initial full load or the current daily full scan. Option D is wrong because changing the trigger from time-based to event-based does not affect the runtime or cost of the job itself; it only changes when the job starts, not how efficiently it processes data.

Full explanation →
726
MCQmedium

A data scientist is training a binary classifier on an imbalanced dataset where the positive class represents only 2% of the data. The model achieves 99% accuracy but only identifies 5% of actual positives. Which metric should the scientist use to evaluate the model's ability to detect the positive class?

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

Recall directly measures the fraction of actual positives captured.

Why this answer

Recall (sensitivity) measures the proportion of actual positives correctly identified, which is the key concern here. Accuracy is misleading due to class imbalance.

Full explanation →
727
Drag & Dropmedium

Drag and drop the steps to set up Amazon SageMaker Ground Truth for a labeling job in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

Ground Truth setup involves dataset preparation, job creation, task configuration, instructions, and execution.

Full explanation →
728
Multi-Selecthard

Which THREE of the following are common causes of multicollinearity in a linear regression model?

Select 3 answers
A.Including a polynomial term (e.g., x^2) along with the original variable
B.Including interaction terms between independent variables
C.Including all dummy variables for a categorical feature
D.Having two or more predictors that are highly correlated
E.Presence of outliers in the target variable
AnswersA, C, D

Polynomial terms are correlated with the original variable.

Why this answer

Options A, C, and D are correct. Dummy variable trap occurs when all categories are included without dropping one. Highly correlated predictors directly cause multicollinearity.

Including polynomial terms creates correlation with the original variable. B (interaction terms) can also cause but is less common. E (outliers) does not cause multicollinearity.

Full explanation →
729
MCQeasy

Refer to the exhibit. A data scientist wants to update the endpoint to use a new model image. The scientist updates the endpoint configuration with the new image and calls UpdateEndpoint. After the update, the endpoint status is 'Updating' but remains in that state for a long time. What is the most likely cause?

A.The new model image is failing health checks
B.The endpoint is already InService, so it cannot be updated
C.The old model image is no longer available
D.The instance count is too low to deploy both variants
AnswerA

SageMaker waits for the new variant to pass health checks; failure can cause indefinite updating.

Why this answer

Blue/green deployment requires the new model to be healthy before traffic is shifted. If the new model fails health checks, the update may hang. Option B is wrong because the endpoint is updating, not failed.

Option C is wrong because the old model is still running. Option D is wrong because there is no indication of insufficient capacity.

Full explanation →
730
Multi-Selecthard

A machine learning engineer is evaluating a classification model that predicts whether a transaction is fraudulent. The model outputs a probability score. The cost of a false negative (missed fraud) is 10 times higher than the cost of a false positive (false alarm). Which TWO evaluation metrics should the engineer use to tune the model? (Choose TWO.)

Select 2 answers
A.F-beta score with beta = 2
B.Accuracy
C.Log loss
D.ROC-AUC
E.Precision-Recall curve
AnswersA, E

F-beta with beta > 1 weights recall higher than precision, matching the cost structure.

Why this answer

Precision-Recall curve (E) is well-suited for imbalanced datasets and when the positive class (fraud) is rare; it directly evaluates the trade-off between precision and recall. F-beta score with beta = 2 (A) weights recall twice as much as precision, aligning with the higher cost of false negatives. Accuracy (B) is misleading for imbalanced data and does not incorporate costs.

ROC-AUC (D) can be overly optimistic on imbalanced data and is less sensitive to the cost of false negatives. Log loss (C) measures probabilistic calibration but does not directly reflect the asymmetric cost structure.

Full explanation →
731
Multi-Selecthard

A company is using Amazon SageMaker to train a large language model. The training job is taking too long. The data scientist wants to reduce training time without sacrificing model accuracy. Which THREE strategies are MOST appropriate?

Select 3 answers
A.Use mixed precision training (float16)
B.Increase the batch size to utilize GPU memory more efficiently
C.Switch from GPU instance to CPU instance
D.Increase the maximum sequence length
E.Use gradient accumulation to increase effective batch size
AnswersA, B, E

Mixed precision reduces memory and speeds up training on GPUs.

Why this answer

Mixed precision training (float16) reduces memory usage and accelerates computation by using half-precision floating-point numbers for most operations, while maintaining a single-precision copy of critical parameters to preserve accuracy. This directly reduces training time on compatible GPUs (e.g., NVIDIA V100, A100) without sacrificing model quality, as the loss scaling technique prevents underflow in gradients.

Exam trap

The MLS-C01 exam often tests the misconception that increasing batch size always speeds up training, but without gradient accumulation, a larger batch size may exceed GPU memory limits and cause out-of-memory errors, while gradient accumulation safely simulates a larger batch size without increasing memory usage.

Full explanation →
732
MCQhard

A data scientist is using Amazon SageMaker to train a gradient boosting model on a dataset with categorical features. The dataset contains a column 'UserID' with over 1 million unique values. The training is taking very long and the model size is large. Which technique would MOST effectively reduce training time and model size while maintaining accuracy?

A.Use one-hot encoding on UserID.
B.Apply feature hashing to UserID.
C.Use label encoding for UserID.
D.Remove UserID from the dataset.
AnswerB

Feature hashing maps user IDs to a fixed number of buckets (e.g., 2^14), reducing dimensionality and preserving some signal.

Why this answer

Hashing reduces the number of distinct categories to a fixed number of buckets, controlling dimensionality. Option A is wrong because one-hot encoding would explode the feature space. Option C is wrong because label encoding creates ordinal relationships that may mislead the model.

Option D is wrong because removing UserID likely loses important signal.

Full explanation →
733
Multi-Selectmedium

A data engineer is designing a streaming pipeline using Amazon Kinesis Data Analytics for Apache Flink. The pipeline reads from a Kinesis data stream and writes to a S3 bucket. The job must recover quickly from failures without reprocessing large amounts of data. Which TWO configurations should be used? (Choose TWO)

Select 2 answers
A.Enable checkpointing with a state backend like RocksDB.
B.Use in-memory state backend for low latency.
C.Configure the S3 sink to use exactly-once delivery semantics.
D.Set the parallelism to the maximum number of shards.
E.Increase the retention period of the Kinesis stream to 365 days.
AnswersA, C

Checkpointing enables state recovery after failure.

Why this answer

Enabling checkpointing with a state backend like RocksDB allows Apache Flink to periodically save the state of the streaming application to durable storage. In the event of a failure, Flink can restart from the last completed checkpoint, avoiding the need to reprocess large amounts of data from the beginning of the stream. RocksDB is specifically designed for large state and provides fast recovery by storing state on disk with memory caching, making it ideal for production streaming pipelines.

Exam trap

The trap here is that candidates often confuse parallelism or stream retention settings with fault-tolerance mechanisms, mistakenly believing that increasing parallelism or retention alone can prevent data reprocessing, when in fact only checkpointing with a durable state backend ensures fast recovery.

Full explanation →
734
MCQmedium

A data engineer needs to transform large CSV files stored in Amazon S3 into Parquet format before loading into Amazon Redshift. The transformation logic is complex and requires custom Python code. Which AWS service should be used to perform this transformation with minimal operational overhead?

A.AWS Glue
B.AWS Lambda
C.Amazon EMR
D.AWS Data Pipeline
AnswerA

Glue is a serverless ETL service that can run complex transformations on data in S3 and write to Parquet.

Why this answer

AWS Glue is the correct answer because it is a fully managed, serverless ETL service that can handle large CSV files, convert them to Parquet, and load into Amazon Redshift with minimal operational overhead. AWS Glue provides a built-in Spark environment and supports custom Python code via Spark jobs. Option B (AWS Lambda) has a 15-minute timeout and is not designed for large-scale data transformations.

Option C (Amazon EMR) requires managing clusters, increasing operational overhead. Option D (AWS Data Pipeline) is a legacy service with less flexibility and is not optimized for complex transformations like CSV to Parquet.

Full explanation →
735
Multi-Selecteasy

A company wants to build a data lake on Amazon S3. The data lake should support both batch and real-time data ingestion. Which AWS services should be used for data ingestion? (Choose TWO.)

Select 2 answers
A.AWS Glue
B.Amazon Kinesis Data Firehose
C.Amazon Redshift
D.Amazon Athena
E.Amazon SQS
AnswersA, B

Glue performs batch ETL and can ingest data into S3.

Why this answer

AWS Glue is correct because it provides a managed ETL service that can handle batch data ingestion into a data lake on Amazon S3. It can be scheduled for periodic batch loads or triggered by events, making it suitable for batch ingestion workflows. Amazon Kinesis Data Firehose is correct because it is a fully managed service for loading streaming data into S3 in near real-time, supporting real-time ingestion with automatic buffering and compression.

Exam trap

The trap here is that candidates often confuse data ingestion services with data query or storage services, mistakenly selecting Amazon Redshift or Athena because they interact with data in S3, but they do not perform the ingestion itself.

Full explanation →
736
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.

Full explanation →
737
MCQeasy

A company is using Amazon SageMaker to deploy a model for real-time inference. The model is updated frequently. Which deployment strategy allows for zero-downtime updates and easy rollback?

A.Canary deployment
B.A/B testing with production variants
C.Blue/green deployment using endpoint updates
D.Multi-model endpoint
AnswerC

Blue/green deployment provides zero-downtime updates and rollback.

Why this answer

SageMaker's blue/green deployment (using endpoint updates with production variants) allows traffic shifting and rollback. A/B testing is for testing variants, not zero-downtime updates by itself. Canary deployment is a type of blue/green but not a separate AWS feature.

Multi-model endpoints are for hosting multiple models.

Full explanation →
738
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.

Full explanation →
739
MCQmedium

A data scientist is training a recurrent neural network (RNN) for time series forecasting. The training loss decreases steadily for the first 10 epochs, then plateaus. The validation loss starts increasing after epoch 10. What is the most appropriate action?

A.Stop training early and use the model from epoch 10
B.Continue training for more epochs
C.Add more layers to the network
D.Increase the batch size
AnswerA

Early stopping prevents overfitting; the model at epoch 10 generalizes better.

Why this answer

The validation loss increasing while training loss decreases indicates overfitting. Early stopping halts training before overfitting worsens, preserving the model that performed best on validation data (epoch 10). Option B (continuing training) would increase overfitting.

Option C (adding layers) may exacerbate overfitting. Option D (increasing batch size) is not directly addressing overfitting and may not help.

Full explanation →
740
MCQhard

A data engineer is designing a data pipeline that transforms raw JSON files (each 50-200 KB) in Amazon S3 into Parquet format using AWS Glue. The pipeline must minimize data processing costs and handle a high volume of small files (millions per day). The engineer configures a Glue ETL job with Spark, but the job is slow and expensive due to overhead of reading many small files. Which optimization should the engineer implement to reduce cost and improve performance?

A.Increase the worker type to G.2X for more memory per worker.
B.Increase the number of DPUs allocated to the Glue job.
C.Change the output format from Parquet to CSV to reduce compression overhead.
D.Use S3 object grouping or batch operations to combine small files before Glue processing.
AnswerD

Combining small files reduces task overhead, leading to faster and cheaper jobs.

Why this answer

The primary performance bottleneck with many small files in S3 is the overhead of listing, opening, and reading each file individually in Spark. By grouping or batching small files into larger objects (e.g., using S3 Batch Operations or a pre-processing step), you reduce the number of input splits and task launches, which dramatically lowers the cost and runtime of the Glue ETL job. This directly addresses the root cause of the inefficiency rather than merely scaling resources.

Exam trap

The trap here is that candidates often assume scaling up resources (more memory or DPUs) will fix performance issues, but the real problem is the small-file overhead, which is a data layout issue that cannot be solved by adding compute power.

How to eliminate wrong answers

Option A is wrong because increasing the worker type to G.2X provides more memory per worker but does not reduce the overhead of reading millions of small files; the bottleneck is the number of files, not memory capacity. Option B is wrong because increasing the number of DPUs adds more parallel workers, which can actually worsen performance by increasing the overhead of scheduling and managing tasks for many small files, and it raises costs without solving the file-size issue. Option C is wrong because changing the output format from Parquet to CSV would increase storage size and I/O, and CSV lacks compression and predicate pushdown benefits, making the job slower and more expensive, not less.

Full explanation →
741
MCQeasy

A data scientist needs to run a one-time SQL query on a large dataset in Amazon S3. The dataset is stored in Parquet format and is about 500 GB. The query requires complex aggregations and joins. Which AWS service should be used to minimize cost and setup time?

A.Amazon Redshift
B.Amazon Athena
C.Amazon RDS for MySQL
D.Amazon EMR with Spark SQL
AnswerB

Serverless, pay-per-query, no setup required.

Why this answer

Amazon Athena is the correct choice because it is a serverless query service that allows you to run SQL directly on data stored in S3 without provisioning any infrastructure. For a one-time query on 500 GB of Parquet data, Athena minimizes cost (pay-per-query, no idle cluster costs) and setup time (no cluster creation or data loading). Its ability to handle complex aggregations and joins on columnar formats like Parquet makes it ideal for this ad-hoc use case.

Exam trap

The trap here is that candidates often choose Amazon EMR with Spark SQL (Option D) because they associate Spark with complex joins and large datasets, but they overlook the fact that for a one-time query, the setup time and cost of provisioning a cluster make Athena a more efficient and cost-effective choice.

How to eliminate wrong answers

Option A is wrong because Amazon Redshift requires provisioning a cluster, loading data into it, and paying for compute even when idle, which is overkill and costly for a one-time query. Option C is wrong because Amazon RDS for MySQL is a transactional database not designed for analytical queries on large datasets in S3; it would require importing 500 GB of data and lacks native Parquet support. Option D is wrong because Amazon EMR with Spark SQL involves provisioning a cluster, managing Spark configurations, and incurring costs for cluster uptime, adding unnecessary setup time and expense for a single query.

Full explanation →
742
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.

Full explanation →
743
MCQhard

A data scientist is training a convolutional neural network (CNN) for image classification using Amazon SageMaker. The training loss decreases steadily but validation loss starts increasing after a few epochs. Which action should the data scientist take to address this issue?

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

Early stopping prevents overfitting by stopping training when validation loss plateaus or increases.

Why this answer

The described behavior—training loss decreasing while validation loss increases—is a classic sign of overfitting. Early stopping monitors the validation loss and halts training when it stops improving (or starts to increase), preventing the model from memorizing noise in the training data. In SageMaker, this can be implemented using the `EarlyStopping` callback in the framework's estimator or by setting `use_early_stopping` to True in a built-in algorithm.

Exam trap

The trap here is that candidates confuse overfitting with underfitting and choose to increase model complexity (Option B) or learning rate (Option A), not recognizing that rising validation loss signals the need to stop training rather than continue with more capacity.

How to eliminate wrong answers

Option A is wrong because increasing the learning rate would make the optimizer take larger steps, which can cause the loss to diverge or oscillate, worsening overfitting rather than fixing it. Option B is wrong because adding more convolutional layers increases model capacity, which typically exacerbates overfitting when validation loss is already rising. Option C is wrong because increasing the batch size provides a more accurate gradient estimate but does not directly address overfitting; it may even lead to sharper minima and poorer generalization.

Full explanation →
744
Multi-Selecteasy

A data scientist is using Amazon SageMaker to train a linear regression model. The dataset has outliers. Which TWO techniques can help reduce the impact of outliers? (Choose TWO.)

Select 2 answers
A.Trim the dataset to remove extreme values
B.Add more features
C.Apply L1 regularization
D.Use Huber loss instead of squared error
E.Standardize the features
AnswersA, D

Removing outliers reduces their influence on the model.

Why this answer

Options A and D are correct. Huber loss is robust to outliers, and trimming the dataset removes extreme values. Option B (more features) is not relevant for handling outliers.

Option C (L1 regularization) reduces overfitting but not outlier impact. Option E (standardization) does not handle outliers.

Full explanation →
745
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.

Full explanation →
746
MCQeasy

A data scientist receives the above error during model training. What is the most likely cause?

A.The training data contains missing or infinite values.
B.The learning rate is too high.
C.The data format is incorrect; expected CSV but received JSON.
D.The instance type lacks sufficient memory.
AnswerA

Correct: The error suggests NaN or infinite values in the data. Cleaning the data by imputing or removing such values resolves the issue.

Why this answer

The error message indicates that the training data contains missing (NaN) or infinite values, which causes the loss function to become NaN. This is a common issue when data has not been properly cleaned. Option B is wrong because a high learning rate typically leads to divergence or instability, not NaN values due to data issues.

Option C is wrong because an incorrect data format would result in a parsing error, not a NaN loss. Option D is wrong because insufficient memory leads to an out-of-memory error, not NaN values.

Full explanation →
747
MCQhard

A data engineer is designing a data pipeline that ingests 500 GB of data daily from an on-premises Oracle database to Amazon S3. The pipeline must minimize data loss and support change data capture (CDC). Which combination of services should they use?

A.AWS Database Migration Service (DMS) with ongoing replication
B.AWS Data Pipeline with SQL query
C.Amazon Kinesis Data Streams with a custom Oracle CDC connector
D.AWS Glue ETL jobs running on a schedule
AnswerA

DMS supports CDC and can write to S3.

Why this answer

AWS DMS with ongoing replication is the correct choice because it provides continuous change data capture (CDC) from an Oracle source database using Oracle LogMiner or binary reader technology, replicating transactions in near real-time to Amazon S3. This minimizes data loss by capturing incremental changes without requiring batch snapshots, and it supports the 500 GB daily volume efficiently with parallel tasks and task tuning.

Exam trap

The trap here is that candidates may confuse Amazon Kinesis Data Streams with a custom CDC connector as a viable alternative, but AWS does not provide a managed Oracle CDC connector for Kinesis, making DMS the only fully managed, production-ready service for this use case.

How to eliminate wrong answers

Option B is wrong because AWS Data Pipeline with SQL query only supports scheduled batch extracts, not real-time CDC, and cannot capture ongoing changes without manual intervention, leading to potential data loss between runs. Option C is wrong because Amazon Kinesis Data Streams does not natively support a custom Oracle CDC connector; building and maintaining such a connector is complex, unreliable, and not a managed service, unlike DMS which provides built-in Oracle CDC. Option D is wrong because AWS Glue ETL jobs running on a schedule are batch-oriented and lack native CDC capabilities; they would require full table scans or custom logic to detect changes, which is inefficient for 500 GB daily and risks data loss between job runs.

Full explanation →
748
MCQhard

A team is using Amazon SageMaker to train a model. The training job repeatedly fails with a 'ResourceLimitExceeded' error. Which action should the team take to resolve this issue?

A.Request a service limit increase for SageMaker resources.
B.Reduce the size of the training dataset.
C.Switch to using Spot Instances.
D.Use a different instance type with less memory.
AnswerA

ResourceLimitExceeded indicates the account limit has been reached; requesting an increase is the standard resolution.

Why this answer

The 'ResourceLimitExceeded' error in Amazon SageMaker indicates that the AWS account has reached a service quota for SageMaker resources, such as the number of concurrent training jobs, total instance count, or specific instance types. The correct action is to request a service limit increase via the AWS Service Quotas console or by contacting AWS Support, as this directly addresses the quota cap causing the failure.

Exam trap

The trap here is that candidates confuse resource limits with performance or cost issues, leading them to choose dataset reduction, Spot Instances, or smaller instance types, when the root cause is a hard AWS service quota that must be increased.

How to eliminate wrong answers

Option B is wrong because reducing the size of the training dataset does not affect the service quota limits; it might reduce training time or cost but will not resolve a 'ResourceLimitExceeded' error, which is a quota-based issue. Option C is wrong because switching to Spot Instances can reduce cost but does not increase the account's resource limits; Spot Instances are still subject to the same service quotas for instance count and concurrent jobs. Option D is wrong because using a different instance type with less memory does not change the fact that the account has hit a resource limit; the error is about exceeding a quota, not about memory capacity.

Full explanation →
749
MCQhard

A research team is training a deep learning model for image classification using Amazon SageMaker. The model is a convolutional neural network (CNN) with 50 layers. The team uses a single ml.p3.2xlarge instance. After 10 hours of training, the model has not converged and the loss is decreasing very slowly. The team suspects vanishing gradients. They want to diagnose and fix the issue without significant code changes. Which action should they take?

A.Add more convolutional layers to increase model capacity
B.Modify the architecture to include residual connections (skip connections)
C.Use batch normalization after each convolutional layer
D.Increase the learning rate by a factor of 10
AnswerB

Residual connections allow gradients to flow directly through the network.

Why this answer

(Modify the architecture to include residual connections) directly addresses vanishing gradients by allowing gradients to flow through skip connections. Option A (adding more layers) worsens the problem. Option C (batch normalization) helps but is not as targeted as residual connections.

Option D (increase learning rate) may cause divergence.

Full explanation →
750
MCQeasy

A data scientist is training a text classification model using a bag-of-words approach. The dataset contains 1 million documents and 100,000 unique words. The resulting feature matrix is very sparse. Which technique should the data scientist use to reduce the dimensionality of the feature space?

A.Apply TF-IDF transformation
B.Use word embeddings to represent documents
C.Remove stop words from the vocabulary
D.Apply Principal Component Analysis (PCA) to the term-document matrix
AnswerB

Word embeddings create dense low-dimensional vectors, reducing sparsity and dimensionality.

Why this answer

Word embeddings (e.g., Word2Vec, GloVe) map words to dense, low-dimensional vectors that capture semantic relationships, effectively reducing the 100,000-dimensional sparse bag-of-words feature space to a much smaller dense representation (e.g., 100–300 dimensions). This directly addresses the sparsity and high dimensionality of the term-document matrix while preserving meaningful word context.

Exam trap

The trap here is that candidates confuse TF-IDF (a reweighting technique) with dimensionality reduction, or assume PCA can be directly applied to sparse text matrices without considering computational cost and loss of interpretability.

How to eliminate wrong answers

Option A is wrong because TF-IDF is a weighting scheme that reweights term frequencies based on inverse document frequency, but it does not reduce the number of features; the feature space remains 100,000 dimensions and still sparse. Option C is wrong because removing stop words reduces the vocabulary size only marginally (typically a few hundred words) and does not significantly reduce the 100,000 unique words or address the sparsity of the feature matrix. Option D is wrong because PCA is a linear dimensionality reduction technique that is computationally infeasible on a 1 million × 100,000 sparse matrix (dense covariance matrix would be 100k × 100k) and destroys the sparse structure without capturing semantic relationships.

Full explanation →
Page 9

Page 10 of 23

Page 11

All pages

1234567891011121314151617181920212223

Practice MLS-C01 by domain

Target a specific domain to shore up weak areas.

Data EngineeringMachine Learning Implementation and OperationsModelingExploratory Data Analysis
See all domains with question counts →