GPU-accelerated sentiment analysis using RAPIDS cuDF from NVIDIA

In the ever-evolving landscape of data science and natural language processing, the choice of tools can significantly impact both performance and productivity. RAPIDS cuDF provides a pandas-like interface but is designed to leverage NVIDIA GPUs for accelerated data processing using CUDA.

Pandas has long been the de facto standard in the Python data science ecosystem and is widely used for data manipulation. Its intuitive syntax, rich API, and widespread adoption make it the first choice for most data scientists. Pandas offers a highly intuitive and expressive API that closely resembles SQL operations, making it accessible to users with varying levels of programming expertise.

However, as data grows in both size and complexity, especially in fields like sentiment analysis where raw text must be cleaned, normalised, and vectorised, the limitations of Pandas become apparent. Pandas operates on a single CPU core by default, making it inefficient for large-scale data processing. The data structures in Pandas are predominantly row-oriented, which are inefficient for columnar analytical workloads. Therefore, performance bottlenecks occur when dealing with datasets exceeding a few hundred thousand rows. Functions such as joins, groupbys, or multi-step transformations become increasingly slow as dataset size grows, limiting their utility in real-time or production pipelines. This situation creates a compelling need to explore and adopt GPU-accelerated alternatives like RAPIDS cuDF to maintain a competitive edge, improve analytical speed, and enable the development of more sophisticated AI capabilities.

A GPU-powered upgrade for text preprocessing with RAPIDS cuDF

RAPIDS cuDF addresses the performance and scalability challenges of Pandas by offloading DataFrame operations to the GPU, offering massive parallelism and higher throughput. cuDF is built on Apache Arrow columnar memory format optimised for GPU memory, allowing more efficient access patterns and memory usage. It supports out-of-core processing and large-scale datasets that would crash in pandas. The design of cuDF reflects a strategic choice to prioritise the most common and computationally intensive string operations that can be efficiently parallelised on GPUs to deliver performance gains. Moreover, the design philosophy of cuDF closely mirrors that of pandas. This ensures a minimal learning curve, allowing developers to migrate existing codebases quickly and take advantage of GPU acceleration without rewriting from scratch. The easiest way to start is by enabling the cudf.pandas accelerator mode.

import pandas as pd 

# Import cuDF and enable the pandas accelerator mode

import cudf

%load_ext cudf.pandas

Instead of pd.read_csv(), use cudf.read_csv(). cuDF’s read_csv is significantly faster, especially for large datasets, as it leverages GPU parallelism for data loading. Ahmedur Rahman Shovon, using the California road network dataset with an NVIDIA A100 GPU and AMD EPYC CPU, tested common operations like CSV reading, DataFrame reversal, merging, and dropping rows.

Reading a CSV took him 7.53 seconds with RAPIDS cuDF compared to 67.29 seconds in Pandas. Similarly, DataFrame reversal is over 50x faster, and merging operations showed drastic improvements: 2.35 seconds for cuDF versus 80.35 seconds for pandas. Shovon attributed these performance gains to cuDF’s use of GPU parallelism, which enables faster, more memory-efficient processing of large datasets (Shovon, 2022).

The significant speedup factors, particularly for large datasets, underscore the compelling rationale for considering RAPIDS cuDF to accelerate data analysis workflows.

In sentiment analysis, preprocessing text data involves numerous steps like HTML cleaning, lowercasing, punctuation removal, stop word filtering, spelling correction, and vectorisation. Each of these steps is applied to millions of text records. Using pandas, these operations are slow and memory-bound. The performance of basic string methods like lower() can be substantially faster on a GPU for large text data.

Furthermore, traditional CPU-based tokenisation becomes a significant bottleneck, especially when processing large text corpora. cuDF addresses this with its GPU subword tokeniser cudf.core.subword_tokenizer, which offers exceptional performance. A critical advantage of this GPU-native tokeniser is its ability to perform the entire tokenisation process and keep all intermediate outputs entirely within GPU memory (Vibhu Jawa, 2021).

cudf.Series.replace() allows for the replacement of specified values or patterns within a Series. However, the limitation is that cudf.Series.replace() currently does not support regular expressions like regex=True, a feature available in pandas.Series.str.replace() (Rapids, 2025). This implies that complex pattern-based text replacements requiring regular expressions cannot be directly accelerated by cudf.Series.replace() and would necessitate alternative approaches. Alternatively, a temporary fallback to Pandas for that specific step can be taken with careful consideration of the performance overhead from CPU-GPU data transfers (Rapids, 2025).

