AI Concepts and Foundations practice questions

Increase data augmentation

Why it fails: Augmentation helps but dropout is more targeted for overfitting.

Decrease the learning rate

Why it fails: Learning rate affects convergence, not generalization.

Increase the number of layers

Why it fails: More layers increase capacity, likely worsening overfitting.

Vanishing gradients

Why it fails: Vanishing gradients would cause slow decrease in loss.

Underfitting

Why it fails: Underfitting would have high training loss as well.

Data leakage

Why it fails: Data leakage would cause abnormally high accuracy.

Training hyperparameters

Why it fails: Hyperparameters are already included.

Model type

Why it fails: Model type is already specified.

Evaluation metrics

Why it fails: Metrics can be defined separately; preprocessing is more fundamental.

All requests are allowed because the model is in the allowed list

Why it fails: The allowed-model list is evaluated alongside the rate-limit rule, not instead of it; 150 requests in 30 minutes breaches the threshold, so the limit still applies. It is tempting because allow-listing feels permissive, but allow-listing governs which models may be called, not how often.

All requests are denied because the rate limit is per minute and 150 exceeds the limit

Why it fails: The rate limit is defined per 30-minute window, not per minute, so 150 requests must be compared against that window's threshold rather than a per-minute figure. It is tempting because rate limits are often quoted per minute, but the policy's stated interval governs the calculation.

All requests are denied because the second rule blocks all models

Why it fails: Rule evaluation stops at the first match, so the specific llama-3-70b rule fires before any broader catch-all denial. It is tempting because a later rule appears to block everything, but ordering determines the outcome. Only the requests exceeding the rate threshold are denied, not all of them.

Logistic regression

Why it fails: Logistic regression outputs a linear decision boundary, so it cannot capture the non-linear feature interactions that distinguish fraudulent from legitimate transactions, undermining precision. It is tempting because it is fast and interpretable, and it would suit a linearly separable, low-dimensional classification task where latency dominates.

Convolutional neural network

Why it fails: Convolutional neural networks exploit spatial locality through learned filters, which suits grid-structured image data; transaction records have no spatial ordering, so the convolution operation adds latency without modelling the relevant tabular relationships. It would be correct for image or signal classification where spatial feature extraction is required.

Deep reinforcement learning

Why it fails: Deep reinforcement learning optimises sequential decisions through reward feedback, requiring many environment interactions before convergence; fraud detection is a supervised binary classification problem with labelled outcomes, so this paradigm cannot exploit those labels directly. It would be correct for tasks such as dynamic pricing or game playing.

K-means clustering

Why it fails: K-means clustering partitions unlabelled data by distance to centroids, producing groups without any mapping from utterance to intent; intent classification requires supervised labels. It would be correct for exploratory segmentation, such as grouping customers by behaviour, not for interpreting query meaning.

Linear regression

Why it fails: Linear regression predicts a continuous numeric output from input features, so it cannot assign an utterance to a discrete intent class. It would be correct for forecasting a quantity such as transaction amount, not for the categorical prediction that NLU intent detection requires.

Decision tree

Why it fails: Decision trees split on feature thresholds to produce classification rules; they cannot derive intent from unstructured utterance text, which requires learned semantic representations. They suit tabular, structured prediction tasks such as loan approval from numeric attributes, not NLU intent classification.

Increasing training data

Why it fails: Adding training data is a legitimate overfitting remedy, but the question asks for three techniques and this option is not among the expected set here. It is tempting because more samples genuinely reduce variance, and it would be correct when data collection is feasible and the model already fits the training distribution.

Reducing number of layers

Why it fails: Reducing layers lowers capacity, which can curb overfitting, but it is not one of the three techniques this question expects. It is tempting because smaller networks generalise differently, and it would be correct when the architecture is clearly oversized relative to the dataset.

Model accuracy below threshold

Why it fails: Accuracy below threshold is a performance symptom, not the issue the exhibit's evidence points to; the stem asks what the team should address based on the shown behaviour. It is tempting because low accuracy is always concerning, and would be correct if validation metrics genuinely trailed the required target.

High latency

Why it fails: Latency measures response delay, not the training or resource symptom the exhibit shows. It is tempting because latency matters in real-time inference, and would be the correct focus if the exhibit showed slow per-request response times rather than the depicted bottleneck.

Low throughput

Why it fails: Throughput counts completed units per interval, whereas the exhibit's evidence points to a different constraint. It is tempting because throughput is a genuine deployment concern, and would be the right diagnosis if the exhibit showed the system processing too few requests per second.

Perform stemming or lemmatization.

Why it fails: Stemming is done after tokenization.

Remove stop words from the text.

Why it fails: Stop word removal is done after tokenization.

Replace missing values with a placeholder.

Why it fails: Missing value handling is not specific to preprocessing before tokenization.

The batch size is too large, making gradient updates insignificant.

Why it fails: Large batches reduce gradient noise but still produce non-zero updates, so five epochs would show some movement, not flat loss. Large batches are tempting because they are a known cause of poor generalisation, but that manifests as a train-validation gap, not absent training progress.

The output layer uses sigmoid activation instead of softmax.

Why it fails: Sigmoid outputs treat the ten classes as independent binaries, so cross-entropy gradients misalign with the mutually exclusive labels and learning stalls. Sigmoid is tempting because it suits multi-label tasks where classes co-occur; softmax is required when exactly one of ten classes is correct.

