AlphaGenome

Durée de la vidéo : 30 minutes

AlphaGenome est un modèle de fondation de deep learning développé par Google DeepMind qui prédit les effets régulateurs fonctionnels des séquences d'ADN dans le génome humain. En analysant des séquences d'ADN jusqu'à un million de paires de bases (1 Mo) à une résolution d'une seule base, le modèle prédit l'impact des variations génétiques sur les mécanismes moléculaires et biologiques dans 11 modalités génomiques : expression génique (RNA_SEQ, CAGE, PROCAP), accessibilité de la chromatine (ATAC, DNASE), modifications des histones et liaison des facteurs de transcription (CHIP_HISTONE, CHIP_TF), épissage de l'ARN (SPLICE_SITES, SPLICE_SITE_USAGE, SPLICE_JUNCTIONS) et cartes de contact de la chromatine en 3D (CONTACT_MAPS).

Ce document décrit les exigences matérielles et de déploiement pour AlphaGenome, et explique comment déployer et interroger le modèle sur Gemini Enterprise Agent Platform.

Configuration matérielle et exigences de déploiement

En raison de l'architecture profonde d'AlphaGenome et de sa fenêtre de contexte de 1 Mo, le modèle présente des exigences matérielles et de mémoire strictes. Cette section aborde les sujets suivants :

Configurations de VM et de GPU compatibles

AlphaGenome nécessite au moins un nœud. Vous pouvez déployer le modèle sur des points de terminaison Agent Platform à l'aide de types de machines équipés d'accélérateurs NVIDIA A100 ou H100.

Si vous avez besoin d'une capacité supplémentaire pour gérer des volumes de requêtes plus élevés, vous pouvez configurer l'autoscaling sur votre point de terminaison Agent Platform afin d'ajouter automatiquement des nœuds. Pour en savoir plus, consultez Procéder au scaling des nœuds d'inférence à l'aide de l'autoscaling.

Types d'accélérateurs et de machines compatibles

Sélectionnez l'un des types de machines compatibles suivants qui fournissent les 80 Go de mémoire GPU requis :

  • NVIDIA H100 (80 Go) : a3-highgpu-1g, a3-highgpu-2g, a3-highgpu-4g, a3-highgpu-8g
  • NVIDIA A100 (80 Go) : a2-ultragpu-1g, a2-ultragpu-2g, a2-ultragpu-4g, a2-ultragpu-8g
  • NVIDIA H100 Mega (80 Go) : a3-megagpu-8g

Pour obtenir des spécifications détaillées, consultez Configurer les ressources de calcul pour l'inférence.

Exigences en matière de quota

Avant de déployer le modèle, assurez-vous que votre projet Google Cloud dispose d'un quota de diffusion de GPU suffisant dans la région cible pour les métriques suivantes :

  • aiplatform.googleapis.com/custom_model_serving_nvidia_h100_gpus
  • aiplatform.googleapis.com/custom_model_serving_nvidia_a100_gpus
  • aiplatform.googleapis.com/custom_model_serving_nvidia_h100_mega_gpus
  • compute.googleapis.com/gpus_per_gpu_family

Déployer AlphaGenome

AlphaGenome est disponible en tant que modèle à déploiement automatique depuis Model Garden. Pour obtenir des instructions détaillées sur le provisionnement de l'infrastructure de point de terminaison et le déploiement du modèle sur un projet Google Cloud , consultez Déployer des modèles ouverts à partir de Model Garden.

