Grade 11 AI & Computer Science Practice Questions — Set 11

ExplanationSimCLR's NT-Xent loss embeds all 2N augmented views together and, for each anchor, computes a softmax over the remaining 2N − 1 embeddings from that step — the anchor's own vector is never compared against itself. Exactly one of those 2N − 1 embeddings, the anchor's other augmented view, is the positive; every remaining embedding is a negative, giving 2N − 2 negatives overall. With N = 128 this works out to 2(128) − 2 = 254, matching the choice that excludes both the anchor's own embedding and its one positive partner from the 2N embeddings produced that step. Excluding only the anchor's own embedding and leaving the positive partner folded in with the negatives, as the 255-count choice does, would corrupt the loss, because InfoNCE's numerator depends on the positive being kept separate from the denominator's negative sum. Assuming negatives come only from the other original images' first-view embeddings, as the 127-count choice does, ignores that SimCLR draws negatives from both augmented views across the entire batch, not just one view. And treating every embedding produced that step as a negative, as the 256-count choice does, is impossible since an anchor's own embedding is excluded from the similarity computation entirely.

ExplanationTraining a VAE with gradient descent requires computing gradients of the loss with respect to the encoder's output parameters, mu and sigma. If z is sampled directly as z ~ N(mu, sigma^2), the sampling operation itself has no meaningful derivative — you cannot ask 'how would this specific random draw change if mu shifted slightly', because a fresh random sample doesn't shift smoothly and predictably with its parameters. The reparameterization trick sidesteps this by rewriting the SAME distribution as z = mu + sigma*epsilon, where epsilon ~ N(0,1) is sampled independently of mu and sigma (its randomness is now external and fixed for that step). Now z is a plain, fully differentiable arithmetic function of mu and sigma (given a fixed epsilon draw), so ordinary backpropagation computes dz/dmu=1 and dz/dsigma=epsilon cleanly, letting gradients flow all the way back through z into the encoder's parameters — exactly as needed to train the encoder end-to-end via standard gradient descent.

ExplanationThe KL divergence term in a VAE's loss measures how far the encoder's learned posterior distribution for a given input is from the prior N(0,1) — near-zero KL for a specific dimension means that dimension's posterior has essentially become identical to the prior REGARDLESS of the input, meaning the encoder has stopped putting any input-specific (useful) information into that dimension at all; the decoder has effectively learned to ignore it (a phenomenon called posterior collapse), because a powerful decoder found it cheaper to reconstruct without paying that dimension's KL cost. This tends to happen when a powerful decoder can achieve low reconstruction loss largely on its own, making the 'cost' of using additional latent dimensions (each contributing to the KL penalty) not worth paying for the marginal reconstruction benefit. KL annealing — starting the KL term's weight near 0 so the model first learns to genuinely USE the latent space to reconstruct well, then gradually ramping the KL weight up to its full value — is a standard mitigation, alongside related techniques like 'free bits' that only penalize a dimension's KL once it exceeds a small threshold.

ExplanationThis tradeoff stems directly from what each model is trained to optimize. A GAN's generator is trained adversarially, purely to fool a discriminator into believing its outputs are real — there is no pixel-wise reconstruction loss pulling outputs toward a blurry 'average' of plausible images, so GANs tend to commit confidently to sharp, high-frequency details, at the cost of training instability and no built-in way to ask 'how likely is this specific real image under my model' (there's no encoder or explicit likelihood in a standard GAN). A VAE's decoder is trained via a reconstruction loss (like pixel-wise MSE) plus a KL regularization term — this objective, applied under genuine uncertainty about the exact right pixel values, mathematically favors predicting the AVERAGE of several plausible outputs rather than committing sharply to one, which is a well-documented cause of VAEs' characteristically blurrier samples; but the same architecture naturally provides both an encoder (letting you compute how well any real image fits, via its reconstruction error) and a principled probabilistic framework. Choosing between them is a genuine tradeoff based on which property (sharpness vs. scorability) matters more for the specific application.

