Free NVIDIA-Certified Professional: Accelerated Data Science (NCP-ADS) Practice Questions

Sample NCP-ADS Practice Questions

Browse all 20 free NVIDIA-Certified Professional: Accelerated Data Science practice questions below.

1. A data scientist needs to accelerate pandas-like DataFrame operations on a single GPU. Which RAPIDS library should they use?

   • cuGraph
   • cuDF, which provides a pandas-like API for GPU-accelerated DataFrame operations including filtering, groupby, joins, and aggregations
   • cuSpatial
   • cuSignal

2. When deploying a trained cuML model to production, which NVIDIA platform provides optimized inference serving with dynamic batching and model versioning?

   • NVIDIA Triton Inference Server, which supports dynamic batching, concurrent model execution, model versioning, and multi-framework serving with GPU-optimized inference pipelines
   • NVIDIA DALI, which provides GPU-accelerated data loading and augmentation pipelines that include built-in model serving capabilities for production workloads
   • NVIDIA NeMo, which bundles conversational AI model training with an integrated inference server designed for general-purpose ML model deployment
   • NVIDIA TensorRT alone, which handles model versioning, dynamic batching, and multi-model serving in addition to its core optimization functionality

3. What is the primary advantage of using cuDF over pandas for data cleansing operations on a dataset with 500 million rows?

   • cuDF provides additional cleansing functions not available in pandas, including proprietary algorithms for outlier detection and automated data imputation
   • cuDF enables massively parallel processing on the GPU, dramatically reducing computation time for large datasets
   • cuDF uses less total system memory than pandas because GPU memory compression is more efficient than CPU RAM allocation for tabular data
   • cuDF automatically detects and corrects data quality issues such as inconsistent formatting, duplicate records, and invalid entries without explicit user code

4. Which GPU architecture concept explains why data science workloads with high arithmetic intensity benefit most from GPU acceleration?

   • The GPU's superior single-threaded performance compared to CPUs, which accelerates sequential computations in iterative algorithms
   • Massive parallelism through thousands of CUDA cores executing the same operation on different data elements simultaneously
   • The GPU's larger L3 cache compared to CPUs, which ensures that the entire dataset fits in cache for rapid in-memory analytics without hitting DRAM
   • Direct memory mapping between GPU VRAM and system disk storage, which eliminates the CPU-to-GPU transfer bottleneck entirely

5. A data scientist wants to train a random forest classifier on a GPU using the RAPIDS ecosystem. Which library provides GPU-accelerated implementations of traditional ML algorithms?

   • cuDF
   • cuML, which offers GPU-accelerated random forest, linear regression, k-means, DBSCAN, PCA, and many other algorithms with a scikit-learn-compatible API
   • cuGraph
   • RAPIDS Memory Manager (RMM)

6. What is the primary advantage of the cuDF-pandas accelerator mode?

   • It requires rewriting all pandas code to use cuDF-specific APIs and function signatures before any GPU acceleration can take effect
   • It accelerates existing pandas code on GPUs with zero code changes
   • It replaces the pandas library entirely and removes CPU fallback capabilities to ensure consistent GPU-only execution
   • It converts pandas DataFrames to Apache Arrow format for distributed processing across multiple cluster nodes using MPI communication

7. When using NVIDIA Triton Model Analyzer, which metrics are primarily evaluated to optimize model serving configuration?

   • Throughput, latency, and GPU memory utilization
   • Training loss curves, validation accuracy, and learning rate schedules across different training epochs and hyperparameter combinations
   • Data preprocessing speed, ETL pipeline efficiency, and storage I/O bandwidth for upstream data feeds entering the serving pipeline
   • Network bandwidth between client and server, DNS resolution time, and TLS handshake overhead for each incoming inference request

8. What is NVTabular primarily designed for in GPU-accelerated data science workflows?

   • Feature engineering and preprocessing for recommender systems and tabular data at scale on GPUs
   • Training deep learning models for computer vision tasks using convolutional neural network architectures with mixed precision support
   • Managing GPU cluster resources and job scheduling
   • Visualizing high-dimensional data in interactive dashboards with real-time streaming capabilities for monitoring model performance

