Grade 11 AI & Computer Science Practice Questions — Set 9

ExplanationLabel smoothing formula: y_smooth = (1-alpha)×y_hot + alpha×(1/K). With alpha=0.1, K=5: uniform component = 0.1/5 = 0.02 for each class. True class: 0.9×1 + 0.02 = 0.92. Other classes: 0.9×0 + 0.02 = 0.02. Smoothed: [0.02, 0.02, 0.92, 0.02, 0.02]. Sum check: 0.02×4 + 0.92 = 0.08+0.92 = 1.0. Label smoothing prevents the model from becoming overconfident because it can never achieve zero loss — even a perfect prediction has loss = -0.92×ln(0.92) - 4×0.02×ln(0.02) > 0.

ExplanationDynamic loss scaling adjusts to balance precision and range in FP16. Starting scale: 65,536 (2^16). Step 1 (no overflow): ×2 → 131,072. Step 2 (no overflow): ×2 → 262,144. Step 3 (no overflow): ×2 → 524,288. Step 4 (overflow detected in the FP16 gradients): ÷2 → 262,144. When an overflow occurs, the optimizer skips that step entirely because the FP16 gradients contain inf/nan values and cannot produce valid weight updates; halving the scale then reduces the chance of overflow on the next step. The loss scale after step 4 is 262,144.

ExplanationU-Net skip connections CONCATENATE encoder and decoder feature maps along the channel axis (not add — that is ResNet). At 64×64: encoder features have shape (batch, 128, 64, 64) and decoder features have shape (batch, 128, 64, 64). Concatenation produces (batch, 256, 64, 64). The next conv layer (typically 3×3) maps 256→128 channels, learning to combine the encoder's high-resolution details with the decoder's semantic understanding. This is why U-Net excels at segmentation — it preserves spatial precision through skip connections while building semantic understanding through the bottleneck.

ExplanationFor stride-1 convolutions, receptive field = 1 + L×(k-1) where L=number of layers, k=kernel size. RF = 1 + 3×(3-1) = 1 + 6 = 7. Alternatively: layer 1 output pixel sees 3×3 input. Layer 2 sees 3×3 of layer 1 outputs, each seeing 3×3 input = 5×5 input. Layer 3: 7×7 input. Parameter comparison: three 3×3 = 3×9C² = 27C². One 7×7 = 49C². Savings: 27/49 = 55% of 7×7 params. Plus, 3 nonlinearities vs 1 means the 3-layer version can represent more complex functions. This VGGNet insight revolutionized CNN architecture design.

ExplanationCosine annealing follows lr(t) = lr_min + 0.5(lr_max − lr_min)(1 + cos(π×t/T)). With lr_max = 0.2, lr_min = 0.0, and T = 200, the amplitude term 0.5(lr_max − lr_min) = 0.1. At t = 50, π×50/200 = π/4, and cos(π/4) ≈ 0.7071, giving lr = 0.1×(1+0.7071) = 0.1707. At t = 100, π×100/200 = π/2, and cos(π/2) = 0, giving lr = 0.1×(1+0) = 0.1000 — exactly the midpoint between lr_max and lr_min, reached halfway through the period. At t = 150, π×150/200 = 3π/4, and cos(3π/4) ≈ −0.7071, giving lr = 0.1×(1−0.7071) = 0.0293. The learning rate therefore decays smoothly and non-linearly from lr_max toward lr_min as t runs from 0 to T, reaching the true minimum only at t = T, never at t = T/2. Treating the decay as linear would instead predict 0.15, 0.1, and 0.05, and assuming the rate stays fixed at the average value throughout ignores the shape of the cosine curve entirely.

ExplanationWith T=2: divide logits by T → [2.5, 1.5, 0.5]. Softmax: e^2.5=12.18, e^1.5=4.48, e^0.5=1.65. Sum=18.31. P = [12.18/18.31, 4.48/18.31, 1.65/18.31] = [0.665, 0.245, 0.090]. With T=1: e^5=148.4, e^3=20.09, e^1=2.718. Sum=171.2. P = [0.867, 0.117, 0.016]. At T=1 the model is very confident (86.7% class 0). At T=2 the distribution is softer (66.5% class 0). The softer distribution reveals that class 1 is more similar to class 0 than class 2 is — this inter-class structure is the dark knowledge the student learns. Temperature scaling works because dividing logits by T > 1 flattens the distribution, while T < 1 sharpens it, calibrating confidence.

