Scenario practice questions

A data scientist trains a linear regression model to predict housing prices. The model achieves a low training error but a high test error. Which concept does this BEST illustrate?

Trap 1: Bias-variance tradeoff

The bias-variance tradeoff describes the general tension between underfitting and overfitting, not the specific diagnosis of a model that fits training data well and generalises poorly. It is tempting as the umbrella concept, but the stem's low training error and high test error names variance directly.

Trap 2: Regularization

Regularization deliberately penalises model complexity to reduce variance, so it would lower the gap rather than cause it. It is tempting because it addresses overfitting, but the stem asks which concept the observed behaviour illustrates, and no penalty term is described in the training process.

Trap 3: Underfitting

Underfitting produces high error on both training and test data, because the model is too simple to capture the underlying pattern. It is tempting as the opposite failure mode, but the stem's low training error with high test error indicates the model memorised the training set.

A
Bias-variance tradeoff
Why it fails: The bias-variance tradeoff describes the general tension between underfitting and overfitting, not the specific diagnosis of a model that fits training data well and generalises poorly. It is tempting as the umbrella concept, but the stem's low training error and high test error names variance directly.
B
Regularization
Why it fails: Regularization deliberately penalises model complexity to reduce variance, so it would lower the gap rather than cause it. It is tempting because it addresses overfitting, but the stem asks which concept the observed behaviour illustrates, and no penalty term is described in the training process.
C
Underfitting
Why it fails: Underfitting produces high error on both training and test data, because the model is too simple to capture the underlying pattern. It is tempting as the opposite failure mode, but the stem's low training error with high test error indicates the model memorised the training set.
D
Overfitting
Low training error with high test error means the model has memorised training noise rather than learning generalisable patterns, so it fails on unseen data. Overfitting is the specific term for this train-test performance gap, which the stem describes directly.

Question 2mediummultiple choice

A company is using Amazon Bedrock's Converse API to build a conversational agent. They want the agent to maintain context across multiple turns. The agent should also be able to call external APIs to retrieve real-time data when needed. Which combination of features should they use?

Trap 1: Use the Converse API with streaming enabled and set max tokens to…

Streaming and max tokens control response delivery length, not conversation state or external API invocation. The Converse API's tool use and message history parameters provide those capabilities; streaming alone suits latency-sensitive chat output where no external data retrieval is required.

Trap 2: Use the InvokeModel API with a conversational prompt template and…

InvokeModel requires you to resend the full conversation history yourself and parse tool-call JSON manually; Converse manages multi-turn message state and tool configuration natively. InvokeModel suits single-shot text or image generation where you control prompt assembly and do not need built-in tool orchestration.

Trap 3: Use the InvokeModel API with a system prompt and store conversation…

InvokeModel is stateless and returns no tool-use orchestration, so the agent cannot natively invoke external APIs; client-side history only replays text. It is tempting because InvokeModel offers fine-grained control over prompts and is correct for single-turn generation where the application manages all state and tool calls itself.

A
Use the Converse API with streaming enabled and set max tokens to 4096
Why it fails: Streaming and max tokens control response delivery length, not conversation state or external API invocation. The Converse API's tool use and message history parameters provide those capabilities; streaming alone suits latency-sensitive chat output where no external data retrieval is required.
B
Use the InvokeModel API with a conversational prompt template and tool use configuration
Why it fails: InvokeModel requires you to resend the full conversation history yourself and parse tool-call JSON manually; Converse manages multi-turn message state and tool configuration natively. InvokeModel suits single-shot text or image generation where you control prompt assembly and do not need built-in tool orchestration.
C
Use the Converse API with system prompts and tool configuration
The Converse API maintains multi-turn conversation context through the messages parameter, while tool configuration supplies function definitions that let the model request external API calls for real-time data. System prompts set behaviour but do not provide tool invocation.
D
Use the InvokeModel API with a system prompt and store conversation history client-side
Why it fails: InvokeModel is stateless and returns no tool-use orchestration, so the agent cannot natively invoke external APIs; client-side history only replays text. It is tempting because InvokeModel offers fine-grained control over prompts and is correct for single-turn generation where the application manages all state and tool calls itself.

Question 3easymultiple choice

After deploying a model, a company notices that the distribution of the input features has shifted compared to the training data. Which feature of Amazon SageMaker Model Monitor can alert them to this change?

Trap 1: Model quality monitoring

Model quality monitoring compares predictions against ground-truth labels to measure accuracy, so it cannot detect a shift in input feature distributions. It is tempting because it also watches deployed models, and would be correct when the concern is degrading prediction accuracy rather than changing input data.

Trap 2: Bias drift monitoring

Bias drift monitoring tracks changes in bias metrics such as demographic parity across groups, not shifts in the distribution of input features. It is tempting because it also monitors drift after deployment, and would be correct when fairness across protected groups is the concern rather than raw feature distribution.

Trap 3: Feature importance drift

Feature importance drift is not a SageMaker Model Monitor capability; Model Monitor offers data quality, model quality, bias drift and explainability monitoring. It is tempting because the name suggests tracking input features, and would be relevant when explaining which features drive predictions rather than detecting distributional shift.

