Skip to content

AlphaMissense

The alphamissense source adds DeepMind's predicted pathogenicity for missense variants to each variant. It looks values up in a copy of DeepMind's released predictions that you build once. It runs no model.

Kind Annotation source; type = "alphamissense"
Install pip install altar-alphamissense (PyPI)
Genome builds hg19, hg38
Variant classes Missense SNVs, as DeepMind scored them
Data Build your own with altar-alphamissense-build
Validation Not spot-checked (Validation)
Licence Predictions CC BY 4.0 (Zenodo version 3)
Upstream Code, Data, Paper

When to use it

  • Use AlphaMissense to ask how likely a missense variant is to be pathogenic. DeepMind's per-build files score all possible single-nucleotide missense variants, about 71 million, in the canonical transcripts of 19,000 human protein-coding genes.
  • It scores missense variants only. A synonymous, nonsense, splice, non-coding or indel variant gets no columns. Choose SpliceAI for a change in splicing, and a model such as Cherimoya for a regulatory effect.
  • Choose ClinVar for what submitters have classified. AlphaMissense is a prediction, not a clinical classification.
  • Choose gnomAD to ask how common a variant is. A pathogenicity score says nothing about frequency.
  • Altar publishes no copy. Build one from DeepMind's release before the first run (Build another release).

Add it to a run

[sources.alphamissense]
type = "alphamissense"
  1. Install the binding: pip install altar-alphamissense.
  2. Build a copy from DeepMind's hg38 file. The builder reads it where DeepMind hosts it, so this needs altar[gcs]:

    pip install "altar[gcs]"
    altar-alphamissense-build --genome-build hg38 --release zenodo-v3 \
      --input gs://dm_alphamissense/AlphaMissense_hg38.tsv.gz \
      --input-storage-option token=anon \
      --output alphamissense-hg38
    
  3. Name the copy as dataset, which is required:

    [sources.alphamissense]
    type = "alphamissense"
    
    [sources.alphamissense.options]
    dataset = "alphamissense-hg38"
    

altar sources alphamissense lists the columns and options. The run spec reference describes the [sources.<name>] section, and Annotate variants with evidence walks through a run.

Outputs

Column Type Meaning
am_pathogenicity float The pathogenicity score of the most pathogenic matching transcript, from 0 to 1; higher is more likely pathogenic.
am_class str That transcript's class: likely_benign, ambiguous or likely_pathogenic.
am_transcript_scores list of struct (uniprot_id, transcript_id, protein_variant, am_pathogenicity, am_class) Every matching transcript, most pathogenic first. Each record holds the UniProt accession, the Ensembl transcript, the protein change such as V2L, and that transcript's score and class.
am_genome_build str The genome build of the copy, hg38 or hg19.
am_source_release str The upstream release the copy was built from, as given to --release.

DeepMind scores a variant once per transcript. The source keeps every transcript in am_transcript_scores and summarizes the most pathogenic one in am_pathogenicity and am_class.

Each record of am_transcript_scores has five fields:

  • uniprot_id: the UniProtKB accession of the protein, from UniProt release 2021_02.
  • transcript_id: the Ensembl transcript, from GENCODE V32 on hg38 or V27 on hg19.
  • protein_variant: the amino-acid change, as reference residue, 1-based residue position and alternate residue, such as V2L.
  • am_pathogenicity and am_class: that transcript's score and class.

DeepMind derives the class from the score: likely_benign below 0.34, likely_pathogenic above 0.564, and ambiguous otherwise.

Transcripts with the same score are ordered by transcript, then UniProt accession, then protein variant, so the order is the same for every store. An empty uniprot_id, transcript_id or protein_variant in DeepMind's file is null. Stores with nested types keep am_transcript_scores as an array of records; SQLite stores it as JSON text.

A variant with no record has no row, so every column is empty in the export. Empty means "not scored", not a score of 0; see Variants a lookup may miss.

An augmented VCF written from a run's export carries the columns as ALTAR1_AM_SCORE, ALTAR1_AM_CLASS and ALTAR1_AM_TRANSCRIPTS, one entry per transcript. The release and build are in the INFO header lines; see Write an augmented VCF.

Configuration

