Deep Learning for Variant Calling: How DeepVariant and Neural Networks Are Improving Genomic Accuracy

Deep learning variant calling has reshaped how researchers extract single nucleotide polymorphisms and small insertions or deletions (indels) from raw sequencing reads, part of a broader shift toward AI-driven genomic analysis. Tools such as DeepVariant reframed the problem as image classification rather than statistical modeling, and the accuracy gains have been substantial. But those gains vary by variant type, sequencing platform, and genomic region.

The persistent challenge of accurate variant calling

Identifying genetic variants from sequencing reads sounds straightforward, but the underlying data are messy. Sequencing platforms introduce errors, reads carrying the same true variant can look different due to alignment artifacts, and repetitive regions make it genuinely ambiguous where a read belongs. Separating a real variant from background noise remains unsolved in parts of the genome, especially at low allele frequencies or in repetitive DNA.

Certain genomic contexts make this especially hard. Homopolymer runs and short tandem repeats cause sequencing instruments to slip and miscount bases, producing systematic errors that look like real insertions or deletions. Segmental duplications and other highly similar regions confuse read mapping, since a short read originating from one copy can align equally well to another. Coverage depth compounds the problem further: a variant supported by only a handful of reads is statistically harder to distinguish from noise than one backed by dozens. The result is that variant calling accuracy is rarely uniform across a genome; it depends heavily on which region, and how deeply that region was sequenced.

Classical variant callers approached this with hand-engineered statistical models built around explicit assumptions about sequencing error rates and read mapping quality. These models work well because they encode decades of domain expertise about how sequencing technologies fail. Deep learning approaches instead learn those failure patterns directly from labeled training data.

How classical and deep learning variant calling methods differ

The Genome Analysis Toolkit (GATK), specifically its HaplotypeCaller tool, developed at the Broad Institute, exemplifies the classical approach. It assembles candidate haplotypes from active regions of the genome, calculates per-read genotype likelihoods using a pair hidden Markov model, and applies machine learning only at a final filtering step to separate true variants from sequencing artifacts. This assembly-based method builds on a unified variant discovery framework that GATK introduced for jointly genotyping variation across multiple samples. That original framework laid out an explicit multi-step pipeline: initial read mapping, local realignment around insertions and deletions, base quality score recalibration, variant discovery and genotyping, and a final machine learning step to distinguish true variation from technical artifacts. Each step encodes a specific, human-authored assumption about how a particular sequencing technology tends to fail.

Figure 1: A side-by-side comparison of classical statistical vs deep learning variant calling methods. Credit: AI-generated image created using Google Gemini (2026).

DeepVariant, published by a Google and Verily research team in 2018, took a fundamentally different path. Rather than modeling the biology of sequencing errors explicitly, the method represents read pileups around a candidate variant as an image and trains a deep convolutional neural network to learn the statistical relationship between those images and the true genotype. In head-to-head published comparisons, DeepVariant outperformed existing state-of-the-art tools and generalized across genome builds and mammalian species, meaning ground-truth data from well-studied human genomes could improve calling even for species with far less reference data. That same generalization property is what has allowed the model to be extended well beyond its original short-read Illumina design, to platforms and chemistries the original 2018 paper never anticipated.

How DeepVariant frames variant calling as image classification

The core insight behind DeepVariant is treating each candidate variant site as a small image built from the reads that overlap it. Each column corresponds to a genomic position, and each row represents a single aligned read, with separate channels encoding features such as base identity, base quality, mapping quality, and strand orientation. A convolutional neural network, borrowed from architectures designed for general-purpose photo classification, scans this image and outputs a probability distribution over three possible genotypes: homozygous reference, heterozygous, and homozygous alternate.

DeepVariant's accuracy depends heavily on having representative training data for the sequencing technology and sample type being analyzed. The tool ships with pretrained models for common platforms, and its GitHub repository documents dedicated case studies for whole genome and exome data, PacBio HiFi reads, and Oxford Nanopore R10.4.1 simplex data, reflecting how far platform-specific tuning has expanded since the 2018 release. A model trained primarily on one sequencing chemistry does not automatically transfer its accuracy to another, which is why maintaining separate, chemistry-specific models has become standard practice rather than relying on a single universal network.

This platform sensitivity also explains why deep learning variant calling has needed continual retraining as sequencing technology itself keeps changing. Newer nanopore chemistries, updated PacBio HiFi library preparations, and even changes to base-calling software can shift the statistical patterns a trained model has learned to recognize, requiring periodic recalibration against updated benchmark data.

Where deep learning outperforms classical variant calling

The most rigorous public comparison of variant calling methods comes from the precisionFDA Truth Challenge V2, a collaboration between the US Food and Drug Administration (FDA) and the Genome in a Bottle Consortium at the National Institute of Standards and Technology (NIST). The challenge drew 20 research teams, who submitted 64 variant call sets evaluated against expanded benchmark sets covering difficult-to-map regions and the highly polymorphic major histocompatibility complex. The best-performing short-read submissions used statistical algorithms with a graph reference rather than a standard linear reference, exemplified by the winning DRAGEN and Seven Bridges pipelines, while the best-performing long-read call sets were deep-learning-based.