A
Model quality monitoring
Why it fails: Model quality monitoring compares predictions against ground-truth labels to measure accuracy, so it cannot detect a shift in input feature distributions. It is tempting because it also watches deployed models, and would be correct when the concern is degrading prediction accuracy rather than changing input data.
B
Bias drift monitoring
Why it fails: Bias drift monitoring tracks changes in bias metrics such as demographic parity across groups, not shifts in the distribution of input features. It is tempting because it also monitors drift after deployment, and would be correct when fairness across protected groups is the concern rather than raw feature distribution.
C
Feature importance drift
Why it fails: Feature importance drift is not a SageMaker Model Monitor capability; Model Monitor offers data quality, model quality, bias drift and explainability monitoring. It is tempting because the name suggests tracking input features, and would be relevant when explaining which features drive predictions rather than detecting distributional shift.
D
Data quality monitoring
Data quality monitoring computes baseline statistics from training data and compares incoming inference requests against them, detecting covariate shift in feature distributions. It directly satisfies the stem's requirement to alert on shifted input features, unlike model quality or bias drift monitoring, which track predictions and fairness rather than input drift.

Question 4mediummultiple choice

A data scientist is training a model using Amazon SageMaker and notices the training loss is decreasing but validation loss starts increasing after a few epochs. Which technique should they apply to address this?

Trap 1: Increase batch size

Larger batches reduce gradient noise but do not counteract the divergence between training and validation loss, which signals overfitting; regularisation such as dropout or early stopping is required. Increasing batch size is genuinely useful for stabilising gradients and speeding up training on hardware with spare memory, not for closing a generalisation gap.

Trap 2: Increase the learning rate

Raising the learning rate worsens the divergence, since overfitting is driven by the model memorising training data rather than by slow convergence. A higher rate is the right lever when training loss plateaus too slowly or the model underfits, not when validation loss has already begun climbing.

Trap 3: Add more training data

Adding training data can reduce overfitting over time, but it does not directly counter the epoch-by-epoch divergence described, and collecting labelled data is slow. More data is the correct remedy when the model has capacity to spare and the dataset is genuinely too small, not for an immediate regularisation fix.

A
Increase batch size
Why it fails: Larger batches reduce gradient noise but do not counteract the divergence between training and validation loss, which signals overfitting; regularisation such as dropout or early stopping is required. Increasing batch size is genuinely useful for stabilising gradients and speeding up training on hardware with spare memory, not for closing a generalisation gap.
B
Increase the learning rate
Why it fails: Raising the learning rate worsens the divergence, since overfitting is driven by the model memorising training data rather than by slow convergence. A higher rate is the right lever when training loss plateaus too slowly or the model underfits, not when validation loss has already begun climbing.
C
Add more training data
Why it fails: Adding training data can reduce overfitting over time, but it does not directly counter the epoch-by-epoch divergence described, and collecting labelled data is slow. More data is the correct remedy when the model has capacity to spare and the dataset is genuinely too small, not for an immediate regularisation fix.
D
Add regularization (e.g., L1 or L2)
Rising validation loss while training loss falls signals overfitting. L1 or L2 regularization penalises large weights, constraining model complexity so it generalises better to unseen data, directly addressing the divergence between the two loss curves.

Question 5hardmultiple choice

An organization uses Amazon Bedrock to generate content. They have implemented guardrails to block toxic content. However, some users are able to bypass the guardrails by encoding their prompts. What step should be taken to improve security?

Trap 1: Encode the prompts before sending to the model.

Encoding prompts does not prevent bypass; the model would decode and potentially still produce toxic content.

Trap 2: Use a different foundation model that is less susceptible.

Model susceptibility is not the root cause; guardrails can be bypassed regardless.

Trap 3: Restrict access to the model using IAM policies.

Access control does not prevent authorized users from submitting encoded prompts.

A
Encode the prompts before sending to the model.
Why it fails: Encoding prompts does not prevent bypass; the model would decode and potentially still produce toxic content.
B
Enable prompt injection detection in the guardrail configuration.
Prompt injection detection can identify and block encoded or malicious prompts.
C
Use a different foundation model that is less susceptible.
Why it fails: Model susceptibility is not the root cause; guardrails can be bypassed regardless.
D
Restrict access to the model using IAM policies.
Why it fails: Access control does not prevent authorized users from submitting encoded prompts.

Question 6mediummultiple choice

A data scientist is training a binary classification model to predict customer churn. The dataset has 10,000 records with 9,500 non-churners and 500 churners. After training a logistic regression model, the model achieves 95% accuracy on the test set. However, the business team reports that the model is not useful because it predicts almost all customers as non-churners. Which metric should the data scientist use to evaluate the model's performance in this scenario?

Trap 1: Accuracy

Accuracy counts all correct predictions, so predicting every customer as a non-churner yields 95% on this imbalanced set while catching zero churners. Accuracy is appropriate only when classes are roughly balanced and both error types carry similar cost.

Trap 2: R-squared

R-squared quantifies how much variance a regression line explains in continuous outcomes, so it cannot be computed meaningfully for a binary churn label. It would be the right metric when evaluating a linear regression predicting a numeric target such as customer lifetime value.

Trap 3: Precision

Precision measures only the proportion of predicted churners that truly churn, so a model predicting almost everything as non-churners can still score highly on the few positive predictions it makes, ignoring the missed churners entirely. Precision suits spam filtering, where false positives are the main cost.

