MLA-C01 Amazon Web Services AWS Certified Machine Learning Engineer - Associate Free Practice Exam Questions (2026 Updated)

The primary requirement in this scenario is achieving sub-second latency for a real-time analytics dashboard powered by Amazon OpenSearch Service. The current architecture uses Amazon Data Firehose, which buffers incoming records based on time or size before delivering them to the destination. A buffer interval of 60 seconds introduces unavoidable latency, making it unsuitable for near-real-time or sub-second use cases.

According to AWS documentation, reducing or eliminating buffering in Firehose is the correct approach when low-latency ingestion is required. Setting the Firehose buffer interval to zero seconds forces Firehose to deliver records as soon as they are received. Additionally, tuning the PutRecordBatch batch size allows efficient ingestion while minimizing delivery delay. This configuration is explicitly recommended for latency-sensitive analytics pipelines.

Option B is incorrect because AWS DataSync is designed for batch-oriented data transfers between storage systems, not real-time streaming. Enhanced fan-out consumers are a feature of Amazon Kinesis Data Streams, not DataSync, making this option invalid.

Option C directly contradicts the requirement. Increasing the buffer interval from 60 seconds to 120 seconds would further increase latency and degrade real-time performance.

Option D is also incorrect because Amazon SQS is a message queueing service, not a streaming ingestion service optimized for indexing data into OpenSearch with minimal latency. Using SQS would add additional processing layers and would not inherently provide sub-second ingestion into OpenSearch.

Therefore, using zero buffering in the Firehose stream and tuning the PutRecordBatch batch size is the only change that aligns with AWS best practices for achieving sub-second latency in real-time analytics pipelines.

A serverless inference endpoint in Amazon SageMaker is ideal for use cases where the model is invoked infrequently, such as running one time each night. It eliminates the cost of idle resources when the model is not in use. Setting the MaxConcurrency parameter to 1 ensures cost-efficiency while supporting the required single nightly invocation. This solution minimizes costs and matches the requirement to process a small amount of data quickly.

When Model Monitor identifies data quality issues, it might be due to a shift in the data distribution compared to the original baseline. By creating a new baseline using the most recent production data and updating Model Monitor to evaluate against this baseline, the ML engineer ensures that the monitoring is aligned with the current data patterns. This approach mitigates false positives and reflects the updated data characteristics without immediately retraining the model.

The scenario describes a classic overfitting problem: the XGBoost model performs well on the training dataset but poorly on the test hold-out dataset. According to AWS Machine Learning and XGBoost documentation, overfitting occurs when a model is too complex and learns noise and patterns specific to the training data rather than generalizable relationships.

One effective way to address overfitting is to reduce model complexity. Option B, reducing the number of features, simplifies the hypothesis space and lowers the risk of fitting spurious correlations. Feature reduction is a recommended best practice when the model shows a large generalization gap between training and test error.

Another effective method is to increase regularization. Option D, increasing the L2 regularization parameter (lambda in XGBoost), penalizes large weights and discourages overly complex trees. AWS documentation explicitly notes that L2 regularization helps improve generalization by smoothing model parameters and reducing variance.

Option A would worsen overfitting by increasing complexity. Option C is incorrect because reducing the number of training samples generally increases overfitting risk. Option E would decrease regularization strength and further degrade test performance.

Therefore, reducing feature complexity and increasing L2 regularization are the correct changes.

The key requirements are real-time processing, high throughput, and minimal operational overhead. Amazon Kinesis Data Streams is designed for ingesting thousands of events per second with low latency.

For anomaly detection on streaming data, Amazon Managed Service for Apache Flink provides a built-in Random Cut Forest (RCF) function. RCF is an unsupervised anomaly detection algorithm that works well on numerical streaming data and does not require labeled training data.

This fully managed combination eliminates the need to deploy or maintain SageMaker endpoints, EC2 instances, or custom ML pipelines. Options B and C introduce unnecessary infrastructure and model management overhead. Option D is batch-oriented and unsuitable for real-time anomaly detection.

Therefore, using Kinesis Data Streams with Flink’s built-in Random Cut Forest is the most scalable and low-overhead solution.

Amazon SageMaker Automated Model Tuning supports several hyperparameter search strategies. Bayesian optimization is explicitly designed to model the relationship between hyperparameters and objective metrics using regression techniques. Based on results from previous training jobs, Bayesian optimization predicts which hyperparameter combinations are most likely to improve model performance and evaluates those next.

AWS documentation highlights Bayesian optimization as the preferred strategy when the hyperparameter search space is small to medium and when training jobs are expensive. Because the algorithm learns from prior runs, it avoids wasting resources on unpromising configurations and converges efficiently.

Grid search exhaustively evaluates all combinations and becomes inefficient even with moderately sized search spaces. Random search does not use information from prior runs and is less efficient. Hyperband focuses on aggressive early stopping and resource allocation, not regression-based sequential selection.

Therefore, Option C is the correct and AWS-verified solution.

