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
- Types d'accélérateurs et de machines compatibles
- Exigences de quota
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_gpusaiplatform.googleapis.com/custom_model_serving_nvidia_a100_gpusaiplatform.googleapis.com/custom_model_serving_nvidia_h100_mega_gpuscompute.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éthodesDnaModelService(predict_sequence,predict_interval,predict_variant,score_variant,score_interval,score_ism_variantsetoutput_metadata) à partir d'un conteneur unifié compatible avec le streaming gRPC HTTP/2 sur le port8081et le streaming HTTP (streamRawPredict) sur le port8080:- 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 dedna_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 dedna_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-004sont compatibles avec la sélection de pli de modèle (ALL_FOLDSpar défaut, ou plis individuelsFOLD_0àFOLD_3) à l'aide du paramètremodel_version.
- 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 (
alphagenome-003(ancien HTTP) : diffuse les prédictions via le streaming HTTP/1.1 (streamRawPredict) sur le port8080et 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.