A
Accuracy
Why it fails: Accuracy counts all correct predictions, so predicting every customer as a non-churner yields 95% on this imbalanced set while catching zero churners. Accuracy is appropriate only when classes are roughly balanced and both error types carry similar cost.
B
R-squared
Why it fails: R-squared quantifies how much variance a regression line explains in continuous outcomes, so it cannot be computed meaningfully for a binary churn label. It would be the right metric when evaluating a linear regression predicting a numeric target such as customer lifetime value.
C
Precision
Why it fails: Precision measures only the proportion of predicted churners that truly churn, so a model predicting almost everything as non-churners can still score highly on the few positive predictions it makes, ignoring the missed churners entirely. Precision suits spam filtering, where false positives are the main cost.
D
Recall
Recall measures the proportion of actual churners correctly identified, directly exposing the model's failure on the 500-positive minority class. With 95% accuracy achievable by predicting all non-churners, recall reveals that sensitivity to churn is near zero, satisfying the need for a metric robust to this class imbalance.

Question 7mediummulti select

A company wants to use AWS Lake Formation to govern access to data used for AI training. They need to ensure that only approved columns of sensitive tables are visible to data scientists. Which THREE steps should they implement? (Choose THREE)

Trap 1: Create a SageMaker notebook instance and attach an IAM role

A SageMaker notebook instance with an IAM role provides compute and identity for training, but IAM policies operate at table and S3 prefix level, not individual columns. It is tempting because notebooks are where data scientists consume data, but it would be correct when the task is provisioning an analysis environment rather than restricting column visibility.

Trap 2: Enable S3 versioning on the training data bucket

S3 versioning preserves object revisions; it grants no column-level access control, so data scientists could still read every column. It is tempting because versioning is a common data-protection step for training buckets, but it would be correct when the requirement is recoverability from overwrites or deletions, not column filtering.

A
Use AWS Glue crawlers to catalog the data and populate the Data Catalog
AWS Glue crawlers scan the underlying data, infer schemas and register tables in the Data Catalog. Lake Formation permissions are granted against those catalogued tables and columns, so cataloguing is the prerequisite step enabling column-level access control.
B
Create a SageMaker notebook instance and attach an IAM role
Why it fails: A SageMaker notebook instance with an IAM role provides compute and identity for training, but IAM policies operate at table and S3 prefix level, not individual columns. It is tempting because notebooks are where data scientists consume data, but it would be correct when the task is provisioning an analysis environment rather than restricting column visibility.
C
Define column-level permissions in Lake Formation to grant access to specific columns for the data scientist role
Column-level grants in Lake Formation restrict which columns a role can query, so data scientists see only approved fields of sensitive tables. This satisfies the requirement that unapproved columns remain invisible, since Lake Formation enforces the restriction at query time.
D
Enable S3 versioning on the training data bucket
Why it fails: S3 versioning preserves object revisions; it grants no column-level access control, so data scientists could still read every column. It is tempting because versioning is a common data-protection step for training buckets, but it would be correct when the requirement is recoverability from overwrites or deletions, not column filtering.
E
Register the S3 bucket containing the training data with Lake Formation
Lake Formation governs permissions only over data it knows about, so the S3 bucket must first be registered as a data location. This establishes the catalogue metadata and IAM role access that column-level security filters then apply to, satisfying the requirement to expose only approved columns.

Question 8hardmultiple choice

A company wants to adapt a foundation model for a custom domain with very limited labeled data and minimal cost. Which approach is most suitable?

Trap 1: Pre-training from scratch

Pre-training from scratch initialises random weights and learns from massive unlabelled corpora, incurring enormous compute and data cost. It is tempting because it yields a fully domain-native model, and it would be correct when a unique domain and vast resources justify building a bespoke foundation model.

Trap 2: Reinforcement learning from human feedback

RLHF optimises model outputs against human preference rankings, requiring extensive human annotation effort rather than few labelled examples. It is tempting because it aligns models to human judgement, and it would be correct for refining helpfulness and safety after an initial adaptation.

Trap 3: Full fine-tuning

Full fine-tuning updates every model weight, which demands large labelled datasets and substantial compute cost. It is tempting because it maximises adaptation quality, and it would be correct when abundant domain data and a generous budget are available.

A
Pre-training from scratch
Why it fails: Pre-training from scratch initialises random weights and learns from massive unlabelled corpora, incurring enormous compute and data cost. It is tempting because it yields a fully domain-native model, and it would be correct when a unique domain and vast resources justify building a bespoke foundation model.
B
Prompt engineering with few-shot examples
Few-shot prompting supplies a handful of labelled examples within the prompt itself, letting the foundation model adapt to the custom domain without weight updates. This satisfies both constraints: very limited labelled data and minimal cost, since no fine-tuning compute is required.
C
Reinforcement learning from human feedback
Why it fails: RLHF optimises model outputs against human preference rankings, requiring extensive human annotation effort rather than few labelled examples. It is tempting because it aligns models to human judgement, and it would be correct for refining helpfulness and safety after an initial adaptation.
D
Full fine-tuning
Why it fails: Full fine-tuning updates every model weight, which demands large labelled datasets and substantial compute cost. It is tempting because it maximises adaptation quality, and it would be correct when abundant domain data and a generous budget are available.

Question 9easymultiple choice

