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

AWS Glue DataBrew is specifically designed to provide no-code and low-code data preparation for analytics and machine learning. It supports common file formats such as Apache Parquet and integrates directly with Amazon S3.

Using DataBrew, users can visually create recipes that apply transformations such as one-hot encoding without writing any code. Once the recipe is defined, a DataBrew job can be run to process the dataset and store the transformed output back into Amazon S3.

Options B, C, and D all require writing SQL or code, which violates the no-code requirement. AWS documentation clearly identifies DataBrew as the correct service for interactive, visual data transformation at scale.

Therefore, Option A is the correct solution.

Option D is correct because Amazon SageMaker Model Registry is the AWS feature specifically designed to catalog models, manage model versions, and organize them into model groups. AWS documentation states that you can create a Model Group and then register each model you train, and the Model Registry adds it to the Model Group as a new model version. That directly matches the requirement to automatically create versions of ML models as models are created.

The AWS docs also describe a standard workflow in which you first create a Model Group, then create an ML pipeline, and for each run of the ML pipeline, create a model version that is registered in that group. This means Model Registry supports exactly the kind of lifecycle management and version tracking needed in an MLOps workflow where new model artifacts are produced over time and need consistent governance.

The other options do not meet the requirement. Amazon ECR stores container images, not model version history. SageMaker Marketplace model packages are for discovering or subscribing to third-party or prebuilt solutions, not for automatically versioning your organization’s trained models. SageMaker ML Lineage Tracking helps trace artifacts, datasets, and processing steps for reproducibility, but AWS documentation distinguishes lineage from the actual model version management capability provided by Model Registry. Model Registry is the AWS-native feature for keeping versioned records of trained models and managing approval status, deployment readiness, and metadata in a centralized way.

Therefore, the fully verified AWS-docs answer is D, because SageMaker Model Registry is the service purpose-built to create and manage model versions as new models are produced.

AWS provides Amazon SageMaker Pipelines as the native CI/CD solution for ML. Pipelines can automatically trigger retraining when new data arrives in Amazon S3, handle large datasets (such as 10 GB files), and orchestrate preprocessing, training, evaluation, and deployment steps.

For governance and auditing, Amazon SageMaker Model Registry integrates directly with Pipelines to manage model versions, approval status, and metadata such as training metrics. This combination eliminates the need for custom tracking logic and ensures traceability across the ML lifecycle.

Option A lacks native ML lineage and version governance. Option C is unsuitable for large data and complex workflows. Option D is manual and not scalable.

Therefore, using SageMaker Pipelines with the Model Registry is the correct and AWS-recommended solution.

Logistic regression requires numeric input features and is sensitive to how categorical variables are encoded. AWS feature engineering best practices recommend one-hot encoding for low-cardinality categorical variables with no inherent order and ordinal encoding for categorical variables with a meaningful order.

The location feature has only three distinct values and no ordinal relationship, making one-hot encoding the most appropriate method. This prevents the model from inferring a false numerical relationship between locations.

The job_seniority_level feature typically has an inherent order (for example: junior, mid-level, senior, lead). Even with more than 10 categories, ordinal encoding preserves this natural hierarchy while keeping the feature dimensionality manageable.

Tokenization is used for unstructured text, not structured categorical variables. Standard scaling applies only to continuous numeric features and is not suitable for categorical string variables.

AWS documentation explicitly highlights using one-hot encoding for nominal features and ordinal encoding for ordered categorical features when preparing data for linear models such as logistic regression.

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

Scenario: The dataset contains duplicate records that need to be detected with minimal code development.

Why FindMatches in AWS Glue?

Purpose-Built for Deduplication: The FindMatches transform in AWS Glue is specifically designed to identify duplicate records in structured or semi-structured datasets.

Machine Learning-Based: It uses ML to identify duplicates based on configurable thresholds and provides flexibility for tuning accuracy.

Low Code Overhead: Minimal development effort is required as Glue provides an interactive console for configuring and running FindMatches transforms.

Steps to Implement:

Prepare the Data: Upload the unstructured dataset to an S3 bucket and define a schema if needed.

Create a Glue Job:

Use the AWS Glue Studio to create a job and select the FindMatches transform.

Specify key attributes for deduplication.

Run and Evaluate: Execute the Glue job, and review the results for duplicates.

