Machine Learning With RAPIDS

A team trains a GPU-accelerated XGBoost classifier on an imbalanced churn dataset and wants a dependable estimate of how it will generalise. They have a single GPU with enough memory to fit the data several times over, and a colleague proposes plain random 5-fold cross-validation. Given the imbalance, which adjustment to the resampling scheme most directly improves the reliability of the per-fold metrics?

• AReplace the cross-validation with one larger 90/10 holdout split, since a single bigger test set is more representative than averaging several small folds.
• BRaise the number of folds from 5 to 20 so each training fold sees more data, which on its own balances the class ratio across folds.
• CUse stratified k-fold cross-validation so each fold preserves roughly the same minority-class proportion as the full dataset.check_circle Correct
• DShuffle the rows before splitting into the 5 folds, because randomising the order alone balances the class ratio within every fold.

Why A is wrong: Tempting because a larger test set feels more stable, but a single split discards the variance reduction of averaging across folds and may leave the rare class barely represented, so it does not address the imbalance.

Why B is wrong: Tempting because larger k does enlarge each training portion, but it shrinks each test fold and can leave individual folds with no minority cases, so increasing k alone does not guarantee balanced representation.

Why C is correct: Correct: stratification holds the rare-class ratio constant across folds, preventing folds with too few or zero positive cases, which stabilises the per-fold metrics and yields a trustworthy averaged estimate under imbalance.

Why D is wrong: Tempting because shuffling removes ordering artefacts, but random shuffling only balances folds in expectation and can still produce folds where the rare class is severely under-represented, which stratification explicitly prevents.

During hyperparameter tuning of a GPU-accelerated XGBoost model, an engineer scores every candidate configuration on the same held-out test set and keeps the configuration with the highest test score. They then report that test score as the model's expected performance on future data. What is the central flaw in this evaluation procedure?

• AGradient-boosted models cannot be tuned against a single test set at all, because boosting requires a dedicated validation set for early stopping, so the procedure cannot run.
• BThe test set is too small to distinguish the candidate configurations, so the procedure would be valid once the test set is made large enough.
• CHeld-out accuracy is never a valid tuning signal, so the engineer should have selected the configuration on training accuracy instead.
• DRepeatedly selecting on the test set leaks information from it into model selection, so the reported score is optimistically biased and overstates true generalisation.check_circle Correct

Why A is wrong: Tempting because boosting does benefit from a validation set for early stopping, but the procedure can run and produce numbers; the genuine defect is the biased selection, not an inability to execute it.

Why B is wrong: Tempting because a bigger test set does reduce variance, but enlarging it does not remove the bias from reusing the same set to both choose and report, so size is not the central flaw.

Why C is wrong: Tempting because held-out evaluation is being misused here, but tuning on training accuracy is worse, since it rewards overfitting outright; this swaps one error for a larger one rather than fixing the leakage.

Why D is correct: Correct: every comparison uses the test set to choose a configuration, so the winning score is partly fitted to that set's noise and is inflated; an honest estimate needs a separate validation split for selection and an untouched test set for the final number.

A data scientist builds a sequence of standard scaling followed by a cuML logistic regression, and evaluates it with five-fold cross-validation. To save effort she fits the scaler once on the whole dataset, then runs cross-validation on the already-scaled features. Why does this ordering bias the cross-validation estimate, and what is the correct ordering?

• AScaling the whole dataset first changes the logistic regression coefficients, so they no longer match the unscaled production data; the model must instead be trained on raw features and scaled only at inference time.
• BScaling the whole dataset first makes the features non-normal, which violates the logistic regression assumption of normally distributed inputs; the features must be normalised per fold to satisfy that assumption.
• CScaling the whole dataset first is slower because it processes all rows at once on the GPU; the scaler should be fitted on a random sample to reduce the per-fold computation time.
• DScaling the whole dataset first lets the scaler's mean and standard deviation absorb information from every validation fold, so each fold is evaluated with statistics it helped compute; the scaler must be refitted on the training portion inside each fold.check_circle Correct