A data scientist at a retail company is tasked with building a model to predict customer churn. The dataset contains 100,000 records with features such as age, purchase history, customer support interactions, and a binary label indicating whether the customer churned in the past. The team needs a model that can be deployed for real-time inference with low latency. They have limited time and want to use a built-in algorithm from Amazon SageMaker that is optimized for classification tasks. Which approach should they take?

Trap 1: Use Amazon SageMaker PCA algorithm

PCA is an unsupervised dimensionality-reduction algorithm; it outputs principal components, not class labels, so it cannot predict churn. It is tempting when feature count is high and preprocessing is needed, but the stem requires a supervised classifier with real-time inference.

Trap 2: Use Amazon SageMaker K-Means algorithm

K-Means is unsupervised clustering; it groups records by similarity and produces no binary churn label. It is tempting for segmenting customers into behavioural groups, but the stem demands supervised classification against a known churn label with low-latency inference.

Trap 3: Use Amazon SageMaker BlazingText algorithm

BlazingText handles text classification and word embeddings, so it expects tokenised natural-language input rather than the tabular age, purchase-history and support-interaction features given. It is tempting because it is a built-in supervised algorithm, but it is the wrong modality for this structured dataset.

A
Use Amazon SageMaker PCA algorithm
Why it fails: PCA is an unsupervised dimensionality-reduction algorithm; it outputs principal components, not class labels, so it cannot predict churn. It is tempting when feature count is high and preprocessing is needed, but the stem requires a supervised classifier with real-time inference.
B
Use Amazon SageMaker XGBoost algorithm
SageMaker's built-in XGBoost is optimised for tabular binary classification and serves low-latency real-time inference from a managed endpoint, meeting the deployment constraint. It handles the 100,000-record dataset without custom training code, saving the limited time available.
C
Use Amazon SageMaker K-Means algorithm
Why it fails: K-Means is unsupervised clustering; it groups records by similarity and produces no binary churn label. It is tempting for segmenting customers into behavioural groups, but the stem demands supervised classification against a known churn label with low-latency inference.
D
Use Amazon SageMaker BlazingText algorithm
Why it fails: BlazingText handles text classification and word embeddings, so it expects tokenised natural-language input rather than the tabular age, purchase-history and support-interaction features given. It is tempting because it is a built-in supervised algorithm, but it is the wrong modality for this structured dataset.

Question 10hardmulti select

A marketing team is using a foundation model to generate marketing copy. Which THREE of the following should they consider to ensure responsible and cost-effective use?

Trap 1: Model size (number of parameters)

Parameter count affects capability and inference cost, but the stem asks which factors ensure responsible and cost-effective use; model size alone neither governs data privacy, bias mitigation nor token-based pricing decisions. It is tempting because larger models often improve output quality, so parameter count matters when accuracy outweighs budget.

Trap 2: Latency of model inference

Inference latency affects user experience, not responsible or cost-effective use; token consumption and pricing drive cost. It tempts because latency is a genuine operational metric for generative AI workloads, but it belongs to performance planning rather than responsibility or budget control.

A
Bias mitigation to avoid unfair stereotypes
Bias mitigation directly addresses fairness, a core responsible-AI dimension for generative marketing copy that could otherwise propagate stereotypes. It satisfies the stem's responsible-use constraint by reducing discriminatory outputs, complementing cost controls. Unlike accuracy or latency tuning, bias mitigation targets the ethical risk inherent in open-ended text generation.
B
Cost per token for the model
Token pricing determines the charge for each generated and input token, so selecting a model with a lower cost per token directly controls spend. This satisfies the cost-effective use requirement for high-volume marketing copy generation.
C
Model size (number of parameters)
Why it fails: Parameter count affects capability and inference cost, but the stem asks which factors ensure responsible and cost-effective use; model size alone neither governs data privacy, bias mitigation nor token-based pricing decisions. It is tempting because larger models often improve output quality, so parameter count matters when accuracy outweighs budget.
D
Toxicity detection in generated content
Toxicity detection screens generated copy for harmful, offensive or abusive language before publication, directly satisfying the responsible-use requirement in the stem. Foundation models can reproduce biased or toxic patterns from training data, so filtering output protects brand reputation and audiences. It addresses safety, not cost, but the stem asks for both dimensions across three selections.
E
Latency of model inference
Why it fails: Inference latency affects user experience, not responsible or cost-effective use; token consumption and pricing drive cost. It tempts because latency is a genuine operational metric for generative AI workloads, but it belongs to performance planning rather than responsibility or budget control.

Question 11hardmulti select

A data science team is fine-tuning a foundation model on Amazon SageMaker. Which THREE steps are part of the best practice? (Choose three.)

Trap 1: Increase model size to improve performance.

Increasing model size raises training cost and can worsen overfitting on small fine-tuning datasets; best practice adjusts hyperparameters and data quality instead. It is tempting because larger models often perform better at pre-training scale, but fine-tuning gains come from curated data and evaluation, not parameter count.

Trap 2: Deploy the model to production immediately after fine-tuning.

Deployment should follow evaluation and validation against a held-out set, not occur immediately after fine-tuning. It is tempting because fine-tuning produces a deployable artefact, but best practice includes assessing metrics, bias, and safety before promoting the model to production endpoints.

