Free NVIDIA-Certified Associate: Accelerated Data Science (NCA-ADS) Practice Questions

Sample NCA-ADS Practice Questions

Browse all 10 free NVIDIA-Certified Associate: Accelerated Data Science practice questions below.

1. An analyst runs these lines in a notebook connected to a Dask-CUDA cluster: ddf = dask_cudf.read_parquet("events/*.parquet") daily = ddf.groupby("day").clicks.sum() The cell finishes in 0.2 seconds, nvidia-smi shows no GPU activity, and printing daily shows a structure with npartitions instead of numbers. What should the analyst do to get the daily totals?

   • Call ddf.repartition(npartitions=1) first, since the GPU cannot aggregate data spread over partitions
   • Call daily.compute(), since Dask records a task graph and executes it when results are requested
   • Use cudf.read_parquet for the whole folder, since dask_cudf cannot run aggregations on the GPU
   • Restart the cluster with more workers, since no worker was free to run the groupby at that moment

2. A disease screening model is evaluated with sklearn.metrics.confusion_matrix(y_true, y_pred), labels [0 = healthy, 1 = sick]. The output is: [[880, 20], [ 45, 55]] A draft report says "20 sick patients were missed by the screen." Which correction is right?

   • 55 sick patients were missed; the 20 are sick patients that the screen detected
   • 20 is right, since column 1 of row 0 counts sick patients the screen labeled healthy
   • 65 sick patients were missed, which is the sum of both off-diagonal cells of the matrix
   • 45 sick patients were missed; the 20 are healthy patients wrongly flagged as sick

3. A churn dataset has numeric columns with missing values and categorical columns with text labels. Today, preprocessing happens in separate notebook cells for training and for scoring, and last month the scoring cells produced one-hot columns in a different order than training. Which pipeline design prevents this class of bug?

   • A FeatureUnion that imputes, scales and one-hot encodes, with each transformer applied to all of the columns
   • A shared helper function that the training and scoring cells each call to fit the preprocessing again
   • A ColumnTransformer that imputes and scales numeric columns and one-hot encodes the rest, in a Pipeline
   • pandas get_dummies on the training data and again on the scoring data, followed by sorting the column names

4. An A/B test compares checkout times. Group A has 900 users with a standard deviation of 12 seconds; group B has 4,000 users with a standard deviation of 31 seconds. The analyst wants to test whether the mean checkout times differ. Which test call matches these data?

   • scipy.stats.ttest_rel(a, b), the paired t-test of the samples
   • scipy.stats.ttest_ind(a, b, equal_var=False), the Welch t-test
   • scipy.stats.ttest_ind(a, b), the default independent t-test
   • scipy.stats.chi2_contingency on a table of the two time columns

5. A new team member trains a cuML random forest and asks why some numbers come from training and others are chosen before training: the split thresholds inside the trees, and settings such as n_estimators and max_depth. Which statement is correct?

   • Both kinds are hyperparameters, since the user can read the split thresholds after training and change them freely
   • Both kinds are learned during fitting, and the constructor values are starting points that training then updates
   • Split thresholds are learned during fitting; n_estimators and max_depth are hyperparameters set beforehand
   • n_estimators and max_depth are learned during fitting; the split thresholds are hyperparameters set by the user

6. A dask_cudf ETL job with many joins and aggregations runs on 8 GPUs. Profiling shows heavy time in GPU memory allocation and free calls, and some workers fail with out-of-memory errors although total memory use is well below capacity. Which worker configuration addresses both symptoms?

   • Start workers with --protocol ucx, so data moves between GPUs over NVLink during shuffles
   • Start workers with --device-memory-limit set to 50%, so each worker uses half of its GPU memory
   • Start one worker for all 8 GPUs, so a single process manages the memory of all eight devices
   • Start workers with --rmm-async and --rmm-pool-size so allocations come from a preallocated pool

7. A fraud model flags very few transactions. On the test set its precision is 1.00 and its recall is 0.10. A manager averages the two and reports a "balanced score" of 0.55. What is the model's F1 score?

   • About 0.18
   • About 0.32
   • About 0.10
   • About 0.55

8. A company runs a monthly data-to-AI pipeline: ETL on a CPU Spark cluster, feature engineering on a second CPU cluster type, and XGBoost training on GPU nodes. Each stage needs its own cluster configuration. AT&T published results from a similar setup. What did AT&T find when it moved the earlier stages to GPUs?

   • GPU clusters needed a full rewrite of the Spark SQL jobs into CUDA code before they could match the CPU clusters on speed
   • GPUs sped up model training, but ETL and feature engineering cost more on GPUs than on CPU Spark clusters of the same speed
   • Using the RAPIDS Accelerator for Apache Spark, GPU pipelines were faster, cheaper and simpler, with no switching between stages
   • GPU clusters helped with real-time inference alone; the batch stages stayed cheaper on CPU, since batch jobs are cost-optimized

9. A team explores a 6 GB dataset in pandas, and each filter or re-render of a chart takes 40 seconds. The manager asks why moving the exploration to RAPIDS libraries would matter, when the final report will contain only a few static charts. Which argument does NVIDIA's visualization guide make?

   • GPU-rendered charts have higher image quality, which makes the final static report charts more accurate
   • pandas cannot plot datasets larger than 2 GB, so the charts would fail to render at all without RAPIDS
   • Interactions slower than about 7-10 seconds break the analyst's short-term memory and train of thought
   • Static report charts must be produced on a GPU, since modern charting libraries require CUDA to draw

10. Two colleagues run the same cudf.pandas notebook on a dataset larger than their GPUs' memory, using the same GPU model. On native Linux the notebook completes; on Windows with WSL2 it fails with an out-of-memory error. What explains the difference?

    • WSL2 runs cudf.pandas on the CPU, and the CPU path has less memory than the GPU path on Linux
    • The Linux machine compresses data in GPU memory automatically, which the Windows driver lacks
    • Windows reserves half of the GPU memory for the display, so cudf.pandas sees half of the device
    • On Linux, cudf.pandas uses managed memory to oversubscribe the GPU; WSL2 supports no oversubscription