Question bank
NVIDIA Certified Associate - Accelerated Data Science
42 NVIDIA Certified Associate - Accelerated Data Science questions with the correct answer and a written explanation, organised across 8 exam domains.
- 42 questions
- 8 domains
- Foundation level
certilumQuestion index
Jump straight to any question. Answers and explanations are inline.
Advance Data Structures
5 questions in this domain
- Question 1Single Choice
What is the primary advantage of using cuDF's optimized readers, such as read_parquet, for data ingestion?
- AThey use GPU kernels to parallelize file parsing directly into GPU memoryCorrect answer
- BThey convert all numeric values to float64 before loading
- CThey store the data on disk to avoid using GPU memory
- DThey require the data to be in CSV format
Why this is the answer
cuDF readers leverage GPU kernels to parse and load data in parallel into VRAM, reducing ingestion time compared to CPU-based loading.
- Question 2Multiple Select
Which methods can you use to quickly inspect a cuDF DataFrame after loading it? (Select all that apply.)
- A.head()Correct answer
- B.tail()Correct answer
- C.info()Correct answer
- D.plot()
Why this is the answer
.head(), .tail(), and .info() are DataFrame inspection methods used to examine rows, structure, and schema before expensive GPU operations.
- Question 3Interactive
Review the code block. What does the printed output represent?
- AThe column names and their data typesCorrect answer
- BThe first five rows of the DataFrame
- CSummary statistics for numeric columns
- DThe total memory usage of the GPU
Why this is the answer
.dtypes returns a Series containing the dtype of each column, enabling schema verification before further GPU processing.
- Question 4Single Choice
What is the primary purpose of downcasting numeric columns in a cuDF DataFrame?
- ATo reduce the memory footprint so more data fits in GPU VRAMCorrect answer
- BTo increase the mathematical precision of calculations
- CTo enable automated string processing
- DTo move the data from device memory to host memory
Why this is the answer
Downcasting reduces memory usage, which is critical for keeping large datasets within GPU VRAM and avoiding OOM errors.
- Question 5Multiple Select
Which of the following are common pitfalls when moving from pandas to cuDF? (Select all that apply.)
- AAssuming every pandas operation is 1:1 compatible with cuDFCorrect answer
- BChoosing int64 when int32 is sufficient and causing OOM errorsCorrect answer
- CConfusing host memory with device memoryCorrect answer
- DStoring data in GPU memory is unnecessary for acceleration
Why this is the answer
Common traps include assuming full pandas compatibility, ignoring dtype memory impact, and confusing host RAM with device VRAM.
Data Manipulation and Preparation
10 questions in this domain
- Question 6Single Choice
What is the primary advantage of using cuDF's optimized readers for CSV and Parquet files compared to CPU-based data loading?
- AThey parallelize parsing with GPU kernels, reducing ingestion time.Correct answer
- BThey always consume less GPU memory than CPU loading.
- CThey automatically convert all columns to pandas object types.
- DThey skip dtype verification entirely.
Why this is the answer
cuDF readers use GPU kernels to parse files in parallel, dramatically cutting the time spent in data ingestion compared to CPU-based loading.
- Question 7Multiple Select
Which of the following are DataFrame inspection methods in cuDF that help verify data structure before GPU operations?
- A.head()Correct answer
- B.tail()Correct answer
- C.info()Correct answer
- D.merge()
Why this is the answer
.head(), .tail(), and .info() are inspection methods; .merge() is used for relational joins, not initial DataFrame inspection.
- Question 8Interactive
The code block reads a CSV and prints the dtypes of the resulting DataFrame. What is the purpose of this operation?
- AThe schema and column data types are correct before executing GPU operations.Correct answer
- BThe DataFrame is sorted by the first column.
- CThe number of missing values in each column.
- DThe data has been moved from device memory to host memory.
Why this is the answer
Printing .dtypes verifies schema and dtype alignment, helping avoid OOM and compatibility issues before expensive GPU operations.
- Question 9Single Choice
Where must data reside for cuDF operations to benefit from GPU acceleration?
- AGPU device memory (VRAM)Correct answer
- BSystem RAM (Host memory)
- CCPU cache
- DLocal disk storage
Why this is the answer
cuDF acceleration requires data to reside in GPU high-bandwidth memory; host memory or disk prevents GPU-speed execution.
- Question 10Multiple Select
Which of the following are common traps in accelerated data workflows using cuDF?
- AAssuming all pandas operations are 1:1 compatible with cuDF.Correct answer
- BIgnoring data types and using int64 when int32 suffices.Correct answer
- CConfusing host memory with device memory.Correct answer
- DAlways using categorical types for numeric columns.
Why this is the answer
The traps include pandas compatibility assumptions, ignoring data types, and confusing host/device memory. Categorical types are beneficial for repeated strings.
- Question 11Interactive
The code block casts an int64 column to int32 after reading a Parquet file. What is the primary benefit of this downcasting?
- AIt reduces the memory footprint on the GPU.Correct answer
- BIt increases numeric precision.
- CIt converts the column to a categorical type.
- DIt enables string regex operations.
Why this is the answer
Downcasting from int64 to int32 reduces GPU memory usage, helping avoid OOM errors while maintaining sufficient precision.
- Question 12Single Choice
How does boolean indexing enable efficient row filtering in cuDF?
- AIt creates a vectorized mask evaluated in parallel across GPU cores.Correct answer
- BIt iterates through rows one by one on the CPU.
- CIt transfers the whole DataFrame to disk first.
- DIt converts all columns to strings for comparison.
Why this is the answer
cuDF evaluates boolean masks as vectorized operations across GPU cores, avoiding slow Python-level row-wise conditional loops.
- Question 13Multiple Select
Which of the following are join- or groupby-related traps mentioned in the playbook?
- AAssuming a join will not change the total row count.Correct answer
- BConfusing groupby().transform() with groupby().aggregate().Correct answer
- CNeglecting the impact of NaNs during grouping or joining.Correct answer
- DFiltering rows before a groupby to reduce data size.
Why this is the answer
The playbook lists row-count assumptions, transform/aggregate confusion, and NaN neglect as join/groupby traps. Pre-filtering is not presented as a trap.
- Question 14Interactive
The code block applies a transformation after a groupby. What does the resulting result Series contain?
- AA reduced Series with one mean per group.
- BA Series of the same length as the original DataFrame with each value replaced by its group mean.Correct answer
- CA DataFrame with groups and means.
- DAn error because transform is not supported in cuDF.
Why this is the answer
groupby().transform() returns a Series aligned with the original DataFrame, unlike aggregate(), which reduces dimensionality by group.
- Question 15Single Choice
Which factor should guide the choice between mean, median, or constant imputation in accelerated data pipelines?
- AThe feature distribution and impact on model variance.Correct answer
- BThe number of columns in the DataFrame.
- CThe GPU model being used.
- DThe alphabetical order of column names.
Why this is the answer
The playbook states imputation choice depends on the feature's distribution and its impact on model variance, not hardware or schema ordering.
Data Science Pipelines and Workflow Automation
4 questions in this domain
- Question 16Single Choice
Which method should be used to check the data types of each column in a cuDF DataFrame?
- A.head()
- B.dtypesCorrect answer
- C.describe()
- D.info()
Why this is the answer
The .dtypes method returns the data type of every column in a cuDF DataFrame, making it the direct way to verify schema and dtype alignment. .head() shows rows, .describe() gives statistics, and .info() provides a broader summary rather than a dedicated dtype series.
- Question 17Multiple Select
Which of the following are common traps when managing data types and memory in GPU-accelerated DataFrames? (Choose all that apply.)
- AUsing int64 for every integer column even when int32 would be sufficientCorrect answer
- BConverting high-precision float64 columns to float32 to save memory
- CAssuming data exists in GPU memory when it actually remains in system RAMCorrect answer
- DUsing category dtype for repeated string values
Why this is the answer
Using unnecessarily wide integer types can cause OOM errors in VRAM, and confusing host memory with device memory prevents acceleration because data must reside on the GPU. Downcasting float64 to float32 and using category dtype are both effective optimization strategies, not traps.
- Question 18Interactive
After executing the provided code, where is the 'transactions' dataset stored so that cuDF operations can accelerate it?
- AIn GPU high-bandwidth memory (VRAM)Correct answer
- BIn CPU system RAM (host memory)
- COn the disk in the original Parquet file
- DIn CPU cache
Why this is the answer
cuDF loads data directly into GPU memory by leveraging fast device-side readers. The DataFrame resides in GPU high-bandwidth memory, enabling subsequent operations to run without moving data back to the CPU.
- Question 19Single Choice
In a cuDF groupby operation, which method returns a result with the same number of rows as the original DataFrame?
- Agroupby().aggregate()
- Bgroupby().transform()Correct answer
- Cgroupby().count()
- Dgroupby().sum()
Why this is the answer
groupby().transform() returns an object of the same length as the original DataFrame, while aggregate(), count(), and sum() reduce the dimensionality by producing one row per group.
Descriptive Analysis and Visualization
4 questions in this domain
- Question 20Single Choice
What is the primary advantage of using cuDF's optimized readers for CSV and Parquet files?
- AThey use GPU kernels to parallelize parsing, significantly reducing ingestion time.Correct answer
- BThey compress data before storing it in CPU memory.
- CThey automatically convert all columns to string types.
- DThey load data directly into System RAM without GPU involvement.
Why this is the answer
cuDF readers leverage GPU kernels to parse formats like CSV and Parquet in parallel, minimizing the initial data ingestion phase compared with CPU-based loading.
- Question 21Multiple Select
Which of the following methods are recommended for inspecting a cuDF DataFrame's structure before executing expensive GPU operations?
- A.head()Correct answer
- B.info()Correct answer
- C.tail()Correct answer
- D.to_pandas()
Why this is the answer
Inspection methods such as .head(), .tail(), and .info() let data scientists quickly verify data structure and dtype alignment before running costly GPU operations.
- Question 22Interactive
What is the type of the object returned by this cuDF groupby operation?
- AA cudf.Series with the same length as the original DataFrameCorrect answer
- BA cudf.DataFrame with one row per group
- CA cudf.Index containing the group labels
- DA Python float representing the overall mean
Why this is the answer
groupby().transform() returns a Series of the same length as the original, unlike aggregate(), which reduces the dimensionality.
- Question 23Single Choice
Why is dtype verification important before running GPU-accelerated operations?
- AIt optimizes memory footprint and ensures compatibility with NVIDIA libraries.Correct answer
- BIt automatically cleans all missing values.
- CIt converts data into Python lists.
- DIt increases CPU-GPU data transfer by tenfold.
Why this is the answer
Checking dtypes allows correct type selection, which optimizes GPU memory footprint and ensures compatibility with libraries like NVIDIA's Float16 precision for deep learning.
Foundations of Accelerated Data Science
4 questions in this domain
- Question 24Single Choice
Which NVIDIA library provides GPU-accelerated DataFrame readers that ingest CSV and Parquet files directly into GPU memory?
- AcuDFCorrect answer
- Bpandas
- CNumPy
- DMatplotlib
Why this is the answer
cuDF is RAPIDS' GPU DataFrame library. Its optimized readers use GPU kernels to parse CSV and Parquet files directly into GPU memory, significantly reducing ingestion time compared to CPU-based pandas loading.
- Question 25Multiple Select
Which of the following are common traps when working with cuDF in accelerated data science? Select all that apply.
- AAssuming all pandas operations are 1:1 compatible with cuDFCorrect answer
- BConfusing host memory with device memoryCorrect answer
- CUsing int32 instead of int64 when memory is limited
- DAlways dropping missing values to speed up preprocessingCorrect answer
Why this is the answer
Common cuDF traps include assuming pandas compatibility, confusing host and device memory, and dropping missing values without analysis. Downcasting to int32 is a recommended memory-saving practice, not a trap.
- Question 26Interactive
Review the code block. What dtype is assigned to the `scores` column when `df.dtypes` is printed?
- Afloat64Correct answer
- Bfloat32
- Cint64
- Dobject
Why this is the answer
When a cuDF DataFrame is created from Python float values, cuDF infers a float64 dtype for the column. Therefore, `scores` is displayed as float64.
- Question 27Single Choice
What is the primary benefit of using cuDF for initial data inspection compared to pandas?
- AThey parse data in parallel on GPU kernels and load it directly into GPU memoryCorrect answer
- BThey automatically compress all data before loading
- CThey always use a larger CPU cache
- DThey skip schema and dtype verification
Why this is the answer
cuDF readers use GPU kernels to parse file formats in parallel and place the resulting DataFrame directly in GPU memory. This avoids CPU-GPU transfer bottlenecks and reduces ingestion time.
Introductory MLOps Practices
4 questions in this domain
- Question 28Single Choice
What is the primary reason cuDF readers accelerate the initial ingestion of large datasets compared to CPU-based loading?
- AGPU kernels parallelize parsingCorrect answer
- BData is compressed automatically
- CData stays in host memory
- DFiles are converted to CSV first
Why this is the answer
cuDF uses GPU kernels to parse formats like Parquet and CSV in parallel, moving data directly into VRAM unlike CPU-based loading.
- Question 29Multiple Select
Which actions help prevent Out-of-Memory errors when using cuDF on the GPU?
- AConvert string columns to categorical typesCorrect answer
- BDowncast numeric columns to smaller typesCorrect answer
- CUse float64 for all numeric columns
- DKeep data in system RAM
Why this is the answer
Categorical encoding and downcasting reduce memory footprint. High-precision types and host memory placement increase memory pressure or prevent acceleration, causing OOM.
- Question 30Interactive
What does the output of `.dtypes` in this snippet confirm before further GPU processing?
- AColumn types and schema alignmentCorrect answer
- BDescriptive statistics
- CNumber of null values
- DJoin compatibility
Why this is the answer
.dtypes shows the data type of each column, allowing schema verification before expensive GPU operations.
- Question 31Single Choice
How does `groupby().transform()` differ from `groupby().aggregate()`?
- Atransform returns original length; aggregate reduces rowsCorrect answer
- Btransform reduces rows; aggregate returns original length
- CBoth always return the same shape
- DBoth require a GPU restart
Why this is the answer
transform returns a Series of the same length as the original, while aggregate reduces dimensionality by returning grouped summary values.
Machine Learning With NVIDIA RAPIDS
7 questions in this domain
- Question 32Single Choice
What is the primary benefit of using cuDF’s optimized readers, such as read_parquet, for data ingestion?
- AIt parallelizes file parsing across GPU cores, reducing ingestion time.Correct answer
- BIt automatically sorts all data after reading.
- CIt converts all columns to float64 by default.
- DIt moves data from GPU to host memory automatically.
Why this is the answer
cuDF uses GPU kernels to parse file formats such as Parquet and CSV in parallel, loading data directly into GPU memory and significantly reducing ingestion time. It does not sort the data automatically, does not default to float64, and does not move data to host memory.
- Question 33Multiple Select
Which two statements about data types and memory in accelerated RAPIDS workflows are correct?
- AChoosing int64 when int32 is sufficient can cause OOM errors on the GPU.Correct answer
- BUsing 64-bit types always improves GPU processing performance.
- CDowncasting columns reduces the memory footprint in GPU VRAM.Correct answer
- DString-heavy columns require no extra memory management.
Why this is the answer
Selecting unnecessarily large dtypes such as int64 can waste GPU memory and lead to OOM errors. Downcasting, such as converting int64 to int32 or float64 to float32, reduces VRAM usage. 64-bit types are not always better, and string-heavy columns require careful memory management.
- Question 34Interactive
What is the purpose of the operation shown in the code block?
- AInspect the schema and dtype of each column.Correct answer
- BSort the DataFrame by index.
- CCompute descriptive statistics for numeric columns.
- DFilter rows where values are null.
Why this is the answer
Using .dtypes on a cuDF DataFrame displays each column’s data type. This is a schema and dtype verification step, allowing the user to confirm whether column types are appropriate before performing expensive GPU operations.
- Question 35Single Choice
What is a key purpose of sorting data in a GPU-accelerated data pipeline?
- AIt enables more efficient joins and window functions.Correct answer
- BIt reduces the memory footprint of categorical columns.
- CIt eliminates the need to check for missing values.
- DIt automatically encodes string columns as integers.
Why this is the answer
Sorting is a prerequisite for efficient joins and window functions in GPU-accelerated workflows. It does not reduce categorical memory usage, remove missing values, or automatically encode strings.
- Question 36Multiple Select
Which two statements about the category dtype in cuDF are true?
- AIt represents repeated strings as integers.Correct answer
- BIt reduces memory footprint compared to raw string columns.Correct answer
- CIt slows down groupby and join operations.
- DIt can only be used after dropping all null values.
Why this is the answer
Categorical data uses integer codes to represent repeated strings, reducing memory usage and accelerating grouping and joining operations. It is not slower, and it does not require dropping all null values before use.
- Question 37Interactive
What does the code block produce?
- AA Series with the same length as the original DataFrame.Correct answer
- BA reduced DataFrame with one row per category.
- CAn error because groupby().transform() is not supported.
- DA new column containing the grouped sum for each category.
Why this is the answer
groupby().transform() returns a Series of the same length as the original DataFrame, preserving the original number of rows. This is different from groupby().aggregate(), which reduces dimensionality.
- Question 38Single Choice
When preparing a dataset for machine learning, what should be evaluated before dropping rows containing missing values?
- AWhether dropping the rows will cause loss of critical signal or biased datasets.Correct answer
- BWhether the data was loaded from a CSV or a Parquet file.
- CWhether the DataFrame has a categorical column.
- DWhether the GPU has more than 16 GB of VRAM.
Why this is the answer
Dropping missing values can remove important information and introduce bias. Before deciding to drop rows, it is essential to evaluate the impact on signal and dataset representativeness rather than focusing only on file format, categorical columns, or VRAM size.
Software and Environment Management
4 questions in this domain
- Question 39Single Choice
What is the primary reason cuDF's optimized readers can load large-scale datasets faster than CPU-based loading?
- AThey use GPU kernels to parallelize parsing of file formats like Parquet and CSV.Correct answer
- BThey bypass VRAM and read data directly into system RAM.
- CThey rely on pandas for parsing and add a caching layer.
- DThey load only a sample of the data instead of the full file.
Why this is the answer
cuDF's optimized readers leverage GPU kernels to parse files in parallel, which significantly reduces the time spent in the data ingestion phase compared to CPU-based loading.
- Question 40Multiple Select
Which of the following are common traps when working with cuDF in accelerated workflows? Select all that apply.
- AAssuming every pandas operation is 1:1 compatible with cuDF.Correct answer
- BUsing int64 when int32 would be sufficient, potentially causing out-of-memory errors.Correct answer
- CFailing to distinguish between GPU memory and system RAM.Correct answer
- DConverting string-heavy columns to categorical types to reduce memory.
Why this is the answer
Common traps include assuming pandas compatibility for every operation, ignoring data types, and confusing host memory with device memory. Converting string-heavy columns to categorical types is a recommended practice, not a pitfall.
- Question 41Interactive
A data scientist runs the following code on a cuDF DataFrame. What is returned when the line containing `print` is executed?
- AA Series containing the data type of each column.Correct answer
- BA DataFrame with descriptive statistics.
- CThe first few rows of the DataFrame.
- DThe total GPU memory usage of the DataFrame.
Why this is the answer
The `.dtypes` attribute returns a Series that maps each column name to its corresponding data type, allowing the user to verify schema and dtype alignment before running GPU operations.
- Question 42Single Choice
Which cuDF method generates a high-level statistical summary, including mean, standard deviation, min, and max, for numerical columns?
- A.head()
- B.tail()
- C.info()
- D.describe()Correct answer
Why this is the answer
The `.describe()` method computes descriptive statistics such as mean, standard deviation, min, and max, providing an immediate high-level view of data distribution and potential quality issues.
Frequently asked questions
Everything about the NVIDIA Certified Associate - Accelerated Data Science question bank and how to use it.