NCP-ADS Data Preparation: Feature Engineering at GPU Scale [2026]

Data Preparation carries 17% of the NCP-ADS exam, and its questions have a signature: a preparation choice you learned on 10,000-row datasets, re-asked at 300 million rows on a GPU, where the wrong choice either destroys signal, leaks the future into training, or blows the memory budget. Mean or median. One-hot or target encoding. Drop the rows or impute them. Fit the scaler before or after the split. None of these are new questions, but the exam grades them under production constraints: skewed distributions, million-value categorical columns, hourly pipelines, and device memory that punishes careless representations. This guide works through the four decision families the domain draws from, the leakage rule that quietly grades several questions at once, and two worked scenarios with the exam-correct reasoning.

Missing values: the distribution decides

Imputation questions hand you a column, a missingness percentage, and a distribution shape, and the shape is the answer key. On a symmetric distribution, mean and median agree and either fills reasonably. On a skewed one (transaction amounts, incomes, latencies), the mean is dragged toward the tail, so mean-filling injects values that look like large observations; the median stays representative, which is why it is the default graded answer for skewed numeric columns.

The supporting rules the exam checks: dropping rows is defensible only when missingness is rare and random, because every dropped row discards the other columns' signal; constant fills (zero, sentinel values) need a missingness indicator column so the model can distinguish "filled" from "real"; and categorical gaps usually take a dedicated "missing" category rather than the mode, because missingness itself is often predictive. At GPU scale, all of these are one-liner cuDF operations (fillna, masks, categoricals), so the exam grades the statistics, and the statistics only.

Encoding: cardinality is the constraint

The encoding family has one axis that decides everything: how many distinct values the categorical column holds. Low-cardinality columns (payment method, region, device type) one-hot encode cleanly into a handful of columns. High-cardinality columns (merchant IDs, user IDs, URLs) make one-hot an out-of-memory generator: a million distinct values means a million new columns, and no cluster makes that sensible for tree models.

Target encoding (replacing each category with a statistic of the label for that category) is the domain's favorite advanced answer, and it arrives with a mandatory caveat the exam tests separately: the statistic must be computed with leakage controls (out-of-fold or smoothed estimates, fitted on training data only), or the feature memorizes the label. When a stem offers target encoding "computed over the full dataset," that phrasing is the trap.

Scaling, outliers, and the string layer

Three smaller decision families fill out the domain. Scaling: distance-based and gradient-based models (k-means, logistic regression, neural networks) need standardized features; tree ensembles are scale-invariant, and the exam likes asking which preprocessing step is unnecessary for which model family. Robust scalers (median and interquartile range) beat standard scalers when outliers are real and staying.

Outliers: the graded behavior is diagnosis before deletion. An outlier that is a data error (a negative age, a timestamp from 1970) gets corrected or removed; an outlier that is a real extreme (a genuine million-dollar transaction) is signal, and clipping or robust methods preserve the row while taming its leverage. Stems that say "remove all outliers beyond three standard deviations" are usually offering the reflex answer for you to reject.

Strings and dates: at 50 million rows an hour, text normalization and datetime decomposition stay on the GPU via vectorized accessors (.str, .dt), and the recurring wrong answer is any detour through Python loops or host memory. Derived time features (hour, day-of-week, elapsed-since) are cheap, powerful, and tested mostly through "which feature would capture the weekly pattern" stems.

Leakage: the rule that grades five questions at once

Data leakage (information from outside the training window influencing training) is the domain's highest-stakes idea because it silently inflates every offline metric. The exam encodes it through one operational rule: everything that learns from data is fitted on the training split only, then applied to validation and test. Scalers, imputers, encoders, feature selectors, all of them.

Stems test it in costume: a scaler fitted before the split, a target encoding computed over all rows, a time-series model validated with a random shuffle (future rows training a past-facing model), a feature that is a proxy for the label ("account closed date" predicting churn). The tell is always chronology or fit-scope, and the graded answer restores the boundary: fit on train, transform elsewhere, split time-series data by time.

Worked scenario 1: the million-merchant column

A fraud features table has merchant_id with 1.1 million distinct values. One-hot encoding exhausts GPU memory, and dropping the column measurably hurts the model. The pipeline must stay on GPU and fit in 80 GB. What is the graded move?

Target or frequency encoding: merchant risk collapses into one or two dense columns, memory stops being a topic, and the signal the stem says matters survives. The distractor set writes itself: bigger hardware (spends money on a representation problem), arbitrary small-bucket hashing (destroys most of the merchant signal), and dropping the column (the stem already told you it hurts). If the item mentions computing the encoding "on the full dataset," it is also quietly testing the leakage rule, and the out-of-fold variant becomes the fully correct answer.

Worked scenario 2: the perfect validation score

A churn model validates at 0.99 AUC. Features were standardized before the train/test split, and one feature is days_since_last_login computed at label-collection time. Production performance is poor from the first week. What went wrong?

Two leaks, one big and one small. The dominant one is the feature: days_since_last_login measured at label time is nearly the label itself for churned users (churned customers have not logged in by construction). The scaler fitted before the split is the textbook secondary leak: test-set statistics influenced training-set scaling. The graded answer identifies the label proxy as the reason for immediate production failure and re-fits all preprocessing on the training split; answers that reach for drift or retraining miss that day-one failure indicts the evaluation, which is exactly the pattern the warning box above describes.

Next steps

Run the decision families against real items: the practice questions article contains four preparation scenarios with full reasoning, and the seven full-length tests drill the domain at exam weight under the two-hour clock. If several certifications are in your plan, Preporato Pro covers all of them, tests and labs both.

Sources:

• RAPIDS cuDF documentation
• RAPIDS cuML documentation
• NVIDIA DALI documentation
• NVIDIA Accelerated Data Science Professional certification