Resolve Duplicates: Export results to an S3 bucket or process them as needed.

SageMaker script mode allows you to bring existing custom Python scripts and run them on AWS with minimal changes. SageMaker provides prebuilt containers for ML frameworks like PyTorch, simplifying the migration process. This approach enables the company to leverage their existing Python scripts and domain knowledge while benefiting from the scalability and managed environment of SageMaker. It requires the least effort compared to building custom containers or retraining models from scratch.

SageMaker Serverless Inference is ideal for workloads with predictable, intermittent demand. By enabling provisioned concurrency, the model can handle multiple invocations quickly during the high-demand 2-hour period. AWS manages the underlying infrastructure and scaling, ensuring the solution meets performance requirements with minimal operational overhead. This approach is cost-effective since it scales down when not in use.

The model is underperforming in production due to variations in image quality from different cameras. Using the corrupt image transform with the impulse noise option in SageMaker Data Wrangler simulates real-world noise and variations in the training dataset. This approach helps the model become more robust to inconsistencies in image quality, improving its accuracy in production without the need to collect and process new data, thereby saving time.

For near real-time predictions, AWS documentation recommends Amazon SageMaker real-time inference endpoints. These endpoints support automatic scaling based on metrics such as ConcurrentInvocationsPerInstance, ensuring low latency and high availability during traffic spikes.

For long-running historical analysis, SageMaker Processing jobs are the appropriate solution. Processing jobs are designed for batch workloads, can run for hours, and integrate cleanly with SageMaker pipelines. Scheduling them with Amazon EventBridge provides a fully managed, scalable, and serverless solution.

AWS Lambda is unsuitable for multi-hour workloads. EC2 Auto Scaling adds unnecessary infrastructure management overhead.

Therefore, Options A and C together meet all requirements and align with AWS best practices.

A sudden drop in model performance after a long period of stability is a classic indicator of data drift. According to AWS ML documentation, production data distribution drift occurs when the statistical properties of incoming data change over time compared to the training dataset.

This drift can be caused by changes in user behavior, market conditions, seasonal trends, or upstream data pipelines. When drift occurs, the model’s learned patterns no longer align with real-world data, leading to degraded accuracy and other performance metrics.

Lack of training data (Option A) and overfitting (Option D) are issues that typically manifest during initial training, not after months of stable production performance. Compute constraints (Option C) may affect latency but do not usually cause sustained accuracy degradation.

AWS recommends using SageMaker Model Monitor to detect such drift and trigger retraining workflows.

Therefore, drift in the production data distribution is the most likely cause of the observed performance degradation.

Option A is correct because AWS documentation states that regularization helps prevent linear models from overfitting, and specifically that L1 regularization reduces the number of features used in the model by pushing small feature weights to zero. AWS further explains that L1 regularization produces sparse models and reduces noise. That is the exact combination needed in this scenario: the model is overfitting, and the data contains unnecessary features whose impact should be reduced.

AWS guidance on overfitting also says that to reduce model overfitting, you should reduce model flexibility by using feature selection and increasing the amount of regularization. L1 regularization is especially suitable here because it does both in practice: it acts as a regularizer and also effectively performs feature selection by shrinking unhelpful feature coefficients to zero. Even though the option wording says “apply L1 regularization to the training data,” the only answer choice that aligns with AWS-documented techniques for both overfitting reduction and unnecessary-feature suppression is L1 regularization with retraining.

The other options do not meet both requirements. SageMaker Debugger monitors and helps analyze training jobs, but it is not the feature that “applies L1 regularization” to a running model. Increasing training iterations can make overfitting worse, not better. Decreasing training iterations may reduce overfitting in some cases, but it does not specifically address the presence of unnecessary features. Therefore, the AWS-aligned choice that best reduces overfitting and the impact of irrelevant features is A.

The target_precision hyperparameter in the Amazon SageMaker linear learner controls the trade-off between precision and recall for the model. Increasing the target_precision prioritizes minimizing false positives by making the model more cautious in its predictions. This approach is effective for use cases where false positives have higher consequences than false negatives.

AWS Secrets Manager is designed for securely storing, managing, and automatically rotating secrets, including API tokens. By configuring a Lambda function for custom rotation logic, the solution can automatically rotate the API tokens every 3 months as required. Secrets Manager simplifies secret management and integrates seamlessly with other AWS services, making it the ideal choice for this use case.