Option Set in Type Default Meaning
dataset [sources.alphamissense.options] path required the copy altar-alphamissense-build wrote, as a path or URI
genome_build [sources.alphamissense.options] text not set the genome build of the data, checked against it when given
storage_options [sources.alphamissense.options] table not set fsspec settings for reading the files, such as credentials
connection [sources.alphamissense] not set connection = "<name>": the [connections.<name>] section to read the data through
  • dataset is required: the copy altar-alphamissense-build wrote, as a path or a URI such as gs://my-bucket/alphamissense-hg38/.
  • genome_build, when given, must be the copy's build: hg38 or hg19.
  • storage_options is not allowed with connection.
  • connection = "<name>", set in [sources.alphamissense] itself, names the [connections.<name>] section to read through; see Pass credentials through connections.

An unknown option stops the run with an error that lists the valid ones.

Inputs

  • Genome builds: hg38 or hg19, one per copy. A run on another build stops before it reads the cohort, and the error names the source.
  • Variant classes: missense variants only, single-nucleotide substitutions in protein-coding transcripts that change an amino acid, as DeepMind scored them.
  • Allele matching: variants are matched on their minimal representation, so chr1:100:CA:CG matches the record for chr1:101:A:G.

Where it comes from

DeepMind publishes the predictions on Zenodo, as the Predictions for AlphaMissense record (version 3), and in the public bucket gs://dm_alphamissense. The builder reads the per-build files, AlphaMissense_hg38.tsv.gz (643 MB) and AlphaMissense_hg19.tsv.gz (622 MB).

Altar publishes no copy of AlphaMissense. Build one, then read it from disk or from your own bucket; see Read your own copy.

Release and identity

The source's identity is the org.kundajelab.altar.annotation.alphamissense contract, version 1.0.0, with the release you gave the builder and the copy's genome build. A run records it in its provenance. Where the copy is read from is not part of it.

The builder records the release, the genome build and the file layout in every Parquet file. The source reads them from the first file in sorted order and refuses to open:

  • a copy whose first file records no release;
  • a copy built for another genome build than a genome_build option names;
  • a copy laid out in CHROM=<chromosome>/ directories. Rebuild it with the command below.

When it looks a variant up, it also refuses a record whose native genome value is not the copy's build.

Build another release

altar-alphamissense-build streams DeepMind's TSV into a Parquet copy. It reads the file where DeepMind hosts it, with no download step:

pip install "altar[gcs]" altar-alphamissense
altar-alphamissense-build --genome-build hg38 --release zenodo-v3 \
  --input gs://dm_alphamissense/AlphaMissense_hg38.tsv.gz \
  --input-storage-option token=anon \
  --output alphamissense-hg38

--genome-build is hg38 or hg19. --release names the upstream release you downloaded, such as the Zenodo version; it becomes am_source_release and the identity's release. A downloaded file works too: --input AlphaMissense_hg38.tsv.gz.

