# alphagenome_research, DeepMind's research code for AlphaGenome

> AlphaGenome is a unified DNA sequence model for regulatory variant-effect prediction, and this repository holds the JAX implementation, the variant scorers, a TFRecords dataset loader and the Colab notebooks. It exists for people who need the model locally, while DeepMind recommends the hosted API for everyone else.

**google-deepmind/alphagenome_research** — Research code accompanying AlphaGenome 

- Repository: https://github.com/google-deepmind/alphagenome_research
- Stars: 918 · Forks: 162
- Language: Python
- License: Apache-2.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/google-deepmind-alphagenome-research

## What AlphaGenome predicts, and what the repository is for

AlphaGenome is a unified DNA sequence model designed to advance regulatory variant-effect prediction and to shed light on genome function. It analyzes DNA sequences of up to 1 million base pairs and delivers predictions at single base-pair resolution across diverse modalities, and the README names them: gene expression, splicing patterns, chromatin features and contact maps.

The repository is described as research code accompanying AlphaGenome, and it contains four things. An implementation of the AlphaGenome model written in JAX. An implementation of the AlphaGenome API with accompanying variant scorers. A dataset loader for reading AlphaGenome training data from TFRecords. And Colab notebooks for running the model and for analysing evaluations.

That last item is the one to look at first, because the two notebooks, a quick start notebook and a variant evaluation examples notebook, are how most people will actually meet this code. They are hosted on Colab, which means the model can be exercised without a local GPU at all.

The model itself is a Nature paper rather than a repository artefact. The citation the README asks you to use is Advancing regulatory variant effect prediction with AlphaGenome, published in Nature, volume 649, number 8099, pages 1206 to 1218, in 2026, with the DOI 10.1038/s41586-025-10014-0. The package metadata is Apache-2.0, the licence file is at the root, and the version series has moved from v0.1.0 in February 2026 to v0.3.0 in July 2026.

## DeepMind points you at the API first

The README says it strongly recommends using the AlphaGenome API to interact with the model without needing specialized hardware, and the documentation site and the community site are linked at the top alongside the model terms.

That recommendation is worth taking at face value, because the alternative carries a hardware requirement that is not casual. To run the model, the README recommends running with at least an NVIDIA H100 GPU, and asks that CUDA, cuDNN and JAX are correctly installed, pointing at the JAX installation documentation for the NVIDIA GPU path. For training, it recommends running on Tensor Processing Units v3 or higher.

So the decision is between two very different costs. The hosted API costs a network round trip and an account, and gives you predictions. The research code costs an H100 and a working JAX installation, and gives you the model itself, the variant scorers and the training data loader.

The research code is worth the hardware when you need the model inside your own pipeline, when you need to score many variants, when you need the raw outputs rather than the API's response, or when you are doing anything with the training data. The README's dataset loader for reading AlphaGenome training data from TFRecords exists for that last case, and nothing in the API replaces it.

## Installing the package in editable mode

Installation is a clone and a pip install, and the README recommends working inside a Python virtual environment to prevent conflicts with the system's Python environment.

```bash
$ git clone https://github.com/google-deepmind/alphagenome_research.git
$ pip install -e ./alphagenome_research
```

The editable install installs the required dependencies and the repository itself in development mode.

The dependency list in pyproject.toml tells you what you are signing up for. The project name is alphagenome_research, the build backend is hatchling, and Python 3.11 or newer is required, with classifiers for 3.11, 3.12 and 3.13 and a Development Status of 4 - Beta. Alongside the model packages there is alphagenome>=0.7.0, JAX, dm-haiku, chex, jaxtyping, optax, orbax-checkpoint, einhape and etils, and the data stack of tensorflow, pyarrow, pyBigWig, pyfaidx and pyranges. There is a comment in the dependency list explaining one pin: pandas<3, because Pandas 3.0 seems to break compatibility with pyranges.

The package version is dynamic, read from src/alphagenome_research/__init__.py, and the build uses a custom hatch build hook, hatch_build.py, which the comment says calls to generate Python bindings for protos. There is also a conftest.py at the root and a docs/ directory, and a CHANGELOG.md and CONTRIBUTING.md.

## Weights come from Kaggle or Hugging Face, under non-commercial terms

The pre-trained model weights are downloaded from either Kaggle or Hugging Face, and both routes require accepting the non-commercial model terms, with requests processed immediately.

That last clause is the one to read carefully. The repository itself is Apache-2.0, and the code is free to use in the sense of that licence. The weights are a separate grant with a different restriction, and they are the part you need in order to do anything useful with the model. A commercial use that is fine with the code licence is not automatically fine with the weights.

The two hosting options are otherwise equivalent in what they give you, and the README offers both so you are not tied to one platform's tooling. Which one to pick comes down to how you already work: kagglehub and huggingface_hub are both in the dependency list, and the factory functions in the quick start mirror the choice.

The repository is not the only route to the model, and it is worth being explicit about that: the hosted API needs no weights download at all. Downloading multi-gigabyte checkpoints onto a workstation is a cost you take on only when the local path buys you something.

## The DNA Model class wraps predictions, scoring and mutagenesis

The documented entry point is the DNA Model class, which the README says wraps the core model and provides a more intuitive set of functions for creating predictions, scoring variants, performing in silico mutagenesis and more.

Two factory functions create an instance from the pre-trained weights:

```python
from alphagenome_research.model import dna_model

# To download from Kaggle:
model = dna_model.create_from_kaggle('all_folds')

# or Hugging Face:
model = dna_model.create_from_huggingface('all_folds')
```