Model Garden fournit les versions de diffusion suivantes pour AlphaGenome :

  • alphagenome-004 (par défaut, gRPC et HTTP unifiés) : diffuse les sept méthodes DnaModelService (predict_sequence, predict_interval, predict_variant, score_variant, score_interval, score_ism_variants et output_metadata) à partir d'un conteneur unifié compatible avec le streaming gRPC HTTP/2 sur le port 8081 et le streaming HTTP (streamRawPredict) sur le port 8080 :
    • Public (point de terminaison partagé) (gRPC) : sélectionnez Public (point de terminaison partagé) sous Accès au point de terminaison lors du déploiement dans Model Garden pour interroger le modèle via le streaming gRPC (PredictionService.StreamDirectRawPredict à l'aide de dna_client_grpc.create_vertex_client). L'appel du modèle via gRPC transmet directement des fragments de tenseurs binaires compressés sans surcharge de sérialisation JSON ou base64, ce qui réduit la latence sur les prédictions de pistes de 1 Mo et évite les délais d'expiration de la passerelle HTTP sur les charges de travail multivariantes à forte simultanéité, telles que la mutagenèse par saturation in silico (score_ism_variants).
    • Public (point de terminaison dédié) (HTTP) : conservez l'option par défaut Public (point de terminaison dédié) lors du déploiement dans Model Garden pour interroger le modèle via le streaming HTTP (streamRawPredict à l'aide de dna_client_http.create_http_client), qui diffuse des charges utiles protobuf binaires fragmentées (proto_b64) sans la limite de taille de réponse HTTP de 10 Mo des points de terminaison partagés.
    • Sélection de pli : les clients gRPC et clients HTTP sur alphagenome-004 sont compatibles avec la sélection de pli de modèle (ALL_FOLDS par défaut, ou plis individuels FOLD_0 à FOLD_3) à l'aide du paramètre model_version.
  • alphagenome-003 (ancien HTTP) : diffuse les prédictions via le streaming HTTP/1.1 (streamRawPredict) sur le port 8080 et reste disponible pour assurer la rétrocompatibilité avec les déploiements de clients HTTP existants.

Utiliser AlphaGenome

Vous pouvez interagir avec un point de terminaison AlphaGenome déployé de manière programmatique à l'aide du SDK Python (via gRPC sur des points de terminaison partagés ou HTTP sur des points de terminaison dédiés).

Pour obtenir la documentation de référence complète de l'API, les définitions des paramètres et les schémas détaillés, consultez la documentation officielle d'AlphaGenome.

Prérequis et authentification

Agent Platform utilise Identity and Access Management (IAM) pour gérer l'accès aux points de terminaison déployés. Assurez-vous que votre environnement d'exécution (par exemple, un terminal local, une VM ou Colaboratory) est authentifié avec un compte de service ou des identifiants utilisateur disposant du rôle IAM "Utilisateur Agent Platform" (roles/aiplatform.user).

Utilisation (alphagenome-004)

Les exemples suivants montrent comment interroger un point de terminaison alphagenome-004 déployé à l'aide du SDK Python :

Python

Installer le SDK

Le fichier wheel du Cloud SDK AlphaGenome (alphagenome-004) est disponible dans le dépôt GitHub GoogleCloudPlatform. Téléchargez et installez le fichier wheel en exécutant les commandes suivantes :

# Download the wheel file
wget -q https://github.com/GoogleCloudPlatform/vertex-ai-samples/raw/main/notebooks/community/alphagenome/whl/alphagenome_cloud_sdk-0.4.2.12-py3-none-any.whl

# Install the wheel file
pip install alphagenome_cloud_sdk-0.4.2.12-py3-none-any.whl

Initialiser le client

Avant d'interroger le modèle, initialisez le client pour votre point de terminaison alphagenome-004 déployé. Le client gRPC (GrpcDnaClient) et le client HTTP (HttpDnaClient) implémentent l'interface alphagenome.models.dna_model.DnaModel standard.

Pour vous connecter à un point de terminaison partagé (standard) alphagenome-004 via le streaming gRPC, transmettez le nom de ressource de votre point de terminaison Agent Platform à dna_client_grpc.create_vertex_client :

from alphagenome.models import dna_client
from alphagenome_cloud_sdk.models import dna_client_grpc

# Specify the standard (shared) endpoint resource name:
endpoint = "projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID"

# Optional: Specify `service_account` for service account impersonation, or
# `model_version` to select a specific fold ("ALL_FOLDS", "FOLD_0", "FOLD_1",
# "FOLD_2", or "FOLD_3").
dna_model = dna_client_grpc.create_vertex_client(
    endpoint=endpoint,
    # service_account="SERVICE_ACCOUNT_EMAIL",
    # model_version=dna_client.ModelVersion.ALL_FOLDS,
)