A
Increase model size to improve performance.
Why it fails: Increasing model size raises training cost and can worsen overfitting on small fine-tuning datasets; best practice adjusts hyperparameters and data quality instead. It is tempting because larger models often perform better at pre-training scale, but fine-tuning gains come from curated data and evaluation, not parameter count.
B
Monitor for catastrophic forgetting during fine-tuning.
Fine-tuning can overwrite pretrained weights, causing catastrophic forgetting where the model loses general capabilities. Monitoring benchmark performance during training detects this degradation early, satisfying the best-practise requirement to preserve the foundation model's original knowledge while adapting it to the new task.
C
Use early stopping to prevent overfitting.
Early stopping halts training when validation loss stops improving, preventing the model from memorising training data. This satisfies the overfitting-prevention best practise, since continued epochs would degrade generalisation on unseen inputs despite falling training loss.
D
Deploy the model to production immediately after fine-tuning.
Why it fails: Deployment should follow evaluation and validation against a held-out set, not occur immediately after fine-tuning. It is tempting because fine-tuning produces a deployable artefact, but best practice includes assessing metrics, bias, and safety before promoting the model to production endpoints.
E
Use a diverse dataset representing various scenarios.
A diverse dataset spanning varied scenarios directly counteracts overfitting during fine-tuning, exposing the foundation model to the breadth of inputs it will encounter in production. This satisfies the stem's best-practise requirement by improving generalisation, reducing bias, and ensuring the fine-tuned model performs reliably across the real-world conditions the data science team targets.

Question 12hardmultiple choice

An e-commerce company stores user interaction logs in Amazon S3. They want to use machine learning to segment users based on purchasing behavior. Which unsupervised learning algorithm is most appropriate?

Trap 1: Linear regression

Linear regression predicts a continuous numeric target from labelled data, so it cannot discover the behavioural groupings segmentation requires. It would be correct for forecasting a value such as spend, not for clustering users by purchasing behaviour without labels.

Trap 2: Random forest

Random forest is a supervised classifier or regressor requiring labelled outcomes; it cannot uncover latent segments in unlabelled interaction logs. It would be the right choice for predicting a known label, such as churn, rather than clustering users by behaviour.

Trap 3: Neural network

Can be used but typically supervised; overkill for simple segmentation.

A
Linear regression
Why it fails: Linear regression predicts a continuous numeric target from labelled data, so it cannot discover the behavioural groupings segmentation requires. It would be correct for forecasting a value such as spend, not for clustering users by purchasing behaviour without labels.
B
Random forest
Why it fails: Random forest is a supervised classifier or regressor requiring labelled outcomes; it cannot uncover latent segments in unlabelled interaction logs. It would be the right choice for predicting a known label, such as churn, rather than clustering users by behaviour.
C
K-means clustering
K-means clustering partitions unlabelled interaction logs into k groups by minimising within-cluster variance, directly satisfying the requirement to segment users by purchasing behaviour without predefined labels. Unlike supervised methods, it needs no target variable, making it appropriate for discovering behavioural cohorts in the S3-stored data.
D
Neural network
Why it fails: Can be used but typically supervised; overkill for simple segmentation.

Question 13mediummulti select

A team is using Amazon SageMaker to build a text classification model. They have raw text data in CSV files stored in Amazon S3. Before training, they need to perform feature engineering. Which THREE actions should they take? (Select THREE.)

Trap 1: Normalize numerical features to have zero mean and unit variance

Zero-mean unit-variance scaling applies to continuous numerical columns; raw text CSV data contains no numerical feature vectors to standardise until after tokenisation and vectorisation. It is tempting because normalisation is standard practice for numerical inputs, and it would be correct if the dataset included numeric attributes such as word counts or metadata.

Trap 2: Encode categorical variables using one-hot encoding

One-hot encoding expands categorical values into sparse binary columns, which suits tabular categorical fields rather than free-text tokens; text classification needs tokenisation and vectorisation instead. It is tempting because one-hot encoding is standard preprocessing for categorical features, and it would be correct if the CSV held labelled categorical attributes rather than raw sentences.

A
Normalize numerical features to have zero mean and unit variance
Why it fails: Zero-mean unit-variance scaling applies to continuous numerical columns; raw text CSV data contains no numerical feature vectors to standardise until after tokenisation and vectorisation. It is tempting because normalisation is standard practice for numerical inputs, and it would be correct if the dataset included numeric attributes such as word counts or metadata.
B
Tokenize the text into words or subwords
Tokenisation splits raw text into words or subwords, producing discrete units that downstream vectorisers such as TF-IDF or embedding layers require. Without this step, the CSV text strings cannot be mapped to any numerical representation, so the feature engineering pipeline for the classification model cannot proceed.
C
Remove punctuation and stop words from the text
Stripping punctuation and stop words reduces noise and vocabulary size, so the classifier learns from content-bearing terms rather than filler. This normalisation directly serves the feature engineering stage required before training on the raw CSV text held in Amazon S3.
D
Convert the text into numerical features using techniques like TF-IDF or word embeddings
Machine learning algorithms require numeric input, so TF-IDF or word embeddings transform tokenised text into vectors capturing term importance or semantic meaning. This conversion is the essential feature engineering step that makes the CSV text usable by the SageMaker classification model.
E
Encode categorical variables using one-hot encoding
Why it fails: One-hot encoding expands categorical values into sparse binary columns, which suits tabular categorical fields rather than free-text tokens; text classification needs tokenisation and vectorisation instead. It is tempting because one-hot encoding is standard preprocessing for categorical features, and it would be correct if the CSV held labelled categorical attributes rather than raw sentences.

