deepvariant

Run a GPU-accelerated DeepVariant algorithm.

Refer to the deepvariant Reference section for a detailed listing of all available options.

What is DeepVariant?

DeepVariant is a deep learning based variant caller developed by Google for germline variant calling of high-throughput sequencing data. It works by taking aligned sequencing reads in BAM/CRAM format and utilizes a convolutional neural network (CNN) to classify the locus into true underlying genomic variation or sequencing error. DeepVariant can therefore call single nucleotide variants (SNVs) and insertions/deletions (InDels) from sequencing data at high accuracy in germline samples.

Why DeepVariant?

DeepVariant’s approach is able to detect variants that are often missed by traditional (for example Bayesian) variant callers, and is known to reduce false positives. It offers several advantages over similar tools, including its ability to detect a wide range of variants with high accuracy, its scalability for analyzing large datasets, and its open source availability. Additionally, its deep learning-based approach allows it to provide better support for different sequencing platforms, as it can be retrained to provide higher accuracy for specific protocols or research areas.

How Should I Use DeepVariant?

DeepVariant is designed for use as a germline variant caller that can apply different models trained for specific sample types (such as whole genome and whole exome samples) to yield higher accuracy results. DeepVariant can be deployed within NVIDIA’s Parabricks software suite, which is designed for accelerated secondary analysis in genomics, bringing industry standard tools and workflows from CPU to GPU, and delivering the same results at up to 60x faster runtimes. A 30x whole genome can be run through DeepVariant in as little as 8 minutes on an NVIDIA DGX station, compared to 5 hours on a CPU instance (m5.24xlarge, 96 x vCPU). DeepVariant in Parabricks is used in the same way as other command line tools that users are familiar with: It takes a BAM/CRAM and the reference genome as inputs and produces the variants (a VCF file) as outputs. Currently, DeepVariant is supported for T4 and newer GPUs out of the box.

Available Operating Modes

Parabricks DeepVariant can run in one of three operating modes:

1. shortread
2. PacBio
3. ONT

See the —mode option below.

Quick Start

1
# This command assumes all the inputs are in the current working directory and all the outputs go to the same place.
2
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
3
    --workdir /workdir \
4
    nvcr.io/nvidia/clara/clara-parabricks:4.7.1-1 \
5
    pbrun deepvariant \
6
    --ref /workdir/${REFERENCE_FILE} \
7
    --in-bam /workdir/${INPUT_BAM} \
8
    --out-variants /outputdir/${OUTPUT_VCF}

Compatible Google DeepVariant Commands

The commands below are the Google counterpart of the Parabricks command above. The output from these commands will be identical to the output from the above command. Refer to the Output Comparison page for comparing the results.

1
sudo docker run \
2
--volume <INPUT_DIR>:/input \
3
--volume <OUTPUT_DIR>:/output \
4
google/deepvariant:1.9.0 \
5
/opt/deepvariant/bin/run_deepvariant \
6
--model_type WGS \
7
--ref /input/${REFERENCE_FILE} \
8
--reads /input/${INPUT_BAM} \
9
--output_vcf /output/${OUTPUT_VCF} \
10
--num_shards $(nproc) \
11
--disable_small_model=true \
12
--make_examples_extra_args "ws_use_window_selector_model=true"

Models for Additional GPUs

Parabricks DeepVariant supports the following models:

1. Short-read WGS
2. Short-read WES
3. PacBio
4. ONT

Parabricks DeepVariant ships with model files for T4 and all GPUs that are Ampere or newer. Since v4.7, these model files are created using TensorRT 10.14.1.48.

Source of Mismatches

While Parabricks DeepVariant does not lose any accuracy in functionality when compared with Google DeepVariant there is one reason that can result in different output files.

• CNN Inference

Google DeepVariant uses a CNN (convolutional neural network) to predict the possibilities of each variant candidate. The model is trained, and does inference through, Keras. In Parabricks DeepVariant we convert this Keras model to an engine file with TensorRT to perform accelerated deep learning inferencing on NVIDIA GPUs. Because of the optimizations from TensorRT, there is a small difference in the final possibility scores after inferencing (10^-5), which could cause a few different variants in the final VCF output. Based on current observations, the mismatches only happen to RefCalls with a quality score of zero.

Options