The broader NVIDIA ecosystem also offers GPU-accelerated solutions for advanced text processing tasks. NVIDIA’s NeMo framework includes SpellMapper, a specialised non-autoregressive model designed for postprocessing Automatic Speech Recognition (ASR) output. Its purpose is to correct highly specific user terms, out-of-vocabulary (OOV) words, or spelling variations, and it leverages GPUs for its operations (NVIDIA, n.d.). While cuDF itself does not offer direct spell correction, a comprehensive GPU-accelerated NLP pipeline for sentiment analysis can integrate cuDF for efficient data loading and initial, highly parallelizable preprocessing steps like lowercasing, basic replacements and tokenisation. Complex linguistic tasks like spell correction and advanced text feature engineering can be offloaded to specialised RAPIDS libraries or NVIDIA NLP frameworks like cuML or NeMo.

Text Vectorisation for Sentiment Analysis with cuML

Once the text is preprocessed, vectorisation using TF-IDF or word embeddings can be offloaded to cuML, and the resulting vectors can be fed into GPU-powered classifiers like logistic regression, creating a seamless GPU-accelerated pipeline. Empirical benchmarks show significant performance improvements in vectorisation. For a substantial dataset comprising 5 million COVID-related tweets (approximately 3GB of text data), cuML’s TfidfVectorizer demonstrated a remarkable 21x speedup compared to scikit-learn’s CPU-based implementation. This reduced the vectorisation runtime from 2 minutes 54.6 seconds on CPU to a mere 25.9 seconds on an NVIDIA Tesla V100-32Gb GPU (Simon Andersen, 2021). This significant performance gain was also accompanied by a substantial reduction in peak memory usage, decreasing from 19 GB to 8 GB. This efficiency is largely attributable to cuML’s optimised handling of sparse matrices, which are characteristic outputs of TF-IDF transformations. Additionally, cuML’s HashingVectorizer has been benchmarked to be 20x faster than its scikit-learn counterpart (Vibhu Jawa, 2021).

Also, word embeddings, such as those generated by Word2Vec, are crucial for capturing semantic relationships and contextual information in text, representing words as dense vectors in a low-dimensional space. While cuML does not directly implement Word2Vec training, it plays a crucial role in the downstream processing of text embeddings. NVIDIA ecosystem also provides GPU-accelerated solutions for word embedding generation. A fine-grained parallelism GPU algorithm, FULL-W2V, achieved a 5.72x speedup over state-of-the-art multi-threaded CPU implementations for Word2Vec training on NVIDIA V100 cards. It demonstrated 8.647x speedup over other modern GPU implementations. This acceleration is achieved through optimised data reuse and by exploiting the independence of negative samples during training (Randall et al., 2021). Direct Word2Vec model training or inference within cuML requires integration with external libraries like Gensim, which offers CPU-based Word2Vec implementations (Gaurav, 2025).

The Value Proposition: Why Adopt RAPIDS cuDF Methods?

The adoption of RAPIDS cuDF methods offers compelling advantages for accelerating sentiment analysis workflows, driven by unprecedented performance gains, seamless integration, end-to-end GPU acceleration, enhanced scalability, and improved developer productivity. The above empirical results unequivocally demonstrate that cuDF, and the broader RAPIDS ecosystem, can transform data processing tasks that traditionally take minutes or hours on CPUs into mere seconds or minutes on GPUs. A major advantage of cuDF is its highly compatible Pandas-like API, which significantly reduces the learning curve for data scientists already proficient in Pandas (Reid, 2024).

Furthermore, the RAPIDS ecosystem is designed for holistic GPU acceleration, allowing data to remain on the GPU throughout the entire data science pipeline. This includes data loading and preprocessing with cuDF, machine learning tasks with cuML, and even visualisation (Siddharth Sharma et al., 2025). The dramatic reduction in execution times directly translates to significantly faster iteration cycles for data analysis. This enables more rapid experimentation, quicker refinement of models, and ultimately, accelerated delivery of insights and solutions. For organisations operating with large-scale text data, such as those performing real-time sentiment analysis on customer feedback or social media trends, the ability to process data orders of magnitude faster provides a significant competitive advantage.

Limitations and performance considerations for small datasets

GPUs excel at massively parallel processing of large datasets, but there is an inherent overhead associated with transferring data between CPU host memory and GPU device memory. For relatively small datasets (fewer than 10,000-100,000 rows), this data transfer overhead can negate the benefits of GPU acceleration, potentially making cuDF slower than Pandas (RAPIDS, n.d.). Operations that involve frequent scalar access or element-wise iteration are inherently sequential and do not leverage the GPU’s parallel architecture effectively. Such operations can be significantly slower in cuDF compared to Pandas, as demonstrated by instances where looping through a DataFrame elementwise was 100x slower with cuDF enabled (magnus-ekman, 2024).

