Evo2

Evo2: Genome-Scale DNA Foundation Model

Overview

Evo2 is a DNA language model from Arc Institute that operates at single-nucleotide resolution with up to 1 million base pair context. It is trained on 8.8 trillion tokens from OpenGenome2 — sequences spanning all domains of life.

This is a DNA model, not a protein model. Input is raw nucleotide sequence (A/C/G/T). For protein tasks, use ESM2 or ESM-C instead.

Core capabilities:

• Variant effect scoring — zero-shot log-likelihood scoring of SNPs, indels, regulatory variants
• Sequence embeddings — genomic representations for downstream ML (classification, regression)
• Sequence generation — autoregressive DNA sequence design from a prompt
• Positional entropy — per-nucleotide uncertainty across a sequence
• Perplexity analysis — sliding window perplexity for detecting unusual regions

Architecture: StripedHyena 2 — hybrid attention + gated convolutions. Not a standard Transformer. Attention only at layers 3, 10, 17, 24, 31; the rest are Hyena convolution blocks.

Installation

# Full install (all models including 20B/40B)
conda install -c nvidia cuda-nvcc cuda-cudart-dev
conda install -c conda-forge transformer-engine-torch=2.3.0
pip install flash-attn==2.8.0.post2 --no-build-isolation
pip install evo2

# Light install (7B models only — no FP8 required)
pip install flash-attn==2.8.0.post2 --no-build-isolation
pip install evo2

Requirements: Python 3.11–3.12, CUDA 12.1+, Linux (WSL2 with caveats).

Model Selection

| Checkpoint | Context | Params | Hardware | Use case | |---|---|---|---|---| | evo2_1b_base | 8K | 1B | Any GPU | Testing, quick iteration | | evo2_7b_base | 8K | 7B | Any GPU | Good quality, short contexts | | evo2_7b_262k | 262K | 7B | Any GPU | Mid-range genomic context | | evo2_7b | 1M | 7B | Any GPU | Best default | | evo2_20b | 1M | 20B | H100 (FP8) | High accuracy | | evo2_40b | 1M | 40B | Multi-H100 | Maximum accuracy | | evo2_7b_microviridae | 8K | 7B | Any GPU | Phage/viral sequences |

Start with evo2_7b. Model weights download automatically from HuggingFace on first use.

Core Usage

Load the model

from evo2 import Evo2

model = Evo2('evo2_7b')    # downloads from HuggingFace on first run
# model.model      — StripedHyena2 backbone
# model.tokenizer  — CharLevelTokenizer (vocab size 512)

1. Variant Effect Scoring

Score the effect of a variant by comparing log-likelihoods between reference and variant sequences.

reference = "ACGTACGTACGTACGT"
variant   = "ACGTACGAACGTACGT"   # T→A at position 7

scores = model.score_sequences(
    seqs=[reference, variant],
    batch_size=1,
    reduce_method='mean',            # 'mean' or 'sum'
    average_reverse_complement=True, # recommended: average both strands
)

delta_ll = scores[1] - scores[0]
# delta_ll > 0 → variant more likely than reference (neutral or beneficial)
# delta_ll  1M bp: use a sliding window
window = 500_000
step   = 250_000
windows = [long_seq[i:i+window] for i in range(0, len(long_seq), step)]
scores = model.score_sequences(windows, batch_size=1, reduce_method='mean')

Scoring Conventions

• score_sequences returns mean (or sum) log-likelihood per sequence — more negative = less likely
• For variant scoring: delta = variant_score - reference_score
• delta > 0 → variant more consistent with training data distribution
• delta < 0 → variant less likely (potentially deleterious for functional sequences)
• No absolute cutoff exists — comparisons are relative; always score against a reference
• average_reverse_complement=True is strongly recommended for coding sequences and regulatory elements, as they can be on either strand

Scripts

# Score all SNVs in a 50bp window around a target position
python scripts/score_variants.py genome.fasta chr1:230100 \
  --window 50 --output variants.csv

# Score named variants from a VCF
python scripts/score_variants.py genome.fasta --vcf mutations.vcf \
  --flanking 100 --output scores.csv

# Embed a FASTA file of genomic sequences → .npy
python scripts/embed.py sequences.fasta --output embeddings.npy

# Embed with layer selection
python scripts/embed.py sequences.fasta --layer blocks.28.mlp.l3 \
  --output embeddings.npy --normalize

When to Use Evo2 vs. Protein Models

| Task | Recommended model | |---|---| | Score a DNA variant (SNP, indel) | Evo2 | | Model a regulatory element, promoter, enhancer | Evo2 | | Predict protein function from sequence | ESM2 / ESM-C / ProtT5 | | Protein variant effect prediction | ESM2 (scan_variants.py) | | Structure prediction | AlphaFold, Boltz-2, ESMFold | | Generate a genomic region de novo | Evo2 | | Generate a novel protein sequence | ESM3 |

Resources

• GitHub: https://github.com/arcinstitute/evo2
• Paper: Brixi et al., Nature 2026 — https://doi.org/10.1038/s41586-026-10176-5
• HuggingFace: https://huggingface.co/arcinstitute
• NVIDIA hosted API: https://build.nvidia.com/arc/evo2-40b

References

• references/api.md — full API reference: all scoring functions, embedding extraction, generation parameters, long-sequence strategies, fine-tuning

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: naity
• Source: naity/FM4Life
• License: MIT

Install and usage instructions live in the source repository linked above.