Question 14hardmultiple choice

A financial services company is deploying a foundation model on Amazon Bedrock to generate compliance reports from internal audit logs. The model must not output any personally identifiable information (PII). They have configured a Bedrock Guardrail with sensitive information filters set to the 'HIGH' sensitivity level. During testing in a staging environment, testers still observed PII being occasionally generated in the report outputs. The guardrail did not block these instances because the PII was embedded in a context that the guardrail's pattern matching did not catch (e.g., structured JSON data with embedded names). The company requires a solution that minimizes latency and cost, as they process thousands of reports daily. They cannot afford to increase inference time significantly due to strict SLAs. They also want to avoid re-engineering the entire solution. Which additional step should they take to effectively eliminate PII leakage while maintaining performance?

Trap 1: Add a prompt instruction to the model to never output PII, with…

Prompt instructions and few-shot examples only bias generation probabilistically; they cannot guarantee that structured JSON with embedded names is stripped, so leakage persists. This approach suits steering style or format, but the scenario needs deterministic detection and redaction of PII patterns after generation, which instructions alone cannot enforce.

Trap 2: Fine-tune the foundation model on a dataset that excludes PII.

Fine-tuning changes model weights and behaviour but cannot guarantee PII suppression, since the model may still generate sensitive strings from prompt context; it also requires training data, cost and retraining cycles. It suits adapting tone or domain style, not enforcing deterministic output filtering, which a post-generation guardrail layer handles.

Trap 3: Increase the guardrail sensitivity to 'MAXIMUM'.

Guardrail sensitivity levels adjust confidence thresholds for the existing pattern-matching filters; they do not add detection for structured JSON-embedded names that the filters never parse. Raising sensitivity to MAXIMUM risks more false positives without catching the missed PII. Guardrails suit general content moderation, not schema-aware PII redaction.

A
Add a prompt instruction to the model to never output PII, with few-shot examples of non-PII outputs.
Why it fails: Prompt instructions and few-shot examples only bias generation probabilistically; they cannot guarantee that structured JSON with embedded names is stripped, so leakage persists. This approach suits steering style or format, but the scenario needs deterministic detection and redaction of PII patterns after generation, which instructions alone cannot enforce.
B
Fine-tune the foundation model on a dataset that excludes PII.
Why it fails: Fine-tuning changes model weights and behaviour but cannot guarantee PII suppression, since the model may still generate sensitive strings from prompt context; it also requires training data, cost and retraining cycles. It suits adapting tone or domain style, not enforcing deterministic output filtering, which a post-generation guardrail layer handles.
C
Increase the guardrail sensitivity to 'MAXIMUM'.
Why it fails: Guardrail sensitivity levels adjust confidence thresholds for the existing pattern-matching filters; they do not add detection for structured JSON-embedded names that the filters never parse. Raising sensitivity to MAXIMUM risks more false positives without catching the missed PII. Guardrails suit general content moderation, not schema-aware PII redaction.
D
Implement a post-processing Lambda function that uses Amazon Comprehend's PII detection to scan and redact any PII from the model output before returning it.
Amazon Comprehend's PII detection uses trained machine-learning models rather than regex patterns, so it recognises names embedded in structured JSON that Guardrail filters miss. Running it as a post-processing Lambda adds only milliseconds per report, satisfying the latency and cost constraints without re-engineering the Bedrock invocation path.

Question 15mediummulti select

A company is developing a generative AI application for content creation. They want to ensure transparency as per responsible AI guidelines. Which THREE practices should they implement? (Choose three.)

Trap 1: Encourage users to trust the AI outputs without question

Transparency requires disclosing AI involvement and limitations, not suppressing scrutiny; blind trust conceals the model's uncertainty and provenance. It is tempting because user confidence aids adoption, and trust-building is legitimate for change management — but responsible AI demands informed trust through disclosure, not unquestioning acceptance.

Trap 2: Monitor the model for bias in production

Bias monitoring addresses fairness and harm detection, not transparency; it reveals nothing to users about how outputs are generated. It is tempting because bias monitoring is a genuine responsible AI practise, and it would be correct when the requirement is ongoing fairness assurance rather than disclosing model behaviour and data usage.

A
Encourage users to trust the AI outputs without question
Why it fails: Transparency requires disclosing AI involvement and limitations, not suppressing scrutiny; blind trust conceals the model's uncertainty and provenance. It is tempting because user confidence aids adoption, and trust-building is legitimate for change management — but responsible AI demands informed trust through disclosure, not unquestioning acceptance.
B
Label AI-generated content with a clear disclosure
Labelling AI-generated content with a clear disclosure directly satisfies the transparency requirement by informing end users that output is machine-generated. Disclosure prevents audiences from mistaking synthetic material for human-authored work, which is a core responsible AI transparency practise for generative content creation applications.
C
Provide a disclaimer about the model's capabilities and limitations
Publishing a disclaimer about the model's capabilities and limitations sets accurate user expectations, satisfying the transparency requirement. It clarifies what the generative system can and cannot reliably produce, so consumers understand output boundaries rather than over-trusting results, which is a recognised responsible AI transparency practise.
D
Monitor the model for bias in production
Why it fails: Bias monitoring addresses fairness and harm detection, not transparency; it reveals nothing to users about how outputs are generated. It is tempting because bias monitoring is a genuine responsible AI practise, and it would be correct when the requirement is ongoing fairness assurance rather than disclosing model behaviour and data usage.
E
Document the training data sources and potential biases
Documenting training data sources and potential biases exposes how the generative model was built and where its outputs may be skewed. This satisfies transparency by making provenance and known limitations auditable, letting stakeholders assess reliability and fairness instead of treating the model as an opaque black box.

