Amazon Web Services MLA-C01 AWS Certified Machine Learning Engineer - Associate Exam Practice Test

Dynamic data masking allows you to control how sensitive data is presented to users at query time, without modifying or storing transformed versions of the source data. Amazon Redshift supports dynamic data masking, which can be implemented with minimal effort. This solution ensures that the data scientist can access the required information while sensitive data remains protected, meeting the requirements efficiently and with the least implementation effort.

Managing permissions for multiple Amazon SageMaker notebook instances can become complex when handled individually. To centralize and streamline permission management, AWS recommends creating a single IAM role with the necessary permissions and attaching this role to each notebook instance used by the data science team.

Steps to Implement the Solution:

Create a Single IAM Role with Necessary Permissions:

Define an IAM role that encompasses all permissions required by the data scientists for their tasks. This includes permissions for SageMaker operations and any other AWS services they interact with.

AWS provides managed policies like AmazonSageMakerFullAccess that can be attached to the role to grant comprehensive SageMaker permissions.(IAM Policies for SageMaker)

Attach the IAM Role to Each Notebook Instance:

When creating or updating a SageMaker notebook instance, specify the IAM role created in the previous step. This ensures that all notebook instances operate under a consistent set of permissions.

In the SageMaker console, during the notebook instance setup, you can choose an existing IAM role to associate with the instance.(Creating SageMaker Workspaces)

Benefits of This Approach:

Centralized Permission Management:By using a single IAM role, you simplify the process of updating permissions. Changes to the role ' s policies automatically propagate to all associated notebook instances, ensuring consistent access control.

Adherence to Best Practices:AWS recommends using IAM roles to manage permissions for applications running on services like SageMaker. This approach avoids the need to manage individual user permissions separately.(IAM Best Practices for SageMaker)

Alternative Options and Their Drawbacks:

Option B: Creating a single IAM group and adding data scientists to it does not directly associate the group with notebook instances. IAM groups are used to manage user permissions, not to assign roles to AWS resources like notebook instances.

Option C: Using a single IAM user with the AdministratorAccess policy is not recommended due to security risks associated with granting broad permissions and the challenges in managing shared user credentials.

Option D: Associating an IAM group with a role and then with notebook instances is not a valid approach, as IAM groups cannot be directly associated with AWS resources.

Conclusion: Option A is the most effective solution to centralize and manage permissions for SageMaker notebook instances, aligning with AWS best practices for IAM role management.

Amazon SageMaker supports direct file system access for training jobs through Amazon FSx. AWS documentation states that FSx for NetApp ONTAP file systems can be mounted directly to SageMaker training instances when they are located in the same VPC.

Mounting the FSx file system allows SageMaker to stream large datasets efficiently without copying data into Amazon S3. This is ideal for very large datasets such as 6 TB of image data and avoids unnecessary storage duplication.

Options involving SageMaker Data Wrangler are intended for data preparation and exploration, not large-scale training data access. Mountpoint for Amazon S3 is not required and introduces additional complexity.

Therefore, Option A is the correct and AWS-aligned 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.

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.

Linear regression model whose coefficients should shrink but not become zero

Answer: L2 regularization

AWS says L2 produces smaller overall weight values and is the right fit when coefficients should be reduced without being forced to zero.

Polynomial regression model with irrelevant polynomial terms that should be eliminated

Answer: L1 regularization

AWS says L1 reduces the number of features used by pushing small weights to zero, which matches elimination of irrelevant terms.

Logistic regression model that has highly correlated features to eliminate highly redundant predictors

Answer: L1 regularization

This is the nuanced one. AWS says L2 stabilizes weights when there is high correlation between features, but because the question explicitly says eliminate highly redundant predictors, L1 is the better match since it creates sparsity and removes predictors by zeroing coefficients.

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.

Using custom tags allows you to organize and categorize models in the SageMaker Model Registry without altering their existing groupings or affecting the integrity of the model artifacts. Tags are a lightweight and scalable way to improve model discoverability at scale, enabling the data scientists to filter and identify models by category (e.g., computer vision, NLP, speech recognition). This approach meets the requirements efficiently without introducing structural changes to the existing model registry setup.

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.

AWS ML best practices state that data preprocessing applied during training must be applied identically during inference. For min-max normalization, this requires reusing the minimum and maximum values calculated from the training dataset.

If production data is normalized using different statistics, the feature distributions will differ from what the model learned, leading to degraded prediction accuracy. AWS documentation explicitly warns against recomputing normalization parameters on inference data.

Options A, C, and D introduce data leakage or inconsistent feature scaling. Option B ensures consistency between training and inference pipelines and preserves model integrity.

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

For Amazon EMR, the primary node and core nodes handle the critical functions of the cluster, including data storage (HDFS) and processing. Running them on On-Demand Instances ensures high availability and prevents data loss, as Spot Instances can be interrupted. The task nodes, which handle additional processing but do not store data, can use Spot Instances to reduce costs without compromising the cluster ' s resilience or data integrity. This configuration balances cost-effectiveness and reliability.

Amazon SageMaker Automatic Model Tuning extracts objective metrics directly from training logs. For custom containers, AWS requires the ML engineer to define a metric definition that specifies a regular expression to parse the desired metric value from standard output.

The ObjectiveMetricName in the tuning job must match the metric captured by the regex. This is the only supported method for integrating custom metrics with SageMaker AMT.

TrainingInputMode does not define metrics. CloudWatch metrics cannot be used as tuning objectives. AMT cannot read metrics from S3 artifacts.

AWS documentation explicitly states that regex-based metric definitions are required for custom metrics in hyperparameter tuning jobs.

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