Si vous avez déployé alphagenome-004 sur un point de terminaison dédié, utilisez dna_client_http.create_http_client :

from alphagenome.models import dna_client
from alphagenome_cloud_sdk.models import dna_client_http

# Create the HTTP client pointing to the dedicated endpoint streamRawPredict URL.
dna_model = dna_client_http.create_http_client(
    vertex_ai_url="https://ENDPOINT_DNS/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:streamRawPredict",
    # service_account="SERVICE_ACCOUNT_EMAIL",
    # model_version=dna_client.ModelVersion.ALL_FOLDS,
)

Prédire des pistes pour une séquence d'ADN

Utilisez predict_sequence pour prédire les modalités génomiques d'une chaîne d'ADN brute :

# Pad a synthetic sequence to 1 MB using 'N' for unknown/padding bases
padded_sequence = 'GATTACA'.center(dna_client.SEQUENCE_LENGTH_1MB, 'N')

output = dna_model.predict_sequence(
    sequence=padded_sequence,
    requested_outputs=[
        dna_client.OutputType.CAGE,   # Transcription Start Sites
        dna_client.OutputType.DNASE,  # Chromatin Accessibility
    ],
    ontology_terms=[
        'UBERON:0002048',             # Lung tissue ontology term
    ],
)

# Access prediction values (shape: sequence_length, num_tracks)
dnase_signals = output.dnase.values
dnase_metadata = output.dnase.metadata

Prédire des pistes pour un intervalle de génome de référence

Utilisez predict_interval pour prédire les modalités directement à partir d'une région chromosomique spécifique du génome de référence :

from alphagenome.data.genome import Interval

# Define a genomic interval and resize it to the 1 MB context window
interval = Interval(
    chromosome='chr19',
    start=40991281,
    end=41018398,
    strand='.',
    name='CYP2B6',
).resize(dna_client.SEQUENCE_LENGTH_1MB)

output = dna_model.predict_interval(
    interval=interval,
    requested_outputs=[dna_client.OutputType.RNA_SEQ],
    ontology_terms=['UBERON:0001114'],  # Right liver lobe
)

Prédire les effets des variants sur les pistes génomiques

Utilisez predict_variant pour générer des prédictions de pistes de référence (reference) et de mutation (alternate) associées sur un intervalle :

from alphagenome.data import genome

interval = genome.Interval(
    chromosome='chr19',
    start=41003816,
    end=41005864,
    strand='.',
).resize(dna_client.SEQUENCE_LENGTH_1MB)

variant = genome.Variant(
    chromosome='chr19',
    position=41004840,
    reference_bases='C',
    alternate_bases='T',
)

variant_output = dna_model.predict_variant(
    interval=interval,
    variant=variant,
    requested_outputs=[dna_client.OutputType.RNA_SEQ],
    ontology_terms=['UBERON:0001114'],
)

ref_rna_values = variant_output.reference.rna_seq.values
alt_rna_values = variant_output.alternate.rna_seq.values

Évaluer l'effet d'un variant

Utilisez score_variant pour résumer l'effet prédit d'une variante génétique en comparant une séquence de référence (REF) à une séquence mutée alternative (ALT) :

from alphagenome.data import genome
from alphagenome.models import variant_scorers

# Define the genetic variant
variant = genome.Variant(
    chromosome='chr22',
    position=36201698,
    reference_bases='A',
    alternate_bases='C',
)

# Select the recommended variant scoring method for RNA-Seq
variant_scorer = variant_scorers.RECOMMENDED_VARIANT_SCORERS['RNA_SEQ']

# Execute the scoring
variant_scores = dna_model.score_variant(
    interval=variant.reference_interval.resize(dna_client.SEQUENCE_LENGTH_1MB),
    variant=variant,
    variant_scorers=[variant_scorer],
)

# Output is returned as a list of AnnData objects containing raw and quantile scores
print("Scores shape:", variant_scores[0].X.shape)

Évaluer un intervalle génomique

Utilisez score_interval pour calculer les scores d'intervalle de masquage de gènes dans une région génomique :

