Grade 11 AI & Computer Science Practice Questions — Set 7

ExplanationConv2D learnable parameters include both weights and biases. Each of the 9 output filters has a kernel of size 3×3×3 (27 weights) plus 1 bias term, giving 9×(3×3×3+1) = 9×28 = 252 parameters. For comparison, a Conv2D(3, 64, 3) layer in a ResNet has 64×(3×3×3+1) = 1,792 parameters, showing how the output channel count directly scales the total parameter count.

ExplanationGRU has 3 gates (reset r, update z, candidate h'), each with parameters h×(h+x)+h. Total: 3×(183×(183+46)+183) = 126270. LSTM has 4 gates (input, forget, output, candidate), requiring 4×params = 168360. GRU is more parameter-efficient and computationally faster while often matching LSTM performance. Both RNNs address vanishing gradients through gating mechanisms. GRUs are preferred when computational resources are limited; LSTMs are preferred for complex long-range dependencies.

ExplanationConv2D learnable parameters include both weights and biases. Each of the 10 output filters has a kernel of size 1×4×4, giving 1×4×4 = 16 weights, plus 1 bias term per filter, for 17 parameters per filter. Multiplying across all 10 output filters gives 10×(1×4×4+1) = 10×17 = 170 total learnable parameters.

ExplanationEach of the 8 output filters convolves over all 2 input channels with a 4×4 kernel, giving I×K² = 2×4×4 = 32 weights per filter, plus 1 bias term per filter. Applying the formula O×(I×K²+1) = 8×(2×4×4+1) = 8×33 = 264 total learnable parameters. Omitting the bias term undercounts to 256, swapping in_channels with out_channels gives 258, and failing to square the kernel size gives 72 — each a different way of misapplying the formula rather than the correct full expansion.

ExplanationConv2D learnable parameters include both weights and biases. Each of the 8 output filters has a kernel of shape 4×4×4 (in_channels × kernel_height × kernel_width), contributing I×K²=4×4×4=64 weights, plus 1 bias term, for 65 parameters per filter. Applying the formula O×(I×K²+1) = 8×(64+1) = 8×65 = 520 total learnable parameters. Storing each parameter as a 32-bit float requires 4 bytes, so total memory = 520×4 = 2,080 bytes, or about 2.03 KB. For comparison, a Conv2D(3, 64, 3) layer in a typical ResNet has 64×(3×3×3+1) = 1,792 parameters. Parameter and memory calculations like this matter directly for estimating a model's storage footprint and deployment feasibility on memory-constrained devices.

ExplanationConv2D learnable parameters consist of weights and biases. Each of the 10 output filters convolves across all 2 input channels using a 3×3 kernel, giving 2×3×3 = 18 weights per filter, plus 1 bias term per filter, for 19 parameters per filter. Total parameters = 10×(2×3×3+1) = 10×19 = 190.

ExplanationConv2D learnable parameters include both weights and biases. Each of the 11 output filters has a kernel spanning all 4 input channels, so its weight count is I×K² = 4×4×4 = 64, plus 1 bias term per filter. Total: 11×(64+1) = 11×65 = 715 parameters. For comparison, a Conv2D(3, 64, 3) layer in a ResNet uses the same formula: 64×(3×3×3+1) = 1,792 parameters.

ExplanationEach Conv2D layer's learnable parameters equal out_channels × (in_channels × kernel_height × kernel_width + 1), where the '+1' accounts for one bias term per output filter, and in_channels must match the number of channels actually feeding into that layer — for the second layer, that's the first layer's 32 output channels, not the original 3-channel input. For the first layer: 32 × (3×3×3 + 1) = 32×28 = 896. For the second layer, whose input is now 32 channels: 64 × (32×3×3 + 1) = 64×289 = 18,496. Summing both layers gives 896 + 18,496 = 19,392 total learnable parameters. Dropping the bias term undercounts each layer by exactly its out_channels — 32 and 64 respectively — yielding 864 + 18,432 = 19,296 instead. Counting only the second layer's parameters ignores the first layer entirely, giving just 18,496. And reusing the original 3-channel input for the second layer's in_channels instead of chaining from the previous layer's 32 output channels collapses that layer to 64×(3×3×3+1) = 1,792, producing a total of 896 + 1,792 = 2,688.

ExplanationConv2D learnable parameters include weights and biases: each of the 13 output filters has a kernel of size 3×5×5 (75 weights) plus 1 bias term. Total: 13×(3×5×5+1) = 13×76 = 988 parameters.

ExplanationOutput spatial size: (W - F + 2P) / S + 1 = (32 - 5 + 0) / 1 + 1 = 28. Output depth = number of filters = 16. So output shape is 28x28x16. Parameters per filter: F*F*C_in + 1 (bias) = 5*5*3 + 1 = 76. Each filter has a 5x5 kernel for EACH of the 3 input channels, plus 1 bias. Total: 16 filters * 76 = 1,216 parameters. Common mistakes: forgetting that each filter spans ALL input channels (option C), forgetting the bias term (option B), or thinking output depth matches input depth (option D).

ExplanationReLU(x) = max(0, x). Its derivative: dReLU/dx = 1 if x > 0, 0 if x <= 0. By chain rule: dL/dx = dL/dy * dReLU/dx. Element-wise: x[0]=-2 (<=0): dL/dx[0] = 0.5 * 0 = 0. x[1]=3 (>0): dL/dx[1] = -0.3 * 1 = -0.3. x[2]=0 (<=0): dL/dx[2] = 0.1 * 0 = 0 (ReLU is typically defined with derivative 0 at exactly 0). x[3]=-1 (<=0): dL/dx[3] = 0.4 * 0 = 0. x[4]=5 (>0): dL/dx[4] = -0.2 * 1 = -0.2. Result: [0, -0.3, 0, 0, -0.2]. ReLU acts as a gradient gate — it kills gradients for non-positive inputs (the "dying ReLU" problem).

ExplanationSGD with momentum update rules: v_t = beta * v_{t-1} + g_t, then w = w - alpha * v_t. With beta=0.9: v_t = 0.9 * 2.0 + 4.0 = 1.8 + 4.0 = 5.8. delta_w = -alpha * v_t = -0.01 * 5.8 = -0.058. The velocity v_t is an exponential moving average of past gradients. The momentum term (0.9 * 2.0 = 1.8) carries forward 90% of the previous velocity, accumulating gradient history. This helps SGD accelerate through consistent gradient directions and dampen oscillations. This produces a larger update because momentum accumulates past gradient information. Without momentum, delta_w would be just -0.01 * 4.0 = -0.04.

ExplanationWith inverted dropout (the standard implementation): during training, dropped units are set to 0 and KEPT units are scaled by 1/(1-p) = 1/0.5 = 2 to maintain the expected value. So: [4*1*2, 8*0*2, 2*1*2, 6*0*2] = [8, 0, 4, 0]. During inference, NO dropout is applied and NO scaling is needed — the inverted scaling during training already compensates. This is why inverted dropout is preferred: inference code doesn't need modification. Alternative (non-inverted) dropout would keep values unscaled during training ([4, 0, 2, 0]) but must multiply ALL outputs by (1-p)=0.5 during inference. Both produce the same expected output.

ExplanationBCE for each sample: L_i = -(y_i*ln(p_i) + (1-y_i)*ln(1-p_i)). Sample 1 (y=1, p=0.9): -(1*ln(0.9) + 0*ln(0.1)) = -ln(0.9) = 0.105. Sample 2 (y=0, p=0.3): -(0*ln(0.3) + 1*ln(0.7)) = -ln(0.7) = 0.357. Sample 3 (y=1, p=0.8): -ln(0.8) = 0.223. Sample 4 (y=1, p=0.6): -ln(0.6) = 0.511. Sum = 0.105 + 0.357 + 0.223 + 0.511 = 1.196. Average = 1.196/4 = 0.299. Note: for y=0, we use ln(1-p), not ln(p). Sample 2 has p=0.3, so 1-p=0.7, and -ln(0.7)=0.357 penalizes the model for predicting 30% for a negative sample.

ExplanationEach Dense layer has weights (W) and biases (b). Layer 1 (784→256): W = 784*256 = 200,704 weights + 256 biases = 200,960. Layer 2 (256→128): W = 256*128 = 32,768 weights + 128 biases = 32,896. Layer 3 (128→10): W = 128*10 = 1,280 weights + 10 biases = 1,290. Total = 200,960 + 32,896 + 1,290 = 235,146. The majority (85.5%) of parameters are in the first layer because it connects the high-dimensional input (784 = 28x28 MNIST pixels) to the first hidden layer. This is why modern architectures use convolutions instead of dense layers for image inputs.

ExplanationBatchNorm computes: x_hat = (x - mean) / sqrt(variance + epsilon). Mean = (2+4+6+8)/4 = 20/4 = 5. Variance = ((2-5)^2 + (4-5)^2 + (6-5)^2 + (8-5)^2)/4 = (9+1+1+9)/4 = 20/4 = 5. Std = sqrt(5) = 2.236. With epsilon=0: x_hat[0] = (2-5)/2.236 = -3/2.236 = -1.342. x_hat[1] = (4-5)/2.236 = -1/2.236 = -0.447. x_hat[2] = (6-5)/2.236 = 1/2.236 = 0.447. x_hat[3] = (8-5)/2.236 = 3/2.236 = 1.342. The result has mean=0 and variance=1, which stabilizes training by preventing internal covariate shift.

ExplanationWith a 2x2 window and stride=1 on a 3x3 map, the output size is (3-2)/1 + 1 = 2, so the output is 2x2 and consecutive windows overlap by one row and one column. The top-left window (rows 0-1, cols 0-1) covers {2,8,5,1}, max = 8. The top-right window (rows 0-1, cols 1-2) covers {8,4,1,9}, max = 9. The bottom-left window (rows 1-2, cols 0-1) covers {5,1,3,7}, max = 7. The bottom-right window (rows 1-2, cols 1-2) covers {1,9,7,6}, max = 9. So the output is [[8, 9], [7, 9]]. Because the stride (1) is smaller than the kernel size (2), the windows overlap, so a single high-activation cell — here the 9 at row 1, col 2 — can be the maximum of more than one output cell (it drives both the top-right and bottom-right outputs). This is different from non-overlapping pooling (stride = kernel size), where each input cell contributes to exactly one output cell.

ExplanationStep 1: Compute dot product q·k = 1*0 + 0*1 = 0. Step 2: Scale by sqrt(d_k) = sqrt(2): score = 0/sqrt(2) = 0. Step 3: Apply softmax. With only ONE key, softmax([0]) = [e^0 / e^0] = [1.0]. Softmax of any single value always equals 1.0, regardless of the value. Step 4: Weighted sum: output = 1.0 * [3, 7] = [3, 7]. The key insight: even though q and k are orthogonal (dot product = 0), with only one key available, all attention goes to that key. The dot product would matter if there were MULTIPLE keys to distribute attention across — then higher-scoring keys would receive more weight.

ExplanationA FC layer from input dim 256 to output dim 128 has a weight matrix W of shape (256, 128) — one weight per (input, output) pair = 256×128 = 32,768 weights. The bias vector has one entry per output neuron = 128 biases. Total = 32,768 + 128 = 32,896. Option B swaps the bias count to match input size, which is wrong.

ExplanationReLU(x) = max(0, x). Apply elementwise: max(0,-3)=0, max(0,0)=0, max(0,2)=2, max(0,-1)=0, max(0,5)=5. Derivative: d/dx ReLU(x) = 1 if x>0, 0 if x<0. At x=0 it is technically undefined but conventionally set to 0. So derivatives: [0, 0, 1, 0, 1]. The "dead neuron" problem occurs when neurons consistently get x<0, making gradients permanently zero.