The large gap between training accuracy (99%) and validation accuracy (82%) is a textbook case of overfitting. The model has learned patterns that fit the training data extremely well but do not generalize to unseen data.

AWS ML best practices recommend regularization techniques to address overfitting. Dropout layers randomly deactivate neurons during training, preventing the network from relying too heavily on specific paths. L1 and L2 regularization penalize large weights, reducing model complexity and improving generalization. k-fold cross-validation provides a more robust evaluation by training and validating the model across multiple data splits.

Option A increases complexity, which would worsen overfitting. Option C mixes valid ideas (dimensionality reduction) with unrelated changes (loss function choice) and is less targeted. Option D focuses on data quality but does not directly address model variance.

Therefore, implementing dropout, regularization, and k-fold cross-validation is the correct solution.

Amazon Kendra is an AI-powered search service designed for semantic search use cases. It allows ingestion of documents from an Amazon S3 bucket using the Amazon Kendra S3 connector. Once the documents are ingested, Kendra enables semantic searches with its built-in capabilities, removing the need to manually generate embeddings or manage a vector database. This approach is efficient, requires minimal operational effort, and meets the requirements for a Retrieval Augmented Generation (RAG) application.

AWS documentation identifies Amazon SageMaker Clarify as the primary service for detecting, measuring, and explaining bias in ML models, particularly across demographic and sensitive attributes such as age, gender, and location. Clarify can analyze bias before training, after training, and during inference, making it suitable for audit and compliance requirements.

SageMaker Clarify generates bias reports using established fairness metrics such as difference in positive proportions, disparate impact, and conditional demographic disparity. These reports are exportable and auditor-friendly, directly meeting the requirement to explain bias to an external party.

AWS Glue DataBrew focuses on data preparation and quality, not bias detection. Amazon QuickSight does not provide ML fairness metrics. Amazon CloudWatch captures operational metrics, not demographic bias indicators.

AWS best practices explicitly recommend SageMaker Clarify for model transparency, fairness evaluation, and regulatory reporting.

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

In AWS networking, security groups are stateful and allow-only, meaning they cannot explicitly deny traffic. As a result, Option A is invalid. Network ACLs (NACLs), on the other hand, are stateless and support both allow and deny rules, making them the correct mechanism for blocking traffic from specific IP addresses.

Because the SageMaker AI domain is deployed in a public subnet, inbound traffic reaches the subnet before it reaches the resource. AWS documentation states that NACLs are evaluated at the subnet level and are ideal for implementing IP-based blocking rules.

Route tables control routing paths, not traffic filtering, so Option D is incorrect. Option C is unrelated to network security and does not block traffic.

AWS best practices clearly recommend using network ACL deny rules when an explicit block is required for a specific IP address at the subnet boundary.

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

Amazon Q Business allows configuring blocked phrases to exclude specific terms or phrases from the responses. By adding the competitor ' s name as a blocked phrase, the company can ensure that it will not appear in the API responses, meeting the requirement efficiently with minimal configuration.

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.

Bias detection is a critical step in responsible machine learning and is emphasized in AWS documentation, particularly in Amazon SageMaker Clarify. When analyzing structured datasets that include sensitive or influential attributes such as age, AWS recommends evaluating label distribution fairness and group-based outcome differences before training a model.

The class imbalance metric helps identify whether certain outcomes (for example, purchase vs. no purchase) are overrepresented or underrepresented. Severe imbalance can cause models to favor majority classes, leading to biased predictions. AWS explicitly highlights class imbalance as a key issue to assess during data exploration.

The Difference in Proportions of Labels (DPL) is a fairness metric supported by SageMaker Clarify that measures whether outcome labels are disproportionately distributed across different groups, such as age ranges. DPL compares the proportion of favorable outcomes between groups, making it especially effective for identifying demographic bias in categorical labels.

Options A and D focus on descriptive statistics or correlations, which are useful for data understanding but do not directly measure bias or fairness. Option B partially addresses imbalance and sentiment but sentiment analysis of reviews alone does not quantify demographic bias tied to outcomes.

AWS documentation strongly recommends using group fairness metrics, including DPL, alongside class imbalance checks to identify bias before training. These metrics provide actionable insights into whether a dataset may lead to unfair or skewed model behavior.

Therefore, Option C is the most appropriate and AWS-aligned choice.

This issue occurs because target tracking auto scaling allows the endpoint to scale down to zero, and scaling up only happens after traffic arrives. At the start of the business day, no instances are running, so the first requests experience cold-start delays.

AWS documentation for Amazon SageMaker recommends using scheduled or step scaling policies when predictable traffic patterns exist. In this case, business hours are predictable, so the best practice is to proactively scale the endpoint before traffic arrives.

Option D correctly uses Amazon CloudWatch alarms with step scaling to increase the minimum instance count from zero to one at the start of the business day. This ensures at least one warm instance is ready to handle requests immediately, eliminating startup latency.

Options A, B, and C do not guarantee instance availability before traffic begins. Cooldown tuning and metric changes only react after load is detected.

Therefore, scheduled step scaling using CloudWatch alarms 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.

Early stopping halts training once the performance on the validation dataset stops improving. This prevents the model from overfitting, which is likely the cause of performance degradation after a certain number of epochs.

Dropout is a regularization technique that randomly deactivates neurons during training, reducing overfitting by forcing the model to generalize better. Increasing dropout can help mitigate the problem of performance degradation due to overfitting.

One-hot encoding is the appropriate technique for transforming categorical data, such as color information, into a format suitable for input to a neural network. This technique creates a binary vector representation where each unique category (color) is represented as a separate binary column, ensuring that the model does not infer ordinal relationships between categories. This approach preserves the categorical nature of the data and avoids introducing unintended biases.