ExplanationL2 norm: ||g|| = sqrt(3²+4²+0²+0²) = sqrt(9+16) = sqrt(25) = 5.0. Gradient clipping: if ||g|| > max_norm, scale g by max_norm/||g||. Here ||g|| = 5.0 = max_norm (not strictly greater), so no scaling is needed and the result is [3, 4, 0, 0]. A common error is comparing the squared norm (25) to max_norm instead of the actual norm (5.0), which would wrongly trigger clipping and produce [0.6, 0.8, 0, 0] instead. Another error is using the L1 norm (sum of absolute values = 7) instead of the L2 norm. A third error is clamping each component independently with min(component, max_norm) instead of scaling the whole vector uniformly, which would distort the gradient's direction rather than preserve it. Important: gradient clipping scales the ENTIRE vector uniformly to preserve direction, unlike per-component clamping.

ExplanationStandard cross-entropy for true class B with predicted p=0.3: CE = -ln(0.3) = 1.204. Weighted version multiplies the loss by the class weight: Weighted_CE = w_B × CE = 5.0 × 1.204 = 6.02. The gradient for this sample is also 5× larger, making the model update 5× more strongly to correct this misclassification. The weights are typically set inversely proportional to class frequency: w = N_total/(num_classes × N_class). For class C with only 50 samples, weight=10 ensures that getting C wrong has 10× the penalty of getting A wrong, compensating for the 10:1 sample imbalance.

ExplanationThe chain rule multiplies local gradients: dL/dw1 = dL/dz10 * dz10/dz9 * ... * dz2/dz1 * dz1/dw1. If each factor is < 1, the product shrinks exponentially. Sigmoid's max derivative is 0.25 (at z=0), so 10 sigmoid layers: gradient ≤ 0.25^10 ≈ 1e-6. Early layers receive near-zero gradients and stop learning. ReLU fixes this: its derivative is exactly 1 for positive inputs (no shrinkage). ResNets add skip connections: x + F(x), giving gradient paths that bypass layers entirely. He initialization (variance = 2/n) also helps by keeping initial activations in the linear regime.

ExplanationThe GAN game: D wants to output 1 for real data (maximize log D(x)) and 0 for fake data (maximize log(1-D(G(z)))). G wants D to output 1 for its fakes (minimize log(1-D(G(z)))). If D is perfect: D(real)=1, D(fake)=0. Then G's loss = log(1-0) = 0 with near-zero gradient — G cannot learn which direction to improve. This is why GAN training is notoriously unstable. Wasserstein GAN (WGAN) uses Earth Mover's distance instead, providing meaningful gradients even when D is confident. Practical fix: train D for k=1 step, then G for 1 step, keeping them balanced.

Explanationε-greedy: with probability ε (0.1), choose a random action (explore); with probability 1-ε (0.9), choose argmax Q(s,a) (exploit). Here, exploitation chooses 'right' (Q=8, highest). The 10% exploration ensures the robot occasionally tries non-optimal actions, which might lead to discovering better long-term strategies. The Q-update rule uses the Bellman equation: current estimate + α*(target - current), where target = immediate reward + discounted future value. α controls learning speed, γ controls how much future rewards matter.

ExplanationWord2Vec (skip-gram/CBOW) learns one vector per word type from co-occurrence statistics. The single "bank" vector ends up somewhere between its financial and geographical meanings — a compromise that represents neither perfectly. BERT processes the full sentence through 12+ transformer layers with self-attention: each token's representation is influenced by ALL other tokens. So "bank" attends to "river" and produces a nature-context embedding, while "bank" attending to "loan" produces a finance-context embedding. This is why BERT revolutionized NLP — contextual embeddings capture word sense naturally.

