Grade 10 AI & Computer Science Practice Questions — Set 11

ExplanationBM25's term-frequency component does not behave like a simple normalised-TF ratio: the k1 parameter makes it grow with diminishing returns as raw counts increase, while the b parameter applies an independent, continuously-scaling length penalty rather than switching off once a term has appeared. Working through the numbers shows this clearly. Article P's length-normalisation factor is 1 - 0.75 + 0.75 * (100/250) = 0.55, giving a term-frequency component of (5 * 2.5) / (5 + 1.5 * 0.55) = 12.5 / 5.825 ≈ 2.146. Article Q's length-normalisation factor is 1 - 0.75 + 0.75 * (500/250) = 1.75 - over three times as large as Article P's, confirming the length penalty is very much still active rather than absent - giving a term-frequency component of (20 * 2.5) / (20 + 1.5 * 1.75) = 50 / 22.625 ≈ 2.210. Since "monsoon" is the same term drawn from the same corpus, IDF("monsoon") depends only on N = 50 and df = 10, so it multiplies both articles' scores by an identical constant and cannot be the reason either article outranks the other - this rules out any explanation that ties the outcome to IDF being applied unevenly across documents of different lengths. What actually decides the ranking is that BM25's saturation curve compresses the gap between 5 and 20 occurrences far more than a plain density ratio (5% versus 4%) would suggest, so Article Q's much larger raw term count narrowly outweighs Article P's higher term density despite Q's much steeper length penalty - giving Article Q the higher BM25 score even though Article P would win under a plain normalised-TF-IDF density comparison.

ExplanationA confounder is a variable that influences BOTH the treatment (who gets Drug X) and the outcome (who recovers), creating an association between treatment and outcome that isn't due to the treatment's actual causal effect at all. Here, baseline health does exactly that: healthier patients were more likely to be given the drug AND more likely to recover anyway, so the observed correlation could be entirely explained by baseline health alone, with the drug contributing nothing, because both branches of the comparison trace back to the same underlying cause. The gold-standard fix is a randomized controlled trial: by assigning Drug X purely randomly (e.g., a coin flip per patient), baseline health becomes statistically balanced between the treatment and control groups on average, breaking the confounder's connection to WHO gets the drug — any remaining difference in recovery rates can then be attributed to the drug itself, not to who happened to receive it.