Question 16mediummulti select

A company is deploying an LLM for generating marketing copy. They want to reduce the risk of hallucinations and ensure the content is factually accurate. Which TWO approaches should they implement?

Trap 1: Use a smaller LLM to reduce the chance of hallucinations

Model size does not govern factual grounding; smaller models often hallucinate more, not less. It is tempting because smaller models cut latency and cost, making them the right pick when compute budget or response time is the constraint, but they address no accuracy requirement here.

Trap 2: Disable all guardrails to avoid interference

Removing guardrails eliminates the filtering and grounding controls that catch unsupported claims, directly increasing hallucination risk. It is tempting when latency or refusal rates frustrate users, but disabling them would be correct only in sandboxed experimentation where factual accuracy is not a requirement.

Trap 3: Increase the temperature parameter to generate more diverse outputs

Raising temperature flattens the sampling distribution, favouring less probable tokens and thus more invented content, which worsens hallucination. It is tempting when copy feels repetitive, but higher temperature would be correct for brainstorming or creative variation where factual grounding is not the objective.

A
Use Retrieval-Augmented Generation (RAG) with a verified knowledge base
RAG grounds generation in a verified knowledge base, so the model cites retrieved facts rather than relying on parametric memory, directly reducing hallucination risk. This satisfies the factual-accuracy constraint by constraining outputs to authoritative, auditable content.
B
Implement human review of generated content before publication
Human review catches residual hallucinations that automated grounding cannot eliminate, directly satisfying the requirement for factually accurate marketing copy before publication. Reviewers verify claims against source material, providing a final control layer independent of the model's retrieval or prompting configuration.
C
Use a smaller LLM to reduce the chance of hallucinations
Why it fails: Model size does not govern factual grounding; smaller models often hallucinate more, not less. It is tempting because smaller models cut latency and cost, making them the right pick when compute budget or response time is the constraint, but they address no accuracy requirement here.
D
Disable all guardrails to avoid interference
Why it fails: Removing guardrails eliminates the filtering and grounding controls that catch unsupported claims, directly increasing hallucination risk. It is tempting when latency or refusal rates frustrate users, but disabling them would be correct only in sandboxed experimentation where factual accuracy is not a requirement.
E
Increase the temperature parameter to generate more diverse outputs
Why it fails: Raising temperature flattens the sampling distribution, favouring less probable tokens and thus more invented content, which worsens hallucination. It is tempting when copy feels repetitive, but higher temperature would be correct for brainstorming or creative variation where factual grounding is not the objective.

Question 17mediummultiple choice

A team is using Amazon SageMaker to train a deep learning model. They notice that the training loss decreases steadily but the validation loss starts increasing after 10 epochs. Which technique should they apply to address this issue?

Trap 1: Reduce the batch size

Smaller batch sizes can add noise but are not the primary fix for overfitting.

Trap 2: Increase the learning rate

Increasing learning rate can cause divergence, not fix overfitting.

Trap 3: Add more layers to the network

Adding layers increases model capacity, likely worsening overfitting.

A
Apply early stopping
Early stopping halts training once validation loss stops improving, directly countering the overfitting that emerges after epoch 10. By restoring the best-performing checkpoint, it prevents the model memorising training data while validation performance degrades, satisfying the scenario's need to arrest the diverging loss curves.
B
Reduce the batch size
Why it fails: Smaller batch sizes can add noise but are not the primary fix for overfitting.
C
Increase the learning rate
Why it fails: Increasing learning rate can cause divergence, not fix overfitting.
D
Add more layers to the network
Why it fails: Adding layers increases model capacity, likely worsening overfitting.

Question 18mediummulti select

A data scientist has trained a random forest model that achieves 92% accuracy on the training set but only 75% on the test set. The dataset has 1000 samples and 20 features. Which THREE actions could help improve the model's generalization? (Select THREE.)

Trap 1: Increase the maximum depth of each tree

Increasing maximum depth lets each tree fit the training data more tightly, enlarging the train-test gap rather than closing it. Depth limits are tuned upward when a model underfits and both training and test accuracy are low, which is not the pattern described here.

Trap 2: Decrease the number of trees in the forest

Reducing the number of trees lowers variance averaging across the ensemble, so predictions become noisier and test accuracy typically drops. Tree count is reduced to cut training time or memory when accuracy is already acceptable, not to remedy overfitting on a small dataset.