While cuDF.apply() supports Numba JIT compilation for executing UDFs on the GPU, its direct GPU execution is primarily optimized for numeric dtypes. UDFs that involve complex Python objects, rely on external Python libraries not optimised for GPU, or perform operations that cannot be easily compiled to CUDA kernels may cause automatic fallback to CPU execution (Brandon Miller, 2022). A notable functional limitation is the current lack of regular expression (regex) support in cudf.Series.replace(). This means that complex pattern-based text replacements requiring regex cannot be directly accelerated by the cuDF method, necessitating alternative approaches or CPU fallback (Rapids, 2025). The “zero code change” feature of cudf.pandas is a powerful enabler for GPU adoption. However, the detailed analysis of limitations reveals that this feature is not a complete guarantee of 100% GPU acceleration for all Pandas functionalities. Specifically, the lack of regex support in replace(), the numeric data type constraint for direct GPU UDF execution, and the performance overheads for small datasets or non-vectorised operations indicate that CPU fallback will occur for certain scenarios. While cudf.pandas significantly simplifies the initial transition to GPU acceleration, achieving optimal and consistent performance, especially for complex and diverse NLP pipelines, still requires a nuanced understanding of cuDF’s underlying architecture and its current functional limitations.

However, cuDF stands as a transformative technology for accelerating data processing in Natural Language Processing, particularly for sentiment analysis workflows that involve large and complex text datasets. For data scientists and machine learning engineers grappling with the computational demands of modern sentiment analysis, adopting cuDF is not merely an option but a strategic imperative. It offers an accessible pathway to overcome CPU-bound bottlenecks, drastically reduce processing times, and accelerate development cycles. The journey towards fully GPU-accelerated NLP is continually evolving, with cuDF providing a robust and increasingly comprehensive foundation for high-performance text analytics.

Exercise: Adapting and accelerating the existing sentiment analysis script

The existing script is a comprehensive sentiment analysis pipeline on customer reviews using traditional NLP methods (NLTK, gensim, scikit-learn, etc.). While functional, it relies heavily on CPU-bound operations (pandas, nltk, gensim, etc.), which are not optimised for GPU acceleration.

Major bottlenecks identified in the script are:

Refactoring and rewriting the key parts of this script using cuDF to see the acceleration in action.

References

• Brandon Miller. (2022, May 27). Prototyping Faster with the Newest UDF Enhancements in the NVIDIA cuDF API. NVIDIA Technical Blog. https://developer.nvidia.com/blog/prototyping-faster-using-udfs-and-new-cudf-features/
• Gaurav, P. (2025, March 21). Skyrocket scikit-learn with NVIDIA cuML: 50x Faster, No Code. Let’s Data Science. https://letsdatascience.com/skyrocket-scikit-learn-with-nvidia-cuml/
• magnus-ekman. (2024, August 3). [PERF] looping through dataframe is 100x slower than when running without cudf [Gist]. GitHub. https://github.com/rapidsai/cudf/issues/16491
• nv-edwli. (n.d.). Workbench-example-rapids-cudf . GitHub. Retrieved May 28, 2025, from https://github.com/NVIDIA/workbench-example-rapids-cudf/blob/main/code/performance-comparisons.ipynb
• Randall, T., Allen, T., & Ge, R. (2021). FULL-W2V: Fully exploiting data reuse for W2V on GPU-accelerated systems. Proceedings of the ACM International Conference on Supercomputing, 455–466. https://doi.org/10.1145/3447818.3460373
• RAPIDS. (n.d.). FAQ and Known Issues [Blog post]. Retrieved May 29, 2025, from https://docs.rapids.ai/api/cudf/nightly/cudf_pandas/faq/#which-functions-will-run-on-the-gpu
• Rapids. (2025). Cudf.Series.replace. Cudf.Series.Replace Documentation. https://docs.rapids.ai/api/cudf/stable/user_guide/api_docs/api/cudf.series.replace/
• Reid, T. (2024, April 5). Need for Speed: cuDF Pandas vs. Pandas. Towards Data Science. https://towardsdatascience.com/need-for-speed-cudf-pandas-vs-pandas-16b87009aefa/
• Shovon, A. R. (2022, August 1). cuDF vs Pandas dataframe performance comparison. Ahmedur Rahman Shovon. https://arshovon.com/blog/cudf-vs-df/
• Siddharth Sharma, Nick Becker, Brian Tepera, & Dante Gama Dessavre. (2025, March 18). NVIDIA cuML Brings Zero Code Change Acceleration to scikit-learn. NVIDIA Technical Blog. https://developer.nvidia.com/blog/nvidia-cuml-brings-zero-code-change-acceleration-to-scikit-learn/
• Simon Andersen. (2021, April 25). Gpu_tfidf_demo notebook [Gist]. NLP Preprocessing and Vectorizing at Rocking Speed with RAPIDS cuML. https://gist.github.com/Garfounkel/e96f2f48d1de35b21506a13cdc37a363
• Vibhu Jawa. (2021, May 14). NLP and Text Processing with RAPIDS: Now Simpler and Faster. NVIDIA Technical Blog. https://developer.nvidia.com/blog/nlp-and-text-precessing-with-rapids-now-simpler-and-faster/