NCA-ADS Practice Questions: 20 Exam-Style Questions Explained (2026)

cuDF does not support iterating over a Series, DataFrame or Index, because iterating over data on the GPU performs very badly: GPUs are built for highly parallel operations. The cuDF documentation notes that an existing function or method can almost always replace the loop, here one multiplication over the whole column. Reading values one at a time with iloc copies 50 million single values from the GPU. tolist() moves everything to host memory and gives up the GPU. Fifty million delayed tasks would spend far more time on scheduling than on the additions, since every Dask task carries its own overhead.

The reading calls this the metric trap: on highly unbalanced data, a classifier that predicts the common class every time reaches a high accuracy without analyzing any features. Metrics computed on the fraud class, such as precision, recall and F1, expose that at once. Resampling changes the balance the model learns from: undersampling drops majority rows and can lose valuable information, and oversampling repeats minority rows and can overfit. Resample the training data only, after the split, so the test set keeps the real balance. A larger test set measures the same misleading number more precisely. Removing the fraud rows deletes the class the model exists to find. Shuffling changes the order of the rows and leaves the balance as it was.

Dask's guide warns against calling compute in a loop: each call blocks until it finishes, which stops Dask from running the queries in parallel and from sharing intermediate results between them. Collecting the lazy results and passing them all to one dask.compute call lets Dask compute the shared part, here reading the files, only once and run the 12 aggregations in parallel. Computing the whole DataFrame first pulls all of it into the client's memory, where large data may not fit. More partitions change how the work is split, and each compute call still repeats the reads. Threads let the calls overlap, but each call still computes the shared work on its own.

The pandas documentation notes that pivot() can only handle unique combinations of index and columns, and that data with duplicates needs pivot_table(), which aggregates them, here with a sum per store and month. melt goes the other way, from wide to long. Swapping index and columns keeps the same duplicate store and month pairs. stack moves column labels into the index and adds nothing up.

In cudf.get_dummies, dummy_na=True adds a column that marks missing values, which are ignored by default, and drop_first=True keeps k-1 dummies for k levels by removing the first level. The removed city is implied when all the other city columns are 0, and dtype sets the type of the new columns, bool by default. Option A's default ignores missing values. The documentation describes sparse as non-functional in RAPIDS. Casting to category stores integer codes in a single column and creates no indicator columns.

NVIDIA's tutorial evaluates k-means with inertia, the sum of squared distances between each point and its closest centroid, where lower values mean tighter clusters. The elbow method plots inertia against the number of clusters and picks the point where the curve bends, the balance between low inertia and too many clusters. Inertia keeps falling as k grows, because more centroids sit closer to the points, so the lowest value simply goes to the largest k tried. Stopping at k=2 ignores the steep drop that continues to k=4. Comparing k values is exactly what the elbow plot is for.

In scikit-learn's confusion matrix, rows are true labels and columns are predicted labels, and normalize divides over the true conditions (rows), the predicted conditions (columns) or the whole population. With "pred", each column sums to 1, so a diagonal cell is the fraction of samples predicted as that class that truly belong to it: the class's precision. normalize="true" puts recall on the diagonal, and normalize="all" gives cells whose diagonal sums to the accuracy. F1 combines precision and recall and does not appear in the matrix itself.

The cuml.accel FAQ explains that cuml.accel gives zero-code-change acceleration for scikit-learn and similar packages while cudf.pandas does the same for pandas, and that the two can be combined on the command line with python -m cudf.pandas -m cuml.accel script.py. In Jupyter, both extensions are loaded before the libraries they accelerate are imported. Each accelerator covers its own library, so either one alone leaves the other part on the CPU. A --device flag is an argument to the script itself, and neither library reads it.

scikit-learn's common-pitfalls guide uses this exact setup: selecting features on the whole dataset before the split produces 0.76 accuracy on random data, because the test rows helped choose the features. Like any preprocessing, feature selection should use the training data only. Split first, fit the selector on the training set, and the score falls to what random data deserves, close to chance; a Pipeline does the same automatically inside cross-validation. A larger test split, another statistic or another model all leave the selection step fitted on every row, so the leak remains.

NVIDIA's guide shows that Dask switches between CPU and GPU backends with a setting, much as PyTorch code picks a device: dask.config.set({"dataframe.backend": "cudf"}) or the environment variable DASK_DATAFRAME__BACKEND=cudf on the GPU servers, and pandas elsewhere. The same read_parquet and groupby code then runs on either. Two copies of each pipeline are exactly what the setting avoids. Converting to pandas at every step pulls the data off the GPU. cuml.accel accelerates scikit-learn and similar libraries, and Dask DataFrames are outside its scope.