Stratifying performance by genomic context revealed sharper differences. Comparing Oxford Nanopore PEPPER-DeepVariant calls against Illumina-based DeepVariant calls showed comparable overall single nucleotide polymorphism accuracy (F1 scores, a combined measure of precision and recall, of 99.64% and 99.57%, respectively), but performance differed by more than a hundredfold in some contexts. Illumina-based calls were more accurate in homopolymers and short tandem repeats under 200 base pairs, while the long-read pipeline performed better in segmental duplications. Indel accuracy told a different story: the Illumina pipeline substantially outperformed the Oxford Nanopore pipeline (an F1 of 99.59% versus 72.54% across all benchmark regions), reflecting the higher indel error rate of the R9.4 nanopore chemistry used in that comparison. No single caller is uniformly superior; the right choice depends on the variant types and regions of interest, and often on whether the downstream analysis can tolerate a small number of residual errors in the hardest parts of the genome.

The challenge authors also flagged an important caveat for anyone interpreting these numbers: submissions that used deep learning or other machine learning methods tended to show larger performance gaps between the unblinded training genome and the semi-blinded evaluation genomes, a pattern consistent with some degree of overfitting to the training sample. That does not invalidate the accuracy gains deep learning has delivered, but it is a reminder that published benchmark figures reflect performance on the specific genomes and conditions tested, not a universal guarantee.

Table 1: Comparison of variant calling approaches by strength and typical use case.

Building Reproducible qPCR Workflows From Experimental Design to Data Analysis

This guide walks through a practical six-step workflow covering experimental design, sample preparation, primer validation, reference gene selection, and data analysis to help generate reproducible qPCR data.
View How To Guide

Advertisement

Long-read sequencing and new deep learning variant calling approaches

Long-read sequencing technologies from Oxford Nanopore and PacBio produce reads that span repetitive regions short reads cannot resolve, though earlier long-read chemistries carried far higher per-base error rates than short-read sequencing. Making deep learning variant calling work reliably on that noisier data required new architectures. The PEPPER-Margin-DeepVariant pipeline, developed by researchers at UC Santa Cruz and Google, splits the problem into three cooperating stages: a recurrent neural network component called PEPPER first identifies candidate variant sites directly from noisy nanopore reads, a phasing module called Margin then separates reads by parental haplotype, and a DeepVariant-style classifier makes the final genotype call using that haplotype-resolved information. It was the first published pipeline to demonstrate that a nanopore-only variant calling method could match or exceed short-read Illumina accuracy for single nucleotide variants across an entire genome.

A parallel line of research took a leaner approach. Clairvoyante's neural network design, a five-layer convolutional model built for noisy long-read data, demonstrated that a much smaller, purpose-built architecture could compete with DeepVariant's general-purpose classifier while running considerably faster. The published network contains roughly 1.6 million parameters, about 13 times fewer than the Inception-based architecture DeepVariant originally used, yet it achieved strong single nucleotide variant accuracy on PacBio data while finishing whole-genome analysis in under 2 hours on a single server. Its successors, including Clair3, have refined this lighter-weight design, giving researchers with constrained compute budgets a viable alternative. This same principle, that a purpose-built model can rival a larger general-purpose network, recurs elsewhere in functional genomics, including work on pooled CRISPR screen analysis. A common finding has emerged: combining evidence from more than one sequencing technology, rather than relying on any single model, consistently produces the most accurate calls.

Practical implementation for genomics research teams

Adopting deep learning variant calling starts with matching the pretrained model to the exact sequencing platform and chemistry in use, since a model trained on one read type or coverage depth can perform noticeably worse on another. Most modern pipelines now ship separate models for Illumina short reads, PacBio HiFi, and specific Oxford Nanopore chemistries, and using the wrong one, even one from a closely related platform generation, can silently degrade accuracy without an obvious error message. Teams working with novel organisms should budget time for retraining, since public models are trained overwhelmingly on human samples. This is not a one-time decision either: as sequencing chemistries and library preparation protocols continue to evolve, a model validated on last year's data may need retraining before it can be trusted on this year's runs.

Benchmarking any pipeline against a recognized truth set is equally important. The Genome in a Bottle Consortium continues to expand its reference materials, including a newer HG002 benchmark built from a telomere-to-telomere assembly developed with the Telomere-to-Telomere Consortium that extends coverage into previously inaccessible regions of the genome. Checking performance in the genomic contexts relevant to a given study, rather than relying on a single overall accuracy figure, gives a far more honest picture than accepting published benchmark numbers at face value.

What deep learning variant calling means for genomic accuracy going forward

Deep learning has measurably improved variant calling accuracy since DeepVariant's introduction, but the improvement is best understood as expanding the range of genomic contexts where accurate calls are possible, not a uniform upgrade over every classical method. Choosing the right tool still requires understanding the sequencing technology, variant types, and genomic regions a research question depends on, and, increasingly, whether combining more than one sequencing technology is worth the added cost and complexity for a given project.

As benchmark sets expand into previously unmappable regions of the genome, the gap between what deep learning models can call accurately and what remains genuinely hard is likely to keep narrowing. That mindset, treating AI as one input rather than a replacement for domain judgment, extends to AI across life science research more broadly.

This content includes text that has been created with the assistance of generative AI and has undergone editorial review before publishing. Technology Networks' AI policy can be found here.