ExplanationCNN feature hierarchy: early layers learn edges, corners, textures (universal to all images); middle layers learn shapes, parts (mostly transferable); final layers learn class-specific combinations. This produces the result that food classification works because edges/textures of crispy samosa crust and round vada pav shape are built from universal low/mid-level features. Only the final mapping (features → food classes) is domain-specific. Strategy: (1) Replace final FC layer: nn.Linear(2048, 5), because the original outputs 1000 classes. (2) Freeze early+middle layers (layers 1-45 of 50). (3) Fine-tune last 1-2 residual blocks with lr=1e-4 (10x smaller than new layer's lr=1e-2). This requires only ~500-1000 images per class instead of millions, since the frozen layers already extract useful features.

ExplanationDropout randomly zeroes each neuron's output with probability p during training. With p=0.5 and 100 neurons: E[active] = 100*(1-0.5) = 50. This forces the network to learn redundant representations (no single neuron can be relied upon). At inference, dropout is disabled — all 100 neurons fire, doubling the expected output magnitude. Inverted dropout (standard in PyTorch/TF) scales training outputs by 1/(1-p) = 2, so inference needs no modification. Mathematically: during training, E[output] = (1-p)*x * 1/(1-p) = x. During inference: output = x. The expectations match.

ExplanationThe universal approximation theorem says a single hidden layer CAN approximate any function — but doesn't say it's practical. Depth helps learn hierarchical features (edges → shapes → objects), but too much depth with insufficient data leads to overfitting because the model memorizes noise. A 200-layer model (5M params) on 1000 training images produces training loss near 0.001 but validation loss of 2.5+ — classic overfitting. Additionally, deeper networks face vanishing gradients (gradient shrinks by 0.25^200 with sigmoid), which causes early layers to stop learning entirely. ResNets solve this with skip connections, and GPT-3 with 96 layers cost ~$4.6M to train. The result is that model complexity must match data complexity — 200 layers need millions of samples to generalize.

ExplanationGiven input X (5×64): Q = X·W_Q, K = X·W_K, V = X·W_V, where W matrices are (64×64), giving Q,K,V all (5×64). Attention scores: Q·K^T = (5×64)·(64×5) = (5×5). Each entry = dot product of two 64-dim vectors. Scale by 1/sqrt(64) = 1/8 to prevent large magnitudes. Softmax row-wise: each row sums to 1, giving a probability distribution over tokens. Multiply by V: (5×5)·(5×64) = (5×64). Result: each token's output is a weighted sum of all tokens' values, weighted by attention scores. This is the core of Transformers.

ExplanationVanilla RNN gradient: dL/dh_1 = product(dh_t/dh_{t-1}, t=2..100). Each factor involves tanh derivative (max 1.0) and weight matrix W, producing a product that shrinks exponentially over 100 steps — word 1 gets near-zero gradient from word 100. LSTM cell state: C_t = f_t * C_{t-1} + i_t * tanh(W_C * [h_{t-1}, x_t]). The gradient through C flows as: dC_{t-1}/dC_t = f_t (element-wise multiply, no matrix multiply). If f_t ≈ 1, gradients flow unchanged through 100 steps — this is the "gradient highway." The forget gate f_t = sigma(W_f * [h_{t-1}, x_t] + b_f) learns when to clear memory (f_t→0) vs preserve (f_t→1). For a pronoun resolution task, f_t keeps "she" in memory until the referent is resolved.

Explanationd_k = d_model/h = 512/8 = 64. Each head has separate learned projections: W_Q^i (512×64), W_K^i (512×64), W_V^i (512×64). Head i computes: Attention_i = softmax(Q_i * K_i^T / sqrt(64)) * V_i. All 8 outputs (each 64-dim) are concatenated back to 512-dim, then linearly projected. Why this works: in "The cat sat on the mat because it was tired," different heads learn different "it" → "cat" attention patterns. Head 1 might attend based on recency, head 2 on syntactic role, head 3 on semantic fit. Total parameters: 8 * 3 * (512*64) = 786,432 for Q,K,V projections. This is the same parameter count as a single 512-dim head: 3 * (512*512) = 786,432.

ExplanationSARSA update: Q(S,a) += alpha * [R + gamma * Q(S',a') - Q(S,a)], where a' is the action actually taken at S'. Q-learning update: Q(S,a) += alpha * [R + gamma * max_a' Q(S',a') - Q(S,a)], where max_a' gives the value of the best action. With alpha=0.1, gamma=0.99, and R=10: SARSA target = 10 + 0.99*Q(S',up), Q-learning target = 10 + 0.99*max_a Q(S',a). Practical impact: near a cliff edge with reward -100, epsilon-greedy (epsilon=0.1) sometimes picks 'fall off cliff'. SARSA accounts for this risk because a' might be the bad action, producing lower Q-values near cliffs. Q-learning ignores exploration risk because it uses max (the optimal action). This makes SARSA "safer" — it learns policies that account for the agent's 10% exploration mistakes, giving more conservative behavior.

ExplanationThe core problem: backprop needs d(output)/d(parameters) for every node. A sampling node z ~ N(mu, sigma^2) has no meaningful derivative — "how does z change when mu changes by 0.01?" has no answer because z is random. The trick: z = mu + sigma * epsilon, where epsilon ~ N(0,1) is sampled ONCE and treated as a constant. Now: dz/dmu = 1, dz/dsigma = epsilon — both are well-defined. Gradients flow through: dL/dmu = dL/dz * 1, dL/dsigma = dL/dz * epsilon. This produces the result that the encoder parameters (mu, sigma) receive gradient updates, enabling end-to-end training. Without this trick, VAEs cannot be trained with standard backpropagation — you'd need REINFORCE estimators, which have high variance and slow convergence.