from alphagenome.data import genome
from alphagenome.models import interval_scorers

interval = genome.Interval(
    chromosome='chr19',
    start=40991281,
    end=41018398,
    strand='.',
).resize(dna_client.SEQUENCE_LENGTH_1MB)

interval_scorer = interval_scorers.RECOMMENDED_INTERVAL_SCORERS['RNA_SEQ']

interval_scores = dna_model.score_interval(
    interval=interval,
    interval_scorers=[interval_scorer],
)

print("Interval scores shape:", interval_scores[0].X.shape)

Exécuter une mutagenèse par saturation in silico

Utilisez score_ism_variants pour évaluer toutes les variantes de nucléotides uniques possibles sur une cible ism_interval :

from alphagenome.data import genome
from alphagenome.models import variant_scorers

# Define the 1 MB sequence context interval and a target 50 bp ISM window
sequence_interval = genome.Interval(
    chromosome='chr19',
    start=41003816,
    end=41005864,
).resize(dna_client.SEQUENCE_LENGTH_1MB)

ism_interval = genome.Interval(
    chromosome='chr19',
    start=41004815,
    end=41004865,
)

dnase_scorer = variant_scorers.RECOMMENDED_VARIANT_SCORERS['DNASE']

ism_scores = dna_model.score_ism_variants(
    interval=sequence_interval,
    ism_interval=ism_interval,
    variant_scorers=[dnase_scorer],
)

print("Number of variants scored:", len(ism_scores))

Utilisation (alphagenome-003)

Python

Installer le SDK

Le fichier Wheel du SDK Cloud AlphaGenome est disponible dans le dépôt GitHub GoogleCloudPlatform. Vous pouvez télécharger le fichier Wheel en exécutant la commande suivante :

# Download the whl file using - 
wget -q https://github.com/GoogleCloudPlatform/vertex-ai-samples/raw/main/notebooks/community/alphagenome/whl/alphagenome_cloud_sdk-0.4.2.11-py3-none-any.whl

# Install the whl file
pip install alphagenome_cloud_sdk-0.4.2.11-py3-none-any.whl

Initialiser le client

Avant de pouvoir utiliser le modèle, vous devez initialiser le client :

from alphagenome.models import dna_client
from alphagenome_cloud_sdk.models import dna_client_http

# Create the HTTP client pointing to the Agent Platform endpoint.
# The `service_account` parameter is optional and only required if you are 
# choosing to authenticate via service account impersonation.
dna_model = dna_client_http.create_http_client(
    vertex_ai_url=vertex_ai_url,
    # service_account=service_account  # Uncomment to use service account impersonation
)

Prédire des pistes pour une séquence d'ADN

Utilisez predict_sequence pour prédire les modalités génomiques d'une chaîne d'ADN brute :

# Pad a synthetic sequence to 1 MB using 'N' for unknown/padding bases
padded_sequence = 'GATTACA'.center(dna_client.SEQUENCE_LENGTH_1MB, 'N')

output = dna_model.predict_sequence(
    sequence=padded_sequence,
    requested_outputs=[
        dna_client.OutputType.CAGE,   # Transcription Start Sites
        dna_client.OutputType.DNASE,  # Chromatin Accessibility
    ],
    ontology_terms=[
        'UBERON:0002048',             # Lung tissue ontology term
    ]
)

# Access prediction values (shape: sequence_length, num_tracks)
dnase_signals = output.dnase.values
dnase_metadata = output.dnase.metadata

Prédire des pistes pour un intervalle de génome de référence

Utilisez predict_interval pour prédire les modalités directement à partir d'une région chromosomique spécifique du génome de référence :

from alphagenome.data.genome import Interval

# Define a genomic interval and resize it to the 1Mb context window
interval = Interval(
    chromosome='chr19',
    start=40991281,
    end=41018398,
    strand='.',
    name='CYP2B6'
).resize(dna_client.SEQUENCE_LENGTH_1MB)

output = dna_model.predict_interval(
    interval=interval,
    requested_outputs=[dna_client.OutputType.RNA_SEQ],
    ontology_terms=['UBERON:0001114']  # Right liver lobe
)