Callback steps in Amazon SageMaker Pipelines allow you to integrate external processes, such as AWS Glue jobs, into the pipeline workflow. By using a Callback step, the SageMaker pipeline can trigger the AWS Glue workflow and pause execution until the Glue jobs complete. This approach provides seamless integration with minimal operational overhead, as it directly ties the pipeline ' s execution flow to the completion of the AWS Glue jobs without requiring additional orchestration tools or complex setups.

The temperature parameter controls the randomness in the model ' s responses. Lowering the temperature makes the model produce more deterministic and consistent answers.

The top_k parameter limits the number of tokens considered for generating the next word. Reducing top_k further constrains the model ' s options, ensuring more predictable responses.

By decreasing both parameters, the responses become more focused and consistent, reducing variability in similar queries.

Logistic regression is a suitable modeling approach for this requirement because it is designed for binary classification problems, such as predicting whether a customer will require long-term support ( " yes " or " no " ). It calculates the probability of a particular class and is widely used for tasks like this where the outcome is categorical.

This scenario describes a severely imbalanced classification problem. In such cases, accuracy is a misleading metric, because the model can achieve high accuracy by predicting only the majority class.

AWS ML best practices recommend using F1 score (or precision/recall) when evaluating imbalanced datasets. The F1 score balances false positives and false negatives, making it ideal for assessing minority-class performance.

For image data, image augmentation (rotations, flips, crops, color jitter) is the preferred technique to increase minority-class representation. SMOTE is designed for tabular data and is not suitable for image pixel data.

Therefore, the correct solution is to optimize for F1 score and apply image augmentation.

Thus, Option B is the correct and AWS-aligned answer.

Predicting apartment prices is a regression problem, where the target variable is continuous. AWS documentation states that classification metrics such as accuracy, AUC, and F1 score are not appropriate for regression tasks.

Mean Absolute Error (MAE) measures the average absolute difference between predicted values and actual values. MAE is easy to interpret because it is expressed in the same units as the target variable (for example, dollars), making it especially useful for business-facing problems like price prediction.

AWS best practices recommend MAE for evaluating regression models when understanding average prediction error magnitude is important and when robustness to outliers is desired.

Therefore, Option D is the correct and AWS-aligned answer.

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.

S3 Gateway Endpoint: Allows private access to S3 from within a VPC without requiring a public IPv4 address, ensuring that data transfer between the primary and secondary accounts is secure and private.

Bucket Policy Update: The S3 bucket policy in the secondary account must explicitly allow access from the primary account ' s IAM principals to provide the necessary permissions.

Interface VPC Endpoints: Required for private communication between the VPC and Amazon SageMaker and Amazon Redshift services, ensuring the solution operates without public internet access.

This configuration meets the requirement to avoid public IPv4 addresses and allows secure and private communication between the accounts.

Amazon Q Business provides built-in guardrails to control and constrain model responses. One such control is the ability to define blocked phrases, which explicitly prevents specified terms from appearing in generated responses.

Configuring the competitor’s name as a blocked phrase guarantees that Amazon Q Business will never include that name in responses, fully meeting the requirement. This approach is deterministic and does not rely on ranking or retrieval behavior.

Option B is incorrect because retrievers control what documents are fetched, not how responses are generated. Option C adds unnecessary complexity and does not guarantee exclusion in generated answers. Option D only deprioritizes content and does not prevent it from appearing.

Therefore, blocking the competitor’s name is the correct solution.

Option B is correct because the bank needs a SageMaker-supported algorithm and the resulting model must be explainable for regulators. AWS documentation states that the Amazon SageMaker AI linear learner algorithm is a built-in algorithm that provides a solution for classification and regression problems. Since determining whether customers qualify for a new product is a classification-style decision problem, linear learner fits the business requirement directly.

The explainability requirement strongly favors a simpler and more interpretable model family. AWS Prescriptive Guidance on model interpretability states that simple models are considered more interpretable because the effects of input features on the output are easier to understand. It specifically gives linear regression as an example where the magnitudes of coefficients provide a clear global feature-importance signal. While the question does not explicitly mention SageMaker Clarify, AWS documentation also says SageMaker offers explainability features to help interpret predictions, which complements inherently interpretable model types such as linear models.

The other options are weaker fits. Object2Vec is mainly for learning embeddings and similarity relationships rather than a straightforward explainable eligibility model. A neural network may work technically, but it is generally less interpretable for regulatory review. k-means is an unsupervised clustering algorithm and is not suitable for predicting whether a customer qualifies for a product. Because the bank wants a directly supported SageMaker algorithm and a model that is easier to explain to regulators, the best AWS-aligned answer is B, linear learner.

City (name): One-hot encoding

Type_year (type of home and year the home was built): Feature splitting

Size of the building (square feet or square meters): Standardized distribution

City (name): One-hot encoding

Why? The " City " is a categorical feature (non-numeric), so one-hot encoding is used to transform it into a numeric format. This encoding creates binary columns for each unique category (e.g., cities like " New York " or " Los Angeles " ), which the model can interpret.

Type_year (type of home and year the home was built): Feature splitting

Why? " Type_year " combines two pieces of information into one column, which could confuse the model. Feature splitting separates this column into two distinct features: " Type of home " and " Year built, " enabling the model to process each feature independently.

Size of the building (square feet or square meters): Standardized distribution

Why? Size is a continuous numerical variable, and standardization (scaling the feature to have a mean of 0 and a standard deviation of 1) ensures that the model treats it fairly compared to other features, avoiding bias from differences in feature scale.