A
Increase the number of trees in the forest
Adding more trees reduces variance in the ensemble's averaged predictions, which typically improves generalisation on unseen data. This addresses the 92% versus 75% train-test gap, satisfying the scenario's requirement for an action that improves the random forest model's generalisation.
B
Increase the maximum depth of each tree
Why it fails: Increasing maximum depth lets each tree fit the training data more tightly, enlarging the train-test gap rather than closing it. Depth limits are tuned upward when a model underfits and both training and test accuracy are low, which is not the pattern described here.
C
Reduce the maximum depth of each tree
Reducing maximum tree depth constrains each tree's complexity, limiting its ability to memorise training noise. This lowers variance and narrows the 92% versus 75% train-test gap, satisfying the scenario's requirement for an action that improves the random forest model's generalisation.
D
Decrease the number of trees in the forest
Why it fails: Reducing the number of trees lowers variance averaging across the ensemble, so predictions become noisier and test accuracy typically drops. Tree count is reduced to cut training time or memory when accuracy is already acceptable, not to remedy overfitting on a small dataset.
E
Increase the minimum number of samples required to split an internal node
Raising the minimum samples per split forces nodes to retain more data before partitioning, producing simpler trees that generalise better. This reduces the 92% versus 75% train-test gap, satisfying the scenario's requirement for an action that improves the random forest model's generalisation.

Question 19mediummultiple choice

A company wants to build a recommendation system for its e-commerce website. Historical data includes user purchase history, product categories, and ratings. Which AWS service is most suitable for this task?

Trap 1: Amazon Forecast

Forecast produces time-series predictions such as demand, inventory and revenue, using historical timestamped values; it cannot model user-item rating matrices for recommendations. It is tempting because it is a managed ML service, but it would be the correct choice for predicting product demand over future periods.

Trap 2: Amazon SageMaker built-in algorithms

SageMaker built-in algorithms require you to select, train and tune a model yourself, adding effort the scenario does not demand. They tempt because they offer flexibility for custom recommendation logic, and would be correct when existing algorithms cannot meet accuracy or feature requirements that Amazon Personalize cannot satisfy.

Trap 3: Amazon Comprehend

Comprehend performs natural language processing tasks such as sentiment analysis, entity recognition and topic modelling; it does not train recommendation models from purchase and rating data. It is tempting because it analyses text, but it would be correct for classifying customer reviews or extracting key phrases from support tickets.

A
Amazon Personalize
Amazon Personalise is purpose-built for recommendations, ingesting purchase history, product categories and ratings to train and serve personalised ranking models. It handles the collaborative filtering and deployment work, unlike general-purpose services such as SageMaker or Comprehend.
B
Amazon Forecast
Why it fails: Forecast produces time-series predictions such as demand, inventory and revenue, using historical timestamped values; it cannot model user-item rating matrices for recommendations. It is tempting because it is a managed ML service, but it would be the correct choice for predicting product demand over future periods.
C
Amazon SageMaker built-in algorithms
Why it fails: SageMaker built-in algorithms require you to select, train and tune a model yourself, adding effort the scenario does not demand. They tempt because they offer flexibility for custom recommendation logic, and would be correct when existing algorithms cannot meet accuracy or feature requirements that Amazon Personalize cannot satisfy.
D
Amazon Comprehend
Why it fails: Comprehend performs natural language processing tasks such as sentiment analysis, entity recognition and topic modelling; it does not train recommendation models from purchase and rating data. It is tempting because it analyses text, but it would be correct for classifying customer reviews or extracting key phrases from support tickets.

Question 20hardmultiple choice

A company is developing an AI system to screen job applications. They want to ensure the system does not discriminate against candidates based on gender. The dataset used contains historical hiring decisions that may reflect past biases. Which type of bias is MOST likely present in this scenario?

Trap 1: Measurement bias

Measurement bias arises when the features or labels used to train the model are systematically inaccurate or inconsistently recorded, such as a proxy variable standing in for the true target. Here the labels faithfully record past decisions; the defect is that those decisions encode historical gender discrimination, which is historical or label bias.

Trap 2: Representation bias

Representation bias occurs when certain groups are underrepresented in the training data relative to the population, so the model learns poorly for them. This dataset contains historical hiring decisions; the labels themselves encode past discriminatory outcomes, which is historical bias. Representation bias would be the answer if, say, women comprised a tiny fraction of applicants sampled.

Trap 3: Aggregation bias

Aggregation bias arises when one model is applied across distinct subgroups that need separate treatment, not when historical labels encode past prejudice. The stem's biased hiring decisions describe historical bias, which is what this option would fit if the dataset pooled dissimilar populations under a single model.

A
Historical bias
Historical bias arises when training data reflects past human decisions that already disadvantaged a group. Because the dataset encodes prior hiring outcomes skewed by gender, the model learns and reproduces those patterns, making historical bias the most likely type present here.
B
Measurement bias
Why it fails: Measurement bias arises when the features or labels used to train the model are systematically inaccurate or inconsistently recorded, such as a proxy variable standing in for the true target. Here the labels faithfully record past decisions; the defect is that those decisions encode historical gender discrimination, which is historical or label bias.
C
Representation bias
Why it fails: Representation bias occurs when certain groups are underrepresented in the training data relative to the population, so the model learns poorly for them. This dataset contains historical hiring decisions; the labels themselves encode past discriminatory outcomes, which is historical bias. Representation bias would be the answer if, say, women comprised a tiny fraction of applicants sampled.
D
Aggregation bias
Why it fails: Aggregation bias arises when one model is applied across distinct subgroups that need separate treatment, not when historical labels encode past prejudice. The stem's biased hiring decisions describe historical bias, which is what this option would fit if the dataset pooled dissimilar populations under a single model.