Single-Cell Analysis

Investigate, understand, and interpret single-cell data in minutes, not days, by leveraging RAPIDS-singlecell, powered by NVIDIA RAPIDS™

Overview

For single-cell analysis, scientists can test near-real-time data analysis and visualization easily, achieving up to 938X faster accelerations versus CPU by using RAPIDS-singlecell, developed by scverse. This blueprint is for scientists who understand single-cell analysis and want to leverage RAPIDS for single-cell data.

Experience Workflow

It is strongly recommended that users review the README in this blueprint before working through the notebooks.

For this blueprint, two possible deployments are provided:

1. The Standard Instance: L40s
2. The Large Instance: 8x H100

Please use the table in the Notebook Overview below to determine which size is right for you.

The workflow is as follows:

1. After initial code setup, this blueprint utilizes publicly available datasets including those from 10x Genomics and CZ CELLxGENE. Scientists can use their Python API to read the data directly into an AnnData object.
2. General data preprocessing is performed to clean up and better understand the dataset. This includes calculating QC metrics, filtering, and data normalization.
3. The data is investigated quantitatively and visually, including feature selection, clustering, dimensionality reduction, and data integration using canonical tools.
4. The data is visualized and plotted to help users investigate the biological diversity within the sample.
5. A number of additional advanced tutorials are available for users who are interested in spatial transcriptomics analysis, as well as scaling to 11M cells easily and quickly.

Notebooks Outline

The outline below is a suggested exploration flow. Unless otherwise noted, users can choose any notebook to get started, as long as the GPU resources are available to run the notebook.

For those who are new to doing basic analysis for single-cell data, the end-to-end analysis of 01_demo_gpu_e2e is the best place to start, where users are walked through the steps of data preprocessing, cleanup, visualization, and investigation.

Notebook	Description	Min GPU Size / Instance
01_demo_gpu_e2e	End-to-end workflow, where we understand the cells, run ETL on the dataset then visualize and explore the results. This tutorial is good for all users.	24GB / Standard Instance
02_decoupler	This notebook continues from the outputs of 01_demo_gpu_e2e as an overview of methods that can be used to investigate transcriptional regulation.	24GB / Standard Instance
demo_gpu_e2e_with_PR	End-to-end workflow, like 01_demo_gpu_e2e, but uses Pearson residuals for normalization.	24GB / Standard Instance
spatial_autocorr	An introduction to spatial transcriptomics analysis and visualization.	24GB / Standard Instance
out-of-core_processing	In this notebook, we show the scalability of the analysis of up to 11M cells easily by using Dask. Requires a 48GB GPU.	48GB / Standard Instance
multi_gpu_large_data_showcase	This notebook enhances the 11M cell dataset analysis with Dask without exceeding memory limits. It fully scales to utilize all available GPUs, uses chunk-based execution, and efficiently manages memory. Requires 8x H100s or better. For all other GPU systems, please run out-of-core_processing instead.	8x 80GB / Large Instance
demo_gpu-seuratv3	In this notebook, show diversity in capability by running a similar workflow to 01_demo_gpu_e2e but on brain cells.	24GB / Standard Instance
demo_gpu-seuratv3-brain-1M	In this notebook, we scale up the analysis of demo_gpu-seuratv3 to 1 million brain cells. Requires an 80GB GPU, like an H100.	80GB / Large Instance

Architecture Diagram

Software

The following containers are used in this blueprint:

• RAPIDS v24.12

Additional software—including use of RAPIDS-singlecell, developed by scverse—is available on GitHub accompanying these notebooks.

Minimum System Requirements

The single-cell analysis blueprint recommends using L40s with minimum 24GB VRAM, unless otherwise stated in the tutorial. Users may have to wait 5–10 minutes for the instance to start, depending on cloud availability.

The blueprint supports:

Hardware Requirements

• We recommend using NVIDIA GPU L40s for the best user experience and performance-to-cost ratio for this blueprint, unless otherwise stated in the tutorial. The Large or MultiGPU notebooks require one or more 80GB GPUs. We suggest using an 8x H100 instance.
• Other supported instances, if available in your region:
  • H100
  • A100
  • A10
  • L4
  • GH200
• 24 GB VRAM or more recommended

Software Requirements

• Environment packages can be found on GitHub

License

Governing Terms:

• This RAPIDS-singlecell Blueprint GitHub repository is provided under Apache License 2.0.
• RAPIDS projects are released under the Apache-2.0 license.
• The RAPIDS-singlecell license is available here.

Ethical Considerations

NVIDIA believes Trustworthy AI is a shared responsibility, and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their supporting model team to ensure the models meet requirements for the relevant industry and use case and addresses unforeseen product misuse. For more detailed information on ethical considerations for the models, please see the Model Card++ Explainability, Bias, Safety & Security, and Privacy subcards. Please report security vulnerabilities or NVIDIA AI concerns here.