9. Which NVIDIA technology enables GPU-accelerated direct data transfer between storage and GPU memory, bypassing the CPU and system memory? (Select TWO)

   • NVIDIA GPUDirect Storage (GDS) which allows a direct data path between local or remote storage and GPU memory
   • NVIDIA CUDA Unified Memory which automatically migrates pages between CPU and GPU memory on demand based on access patterns
   • cuFile API which provides user-space file I/O operations that leverage GDS for direct GPU memory access
   • NVIDIA Multi-Process Service (MPS) which enables concurrent kernel execution from multiple processes sharing a single GPU context
   • NVIDIA TensorRT which optimizes trained neural network models for inference by fusing layers and reducing numerical precision

10. In cuML, how does the GPU-accelerated Random Forest implementation differ from scikit-learn's CPU version?

    • cuML uses a completely different algorithm that produces fundamentally different results and cannot replicate scikit-learn's output regardless of parameter settings
    • cuML builds trees in parallel on the GPU, providing significant speedups while offering a scikit-learn-compatible API
    • cuML requires data to be pre-sorted in ascending order by all feature columns before training, while scikit-learn handles unsorted input automatically
    • cuML's version only supports binary classification tasks and cannot handle multi-class classification or regression problems unlike scikit-learn's full implementation

11. What is the primary role of the Dask distributed scheduler when processing large datasets across a GPU cluster?

    • It replaces the CUDA runtime and manages all GPU kernel launches directly through a custom execution engine
    • It coordinates task execution across multiple workers, managing task dependencies, scheduling priority, and efficient data transfer between nodes in the cluster
    • It automatically converts all Python code into optimized CUDA C++ kernels for maximum GPU throughput on each worker node
    • It functions exclusively as a memory manager that pre-allocates and pools GPU memory across all available devices in the cluster

12. When using NVIDIA TensorRT to optimize a trained model for inference deployment, which step is essential during the optimization process?

    • Building an optimized inference engine by specifying the target GPU architecture, precision modes (FP32, FP16, INT8), and maximum batch size constraints
    • Re-training the entire model from scratch using TensorRT's built-in training loop to ensure the weights are compatible with the inference runtime
    • Converting all model weights to double precision (FP64) to maximize numerical accuracy before generating the inference engine
    • Manually rewriting each neural network layer as a custom CUDA kernel before passing it to the TensorRT builder for compilation

13. Which cuDF operations are GPU-accelerated for string processing? (Select TWO)

    • Running regex pattern matching across millions of string entries in parallel on GPU cores
    • Compiling string values into executable Python bytecode that runs on the GPU's shader processing units
    • Performing string splitting, concatenation, and substring extraction using GPU-parallel string kernels
    • Automatically translating strings between human languages using a built-in neural machine translation engine on the GPU
    • Converting string columns to native GPU tensor format for direct input into convolutional neural network layers without any preprocessing

14. What distinguishes GPU global memory from shared memory in the CUDA memory hierarchy?

    • Global memory is accessible by all threads across all blocks but has higher latency, while shared memory is per-block with much lower latency
    • Global memory resides in the CPU's DDR RAM and is transferred to the GPU on demand, while shared memory is the GPU's only on-device storage
    • Global memory is a software-managed cache layer that exists only in the device driver, whereas shared memory maps directly to physical registers on each streaming multiprocessor
    • Both memory types have identical access latency and bandwidth characteristics, but global memory supports atomic operations while shared memory does not

15. In GPU-accelerated gradient boosting with XGBoost, what is the gpu_hist tree method primarily designed to optimize?

    • It optimizes histogram construction and split evaluation by building feature histograms in GPU memory, enabling parallel bin counting and gain calculation
    • It stores the entire training dataset in GPU texture memory to leverage hardware-accelerated interpolation during feature importance ranking
    • It replaces the gradient descent optimization algorithm with a proprietary NVIDIA CUDA-native solver that runs exclusively on Tensor Cores
    • It moves the loss function computation to the GPU while keeping tree construction on the CPU for better numerical precision and stability

