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¶
- Install the binding:
pip install altar-alphamissense. -
Build a copy from DeepMind's hg38 file. The builder reads it where DeepMind hosts it, so this needs
altar[gcs]: -
Name the copy as
dataset, which is required:
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 asV2L.am_pathogenicityandam_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 |
datasetis required: the copyaltar-alphamissense-buildwrote, as a path or a URI such asgs://my-bucket/alphamissense-hg38/.genome_build, when given, must be the copy's build:hg38orhg19.storage_optionsis not allowed withconnection.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:CGmatches the record forchr1: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_buildoption 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:
--overwritedeletes a previous build in--outputfirst.--input-storage-optionand--output-storage-optionpass non-secret fsspec options, such astoken=anon. Credentials come from the provider's ambient ones.--input-attemptssets 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.gznames 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
genomeis not--genome-build, or a file namedAlphaMissense_<build>.tsv.gzfor 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-alphamissenseis 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.