By applying these feature engineering techniques, the ML engineer can ensure that the input data is correctly formatted and optimized for the model to make accurate predictions.

AWS Compute Optimizer analyzes the resource usage of Amazon EC2 instances, ECS services, Lambda functions, and Amazon EBS volumes. It provides actionable recommendations to optimize resource utilization and reduce costs, such as resizing instances, moving workloads to Spot Instances, or changing volume types. This solution requires the least development effort because Compute Optimizer is a managed service that automatically generates insights and recommendations based on historical usage data.

AWS Key Management Service (AWS KMS) is the recommended service for encryption and key access control. By creating a customer-managed KMS key, the company can define granular IAM policies that control which applications and roles can use the key.

The AWS Encryption CLI integrates directly with KMS and enables client-side encryption of files before storing them in Amazon S3. This approach ensures data is encrypted at rest and that only authorized principals can decrypt it.

SSH keys and API keys are not designed for data encryption. IAM roles alone do not create or manage encryption keys—they only grant permissions.

AWS documentation explicitly states that KMS customer-managed keys provide centralized key management, auditing, and access control.

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

To generate images, the application must invoke a foundation model hosted on Amazon Bedrock. Invoking the Amazon Titan Image Generator requires the bedrock:InvokeModel permission. Read-only permissions such as bedrock:Get* do not allow inference execution and are insufficient.

The application also interacts with Amazon Simple Queue Service. To process messages, the application must be able to receive messages from the queue and delete them after successful processing. These actions require sqs:ReceiveMessage and sqs:DeleteMessage.

sqs:GetQueueAttributes alone does not allow message consumption. SageMaker permissions are unrelated because Bedrock is a separate service.

Therefore, permissions to invoke the model and receive/delete SQS messages are required.

This problem describes severe class imbalance in an image classification task, where the minority class has poor predictive performance. In such cases, accuracy is a misleading metric, because a model can achieve high accuracy by predicting only the majority class. AWS ML best practices recommend using F1 score, which balances precision and recall and is more appropriate for imbalanced classification problems.

To improve performance on the minority image class, image augmentation is the preferred approach. Augmentation techniques—such as rotation, cropping, flipping, and brightness adjustment—create realistic new training examples while preserving semantic meaning. AWS documentation recommends augmentation for computer vision workloads to improve generalization without collecting new data.

SMOTE (Options C and D) is designed for tabular data, not image data, and generating synthetic pixel-level images using SMOTE is not appropriate or supported in typical computer vision pipelines.

Option A is incorrect because optimizing for accuracy does not address minority-class performance. Option D is incorrect because SMOTE is unsuitable for images.

Therefore, optimizing for F1 score and using image augmentation on the minority class is the correct solution.

The correct answer is C. Download the training data to the estimator by using fast file mode. Point the data loader to the location specified by the S3 path.

When training neural network models in Amazon SageMaker, I/O operations can become a bottleneck, especially when reading large datasets directly from S3. SageMaker provides a fast file mode that allows the training job to cache data locally on the compute instance before training. This significantly reduces data-loading latency, as the model can access the data from local storage instead of repeatedly fetching it over the network from S3.

Fast file mode automatically handles staged caching of S3 data in the container’s file system or attached EBS volumes, ensuring that the estimator sees high-throughput access to the dataset. This approach improves overall training speed without requiring manual configuration of EBS or EFS volumes.

Option A, provisioning EBS with io1 storage, may increase I/O performance but requires manual copying of the data and adds operational complexity. Option B, using EFS, introduces network-based I/O overhead and is not optimized for high-throughput sequential reads, which are typical in neural network training. Option D, changing the S3 path to a hyperparameter, has no effect on I/O performance or data-loading speed—it is merely a way to pass metadata to the training job.

Using fast file mode is AWS-recommended when profiling shows that training is bottlenecked by data access. It provides a managed, high-throughput, low-latency caching layer, allowing ML engineers to focus on model architecture and hyperparameter tuning rather than data transfer optimizations. This aligns with best practices for ML model development by reducing training time while maintaining scalability and simplicity in SageMaker training workflows.

Shadow testing allows you to send a copy of live production traffic to a shadow variant of the new model while keeping the existing production model unaffected. This enables you to evaluate the performance of the new model in real-time with live data without impacting end users. SageMaker endpoints support this setup by allowing traffic mirroring to the shadow variant, making it an ideal solution for assessing the new model ' s performance.

Option A is correct because Amazon Rekognition provides a built-in EyeDirection attribute that indicates the direction a person’s eyes are gazing, expressed through pitch and yaw. AWS documentation describes EyeDirection as showing where the eyes are looking independently of head pose. For a driver-monitoring use case, this is directly useful for identifying whether a driver is looking away from the road and may be distracted.

AWS also announced that Rekognition’s eye gaze direction detection is intended to support safety use cases and to help identify where users focus their attention. That makes it a strong match for monitoring in-vehicle cameras for distraction detection. Because Rekognition is a fully managed service with ready-to-use computer vision capabilities, it requires far less operational effort than collecting data, labeling it, training a custom model in SageMaker, and maintaining that model over time.

The other options are less appropriate. Option B could work technically, but building and maintaining a custom SageMaker model would require significantly more engineering and operational work than using a managed Rekognition feature. Option C introduces unnecessary complexity by adding a third-party system when AWS already provides a directly relevant managed capability. Option D is unrelated because Amazon Comprehend analyzes text, while the input here is camera footage. Since the question asks for the solution with the least operational effort, the best AWS-aligned answer is to use the managed Rekognition eye gaze detection capability. Therefore, the fully verified answer is A.