The AWS::SageMaker::Model resource in AWS CloudFormation is used to create an ML model in Amazon SageMaker. This model can then be hosted on an endpoint by using the AWS::SageMaker::Endpoint resource. The model resource defines the container or algorithm to use for hosting and the S3 location of the model artifacts.

The requirement has two key constraints: detect class imbalance and balance classes without losing any existing data. AWS provides Amazon SageMaker Clarify as the native tool to detect pre-training bias, including class imbalance (CI). CI measures differences in label distributions between classes, and a CI value greater than 0 indicates imbalance.

Once imbalance is detected, the engineer must rebalance the dataset without discarding data. Random undersampling would remove samples from the majority class, violating the requirement. Instead, oversampling is required. SMOTE (Synthetic Minority Oversampling Technique) creates synthetic samples for the minority class, preserving all original data while improving class balance.

Amazon SageMaker Data Wrangler natively supports SMOTE, making it the correct AWS-managed tool for this preprocessing task.

Options C and D are incorrect because SageMaker JumpStart is used for pretrained models and solutions, not for bias detection reporting. Option A is incorrect because it uses undersampling and misinterprets CI = 0 (which actually indicates no imbalance).

Therefore, detecting imbalance with SageMaker Clarify and correcting it using SMOTE in Data Wrangler is the correct solution.

AWS documentation strongly recommends using columnar storage formats to optimize analytical query performance on large datasets stored in Amazon S3. Apache Parquet is a columnar, compressed, and splittable file format that significantly improves query speed and reduces I/O compared to row-based formats such as CSV.

By using AWS Glue to convert CSV files into Parquet format, the company can achieve faster query execution with minimal operational overhead. Glue is fully managed, serverless, and integrates natively with S3, Amazon Athena, and Amazon Redshift Spectrum.

Option A does not improve query efficiency; splitting files still leaves the data in an inefficient row-based format. Option B may reduce data size but does not address the fundamental inefficiency of CSV for analytics. Option D introduces significant operational overhead because Amazon EMR requires cluster provisioning, scaling, and maintenance.

Therefore, converting CSV files to Apache Parquet using AWS Glue ETL is the most efficient and low-maintenance solution.

Amazon SageMaker Asynchronous Inference is specifically designed for long-running inference requests and large payloads. It supports payload sizes up to 1 GB and processing times of up to 1 hour, while automatically queuing requests.

Asynchronous inference stores results in Amazon S3 and allows clients to retrieve inference outputs after processing completes. It also supports auto scaling down to zero when there are no incoming requests, reducing cost.

Batch transform is intended for offline, bulk inference and does not return per-request results in an asynchronous request–response pattern. Serverless and real-time inference have strict payload size and timeout limits that do not support 1-hour processing.

Therefore, asynchronous inference is the only SageMaker inference option that meets all stated requirements.

Step 1:

The company commits code changes or new training datasets to a Git repository.

This is the trigger point. A source code or data change initiates the CI/CD pipeline.

Step 2:

CodePipeline detects code changes and starts to build automatically.

CodePipeline monitors the Git repository (for example, AWS CodeCommit, GitHub, or Bitbucket) and automatically triggers the pipeline when changes are detected.

Step 3:

The company builds and deploys ML models and applications to staging servers for testing.

The pipeline runs build, training, and test stages (often using AWS CodeBuild and SageMaker) and deploys artifacts to a staging or test environment for validation.

Step 4:

Human approval is provided after testing is successful.

A manual approval action is a best practice for ML workflows to ensure governance, compliance, and quality checks before production deployment.

Step 5:

CodePipeline deploys ML models and applications to production.

After approval, the pipeline automatically deploys the validated model or application to the production environment.

AWS Glue is a serverless data integration service that is well-suited for creating data ingestion pipelines, especially when raw data is stored in Amazon S3. It can clean, transform, and catalog data, making it accessible for downstream ML tasks.

Amazon SageMaker Studio Classic provides a comprehensive environment for building, training, and deploying ML models. It includes built-in tools and capabilities to create efficient model deployment pipelines with minimal setup.

This combination ensures seamless integration of data ingestion and ML model deployment with minimal operational overhead.