ExplanationAttention scores start as raw dot products between the query and each key: Q·K_A = (1)(1)+(2)(0) = 1; Q·K_B = (1)(0)+(2)(1) = 2; Q·K_C = (1)(1)+(2)(1) = 3. Scaling each by 1/sqrt(d_k) = 1/sqrt(2) ≈ 0.7071 gives approximately 0.7071, 1.4142, and 2.1213 respectively. Applying softmax (exponentiate each, then normalize by the sum): exp(0.7071)≈2.028, exp(1.4142)≈4.113, exp(2.1213)≈8.342, summing to ≈14.483; dividing each by that sum gives approximately [0.140, 0.284, 0.576]. Key C dominates the attention distribution at roughly 57.6%, because it has the highest raw alignment with the query in both dimensions simultaneously (Q=(1,2) shares both a nonzero first component with K_A/K_C and a nonzero second component with K_B/K_C, but only K_C matches on BOTH). This worked example is exactly the mechanism scaled up (with learned Q/K/V projection matrices) inside every transformer's self-attention layer.

ExplanationA common misconception is that multi-head attention must use MORE parameters than single-head attention, since it has multiple heads. In the standard transformer formulation, this isn't the case: the Q, K, V, and output projection matrices are each sized d_model x d_model REGARDLESS of how many heads the computation is split into — splitting into 8 heads of d_k=64 each just means each head operates on a 64-dimensional SLICE of the same overall d_model=512-dimensional projected space, with all 8 slices concatenated back together before the final output projection. The total parameter count (4 x d_model^2, for Q/K/V/output) is IDENTICAL whether you use 1 head of size 512 or 8 heads of size 64 each. What multi-head attention actually buys you, at the SAME parameter budget, is the ability to learn several DIFFERENT attention patterns in parallel — different heads empirically specialize in different kinds of relationships (e.g., syntactic dependencies vs. positional proximity) — rather than being forced into one single, averaged attention pattern that a single large head would compute.

ExplanationMode collapse is one of the most notorious training pathologies of the original GAN formulation: instead of learning to generate the full DIVERSITY of the real data distribution (many different faces, digits, etc.), the generator discovers a narrow set of outputs — sometimes even a single output — that reliably fools the current discriminator, and then keeps producing variations on just that, abandoning the rest of the data distribution's diversity entirely. This is an inherent risk of the vanilla minimax objective, not merely a hyperparameter bug: the generator's loss only cares about fooling D at each step, with no explicit term rewarding output diversity, so if the discriminator has a blind spot that a narrow set of outputs exploits, the generator keeps exploiting exactly that blind spot rather than exploring the broader data manifold, because doing so is the path of least resistance under its own objective. This exact failure mode is a major motivation behind alternative formulations like WGAN, which replaces the original discriminator's binary real/fake classification with a smoother, more informative Wasserstein-distance-based critic that provides more consistent, mode-collapse-resistant training signal.

ExplanationA core problem with the original GAN's discriminator-based loss is that once the discriminator becomes very good at distinguishing real from fake (which tends to happen readily, especially early in training when the generator's outputs are still poor), the JS-divergence-based loss saturates — the discriminator's output becomes extremely confident (near 0 or 1) in regions with little useful gradient signal, meaning the GENERATOR receives a vanishing gradient telling it almost nothing useful about how to improve, even though it clearly still needs to. The Wasserstein distance, by contrast, remains a smooth, meaningful, non-saturating measure of how far apart two distributions are, even when they have little or no overlap — it keeps providing a genuinely informative gradient signal to the generator throughout training, rather than flatlining once the critic becomes confident. This smoother loss landscape is WGAN's central practical advantage, directly addressing the vanishing-gradient and general training-instability problems that plague the original GAN formulation — though it requires additional constraints (like weight clipping, or the improved gradient penalty in WGAN-GP) to keep the critic within the mathematically required 1-Lipschitz function class.