Adding resource tagging to the SageMaker user profile enables tracking and monitoring of costs associated with specific SageMaker resources.

AWS Budgets allows setting thresholds and automated alerts for costs and usage, making it the ideal service to notify the ML engineer when compute costs reach a specified limit.

This solution is efficient and integrates seamlessly with SageMaker and AWS cost management tools.

AWS Glue DataBrew is designed specifically for no-code and low-code data preparation, making it the fastest and lowest-overhead solution for resolving common data quality issues. DataBrew provides built-in transformations for deduplication, missing value imputation, and outlier handling while preserving data integrity.

Option A uses standard statistical techniques such as median imputation and value normalization, which are widely accepted and maintain the distribution of the data. DataBrew jobs are fully managed and do not require infrastructure setup or maintenance.

Option B deletes records, which can lead to data loss and does not preserve integrity. Option C introduces unnecessary infrastructure complexity and uses poor data imputation practices. Option D provides advanced capabilities but requires more configuration and ML expertise, increasing operational overhead.

AWS documentation clearly positions DataBrew as the preferred solution for quick, reliable data cleaning with minimal effort.

Therefore, Option A is the correct answer.

Option A is correct because AWS Glue is the AWS-native managed ETL service built specifically to discover schema, run ETL jobs, and store metadata in the AWS Glue Data Catalog. AWS documentation states that Glue crawlers can automatically discover and catalog new or updated data sources, and that the Data Catalog automatically captures and manages schema metadata. This directly matches the requirement to run an ETL job on data in Amazon S3, discover the schema, and store the metadata with the least manual effort.

AWS Glue is also the lowest-effort answer because the service is managed and purpose-built for this workflow. The Glue Data Catalog serves as a persistent metadata repository, and AWS documents that crawlers infer schema information and integrate it into the catalog automatically. That means the ML engineer does not need to build custom schema inference logic or manually maintain metadata storage. This is exactly the kind of manual work the question is trying to avoid.

The other options are not as good. SageMaker Data Wrangler is primarily for visual data preparation and feature engineering, not for running a managed ETL-plus-catalog workflow with schema stored in a metadata catalog. Athena with Step Functions would require assembling more custom orchestration and still does not naturally replace the Glue Data Catalog workflow. Launching an EC2 instance introduces the highest operational overhead and does not align with the requirement for least manual effort. Therefore, the best verified AWS-docs answer is A, because AWS Glue combines ETL, schema discovery, and metadata cataloging in one managed service.

AWS strongly recommends converting large CSV datasets into columnar formats such as Apache Parquet to improve query performance. Parquet reduces I/O by reading only the required columns and applies compression, which significantly speeds up analytics workloads.

AWS Glue ETL jobs provide a fully managed, serverless way to perform this conversion with minimal operational overhead. Once converted, the Parquet files can be queried efficiently by services such as Amazon Athena, Redshift Spectrum, and SageMaker processing jobs.

Splitting CSV files does not address inefficient storage format. Dropping columns risks data loss. Amazon EMR introduces infrastructure management overhead and is unnecessary for a straightforward format conversion.

AWS documentation clearly identifies CSV-to-Parquet conversion using Glue ETL as a best practice for scalable analytics.

Therefore, Option C is the correct answer.

Tag model packages and use model package groups that include container images for training and deployment → SageMaker Model Registry

Store predefined language packages, kernels, and relevant dependencies → Amazon Elastic Container Registry (Amazon ECR)

Organize models and their images into model groups for better discoverability → SageMaker Model Registry

Pull built-in SageMaker AI images for model training → Amazon Elastic Container Registry (Amazon ECR)

The correct hotspot mapping is based on the different purposes of SageMaker Model Registry and Amazon ECR.

For model packages, model package groups, and model discoverability, the correct choice is SageMaker Model Registry. AWS documentation states that a model package group is a collection of versioned model packages, and each version can contain the model artifacts, metadata, and container information used for deployment. AWS also documents that registered models can be organized into groups to support governance, discoverability, and lifecycle management. That is why both “tag model packages and use model package groups” and “organize models and their images into model groups” map to SageMaker Model Registry.

For storing software environments and pulling training images, the correct choice is Amazon ECR. AWS documentation says SageMaker uses Docker container images, and these images contain the software stack such as frameworks, language packages, kernels, and dependencies. AWS also states that SageMaker provides prebuilt Docker images for training and inference, and these are referenced through Amazon ECR image URIs. Therefore, both “store predefined language packages, kernels, and relevant dependencies” and “pull built-in SageMaker AI images for model training” map to Amazon ECR.

Amazon SageMaker Model Registry is a feature designed to manage machine learning (ML) models throughout their lifecycle. It allows users to catalog, version, and deploy models systematically, ensuring efficient model governance and management.

Key Features of SageMaker Model Registry:

Centralized Cataloging: Organizes models into Model Groups, each containing multiple versions.

Version Control: Maintains a history of model iterations, making it easier to track changes.

Metadata Association: Attach metadata such as training metrics and performance evaluations to models.

Approval Status Management: Allows setting statuses like PendingManualApproval or Approved to ensure only vetted models are deployed.

Seamless Deployment: Direct integration with SageMaker deployment capabilities for real-time inference or batch processing.

Implementation Steps:

Create a Model Group: Organize related models into groups to simplify management and versioning.

Register Model Versions: Each model iteration is registered as a version within a specific Model Group.

Set Approval Status: Assign approval statuses to models before deploying them to ensure quality control.

Deploy the Model: Use SageMaker endpoints for deployment once the model is approved.

Benefits:

Centralized Management: Provides a unified platform to manage models efficiently.