Évaluer l'effet d'un variant (mutagenèse in silico)

Utilisez score_variant pour comparer l'expression prédite d'une séquence de référence (REF) à une séquence mutée alternative (ALT) :

from alphagenome.data import genome
from alphagenome.models import variant_scorers

# Define the genetic variant
variant = genome.Variant(
    chromosome='chr22',
    position=36201698,
    reference_bases='A',
    alternate_bases='C',
)

# Select the variant scoring method for RNA-Seq
variant_scorer = variant_scorers.RECOMMENDED_VARIANT_SCORERS['RNA_SEQ']

# Execute the scoring
variant_scores = dna_model.score_variant(
    interval=variant.reference_interval.resize(dna_client.SEQUENCE_LENGTH_1MB),
    variant=variant,
    variant_scorers=[variant_scorer],
    fix_negative_strand=True
)

# Output is returned as an AnnData object containing raw and quantile scores
print("Scores shape:", variant_scores[0].X.shape)

Tarifs

AlphaGenome nécessite un abonnement payant. Pour en savoir plus sur les tarifs d'AlphaGenome, contactez un Google Cloud spécialiste des ventes ou contactez votre équipe chargée du compte Google Cloud.

Vous êtes responsable du coût de l'infrastructure utilisée pour héberger le modèle, y compris le point de terminaison Agent Platform et les instances de GPU sur lesquelles le modèle est déployé. Pour en savoir plus, consultez Tarifs d'Agent Platform.

Limites

AlphaGenome présente les limites suivantes :

  • Utilisation à des fins de recherche uniquement : AlphaGenome est un outil de recherche. Il n'est pas destiné à un usage de diagnostic clinique et n'a pas été approuvé pour cet usage.
  • Horizon de contexte de 1 Mo : une seule requête de prédiction ne peut pas capturer les interactions génomiques qui se produisent sur des distances supérieures à 1 Mo.
  • Pas de prise en charge de l'affinage : AlphaGenome n'est pas compatible avec l'affinage sur des ensembles de données d'entraînement privés. Le modèle n'est disponible que pour l'inférence.

Annuaire de références scientifiques

Pour aider les communautés scientifiques et de développeurs, le tableau suivant liste les principaux documents de référence, publications et ressources pour AlphaGenome :

Type de ressource Titre et lien Description
article révisé par un comité de rédaction Advancing regulatory variant effect prediction with AlphaGenome, Nature (janvier 2026) La principale publication scientifique détaillant l'architecture, les évaluations et les benchmarks de performances du modèle.
Article prépublié AlphaGenome: advancing regulatory variant effect prediction with a unified DNA sequence model, bioRxiv (juillet 2025) Le manuscrit initial avant l'examen par les pairs.
Annonce AlphaGenome: AI for better understanding the genome, blog Google DeepMind (juin 2025) Article de blog de haut niveau décrivant l'impact du modèle sur la génomique.
Documentation de l'API Documentation AlphaGenome Documentation technique pour le SDK Python et les schémas de l'API HTTP.
Vidéo de visite AlphaGenome : l'IA pour mieux comprendre le génome Tutoriel vidéo décrivant les fonctionnalités du modèle et les flux d'interaction de base. (Durée de la vidéo : 30 minutes)
Notebook de démarrage rapide Notebook Colab de démarrage rapide d'AlphaGenome Notebook fournissant des exemples exécutables d'initialisation du SDK et de calcul du score de l'effet des variants.

Assistance et commentaires

Vous pouvez obtenir de l'aide pour AlphaGenome de différentes manières :

  • Assistance pour la science génomique et les sorties de modèle : pour discuter de biologie, de prédictions de modèles ou d'interprétabilité, ou pour échanger avec Google DeepMind, rejoignez le forum public de la communauté AlphaGenome à l'adresse alphagenomecommunity.com.
  • Assistance pour l'infrastructure et la plate-forme : pour toute question concernant les quotas Google Cloud, les accélérateurs, les problèmes de bibliothèque cliente ou la facturation, contactez l'équipe chargée de votre compteGoogle Cloud ou ouvrez une demande auprès de Cloud Customer Care.