ExplanationThe Poisson distribution is the standard model for 'how many independent, rare-ish events happen in a fixed window of time or space, given a known average rate' — exactly this factory scenario, with an average rate of 1 defect per 15 minutes (so 4 per hour on average). Binomial, by contrast, models the count of successes across a FIXED, PRE-DEFINED number of discrete trials, each with the same success probability (like 'exactly 20 coin flips, what's the chance of exactly 12 heads') — there's no natural way to carve continuous time into a fixed number of discrete 'trials' here, since a defect could in principle occur at any instant, not just at pre-defined checkpoints. In fact, Poisson can be derived mathematically as the LIMIT of a Binomial distribution as the number of trials grows to infinity while the per-trial probability shrinks proportionally — which is exactly the intuition for why Poisson is the right tool when events are effectively continuous-time rather than discrete-trial.

ExplanationLabel encoding assigns an arbitrary integer to each category, but a model like linear regression interprets numeric features as having real magnitude and ORDER — it would implicitly assume Bengaluru (2) is 'twice as much city' as Delhi (1), or that the cities exist on a meaningful numeric scale where distances between them matter, none of which reflects reality for a nominal (unordered) category like a city name. One-hot encoding sidesteps this entirely: it creates one binary column per category (is_Mumbai, is_Delhi, is_Bengaluru), each independently 0 or 1, so the model can learn a separate, unconstrained coefficient for each city's effect without any invented ordering or distance relationship between them. Label encoding IS appropriate for genuinely ORDINAL categories with a real inherent order (like 'small/medium/large'), where the implied ordering is actually meaningful — the choice depends entirely on whether the category has true order, not on convenience.

ExplanationThe single non-negotiable requirement for any data augmentation technique is that it must be LABEL-PRESERVING — the transformed image must still genuinely represent the same class it's labeled as. Small rotations, minor pixel noise, and small pixel shifts are all safe for digit recognition because a slightly rotated, slightly noisy, or slightly shifted '7' is still unambiguously a '7' to a human. But horizontal flipping is different in kind: a mirrored '2' does not look like a valid, correctly-oriented '2' at all (and a mirrored '3' looks similar to an 'E' or nothing meaningful) — the flip has effectively created a picture that no longer matches its label, actively teaching the model an incorrect association. This exact category of mistake — augmenting in a way that breaks the label — is a common real bug: horizontal flips are perfectly fine for many photo-classification tasks (a mirrored cat is still recognizably a cat) but actively harmful for tasks where orientation carries meaning, like digit or text recognition.

ExplanationThe entire point of learning node embeddings (via methods like node2vec, DeepWalk, or a GNN) is to capture STRUCTURAL relationships in a graph as GEOMETRIC relationships in a continuous vector space — nodes that are 'close' in the graph's connectivity pattern (frequently co-occurring, sharing many neighbors, or connected through similar paths) are trained to end up with embedding vectors that are close together by some distance measure (like cosine similarity or Euclidean distance). This is what makes embeddings practically useful: instead of needing to traverse the raw graph structure every time you want to find similar items, you can just compute vector distances directly, which is fast and works well with standard machine-learning tools (like nearest-neighbor search or feeding embeddings into a downstream classifier). Two products being close in embedding space is a learned SIGNAL of behavioral or structural similarity — not a claim about their literal identity or price.

ExplanationBayes' theorem combines a PRIOR belief with observed EVIDENCE to produce a POSTERIOR probability: P(spam|free) = P(free|spam)xP(spam) / P(free), where P(free) is the total probability of seeing 'free' across both classes (spam and not-spam), computed as P(free|spam)xP(spam) + P(free|not spam)xP(not spam). Plugging in the numbers: the numerator is 0.7x0.4=0.28 (probability an email is BOTH spam AND contains 'free'). The denominator is 0.28 + (0.1x0.6=0.06) = 0.34 (total probability of 'free' appearing, from either class). Dividing: 0.28/0.34 ≈ 0.8235. This means observing the word 'free' shifted the model's belief from a 40% prior probability of spam up to about 82.35% posterior probability — a substantial update, driven by the fact that 'free' is 7 times more likely to appear in a spam email (0.7) than a legitimate one (0.1).

ExplanationFor linearly separable data, there are generally INFINITELY many possible boundaries that would correctly separate the two classes on the training set — but not all of them generalize equally well to new data. SVM's specific criterion is to choose the boundary that maximizes the MARGIN: the gap between the boundary and the closest training points from each class (these closest points are called support vectors, since they are the ones that literally 'support', or define, the boundary's position). The intuition is that a boundary hugging one class too closely leaves little room for natural variation in new test points from that class before they'd be misclassified — maximizing the margin builds in the largest possible safety buffer on both sides. This margin-maximization objective is the defining, name-giving idea behind Support Vector Machines, and it's why SVMs tend to generalize well even with relatively few training examples, compared to boundaries chosen by less principled criteria.

ExplanationAn eigenvector v of matrix W satisfies Wv = lambda*v for some scalar lambda (the eigenvalue) — meaning applying W to v just SCALES v by lambda, without changing its direction. For W = [[3,0],[0,3]] = 3 times the identity matrix: applying W to ANY vector (x,y) gives (3x, 3y), which is exactly 3 times the original vector, for literally every possible input vector. This means every nonzero vector in the plane is an eigenvector of W, all sharing the identical eigenvalue 3 (since the identity matrix itself has eigenvalue 1 for every vector, and multiplying by 3 scales every eigenvalue by 3 as well: computed formally, the characteristic equation det(W - lambda*I)=0 gives (3-lambda)^2=0, so lambda=3 is a repeated eigenvalue). Geometrically, this matrix performs a uniform scaling (dilation) by factor 3 in every direction — no rotation, no shear, no direction-dependent stretching, which is precisely why every direction qualifies as an eigenvector: uniform scaling doesn't treat any direction specially.