Streamlined Deployment: Facilitates smooth transitions from development to production.

Governance and Compliance: Supports metadata association and approval processes.

By leveraging the SageMaker Model Registry, the company can ensure organized management of models, version control, and efficient deployment workflows with minimal operational overhead.

AWS Documentation: SageMaker Model Registry

AWS Blog: Model Registry Features and Usage

Amazon SageMaker AI automatically collects aggregated metadata from training jobs to improve service reliability, performance, and operational insights. This metadata can include information such as algorithm usage, instance types, resource utilization, and job configuration details. However, AWS documentation clearly states that customers can opt out of SageMaker metadata collection to meet regulatory or compliance requirements.

SageMaker provides a supported mechanism to disable metadata tracking at the training job level. By explicitly opting out of metadata tracking when submitting training jobs—either through the AWS Management Console, AWS CLI, or SDK—the service will stop collecting aggregated metadata for those jobs. This option is specifically designed for customers with strict compliance, data residency, or regulatory constraints.

Option B is incorrect because running training jobs in a private subnet within a custom VPC controls network isolation, not service-level telemetry or metadata collection. Metadata collection occurs at the SageMaker service layer and is independent of VPC configuration.

Option C is also incorrect because encrypting training data with a customer-managed AWS KMS key protects data at rest and in transit but does not prevent SageMaker from collecting operational metadata about training jobs.

Option D is incorrect because AWS Nitro instances provide enhanced security and performance isolation at the infrastructure level but have no impact on SageMaker’s metadata collection mechanisms.

Therefore, opting out of metadata tracking for training jobs is the only solution that directly addresses the compliance requirement and is explicitly supported by AWS documentation.

Amazon FSx for Lustre is designed for high-performance workloads like ML training. It provides fast, low-latency access to data by linking directly to the existing S3 bucket and caching frequently accessed files locally. This significantly improves training performance compared to directly accessing millions of files from S3. It requires minimal changes to the training job and avoids the overhead of transferring or restructuring data, making it the fastest and most efficient solution.

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.

To pinpoint inefficiencies inside a training script, AWS recommends using Amazon SageMaker Profiler. SageMaker Profiler provides fine-grained visibility into CPU, GPU, memory, I/O usage, and framework-level operations during training.

By adding profiler annotations directly to the training script, the ML engineer can identify bottlenecks such as inefficient data loading, synchronization delays in DDP, or idle GPU time between training steps.

CloudWatch metrics provide high-level utilization trends but cannot identify exact code-level inefficiencies. CloudTrail is an auditing service and is irrelevant to performance profiling. Model Monitor focuses on data and model quality, not training resource utilization.

Therefore, SageMaker Profiler is the correct tool.

The requirement that each parameter trial is built based on the performance of the previous trial is the defining characteristic of Bayesian optimization. In Amazon SageMaker Automatic Model Tuning, Bayesian optimization uses prior trial results to intelligently select the next set of hyperparameters, making it far more efficient than grid or random search—especially in large, mixed search spaces.

This scenario includes both categorical (20) and continuous (7) hyperparameters and allows up to 1,000 training jobs, which is well within the supported limits of SageMaker AMT. Bayesian optimization natively supports mixed parameter types and is explicitly recommended by AWS for large, high-dimensional search spaces where exhaustive grid search is impractical.

Option A and D (grid search) do not meet the requirement because grid search evaluates combinations independently and does not learn from previous trials. Additionally, grid search becomes computationally infeasible as dimensionality increases.

Option B (random search) also evaluates trials independently and does not leverage previous results, violating the core requirement.

Therefore, defining both categorical and continuous parameters and using Bayesian optimization with a maximum of 1,000 jobs is the correct and AWS-recommended solution.

Option A is correct because Amazon SageMaker Feature Store is the AWS service designed to act as a centralized repository for ML features that are used consistently across training and inference. AWS documentation states that SageMaker Feature Store simplifies how you create, store, share, and manage features for data exploration, model training, and model inference. This directly matches the requirement to create a repository for streamed song ratings that will be used in both batch training and real-time inference.

The most important requirement in the question is that the data must stay synchronized between batch training and real-time inference. AWS documents explain that Feature Store provides both an offline store and an online store. The offline store is used for historical data, model training, and batch inference, while the online store is a low-latency, high-availability store intended for real-time lookup during inference. This dual-store design is exactly why Feature Store is used to maintain feature consistency across training and serving workflows. AWS Well-Architected guidance also explicitly says Feature Store provides online storage for real-time inference and offline storage for model training and batch inference.

The other options do not solve the full problem. Athena CTAS can organize query results but does not provide a synchronized feature repository for online and offline ML use. Lake Formation governs access to data lakes but is not a feature repository for training and inference consistency. Data Wrangler Generate Data Insights is for analysis and preparation, not synchronized feature serving. Therefore, the best AWS-documented answer is A.

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.

Step 1

Create an IAM role for Amazon Redshift to use to access the Data Catalog and the S3 bucket that contains underlying data.

This role must include:

Permissions for AWS Glue Data Catalog (e.g., glue:GetDatabase, glue:GetTables)

Permissions for the Amazon S3 bucket that stores the underlying data

Step 2

Attach the IAM role to the Redshift namespace.

Redshift Serverless uses a namespace, not a cluster, so the role must be associated with the namespace to allow Redshift to assume it when querying external data.

Step 3

Create an external schema in Amazon Redshift to point to the Data Catalog database.

The external schema maps Redshift to the Glue Data Catalog database so Redshift can query the tables stored in S3.