The 'all_folds' argument selects the ensemble of model folds rather than a single one, which is the configuration the examples use.

The prediction call takes a genome interval, a variant, a set of ontology terms and a list of requested output types:

```python
outputs = model.predict_variant(
    interval=interval,
    variant=variant,
    ontology_terms=['UBERON:0001157'],
    requested_outputs=[dna_model.OutputType.RNA_SEQ],
)
```

The interval and variant come from the alphagenome.data genome module, with a chromosome, start and end for the interval and a position with reference and alternate bases for the variant. The ontology terms are expressed in UBERON identifiers, and the requested output is an OutputType enumerator, here RNA_SEQ.

The output is then visualised with the alphagenome.visualization package, where plot_components.plot takes overlaid tracks for the reference and alternate outputs, an interval to resize to, and annotations that place a vertical line at the variant position. The example uses the alpha channel on the VariantAnnotation to fade it. The plotting code is what makes the output legible as a comparison between what the reference allele predicts and what the alternate allele predicts, which is the actual question a variant effect prediction is asked.

## JAX, TFRecords and the Google research stack

The implementation is in JAX, and the acknowledgement section lists the libraries the model release uses: Abseil, anndata, Chex, Einshape, Etils, Haiku, huggingface_hub, JAX, jaxtyping, kagglehub, NumPy and Optax, among others.

Those names tell you the shape of the codebase. Haiku is the neural network library, Chex is the testing library, jaxtyping adds shape and dtype annotations to JAX code, and Optax is the optimiser and gradient library. TensorFlow is in the dependency list alongside pyarrow, and that combination is there for the TFRecords side of the project: the dataset loader for reading AlphaGenome training data from TFRecords.

That loader is the part with no equivalent elsewhere. A prediction API can give you outputs for a variant you name; it cannot hand you the training corpus in the form the model was trained on. If your work involves training, fine-tuning, or evaluating the model against data you hold yourself, that loader and the TFRecords path are the reason to install this repository rather than calling the API.

The JAX installation for an NVIDIA GPU is the practical gate, and the README points at the JAX documentation for the details of CUDA and cuDNN setup.

## When the research code is the wrong door

Three situations point you away from this repository.

The first is a handful of variants. If you need a prediction for a few loci, the hosted API does it without an H100, without a JAX installation and without downloading checkpoints. Setting up the research code for that is a day of work and a GPU rental to get one answer.

The second is a team without hardware discipline. The requirement is an H100 at minimum, with CUDA, cuDNN and JAX configured, and training wants TPUs v3 or above. The codebase is a research codebase, published as research code accompanying a model, with a Beta development status and a short release series so far. A team that needs a service with a support commitment should not be running it on that basis.

The third is commercial use of the weights. The weights require accepting non-commercial model terms, whatever the code licence allows. That is a separate decision from the engineering one, and it is the one to settle before downloading anything.

There is a positive case as well, and it is a good one. For anyone doing research on variant effects at scale, needing per-base-pair resolution across several modalities, or working with the training data directly, this repository is the only route to that, and the variant scorers and the Colab notebooks mean you can start from a notebook and work down into the model when you need to.

## Conclusion

alphagenome_research suits a research group that needs the AlphaGenome model in its own pipeline, needs to score variants at scale, or needs the training data loader to work with AlphaGenome TFRecords directly. It does not suit anyone who only wants a prediction for a handful of variants, since the hosted API covers that without a GPU. Before you set it up, confirm you can meet the hardware requirement of at least an NVIDIA H100 with CUDA, cuDNN and JAX, and read the model terms, because the weights on Kaggle and Hugging Face require accepting non-commercial terms.

## FAQ

### What is in the alphagenome_research repository?

It holds research code accompanying AlphaGenome: an implementation of the model in JAX, an implementation of the AlphaGenome API with variant scorers, a dataset loader for reading AlphaGenome training data from TFRecords, and Colab notebooks for running the model and analysing evaluations.

### What hardware do I need to run AlphaGenome locally?

The README recommends at least an NVIDIA H100 GPU to run the model, with CUDA, cuDNN and JAX correctly installed. For training, it recommends Tensor Processing Units v3 or higher. DeepMind strongly recommends using the hosted AlphaGenome API instead if you do not need specialized hardware.

### How do I install the AlphaGenome research code?

Clone the repository and run pip install -e ./alphagenome_research, ideally inside a Python virtual environment to avoid conflicts with the system Python. Python 3.11 or newer is required, and the build uses hatchling with a custom hook that generates Python bindings for the protos.

### Where do I get the AlphaGenome model weights and can I use them commercially?

The pre-trained weights are downloaded from Kaggle or Hugging Face, and both require accepting the non-commercial model terms. The repository code itself is licensed Apache-2.0, so the code and the weights carry different terms.

### How do I make a variant prediction with the DNA Model class?

Create the model with dna_model.create_from_kaggle('all_folds') or create_from_huggingface('all_folds'), then call model.predict_variant with a genome interval, a genome variant, ontology terms such as UBERON identifiers and requested outputs such as dna_model.OutputType.RNA_SEQ. The results can be plotted with the alphagenome.visualization plot_components helpers.

## Sources

- [google-deepmind/alphagenome_research on GitHub](https://github.com/google-deepmind/alphagenome_research)
- [Issues](https://github.com/google-deepmind/alphagenome_research/issues)
- [License: Apache-2.0](https://github.com/google-deepmind/alphagenome_research/blob/main/LICENSE)
- [README](https://github.com/google-deepmind/alphagenome_research/blob/main/README.md)
- [Releases](https://github.com/google-deepmind/alphagenome_research/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/google-deepmind-alphagenome-research