The learning rate is too high, causing the loss to oscillate.

Why it fails: Oscillating loss would still show epoch-to-epoch variation, whereas the log reports no improvement at all, which points to a learning rate too low or a saturated output layer. A high learning rate is genuinely the culprit when loss spikes or diverges rather than flatlining.

Remove all examples except 'billing' and use a one-class classifier.

Why it fails: Discarding the 2,000 'technical' examples destroys the minority class entirely, leaving a one-class model that cannot learn the decision boundary between billing and technical tickets. It is tempting because one-class classifiers suit anomaly detection, where only normal data exists and outliers must be flagged.

Use accuracy as the only evaluation metric.

Why it fails: Accuracy would report roughly 80% by predicting 'billing' always, hiding the poor 'technical' recall the imbalance causes. It is tempting because accuracy is a valid headline metric on balanced datasets, where classes are equally represented and errors cost the same.

Train the model as is, then adjust thresholds post-training.

Why it fails: Threshold tuning shifts the decision boundary after training, but the model still learns from an 80:20 split, so minority-class patterns remain underrepresented in the learned weights. It is tempting because threshold adjustment is a legitimate post-training step once class weights or resampling have already balanced the training signal.

Accuracy

Why it fails: Incorrect; accuracy can be high even if all positives are missed in rare class scenarios.

F1-score

Why it fails: Incorrect; F1 balances precision and recall, but precision alone is prioritized when false positives are costly.

Recall

Why it fails: Incorrect; recall measures how many actual positives are captured, not false positive control.

Retrain the model

Why it fails: Retraining alters model weights and accuracy, not inference latency, so it cannot bring response times within the SLA. It is tempting because retraining is the standard remedy for poor model quality, but it is the right action when predictions are inaccurate, not when the deployment is too slow.

Implement caching

Why it fails: Caching returns previously computed responses for repeated identical requests, so it cannot help unique or first-time queries, which still hit the model directly. It is tempting because caching is a standard latency optimisation, but it is the right action only when request patterns repeat heavily and results are safely reusable.

Reduce model input size

Why it fails: Shrinking the input reduces per-request compute and can lower latency, but it changes what the model receives and may degrade prediction quality rather than address the deployment bottleneck shown. It is tempting because smaller inputs do speed inference, yet it is correct only when input dimensionality itself is the constraint.

Supervised learning

Why it fails: Supervised learning requires labeled training data; recommendation systems often use unlabeled data.

Semi-supervised learning

Why it fails: Semi-supervised learning uses some labels; recommendation systems rarely have labels.

Transfer learning

Why it fails: Transfer learning is for reusing a model on a different task, not for building a new recommendation system from scratch.

Recall

Why it fails: Maximizing recall increases true positive rate but often increases false positives, which is already a problem.

Accuracy

Why it fails: Accuracy is misleading with imbalanced classes; it can be high even with many false positives.

Precision

Why it fails: Precision alone would reduce false positives but may increase false negatives, which is not fully addressed.

Increase the replay buffer size and continue training on the original dataset

Why it fails: Larger buffer doesn't add new experiences; the agent still misses high-volatility scenarios.

Keep the DQN but perform extensive hyperparameter tuning on the original data

Why it fails: Tuning hyperparameters doesn't introduce new data; the agent remains vulnerable to unseen conditions.

Switch to a policy gradient method with a random exploration strategy

Why it fails: Random exploration may not converge to a profitable policy and wastes compute.

Use a bagging ensemble method

Why it fails: Bagging trains base learners on bootstrap samples drawn from the same skewed distribution, so the 0.1% minority remains equally rare in every sample. It is tempting because it reduces variance, and it would be correct for stabilising high-variance models on balanced data.

Undersample the legitimate transactions

Why it fails: Undersampling discards the majority class, removing roughly 99.8% of legitimate transactions and destroying patterns the model needs to recognise normal behaviour. It is tempting because it balances class counts quickly, and it would be correct when the majority class is genuinely redundant.

Use cost-sensitive learning with higher weight on fraudulent class

Why it fails: Cost-sensitive learning modifies the algorithm's penalty, but it does not address data imbalance directly; SMOTE is preferred for preprocessing.

Algorithmic bias

Why it fails: Algorithmic bias is a consequence of biased data or design, not a type of data bias.

Sampling bias

Why it fails: Sampling bias is a subset of selection bias; the question expects distinct types.

Confirmation bias

Why it fails: Confirmation bias is a human tendency, not a data bias.

Switch to a linear regression model

Why it fails: Simplifying the model may help, but regularization is a more nuanced approach and typically the first step.

Increase the model complexity by adding more layers

Why it fails: Increasing complexity typically worsens overfitting, especially when the model already overfits.

Collect more data from the same hospital

Why it fails: More data from the same source may not address the distribution shift; it could reinforce existing biases.

Increase the minibatch size

Why it fails: Larger batches can speed up training but may lead to poor generalization; regularization is more effective for convergence issues.

Reduce the number of latent factors

Why it fails: Fewer factors may underfit and lose expressive power; regularization is more targeted.

Switch to the Adam optimizer

Why it fails: Adam can help, but the scenario already uses SGD; the primary issue is likely overfitting, which regularization addresses.