> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/clara/parabricks/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/clara/parabricks/_mcp/server.

# deepvariant

Run a GPU-accelerated DeepVariant algorithm.

Refer to the [deepvariant Reference](#options) 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.**

In version 3.8 the *--run-partition* option was added, which can lead
to a significant speed increase. However, using the
*--run-partition*, *--proposed-variants*, and *--gvcf* options at the same time will
lead to a substantial slowdown.  A warning will be issued and the
*--run-partition* option will be ignored.

## 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

```sh
# This command assumes all the inputs are in the current working directory and all the outputs go to the same place.
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.7.1-1 \
    pbrun deepvariant \
    --ref /workdir/${REFERENCE_FILE} \
    --in-bam /workdir/${INPUT_BAM} \
    --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](/about-parabricks/comparison-with-baseline-tools) page for comparing the results.

```sh
sudo docker run \
--volume <INPUT_DIR>:/input \
--volume <OUTPUT_DIR>:/output \
google/deepvariant:1.9.0 \
/opt/deepvariant/bin/run_deepvariant \
--model_type WGS \
--ref /input/${REFERENCE_FILE} \
--reads /input/${INPUT_BAM} \
--output_vcf /output/${OUTPUT_VCF} \
--num_shards $(nproc) \
--disable_small_model=true \
--make_examples_extra_args "ws_use_window_selector_model=true"
```

In Google DeepVariant, the small model is enabled by default and must be explicitly disabled
(with `--disable_small_model=true`). In Parabricks DeepVariant, the small model is opt-in and
must be explicitly enabled (with `--enable-small-model`).

Variants called by the small model will have an additional `MID` field in their VCF record,
which denotes which model called the variant. This is consistent with VCF files produced by
Google DeepVariant.

## 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](https://developer.nvidia.com/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