NVIDIA's glossary describes a data flywheel as a self-improving loop in which data collected from AI interactions or processes is used to keep refining the models, which in turn produces better outcomes and more valuable data. Its steps run from processing and curating data through customizing and evaluating the model to deployment, after which new data and feedback flow back into processing. A frozen model learns nothing from production. A nightly search on the original training set sees no new data. Copying logs into a warehouse helps reporting and sends nothing back to the model.

SciPy lists Levene's test among its tests for equal variances. ttest_ind assumes equal population variances by default; with equal_var=False it performs Welch's t-test, which does not. ttest_rel is for related samples, such as the same customers measured before and after a change. chi2_contingency tests independence in a table of counts. pearsonr measures the linear correlation between paired values, and two independent groups have no pairs to correlate.

NVIDIA's guide uses this example: an hvPlot histogram of trip durations shows that most trips are short, and because hvPlot has built-in interactivity, you can zoom in to inspect the long tail of durations without creating another query. hvPlot charts display interactively through the Bokeh and Plotly extensions, with Matplotlib as the static option. A filtered query would work, and zooming gets there without new code. The guide works with the full data on the GPU and adds Datashader when millions of individual points have to be drawn.

pandas crosstab builds a frequency table, and its normalize argument turns counts into shares: True divides by the grand total, "index" normalizes within each row and "columns" within each column. With regions as rows, "index" gives each region's plan mix summing to 1. True gives each cell's share of all customers. "columns" shows how each plan's customers split across regions. value_counts on the plan column alone loses the regions.

cuDF's comparison with pandas states that cuDF supports all the data types in pandas except pandas.PeriodDtype, pandas.SparseDtype and third-party ExtensionDtypes. cudf.pandas runs what cuDF supports on the GPU and falls back to pandas for the rest, so the operations on a period column run on the CPU. Converting the periods to timestamps (datetime64), a type cuDF supports, is one way to keep those steps on the GPU. cuDF has native datetime types, so dates in general stay on the GPU. Fallback depends on what cuDF supports, and a column's number of distinct values plays no part in it. Spilling moves data to host memory under memory pressure, a separate mechanism from fallback.

NVIDIA's overview of learning types describes supervised learning as training on a fully labeled dataset, and unsupervised learning as finding features and patterns in unlabeled data on its own, with clustering, which groups similar items together, as its most common application. Classification needs the segment labels the retailer does not have. Regression predicts a number such as a purchase amount and forms no groups. Reinforcement learning trains an agent through rewards for its actions.

Prometheus's guide to histograms explains that for a classic histogram or a summary, you get the average duration over a window by dividing the rate of the sum by the rate of the count; native histograms have histogram_avg for the same job. histogram_quantile(0.5, ...) estimates the median, which can be far from the mean when latencies are skewed. Averaging the bucket counters over time mixes cumulative counts from different buckets and yields no duration. Dividing the summed rate of the le="0.3" bucket by the summed rate of the count is the guide's example for a service-level objective: it gives the fraction of requests that took 0.3 seconds or less.

Datadog's guide treats data drift metrics as early indicators when ground truth is delayed, and gives this example: for a categorical recommendation model, find the Jensen-Shannon divergence between samples of the most recent input data and the test data used during training, with a rollup range chosen so that local seasonal swings do not trigger it. RMSE needs the labels that arrive weeks later. Nightly retraining changes the model without telling anyone that the inputs moved, and the guide notes that repeated retrains can cause drift of their own. A categorical feature such as device type has no mean, so a t-test on means does not apply.

TimeSeriesSplit's max_train_size sets the maximum size of a single training set, so each fold trains on the latest 730 samples before its test period, a window that slides forward with every fold. test_size limits the size of each test set. gap excludes samples between the end of the training set and the start of the test set, which helps when a target looks ahead in time. Fewer splits change the number of folds, and their training sets still grow.

conda keeps a history of the changes made to an environment so that you can roll back: conda list --revisions shows each change, and conda install --revision=REVNUM, or --rev REVNUM, restores the environment to that revision. Exporting now records the broken state after the upgrade. conda clean removes caches and unused packages and restores no versions. Updating everything moves the environment further from the state that worked.