ExplanationREINFORCE's raw gradient estimator uses the full return G to scale the log-probability gradient of each action taken — but G's raw scale can vary enormously between trajectories (a return of 100 in one episode vs. 10,000 in another, even for similarly-good actions relative to what was achievable in that state), producing a noisy, high-variance gradient estimate that makes learning slow and unstable. Subtracting a baseline b(s) — commonly an estimate of the state's expected value V(s) — reframes the learning signal as an ADVANTAGE: (G - b(s)) captures 'how much better or worse did this action's outcome turn out compared to what was expected from this state', a naturally more centered, lower-variance quantity that still points gradients in the correct direction. Critically, this subtraction is UNBIASED as long as the baseline depends only on the state (not on the specific action chosen) — a well-known result in policy gradient theory shows that the expected value of the gradient contribution from any action-independent baseline term is exactly zero, so subtracting it changes the estimator's VARIANCE without shifting its expected value (and thus without changing what the algorithm converges to).

ExplanationRLHF's reward model is trained on human-labeled PAIRWISE COMPARISONS: for a given prompt, two (or more) candidate model responses are shown to a human labeler, who indicates which response they prefer — a RELATIVE judgment, not an absolute numeric rating. This design choice is deliberate and well-documented: extensive research (including in the original InstructGPT-style RLHF papers) has found that human raters are considerably more consistent when making relative comparisons ('is response A better than response B') than when assigning absolute numeric scores ('rate this 1 to 10') — the same response might get wildly different absolute scores from different labelers, or even the same labeler at different times, whereas 'which of these two is better' tends to produce much more stable, reproducible agreement. These pairwise preference labels are then used (typically via a Bradley-Terry style model) to train a reward model that outputs a SINGLE numeric score per response, which subsequently serves as the reward signal for the actual PPO reinforcement learning step that fine-tunes the language model's policy.