--input and --output take a local path or a URI (gs://, s3://, https://, hf://); a URI needs its provider's extra, such as altar[gcs]. Other options:

  • --overwrite deletes a previous build in --output first.
  • --input-storage-option and --output-storage-option pass non-secret fsspec options, such as token=anon. Credentials come from the provider's ambient ones.
  • --input-attempts sets how often a remote read or upload is retried when its stream fails or ends early.
  • --input - reads standard input; --stdin-name AlphaMissense_hg38.tsv.gz names it.

An --output URI receives each input's files as they finish, so running the same command again resumes a build that stopped.

The builder writes <output>/chr=<chromosome>/<input name>.parquet. Each file holds variant_id, the key columns chr, pos, ref and alt, and DeepMind's genome, uniprot_id, transcript_id, protein_variant, am_pathogenicity and am_class. It refuses:

  • a file whose header does not name DeepMind's ten columns;
  • a record whose genome is not --genome-build, or a file named AlphaMissense_<build>.tsv.gz for another build;
  • input not sorted by position within each chromosome, as DeepMind's file is;
  • a variant scored twice for one transcript, across all inputs;
  • a build that writes no rows.

It skips and counts records whose REF or ALT is not a single A, C, G or T different from the other.

Compute and scale

  • A lookup runs no model and needs no GPU.
  • The builder streams DeepMind's per-build file, 643 MB for hg38 and 622 MB for hg19.
  • A lookup reads your copy from disk or from your own bucket.
  • On BigQuery, load the built Parquet files into a table and read it with BigQueryAllelicRecordBackend (Python and extension).

Prioritization

The source prioritizes a variant by default when am_class is likely_pathogenic or ambiguous. The rule passes DeepMind's classes through. It is predictive evidence, not a clinical classification. What prioritized means explains how rules combine.

Validation

Validation label: Not spot-checked. There is no recorded comparison of a built copy with DeepMind's files. The builder checks the header, the genome build of each record, the sort order and duplicate scores as it reads (Build another release).

Not validated:

  • values in a built copy against DeepMind's TSV, for either genome build;
  • the BigQuery backend on live BigQuery. It is Preview: tested on the BigQuery emulator and DuckDB.

Limits

  • DeepMind scores missense variants only: single-nucleotide substitutions in protein-coding transcripts that change an amino acid. Synonymous, nonsense, splice, non-coding and indel variants get no row.
  • A copy holds one genome build. A run on another build stops before it reads the cohort, and the error names the source.
  • Altar publishes no copy; each user builds one.
  • The scores are DeepMind's predictions. Altar does not run AlphaMissense on variants the files lack.

Cite and licence

Cite the AlphaMissense paper, and name the release you used, such as "AlphaMissense predictions, Zenodo version 3":

@article{cheng2023alphamissense,
  author = {Cheng, Jun and Novati, Guido and Pan, Joshua and Bycroft, Clare and {\v{Z}}emgulyt{\.e}, Akvil{\.e} and
    Applebaum, Taylor and Pritzel, Alexander and Wong, Lai Hong and Zielinski, Michal and Sargeant, Tobias and
    Schneider, Rosalia G. and Senior, Andrew W. and Jumper, John and Hassabis, Demis and Kohli, Pushmeet and
    Avsec, {\v{Z}}iga},
  title = {Accurate proteome-wide missense variant effect prediction with {AlphaMissense}},
  journal = {Science},
  volume = {381},
  number = {6664},
  pages = {eadg7492},
  year = {2023},
  doi = {10.1126/science.adg7492}
}

@misc{cheng2023alphamissensepredictions,
  author = {Cheng, Jun and Novati, Guido and Pan, Joshua and Bycroft, Clare and {\v{Z}}emgulyt{\.e}, Akvil{\.e} and
    Applebaum, Taylor and Pritzel, Alexander and Wong, Lai Hong and Zielinski, Michal and Sargeant, Tobias and
    Schneider, Rosalia G. and Senior, Andrew W. and Jumper, John and Hassabis, Demis and Kohli, Pushmeet and
    Avsec, {\v{Z}}iga},
  title = {Predictions for {AlphaMissense}},
  howpublished = {Zenodo},
  note = {Version 3},
  year = {2023},
  doi = {10.5281/zenodo.10813168}
}
  • Predictions: DeepMind licenses the predictions in the bucket and in the current Zenodo version (version 3) under CC BY 4.0, which allows reuse with attribution. The first Zenodo version, 10.5281/zenodo.8208688, was published under CC BY-NC-SA 4.0; check the licence of the version you download. See the AlphaMissense repository.
  • Binding: altar-alphamissense is MIT-licensed. It ships no predictions.

Python and extension

AlphaMissenseSource.from_options() builds the same source as a run spec, with the same options as keywords. AlphaMissenseSource.from_dataset() builds it over a copy, and takes the release and build from the copy's metadata:

from altar.sources import fetch_annotations
from altar_alphamissense import AlphaMissenseSource

source = AlphaMissenseSource.from_dataset("alphamissense-hg38")
annotations = await fetch_annotations([source], ["chr1:69134:A:G"])
source.close()

To read another store, pass any AllelicRecordBackend and an AlphaMissenseRelease(genome_build=..., source_release=...) to AlphaMissenseSource(backend, release=..., genome_build=...).

A BigQuery table loaded from the built Parquet files is read with BigQueryAllelicRecordBackend and the key columns chr, pos, ref and alt. The chromosome must be spelled chr1. A table that holds both builds must be filtered to one, for example filters={"genome": "hg38"}. staged_annotation_source stages the annotations for a BigQuery store's results and exports; see Run at warehouse scale on BigQuery. The BigQuery backend is Preview: tested on the BigQuery emulator and DuckDB; not run against live BigQuery.