ExplanationF1 score is the HARMONIC mean of precision and recall, specifically chosen (rather than a simple average) because it penalizes a large imbalance between the two more heavily — a classifier with, say, perfect precision but terrible recall gets a low F1, not a misleadingly high average. Step by step: precision = TP/(TP+FP) = 42/(42+8) = 42/50 = 0.84 (of everything the model FLAGGED as positive, 84% actually were). Recall = TP/(TP+FN) = 42/(42+10) = 42/52 ≈ 0.8077 (of everything that WAS actually positive, about 80.77% got correctly flagged). F1 = 2 x (0.84 x 0.8077) / (0.84 + 0.8077) ≈ 2 x 0.6785 / 1.6477 ≈ 0.8235. Notably, TN (true negatives) never enters the F1 formula at all — F1 deliberately focuses only on how the model performs on the POSITIVE class, which is exactly why it's the preferred metric over raw accuracy for imbalanced datasets (like rare-disease detection) where TN can be enormous and would otherwise dominate and hide poor positive-class performance.

ExplanationGradient descent updates each parameter proportionally to the loss function's SLOPE (gradient) with respect to that parameter, using a single shared learning rate across all parameters. When features live on wildly different scales, the loss surface becomes elongated: because income values are roughly 100,000x larger than age values, the loss changes MUCH more steeply per unit change in the income coefficient than per unit change in the age coefficient. A learning rate large enough to make reasonable progress along the shallow (age) direction will wildly overshoot and oscillate along the steep (income) direction, while a learning rate small enough to be stable on the steep direction makes painfully slow progress on the shallow one — there is no single learning rate that's ideal for both simultaneously. Standardizing every feature to a comparable scale (like mean 0, standard deviation 1) makes the loss surface much more circular/well-conditioned, so a single learning rate works reasonably well in every direction, letting gradient descent converge both faster and more reliably. Note the underlying OPTIMAL solution itself is mathematically unaffected by scaling — only how EASILY gradient descent finds it changes.

ExplanationInformation Gain measures how much a split REDUCES uncertainty (entropy) about the class label, computed as: parent entropy - weighted average of the resulting children's entropy. Lower CHILD entropy means the split produced purer, more class-homogeneous groups — which is the actual goal of a decision tree split (separating classes cleanly). For Feature A: gain = 0.9 - 0.25 = 0.65. For Feature B: gain = 0.9 - 0.65 = 0.25. Feature A wins decisively, because its children (average entropy 0.25) are much purer/less mixed than Feature B's children (average entropy 0.65) — Feature A's split resolved much more of the original uncertainty. A common point of confusion: HIGHER child entropy is BAD, not good, since it means the split failed to separate the classes well; the feature to prefer is the one whose split leaves the LEAST remaining disorder, hence the biggest DROP (gain) from the parent's entropy.

ExplanationIn PCA, each eigenvalue of the covariance matrix directly represents the AMOUNT OF VARIANCE captured by its corresponding principal component (the eigenvalues are sorted so the first component captures the most variance, the second captures the next-most, and so on). The proportion of variance retained by keeping the top-k components is simply the SUM of those k eigenvalues divided by the sum of ALL eigenvalues (total variance). Here: total variance = 8.2+2.1+0.9+0.3 = 11.5. Keeping the top 2 components captures 8.2+2.1=10.3 of that. The ratio is 10.3/11.5 ≈ 0.8957, or about 89.57%. This is exactly why PCA is such an effective dimensionality-reduction tool: despite discarding HALF the components (2 out of 4), it retains nearly 90% of the original data's variance/information, because the discarded components (with small eigenvalues 0.9 and 0.3) were capturing comparatively little of the data's actual spread to begin with.