Why A is wrong: It is true that scaling affects coefficients, which makes this sound plausible, but scaling is a legitimate and expected preprocessing step and training on raw features would not fix any cross-validation bias, so this misidentifies both the problem and the remedy.

Why B is wrong: Logistic regression does not assume normally distributed inputs, so the stated assumption is false even though standardisation is being discussed; the real defect is leakage of validation statistics, not a distributional assumption, making this a confident but incorrect diagnosis.

Why C is wrong: Performance is not the issue and fitting on a random sample would itself introduce sampling bias and still leak across folds, so this answer mistakes a correctness problem for a speed problem and proposes a fix that does not address leakage.

Why D is correct: Fitting the scaler on all rows means the centring and scaling constants are computed partly from the validation rows, so those rows are no longer truly held out and the score is optimistic; refitting the scaler on each fold's training portion keeps every validation fold unseen and restores an unbiased estimate.

A data scientist evaluates a cuML binary classifier that screens loan applications for default, with the confusion matrix below where rows are the true class and columns are the predicted class. The risk team wants to know what fraction of genuinely non-defaulting applicants the model correctly cleared, so it does not needlessly reject good customers. Which value answers that question?

                 Pred: no-default   Pred: default
True: no-default       760              40
True: default           60             140

• A0.93, the 760 correctly cleared non-defaulters divided by the 820 applicants the model predicted would not default.
• B0.70, the 140 correctly caught defaulters divided by the 200 applicants who genuinely defaulted.
• C0.90, the 900 rows the model classified correctly divided by the full 1000 applications in the evaluation set.
• D0.95, the 760 correctly cleared non-defaulters divided by the 800 applicants who genuinely did not default.check_circle Correct

Why A is wrong: Tempting because 760 / (760 + 60) = 0.93 uses the right numerator, but dividing by predicted negatives gives the negative predictive value, not the share of actual non-defaulters correctly cleared.

Why B is wrong: Tempting because 140 / (140 + 60) = 0.70 is a valid metric, but it is recall for the positive default class, which answers the opposite question to the one asked about non-defaulters.

Why C is wrong: Tempting because (760 + 140) / 1000 = 0.90 looks like a clean headline figure, but it is overall accuracy across both classes, not the class-specific true-negative rate the risk team requested.

Why D is correct: Correct: the question asks for the negative-class recall (specificity), which is true negatives over actual negatives, 760 / (760 + 40) = 0.95, read across the true no-default row.

A data scientist must train a model on tabular data already on a single GPU and is choosing between a cuML Random Forest classifier and a GPU-accelerated XGBoost classifier. The team wants a sequential boosting approach where each new tree is fitted to correct the errors of the ensemble built so far. Which choice matches that requirement, and why?

• AChoose the cuML Random Forest, because a random forest grows its trees in sequence, with each new tree fitted to the residual errors left by the trees grown before it.
• BChoose either model, because the cuML Random Forest and XGBoost use the same sequential boosting procedure internally and differ only in their GPU memory layout.
• CChoose the GPU-accelerated XGBoost classifier, because boosting builds trees in sequence so each new tree is fitted to reduce the errors of the ensemble that was assembled before it.check_circle Correct
• DChoose the cuML Random Forest, because boosting is unavailable on the GPU and only bagging ensembles such as random forests can be trained directly on the device.

Why A is wrong: Tempting because both are tree ensembles, but it is wrong: a random forest grows its trees independently in parallel on bootstrap samples and does not fit later trees to the residuals of earlier ones.

Why B is wrong: Tempting because both train decision-tree ensembles on the GPU, but it is wrong: a random forest uses bagging with independent trees while XGBoost uses boosting, so they do not share the same sequential procedure.

Why C is correct: Correct: XGBoost is a gradient-boosting method that adds trees sequentially, with each new tree fitted to the gradient of the current ensemble's errors, which is exactly the sequential error-correction behaviour required.

Why D is wrong: Tempting because cuML offers a GPU random forest, but it is wrong: GPU-accelerated boosting is fully available through XGBoost, so the claim that only bagging ensembles can train on the device is false.