Option C is correct because the requirement has two separate parts: first, the company must track model versions; second, it needs recommendations for which instance types to use for hosting the model in SageMaker AI. AWS documentation identifies the SageMaker Model Registry as the SageMaker feature used to register and manage model packages and versions as part of the ML lifecycle. For hosting recommendations, AWS documentation says Amazon SageMaker Inference Recommender helps select the best instance type and configuration for ML models and workloads by automating benchmarking and load testing across SageMaker AI instances.

The AWS Inference Recommender documentation is especially important here because it explicitly says you can use it after you register a model to the SageMaker Model Registry with model artifacts. It also states that Inference Recommender helps choose the best endpoint type and configuration and returns recommendations that include the instance type in the resulting endpoint configuration. That is an exact match to the question’s requirement to recommend hosting instance types for a model that has not yet been hosted on SageMaker AI.

The other options do not match AWS service purposes. Amazon ECR stores container images, not model versions. AWS Compute Optimizer is not the SageMaker-native service documented for inference benchmarking of ML models. SageMaker Autopilot is for automated model building, not inference instance recommendations. SageMaker Experiments tracks experiment metadata, trials, and runs, but it does not recommend deployment instance types. Therefore, the fully verified AWS-docs answer is C.

AWS documentation recommends using RecordIO format with lazy loading to optimize data input pipelines for image-based training workloads. RecordIO is a binary data format that enables sequential reads, reducing I/O overhead and improving throughput during training.

By converting JPEG images into RecordIO format, the training job can read data more efficiently from Amazon S3. Lazy loading ensures that only the required data is loaded into memory when needed, which optimizes CPU utilization during computationally intensive preprocessing steps.

Option A (file mode) results in many small S3 GET requests, which can become a bottleneck for large image datasets. Option B changes training behavior and can negatively affect convergence and performance. Option C reduces image quality, which directly impacts model accuracy and violates the requirement.

AWS SageMaker documentation explicitly highlights RecordIO and lazy loading as best practices for high-performance image training pipelines, especially when preprocessing is CPU-intensive.

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

The key requirements in this scenario are variable traffic patterns and cost efficiency. The workload has unpredictable spikes during evenings and weekends, followed by long periods of low or no usage. According to AWS Machine Learning documentation, Amazon SageMaker Serverless Inference is specifically designed for such use cases.

SageMaker Serverless Inference automatically provisions, scales, and shuts down compute resources based on incoming inference requests. Customers are billed only for the compute time used during inference, not for idle resources. This makes it highly cost-effective for workloads with intermittent or spiky traffic, such as real-time chat moderation in gaming environments.

Option A is incorrect because batch transform jobs are intended for offline, large-scale inference and require fixed capacity during job execution. They are not suitable for real-time NLP moderation.

Option C is also incorrect because reserving an EC2 GPU instance incurs continuous costs regardless of utilization. This would be inefficient given the long idle periods described in the scenario.

Option D, SageMaker Asynchronous Inference, is designed for workloads with long processing times or large payloads and still requires endpoint provisioning. While it can handle traffic spikes, it does not scale down to zero in the same cost-efficient manner as Serverless Inference.

Therefore, Amazon SageMaker Serverless Inference is the most cost-effective and operationally efficient solution for deploying an NLP moderation model with highly variable usage patterns.

AWS documentation strongly recommends using custom Docker containers when ML workloads require consistent access to custom dependencies across processing jobs, training jobs, and pipelines.

By building a single Docker image that contains all required libraries and hosting it in Amazon ECR, the ML engineer ensures that every SageMaker job uses the same runtime environment. This approach eliminates the need for repetitive installation steps and avoids environment drift.

Manually installing libraries in managed containers is error-prone and not reusable across jobs. Notebook instances are not designed to host production jobs and pipelines. Running code externally breaks the SageMaker workflow and increases operational complexity.

Using a custom container is a one-time setup that provides maximum reuse with minimal ongoing effort, making it the least implementation effort option in the long run.

Therefore, Option B is the correct and AWS-recommended answer.

Amazon SageMaker Data Wrangler provides a comprehensive solution for importing, consolidating, and preparing datasets for ML. It offers tools to handle missing values, duplicates, and outliers through its built-in cleansing and enrichment functionalities, allowing the ML engineer to efficiently prepare the data in a single environment with minimal manual effort.

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.

AWS Glue DataBrew supports datasets sourced directly from Amazon S3 paths. To clean and normalize data, AWS documentation specifies using DataBrew recipes, which define transformation steps such as standardization, deduplication, and formatting.

A profile job is used only for data analysis and statistics generation, not for transformation. A recipe job applies actual transformations to the data and writes the output to Amazon S3.

JDBC connections are used for relational databases, not S3 buckets. Therefore, options C and D are invalid.

AWS clearly documents that the correct workflow is:

Create a DataBrew dataset from an S3 path

Define transformations using a recipe

Run a recipe job to produce cleaned data

Thus, Option B is the correct and AWS-aligned answer.

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.

SageMaker Clarify is designed to provide explainability for ML models. It can analyze feature importance and explain how input features influence the model ' s predictions. By using Clarify with the deployed SageMaker model, the ML engineer can generate insights and present them to stakeholders to explain the sentiment analysis predictions effectively.

By creating IAM policies with specific permissions, you can restrict access to Amazon S3 buckets or objects based on the user ' s business group. These policies can be attached to IAM users or IAM roles associated with the ML engineers, ensuring that each engineer can only access training data belonging to their group. This approach is secure, scalable, and aligns with AWS best practices for access control.

Change the number of samples used in each iteration of training

Correct selection:

Change the batch size

Why:

Increasing the batch size reduces the number of iterations per epoch, which can significantly shorten training time while maintaining model quality when tuned appropriately. AWS explicitly recommends batch size tuning as a primary performance optimization.