ExplanationPearson's r ranges from -1 to +1, measuring the STRENGTH and DIRECTION of a LINEAR relationship between two variables. A value close to +1 (like the computed ≈0.986 here) indicates a very strong POSITIVE linear association — points lie very close to an upward-sloping straight line, with x and y increasing together. A value close to -1 would indicate an equally strong relationship, but NEGATIVE (downward-sloping) — as one variable increases, the other tends to decrease proportionally; the MAGNITUDE (closeness to 1, ignoring sign) reflects the same strength of linear fit either way, only the sign flips. Critically, correlation — no matter how strong or how close to +-1 — never by itself establishes causation: two variables can be strongly correlated because one causes the other, because both are driven by a shared confounding factor, or purely by coincidence in a limited sample. 'Correlation is not causation' is one of the most important, frequently-violated principles in interpreting statistical results.

ExplanationWhen a dataset has any structure correlated with its stored ORDER — very commonly, chronological order — an unshuffled 80/20 split doesn't produce a representative random sample in each half; it instead cleanly separates 'older data' from 'newer data'. If the underlying relationships in the data drift over time (a common real phenomenon called concept drift or distribution shift — customer behavior changes, prices inflate, product mixes shift), the model trained purely on the older 80% may be tested on a genuinely different data distribution in the newer 20%, which is a fundamentally different question than 'does this model generalize to new random examples drawn from the same distribution it trained on'. This is why standard practice is to SHUFFLE data (breaking any incidental order-based structure) before splitting into train/test, UNLESS you specifically intend to test time-based generalization (as in real financial forecasting, where a deliberately chronological split — train on the past, test on the future — is actually the CORRECT choice, since that mirrors how the model will actually be used in production).