Amazon SageMaker AI shadow testing enables ML engineers to evaluate new model versions by sending a copy of live production traffic to a shadow variant without affecting production inference responses. AWS documentation specifies that shadow variants are configured separately from production variants and can use different instance types, including higher-performance GPU instances.

The correct approach is to create a new endpoint configuration using the CreateEndpointConfig API. This configuration includes the existing production variant and a separate ShadowProductionVariants list. The shadow variant can be assigned a larger instance type to meet GPU performance requirements while leaving the production variant unchanged. After creating the configuration, the engineer deploys it using the CreateEndpoint action.

Option A is incorrect because production variant configurations cannot be directly modified to include shadow variants. Option B is incorrect because shadow variants are not defined as standard production variants; defining two production variants would route traffic differently and could affect production behavior. Option C introduces unnecessary complexity and deviates from SageMaker’s built-in shadow testing functionality.

AWS explicitly documents that shadow variants are designed to isolate testing resources, support different instance types, and ensure zero impact on production inference. Therefore, Option D is the correct and AWS-recommended solution.

Network ACLs (Access Control Lists) operate at the subnet level and allow for rules to explicitly deny traffic from specific IP addresses. By creating an inbound rule in the network ACL to deny traffic from the suspicious IP address, the company can block traffic to the Amazon SageMaker domain from that IP. This approach works because network ACLs are evaluated before traffic reaches the security groups, making them effective for blocking traffic at the subnet level.

The ETL process has two critical characteristics: it is long-running (6 hours) and written in R. AWS Lambda is unsuitable because it has a maximum execution time of 15 minutes. AWS Glue primarily supports Spark-based ETL and does not natively support custom R-based workloads.

AWS documentation recommends using Amazon SageMaker Processing Jobs for long-running, custom data processing workloads. Processing jobs allow users to run arbitrary code in custom Docker containers, making them ideal for migrating on-premises ETL jobs written in R.

By building a custom Docker image that includes the R runtime and required libraries and storing it in Amazon ECR, the company can run the ETL job at scale on managed infrastructure without rewriting the code.

SageMaker script mode is intended for training, not ETL. Therefore, SageMaker processing jobs with a custom container are the correct solution.

For near real-time anomaly detection on streaming IoT data, AWS recommends Amazon Managed Service for Apache Flink. Flink is designed for stateful, low-latency stream processing and is well suited for time-series sensor analytics.

A key requirement is application resilience during deployments. Managed Flink supports system rollback, which automatically reverts to the last stable application version if a new deployment fails. This capability ensures uninterrupted processing even if application bugs are introduced, meeting the company’s reliability requirement.

Manual rollback (Option B) introduces operational risk and delays. Amazon Data Firehose (Options C and D) is a delivery service and does not support complex anomaly detection logic or application version rollback.

Therefore, using Managed Flink with system rollback enabled is the correct solution.

In regression problems such as house price prediction, extreme values can significantly distort model learning. In this dataset, the presence of a large mansion and an extremely small apartment represents clear outliers in the Square Meters feature. According to AWS Machine Learning best practices, outliers can disproportionately influence loss functions (such as mean squared error), leading to poor predictions for the majority of typical data points.

Removing these outliers helps the model focus on learning patterns that apply to the majority of houses and apartments, which aligns with the requirement to produce accurate predictions for typical properties. After removing outliers, applying a log transformation to the Square Meters feature further improves model performance by reducing skewness and stabilizing variance. Log transformations are commonly recommended in AWS and general ML documentation when numerical features span multiple orders of magnitude.

Option B is incorrect because normalization alone does not address the undue influence of extreme outliers. Option C and D are incorrect because one-hot encoding is intended for categorical variables, not continuous numerical features such as square meters.

Therefore, removing outliers and applying a log transformation is the most statistically sound preprocessing approach.

Patient ID is a unique identifier and does not contain predictive information. Including it can cause the model to overfit by memorizing records rather than learning meaningful patterns.

AWS ML best practices recommend removing identifiers that are not causally related to the target variable. Age, medical conditions, and test results are clinically relevant features and should be retained. The target column must remain for supervised learning.

Therefore, Option A is the correct and AWS-aligned choice.

The issue is caused by oversized Parquet files that cannot be efficiently read into memory during training. The most effective and scalable solution is to repartition the dataset into smaller Parquet files.

AWS best practices for large-scale ML training recommend optimizing data layout, not simply increasing memory. By using Apache Spark on Amazon EMR, the ML engineer can repartition the Parquet files into smaller chunks that can be streamed and processed efficiently by SageMaker training jobs.

Attaching EBS volumes (Option A) increases storage capacity but does not solve in-memory constraints. Changing to memory-optimized instances (Option C) increases cost and does not address long-term scalability. SMDDP (Option D) distributes gradients and computation, not dataset file sizes.

Therefore, repartitioning the Parquet files is the correct solution.

This requirement combines asynchronous inference on large datasets with automated data quality monitoring and alerting. AWS documentation explicitly recommends Amazon SageMaker batch transform for large-scale, asynchronous inference workloads. Batch transform jobs process large datasets stored in Amazon S3 without requiring a persistent endpoint, making them cost-effective and scalable.