ExplanationA Markov Decision Process formalizes sequential decision-making under uncertainty with five core elements: a set of States (S) describing all possible situations; a set of Actions (A) available to the agent; a Transition function P(s'|s,a) giving the probability of landing in state s' after taking action a in state s; a Reward function R(s,a) (or R(s,a,s')) specifying the immediate reward received; and a discount factor gamma weighing future rewards against immediate ones. The defining 'Markov' property is a specific, strong assumption: the transition and reward at any step depend ONLY on the current state and action — NOT on the full history of states/actions that led there. In other words, the current state must be a sufficient statistic capturing everything relevant to predicting the future; if the true dynamics genuinely depended on older history beyond the current state, the state representation itself would need to be redesigned (e.g., by including recent history explicitly) to restore the Markov property, which is exactly why careful STATE DESIGN is such a critical, often underappreciated part of formulating a real-world problem as an MDP.

ExplanationThe search space in NAS defines the full universe of candidate architectures the search process is even allowed to consider — for example, which specific operations (3x3 convolution, 5x5 convolution, max pooling, skip connections, etc.) are available as building blocks at each position, how many layers/blocks the network can have, and what connectivity patterns between them are permitted. This design choice is critically important on both ends of a real tradeoff: an excessively LARGE, unconstrained search space (allowing essentially arbitrary connections and operations) makes the actual search computationally intractable, since the number of possible architectures can be astronomically large, and most search strategies (reinforcement learning controllers, evolutionary methods, or gradient-based approaches like DARTS) become far less sample-efficient as the space balloons. Conversely, a search space designed too narrowly (e.g., only allowing variations on one basic building block) might structurally EXCLUDE any genuinely excellent architecture from ever being considered, no matter how good the search algorithm is — the search can only find the best architecture that actually EXISTS within the space it's given to explore. This is why practical NAS research invests heavily in designing search spaces that are both tractable AND known to contain strong candidates, often based on human architectural intuition as a starting scaffold.

ExplanationThe central appeal of Mixture of Experts is decoupling a model's total PARAMETER COUNT (its overall capacity/knowledge storage) from its per-token COMPUTATIONAL COST (how much compute is spent processing any single input). With 8 experts but a gate that routes each token to only the TOP 2, a given token's forward pass only activates 2/8 = 25% of the expert parameters — the compute cost for that token is roughly the same as a dense network only 2 experts' worth in size, even though the model's TOTAL parameter count (and thus its overall representational capacity, since different tokens can route to different expert combinations) reflects all 8 experts combined. This means an MoE model can have dramatically more total parameters than a comparably-priced (in compute terms) dense model, since most of those parameters sit idle for any given token, only 'switching on' when a token happens to route to them — a property that has made MoE architectures central to scaling modern large language models to enormous total parameter counts without a proportional explosion in the compute required per token processed.

ExplanationSharing lower layers across related tasks provides two complementary benefits. First, it acts as an implicit REGULARIZER: a feature representation that must simultaneously serve multiple different tasks well is under pressure to capture genuinely general, robust patterns (like real edges and textures useful for many vision tasks) rather than overfitting to quirks specific to just one task's training set — features that only happen to help one narrow task, possibly by exploiting spurious correlations in its data, are less likely to also help a genuinely different task, so the shared representation gets pushed toward more transferable structure. Second, and just as importantly, each task's labeled training examples effectively contribute gradient signal to the SAME shared parameters — a task with abundant labeled data can help train better shared features that a DATA-SCARCE related task then benefits from too, a form of implicit knowledge transfer between tasks that wouldn't happen with fully separate models. This is precisely why multi-task learning tends to particularly shine when at least one task has limited labeled data but shares meaningful underlying structure with a data-richer task.

ExplanationIoU measures overlap quality between a predicted box and the ground-truth box, computed as intersection area divided by union area. The predicted box spans x:[0,4], y:[0,4]; the ground-truth spans x:[2,6], y:[2,6]. The INTERSECTION is the overlapping rectangle: x-overlap is [max(0,2), min(4,6)] = [2,4] (width 2), y-overlap is [max(0,2), min(4,6)] = [2,4] (height 2), giving intersection area = 2x2 = 4. The UNION is the total area covered by either box, computed as (area of box 1) + (area of box 2) - (intersection, since it would otherwise be double-counted) = 16+16-4 = 28. IoU = 4/28 ≈ 0.1429. This relatively low IoU (well below the common 0.5 threshold used to judge a 'correct' detection in benchmarks like PASCAL VOC or COCO) illustrates that even two same-sized, substantially-overlapping boxes can have surprisingly low IoU if their overlap region is small relative to their combined footprint — which is exactly why IoU, not simple overlap area alone, is the standard metric for judging localization quality.

ExplanationThe Dice coefficient (also called the F1 score in a set-overlap context) is computed as (2 x intersection) / (size of set A + size of set B): here, (2x8)/(10+12) = 16/22 ≈ 0.7273. Comparing to IoU for the identical scenario — IoU = intersection/union = 8/(10+12-8) = 8/14 ≈ 0.5714 — Dice gives a noticeably HIGHER numeric value for the exact same underlying overlap. This isn't a contradiction; it's a structural property of the two formulas: Dice's numerator counts the overlap TWICE (2x8=16) against a denominator that's simply the sum of both areas (22, which double-counts the overlap region once), while IoU's denominator is the true UNION (14, counting the overlap region only once) — Dice is mathematically always greater than or equal to IoU for the same two sets (in fact, Dice = 2xIoU/(1+IoU) exactly). Despite differing numerically, both metrics rank different candidate predictions in the SAME relative order (a prediction with better overlap always scores higher on both), which is why either metric is a valid choice for segmentation evaluation, with Dice being especially common in medical image segmentation.

ExplanationThe defining trick of self-supervised learning is constructing a training SIGNAL entirely from unlabeled data's own inherent structure, with no human annotation required — the 'labels' for the pretext task are derived programmatically and automatically. For masked-patch prediction: you take an unlabeled image, deliberately hide (mask) a patch, and task the model with predicting what was there — the actual pixel values of the masked patch, which you already know (you masked it yourself), serve as a free, automatically-generated label. Crucially, the pretext task is never the actual end goal — nobody genuinely cares about a model's ability to fill in masked patches for its own sake. What matters is that SOLVING this task well forces the model to learn genuinely useful internal representations: understanding masked-patch content well requires understanding textures, object boundaries, spatial context, and typical scene structure — exactly the kind of general visual knowledge that transfers effectively to real downstream tasks (like image classification or object detection) once the pretrained model is fine-tuned on a smaller labeled dataset for that actual task. This 'pretrain on a free, automatically-generated task, then fine-tune on the real task' pattern underlies most modern self-supervised approaches, in vision and language alike.

ExplanationThe choice between masking (BERT) and left-to-right next-word prediction (GPT-style) reflects a fundamental architectural tradeoff. A standard next-word predictor must be causally constrained — it can only attend to PREVIOUS tokens when predicting the next one, because if it could see future tokens during training, predicting the 'next' word would become a trivial lookup (the answer would be sitting right there in the visible context), making the whole training signal meaningless. Masking sidesteps this constraint entirely: since the model is predicting a token in the MIDDLE of a sequence (with both earlier and later tokens visible, just not the masked position itself), it's free to use FULL bidirectional context — attending to words both before AND after the masked position — without any risk of trivially 'cheating', since the actual masked word is genuinely hidden, not just positioned later in a left-to-right scan. This bidirectional context is what makes BERT's learned representations particularly strong for tasks requiring deep understanding of a word's full surrounding context (like question-answering or sentence classification), which is exactly the design goal MLM was created to serve — at the cost of BERT not being naturally suited to autoregressive text GENERATION the way a next-word predictor is.

ExplanationCBOW and Skip-gram are mirror-image training setups for learning word embeddings from local context, differing in which direction the prediction runs. CBOW (Continuous Bag of Words) takes the SURROUNDING context words as input (here, 'the', 'quick', 'fox', 'jumps' within the window-2 context around 'brown') and tries to predict the single TARGET word ('brown') that belongs in the middle — context words predict the target. Skip-gram works in the opposite direction: it takes the single TARGET word ('brown') as input and tries to predict EACH of the surrounding context words individually ('the', 'quick', 'fox', 'jumps' as separate prediction targets) — the target predicts its context. In practice, Skip-gram tends to perform better on rarer words (since it generates multiple training examples, one per context word, from each occurrence of a word), while CBOW trains faster and can perform slightly better on frequent words, since it smooths over multiple context words as a single averaged input signal rather than treating them as separate training examples.

ExplanationConvolutional neural networks trained on large, diverse image datasets tend to develop a characteristic HIERARCHY of learned features: early layers capture very general, low-level visual patterns (edges, corners, simple textures, color gradients) that are broadly useful across nearly any visual recognition task, since virtually all real images are built from these same basic visual primitives — this generality is exactly why these early features transfer well even to a very different domain like X-rays. Later layers, by contrast, tend to capture increasingly task-specific, high-level, semantic patterns (like 'this combination of shapes typically indicates a cat's face') that are much more tied to the specific dataset and task the network was originally trained on. With only 500 X-ray images, attempting to fine-tune ALL layers (including the early, general ones) risks CATASTROPHICALLY overfitting or degrading those well-learned general features — 500 images is nowhere near enough data to relearn robust low-level feature detectors from scratch without them collapsing into overly narrow, X-ray-specific (and likely worse) versions. Freezing the early layers protects this valuable, broadly-useful general knowledge while still allowing the later, more task-specific layers (and the new classification head) the flexibility to adapt to the new domain and task.

ExplanationThe structural difference translates into a genuine practical tradeoff, not a strict ordering of 'better' and 'worse'. GRU's design — 2 gates instead of 3, and a single merged hidden state instead of LSTM's separate cell state and hidden state — means fewer total learnable parameters for a given hidden size, which typically means faster training per step, lower memory usage, and often better generalization on SMALLER datasets (fewer parameters means less capacity to overfit limited data). LSTM's additional gate and separate cell state (which acts as a more protected, longer-term 'memory highway' distinct from the hidden state used for immediate output) give it finer-grained, more expressive control over exactly what information gets added, kept, or discarded at each timestep — this extra capacity can help capture more complex long-range dependencies, but requires more data and compute to fully exploit; on smaller or simpler tasks that extra capacity may bring no benefit while adding unnecessary training cost. In practice, both remain in active use, and the right choice is typically determined empirically per task and dataset size, not by a universal rule that one always beats the other.