ExplanationSoftmax converts a vector of arbitrary real-valued logits into a valid probability distribution via softmax(z_i) = exp(z_i) / sum(exp(z_j) for all j) — exponentiating first ensures every output is positive (a probability can't be negative), and dividing by the sum of all exponentials ensures the results sum to exactly 1 (a valid distribution). Computing this for [2.0, 1.0, 0.1]: exp(2.0)≈7.389, exp(1.0)≈2.718, exp(0.1)≈1.105, summing to ≈11.212. Dividing each exponential by that sum gives approximately [0.659, 0.242, 0.099] (which does sum to 1.0, up to rounding). Notice the RELATIVE gaps get exaggerated by the exponential — a logit gap of just 1.0 (between 2.0 and 1.0) becomes a probability gap of roughly 0.659 vs 0.242, a much larger relative difference — this is a deliberate property of softmax, making the highest-scoring class's probability dominate more sharply than the raw logit gap alone would suggest, and why temperature scaling (dividing logits by a constant before softmax) is used to control this sharpness.

ExplanationCosine similarity is computed as the dot product of two vectors divided by the product of their magnitudes (lengths): (a·b)/(|a||b|). Working it out: the dot product a·b = (3)(4)+(4)(3)+(0)(0) = 12+12+0 = 24. The magnitude of a is sqrt(3^2+4^2+0^2) = sqrt(25) = 5. The magnitude of b is sqrt(4^2+3^2+0^2) = sqrt(25) = 5. So cosine similarity = 24/(5x5) = 24/25 = 0.96, indicating the vectors point in nearly (though not exactly) the same direction. The reason this metric suits text comparison specifically: it captures the ANGLE between vectors — essentially the relative PROPORTIONS of each word/dimension — while being completely insensitive to overall magnitude/length. A 100-word document and a 10,000-word document discussing the same topic in the same relative word-frequency proportions would have a HIGH cosine similarity (nearly parallel vectors) despite having wildly different Euclidean distances (since one vector is simply much 'longer' than the other in raw magnitude) — exactly the behavior you want when document length shouldn't affect a topical-similarity judgment.

ExplanationBoth regularization methods discourage overly large coefficients (which helps prevent overfitting), but they penalize magnitude differently, with a real geometric consequence. L1 (Lasso) penalizes the SUM OF ABSOLUTE VALUES of the coefficients; its constraint region (in coefficient space) has sharp CORNERS located exactly on the axes (where some coefficient equals precisely zero) — the optimal solution frequently lands exactly on one of these corners, driving some coefficients to EXACTLY zero and effectively removing those features from the model entirely, which is why Lasso is popular for automatic feature selection on high-dimensional data. L2 (Ridge) penalizes the SUM OF SQUARED coefficients; its constraint region is a smooth circle/sphere with no corners, so the optimal solution can land anywhere on that smooth boundary — coefficients get shrunk toward zero (reducing their influence) but essentially never hit EXACTLY zero, so Ridge keeps every feature in the model, just with reduced weight. Choosing between them in practice often comes down to whether you want a sparser, more interpretable model (favoring Lasso) or want to retain and moderately shrink every available feature (favoring Ridge).

ExplanationFor the population standard deviation: the mean of [4,8,6,5,3,10] is (4+8+6+5+3+10)/6 = 36/6 = 6. The squared deviations from this mean are (4-6)^2=4, (8-6)^2=4, (6-6)^2=0, (5-6)^2=1, (3-6)^2=9, (10-6)^2=16, summing to 34. Dividing by n=6 gives variance≈5.667, and the square root gives population std≈2.38. The SAMPLE standard deviation instead divides that same sum of squared deviations by (n-1)=5, giving a slightly LARGER value (≈2.61). The reason for this adjustment, known as Bessel's correction: when you compute a sample's mean FROM the sample itself (rather than knowing the true population mean independently), the sample's data points are, on average, slightly CLOSER to that self-computed sample mean than they would be to the true, unknown population mean — the sample mean is, in a specific mathematical sense, the value that MINIMIZES the sum of squared deviations for that particular sample. Dividing by the smaller n-1 instead of n compensates for this built-in underestimation, producing an unbiased estimate of the true population variance when working from sample data — which is why nearly every real statistics library defaults to n-1 for sample data.

ExplanationThe Central Limit Theorem describes how the distribution of a SAMPLE MEAN behaves as sample size grows: regardless of the original population's shape (a die roll is uniformly distributed, not normal, yet the theorem still applies), the sampling distribution of the mean becomes increasingly concentrated around the true population mean, with standard error = population_std / sqrt(n). Computing this for the die (population std ≈1.708): at n=1, standard error ≈1.708/sqrt(1)=1.708 (identical to the raw population spread, since a 'batch' of 1 roll IS just that one roll). At n=30, standard error ≈1.708/sqrt(30)≈0.312 — over 5 times tighter. At n=100, standard error ≈1.708/sqrt(100)≈0.171 — 10 times tighter than a single roll. This sqrt(n) shrinkage is precisely why machine learning practitioners insist on adequately sized validation and test sets: a model's measured accuracy on just 20 test examples is itself a highly UNSTABLE estimate of its true real-world performance (large standard error), while the same measured accuracy on 10,000 test examples is a far more trustworthy, stable estimate (small standard error) of the same underlying quantity.

ExplanationL1 (Manhattan/taxicab) distance sums the ABSOLUTE differences along each dimension independently: |1-4|+|7-3| = 3+4 = 7 — geometrically, this is the distance you'd travel moving only along grid-aligned streets (like navigating city blocks), never diagonally. L2 (Euclidean) distance instead takes the straight-line distance: sqrt((1-4)^2+(7-3)^2) = sqrt((-3)^2+4^2) = sqrt(9+16) = sqrt(25) = 5.0 — the direct 'as the crow flies' path. Notice L2 (5.0) is smaller than L1 (7) here, which is not a coincidence: by the triangle inequality, the direct diagonal path can never be LONGER than the sum of the axis-aligned detour, so L2 <= L1 always holds for any pair of points. This distinction matters practically in ML: L2 distance is more sensitive to one large per-dimension difference (since squaring amplifies large gaps disproportionately), while L1 treats every unit of difference in any dimension equally — which is part of why L1 regularization (Lasso) tends to produce sparser solutions than L2 regularization (Ridge), echoing the same underlying geometric distinction.