For data quality monitoring, Amazon SageMaker Model Monitor is the AWS-native solution. Model Monitor can be scheduled to analyze inference data, compare it against a baseline, and detect data quality issues such as missing values, schema changes, or statistical drift. When violations occur, Model Monitor emits metrics to Amazon CloudWatch, where alarms can trigger alerts.

Options A, B, and C lack ML-aware data quality monitoring capabilities. AWS Glue and Batch are not designed for model data quality analysis, and CloudTrail tracks API activity—not data quality.

AWS best practices clearly position Batch Transform + Model Monitor as the correct architecture for asynchronous inference with automated monitoring and alerting.

Therefore, Option D is the correct and AWS-verified solution.

Option A is correct because Amazon SageMaker Ground Truth is the AWS service specifically designed to build labeled datasets for machine learning, including video classification and video frame labeling use cases. AWS documentation states that Ground Truth can take video files in MP4 format stored in Amazon S3, automatically connect to that data, and extract video frames for labeling. This directly matches the scenario in the question, where the source data is MP4 in S3 and the company needs to relabel or expand training data for retraining an existing SageMaker workflow.

Ground Truth is also the best choice because AWS documents explain that it can reduce labeling time and cost through automated data labeling (active learning) for supported built-in task types. Instead of relying only on manual human labeling for every item, Ground Truth can use ML-assisted labeling to lower the total amount of human work needed, which is exactly what the company wants after previously spending four months labeling frames.

The other options do not fit as well. JumpStart provides pretrained models and solution templates, but AWS documentation does not position it as the service for running a video-frame labeling operation. Data Wrangler is for data preparation, transformation, and feature engineering, not human labeling of video frames. Amazon A2I with Rekognition is mainly documented for human review workflows such as Rekognition moderation outputs, not as the primary service for large-scale MP4 video-frame annotation used to create training datasets.

AWS provides Amazon SageMaker Data Wrangler as a native tool for importing, transforming, and analyzing data from multiple sources directly into SageMaker Studio. Data Wrangler supports Amazon S3, Amazon Athena, and Snowflake as built-in data sources through managed connectors.

Using Data Wrangler, ML engineers can query data from Athena using SQL, load structured files from S3, and securely connect to Snowflake without writing custom ingestion code. This approach significantly reduces development effort and aligns with AWS best practices for rapid ML experimentation.

Option A is incorrect because AWS Glue DataBrew is designed for data preparation but does not natively integrate with SageMaker training workflows. Option B introduces unnecessary complexity and is not intended for direct ML data loading. Option C focuses on feature storage, not raw historical data ingestion.

Therefore, SageMaker Data Wrangler is the correct solution.

When predicting continuous variables, such as apartment prices, it ' s essential to evaluate the model ' s performance using appropriate regression metrics. The Mean Absolute Error (MAE) is a widely used metric for this purpose.

Understanding Mean Absolute Error (MAE):

MAE measures the average magnitude of errors in a set of predictions, without considering their direction. It calculates the average absolute difference between predicted values and actual values, providing a straightforward interpretation of prediction accuracy.

Advantages of MAE:

Interpretability: MAE is expressed in the same units as the target variable, making it easy to understand.

Robustness to Outliers: Unlike metrics that square the errors (e.g., Mean Squared Error), MAE does not disproportionately penalize larger errors, making it more robust to outliers.

Comparison with Other Metrics:

Accuracy, AUC, F1 Score: These metrics are designed for classification tasks, where the goal is to predict discrete labels. They are not suitable for regression problems involving continuous target variables.

Mean Squared Error (MSE): While MSE also measures prediction errors, it squares the differences, giving more weight to larger errors. This can be useful in certain contexts but may be sensitive to outliers.

Conclusion:

For evaluating the performance of a model predicting apartment prices—a continuous variable—MAE is an appropriate and effective metric. It provides a clear indication of the average prediction error in the same units as the target variable, facilitating straightforward interpretation and comparison.

Accuracy measures the proportion of correctly predicted labels (both positive and negative) out of the total predictions. It is the appropriate metric when the goal is to maximize the correct predictions of both positive and negative labels. However, it assumes that the classes are balanced; if the classes are imbalanced, other metrics like precision, recall, or specificity may be more relevant depending on the specific needs.

For cross-account Amazon S3 access, AWS requires two components:

An S3 bucket policy in the owning account (Account A) that grants access to a principal in another account

An IAM role policy in the consuming account (Account B) that allows the service to access the bucket

Amazon SageMaker training jobs assume an IAM role in the account where the job runs—in this case, Account B. Therefore, the IAM policy must be attached to the SageMaker execution role in Account B.

The S3 bucket policy must reside in Account A because bucket policies are owned and enforced by the bucket owner. This policy explicitly allows the IAM role from Account B to read the training data.

Any other combination fails either because the policy is in the wrong account or because the role is not the one used by SageMaker.

AWS documentation clearly describes this pattern as the correct way to grant cross-account access for SageMaker training jobs.

Therefore, Option B is the correct and AWS-aligned solution.