16. When configuring RAPIDS Memory Manager (RMM) for a long-running ETL pipeline, which memory resource should you use to minimize allocation overhead while maintaining a predictable memory footprint?

    • A pool memory resource that pre-allocates a large block of GPU memory and sub-allocates from it
    • A CUDA memory resource wrapping standard cudaMalloc and cudaFree calls, which provides the most direct interface to the GPU driver's memory management subsystem and avoids additional abstraction layers
    • A managed memory resource that uses CUDA Unified Memory with automatic page migration between host and device, allowing the driver to handle placement decisions transparently based on access patterns
    • A logging memory resource wrapper that records every allocation and deallocation event to a trace file, enabling post-hoc analysis of memory usage patterns and leak detection across pipeline stages

17. A data engineer needs to apply a custom mathematical transformation to a cuDF column that is not available as a built-in operation. Which approach correctly leverages GPU-accelerated user-defined functions?

    • Write a Numba-decorated kernel function and apply it using cuDF's applymap or apply_rows
    • Convert the cuDF column to a pandas Series using .to_pandas(), apply the transformation with a standard Python lambda, then convert back to cuDF with cudf.from_pandas() to maintain the GPU pipeline
    • Use Python's built-in map() function directly on the cuDF Series object, which automatically dispatches the computation to the GPU through cuDF's internal interoperability layer and CUDA runtime hooks
    • Define the transformation as a standard Python function using NumPy operations and pass it to cuDF's .apply() method, which internally translates NumPy calls into equivalent cuBLAS and cuFFT operations

18. When performing a merge of two large cuDF DataFrames, what determines whether RAPIDS uses a hash-based join or a sort-merge join strategy?

    • cuDF uses hash joins by default for most merge operations due to their superior GPU parallelism
    • The join strategy is selected at runtime by cuDF's cost-based query optimizer, which estimates the cardinality of both DataFrames, checks for existing sort orders on join keys, and evaluates available GPU shared memory before choosing the optimal algorithm
    • The user must explicitly specify the join algorithm by passing a method parameter (method='hash' or method='sort') to the merge function, as cuDF provides no automatic selection mechanism and raises an error if the parameter is omitted
    • Sort-merge join is always used when the join keys contain string columns because hashing variable-length strings on the GPU exceeds shared memory bandwidth limits and produces excessive collision rates compared to radix sort decomposition

19. What happens when a cuDF operation requires more GPU memory than is currently available and spilling is enabled in RMM?

    • cuDF automatically moves least-recently-used buffers to host memory to free GPU memory for the new allocation
    • The CUDA driver's unified memory subsystem automatically pages data between host and device memory using hardware-managed page tables, and cuDF triggers a synchronous cudaMemPrefetchAsync to pre-stage data likely to be needed in subsequent kernel launches
    • The operation is automatically partitioned into smaller chunks that each fit in GPU memory, processed sequentially with intermediate results written to disk as Apache Parquet files, and then concatenated once all partitions complete
    • RMM raises a MemoryError exception and halts execution, requiring the user to manually free GPU memory by calling rmm.reinitialize() with a larger pool size before retrying the operation

20. Which two statements correctly describe out-of-core processing patterns with Dask-cuDF for datasets that exceed GPU memory? (Select TWO)

    • Dask partitions the dataset into chunks and schedules them so only a subset of partitions resides in GPU memory at any time
    • The computation graph is lazily constructed, and Dask only materializes partitions when results are explicitly requested via .compute() or .persist()
    • Dask-cuDF requires the entire dataset to fit in aggregate GPU memory across all workers; it cannot process datasets larger than total available GPU memory even with multiple nodes because the task graph must hold all partition references simultaneously
    • Dask-cuDF implements GPU-to-GPU direct memory access (RDMA) via NVLink for all inter-partition communication, and falls back to PCIe only when NVLink topology is unavailable, requiring explicit UCX transport configuration in the Dask cluster settings
    • Out-of-core mode is activated by setting the environment variable DASK_CUDF_SPILL=1 before cluster initialization, which configures each worker to use memory-mapped files backed by NVMe storage as a transparent swap space for GPU allocations