Increase the number of instances used during training

Correct selection:

Use the SageMaker AI distributed data parallelism (SMDDP) library

Why:

SMDDP is designed to efficiently distribute training data across multiple GPU instances with optimized gradient synchronization. This accelerates training without affecting model convergence or accuracy, unlike naive scaling approaches.

Stop training before the maximum number of epochs are reached if performance is sufficient and not improving

Correct selection:

Use early stopping on the training job

Why:

Early stopping automatically terminates training when validation metrics stop improving. AWS recommends this to reduce wasted compute time while preserving optimal model performance.

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.

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.

Step 1

Upload the existing models to the same Amazon S3 bucket path.

Multi-model endpoints require all models to be stored under a single S3 prefix so SageMaker can dynamically load them on demand.

Step 2

Create a SageMaker AI model with multi-model endpoints enabled.

This creates a SageMaker model resource that uses a multi-model–capable container (for example, XGBoost, PyTorch, or TensorFlow MME-compatible containers).

Step 3

Create an endpoint configuration that references a multi-model container.

The endpoint configuration defines:

Instance type

Initial instance count

The multi-model container reference

Step 4

Deploy a real-time inference endpoint by using the endpoint configuration.

Real-time endpoints ensure low-latency inference, which is a strict customer requirement.

Step 5

Update the models to use the new endpoint ID. Pass the model IDs to the new endpoint.

Each inference request specifies a model ID so SageMaker knows which model to load from S3.

Step 1: An S3 event notification invokes the pipeline when new data is uploaded.

Step 2: SageMaker retrains the model by using the data in the S3 bucket.

Step 3: The pipeline deploys the model to a SageMaker endpoint.

Step 1: An S3 Event Notification Invokes the Pipeline When New Data is Uploaded

Why? The CI/CD pipeline should be triggered automatically whenever new training data is uploaded to Amazon S3. S3 event notifications can be configured to send events to AWS services like Lambda, which can then invoke AWS CodePipeline.

How? Configure the S3 bucket to send event notifications (e.g., s3:ObjectCreated:*) to AWS Lambda, which in turn triggers the CodePipeline.

Step 2: SageMaker Retrains the Model by Using the Data in the S3 Bucket

Why? The uploaded data is used to retrain the ML model to incorporate new information and maintain performance. This step is critical to updating the model with fresh data.

How? Define a SageMaker training step in the CI/CD pipeline, which reads the training data from the S3 bucket and retrains the model.

Step 3: The Pipeline Deploys the Model to a SageMaker Endpoint

Why? Once retrained, the updated model must be deployed to a SageMaker endpoint to make it available for real-time inference.

How? Add a deployment step in the CI/CD pipeline, which automates the creation or update of the SageMaker endpoint with the retrained model.

Order Summary:

An S3 event notification invokes the pipeline when new data is uploaded.

SageMaker retrains the model by using the data in the S3 bucket.

The pipeline deploys the model to a SageMaker endpoint.

This configuration ensures an automated, efficient, and scalable CI/CD pipeline for continuous retraining and deployment of the ML model in Amazon SageMaker.

Partitioning the time-series data by date prefix in the S3 bucket significantly improves query performance in Amazon Athena by reducing the amount of data that needs to be scanned during queries. This allows the ML engineers to efficiently analyze trends over specific time periods, such as the past 3 days. Applying S3 Lifecycle policies to archive partitions older than 30 days to S3 Glacier Flexible Retrieval ensures cost-effective data retention and storage management while maintaining high performance for recent data retrieval.

Option A is correct because the issue is that the lead ML engineer’s local notebook environment does not yet contain the latest merged changes from the shared Git repository. In Git, the operation used to fetch remote updates and merge them into the local branch is git pull. AWS documentation for SageMaker notebook collaboration explains that Git repositories can be associated with SageMaker notebook instances so distributed teams can share notebooks and collaborate in a source-control environment.

AWS documentation is even more explicit in the SageMaker Git operations guide: to fetch notebooks committed by other users, you should do a pull from the project repository. That is exactly the situation described in the question. Other team members have already merged their notebook changes into the repository, and the lead engineer needs the latest notebook updates in the local SageMaker notebook environment. Therefore, running !git pull origin master is the correct command among the available choices.

The other options do not solve the problem. git commit records local changes in the user’s own repository history; it does not download new remote content. git push origin master uploads local commits to the remote repository; it is used when you want to send your own changes outward, not retrieve teammates’ updates. git branch only lists or manages branches and does not synchronize notebook content. Because the requirement is to see the latest merged notebook made by others, the necessary operation is a pull from the remote repository. So the best verified answer is A.

This scenario clearly describes an overfitting problem. The neural network performs well on training data but fails to generalize to evaluation data. According to AWS Machine Learning and deep learning best practices, overfitting occurs when a model learns noise or overly specific patterns in the training data instead of generalizable relationships.

L1 and L2 regularization are well-established techniques to combat overfitting. They work by penalizing large weight values during optimization, effectively constraining the model’s complexity. L1 regularization encourages sparsity, while L2 regularization (weight decay) smooths the weight distribution. AWS documentation recommends regularization as a primary method for improving generalization when a model shows a large gap between training and evaluation performance.

Option B is incorrect because removing dropout layers would increase overfitting, not reduce it. Dropout is itself a regularization technique.

Option C would likely worsen overfitting, as training for more epochs allows the model to memorize the training data even further.

Option D increases model complexity, which again exacerbates overfitting rather than resolving it.

Therefore, penalizing large weights using L1 or L2 regularization is the correct solution.