AI Concepts and Techniques practice questions

Precision

Why wrong: Precision only considers the correctness of positive predictions, ignoring false negatives.

Recall

Why wrong: Recall only measures how many actual positives are captured, ignoring false positives.

Accuracy

Why wrong: Accuracy can be high even if the model predicts 'no default' for all cases, which fails to capture the minority class.

Set top-p to 0.1

Why wrong: Top-p controls nucleus sampling; a low top-p can limit creativity but may also cut off plausible continuations.

Increase top-k to 100

Why wrong: Increasing top-k considers more tokens, which can increase randomness and off-topic responses.

Increase temperature to 0.9

Why wrong: Higher temperature increases randomness, likely producing more off-topic responses.

Supervised classification with logistic regression

Why wrong: Supervised classification requires many labeled attack examples, which are not available.

Reinforcement learning

Why wrong: Reinforcement learning is for sequential decision-making, not for detecting anomalies in static data.

Semi-supervised learning

Why wrong: Semi-supervised learning still requires some labeled data; here very few labels exist.

Use early stopping without any other regularisation

Why wrong: Early stopping alone may not sufficiently regularise a small dataset; combining with dropout or weight decay is more robust.

L1 regularisation and batch normalisation

Why wrong: L1 regularisation encourages sparse weights, which may not be ideal for dense layers, and batch normalisation is not a strong regulariser for small datasets.

Increase learning rate and use momentum

Why wrong: Increasing learning rate can cause divergence and does not address overfitting; momentum helps convergence but not regularisation.

Use a convolutional neural network (CNN) on raw text

Why wrong: CNNs are typically used for image data; they can be applied to text but are less effective than transformers for this task.

Train a recurrent neural network (RNN) from scratch

Why wrong: RNNs struggle with long-range dependencies and are outperformed by transformers for text classification.

Word2vec embeddings followed by logistic regression

Why wrong: This approach works but lacks the contextual understanding of transformer models like BERT.

Reinforcement learning

Why wrong: Reinforcement learning is for sequential decision-making in dynamic environments, not static recommendation.

Unsupervised clustering

Why wrong: Clustering can segment users but does not directly predict which product a user will buy.

Self-supervised learning

Why wrong: Self-supervised learning is typically used for pre-training representations, not directly for recommendation.

The learning rate is too high; decrease it to 0.0001

Why wrong: A high learning rate would cause the loss to oscillate or increase, not slowly decrease.

The model is overfitting; add L2 regularisation

Why wrong: Overfitting does not cause slow decrease of loss; regularisation may reduce overfitting but not address the learning rate.

The batch size is too large; reduce it

Why wrong: Batch size affects noise but not the rate of decrease as directly as learning rate.

Mode collapse has occurred; increase the generator's learning rate

Why wrong: Mode collapse leads to limited variety, not necessarily the described loss pattern.

The discriminator is overfitting; decrease its capacity

Why wrong: Overfitting would cause discriminator loss to be low, not high.

The learning rates are too high; reduce both

Why wrong: High learning rates would cause both losses to oscillate, not this specific pattern.

Language translation

Why wrong: Translation changes language but does not extract phrases.

Text classification

Why wrong: Text classification assigns categories but does not extract phrases.

Sentiment analysis

Why wrong: Sentiment analysis determines emotional tone, not key phrases.

Neural network (MLP)

Why wrong: Neural networks are black-box models with low interpretability.

Gradient boosting machine

Why wrong: GBMs are powerful but not easily interpretable.

Random forest classifier

Why wrong: Random forests are less interpretable than a single decision tree.

Positional encoding

Why wrong: Positional encoding adds information about token position, not OOV handling.

Feed-forward layers

Why wrong: Feed-forward layers transform representations but do not address tokenisation.

Attention mechanism

Why wrong: Attention helps the model focus on relevant parts but does not handle OOV tokens.

Increase the number of LSTM units

Why wrong: Increasing model capacity would likely increase overfitting.

Increase the number of training epochs

Why wrong: More epochs can lead to overfitting, making the gap worse.

Reduce the sequence length

Why wrong: Reducing sequence length may lose important information and might not address overfitting.

Fine-tune the model on safe conversational examples

Why wrong: Fine-tuning can improve general safety but is not a direct or immediate injection mitigation.

Use a larger context window

Why wrong: A larger context window does not prevent injection; it may even provide more room for injection.

Limit the maximum output token length

Why wrong: Limiting output length reduces verbosity but does not prevent injection.

Accuracy

Why wrong: Accuracy is high even if the model predicts negative for all cases, hiding poor performance on positives.

Perplexity

Why wrong: Perplexity is used for language model evaluation, not binary classification.

Variational autoencoders (VAEs)

Why wrong: VAEs can generate images but often produce lower quality than GANs or diffusion models.

BERT-based model

Why wrong: BERT is for natural language understanding, not generation.

GPT-style language model

Why wrong: GPT models are designed for text generation, not image generation.

Use a larger foundation model with a longer context window and paste all documents into each prompt

Why wrong: Pasting all documents into every prompt is expensive, hits context limits for large document sets, and does not scale as the document library grows.

Fine-tune a base LLM on the policy documents monthly

Why wrong: Fine-tuning is expensive and time-consuming; monthly cycles are impractical and fine-tuned knowledge becomes stale immediately after cutoff.

Train a custom model from scratch on the policy documents each month

Why wrong: Training from scratch requires massive compute resources and weeks of time — entirely disproportionate for monthly document updates.

Reinforcement learning

Why wrong: Reinforcement learning uses rewards/penalties from interactions; this is not the case here.

Unsupervised learning

Why wrong: Unsupervised learning works with unlabeled data; here labels are available.

Self-supervised learning

Why wrong: Self-supervised learning creates labels from data itself; here labels are provided externally.

The temperature parameter is set too high

Why wrong: Temperature is used during generation, not training, and does not affect perplexity during training.

The batch size is too small

Why wrong: Small batch size adds noise but doesn't typically cause validation loss to increase while training loss decreases.

The learning rate is too low

Why wrong: A low learning rate typically causes slow convergence but not validation loss increase.

Variational autoencoder (VAE)

Why wrong: VAEs generate images but often produce blurry outputs compared to diffusion models.

Generative adversarial network (GAN)

Why wrong: GANs can be difficult to train and may not match the quality and diversity of modern diffusion models.

Recurrent neural network (RNN)

Why wrong: RNNs are designed for sequential data, not image generation.

Precision

Why wrong: Precision focuses on minimising false positives, not false negatives.

F1-score

Why wrong: F1 balances precision and recall; when false negatives are extremely costly, recall alone is more appropriate.

Accuracy

Why wrong: Accuracy can be misleading if class imbalance exists; it does not specifically penalise false negatives.