AlphaGenome

Videolaufzeit: 30 Minuten

AlphaGenome ist ein von Google DeepMind entwickeltes Deep-Learning-Foundation-Model, das die funktionellen regulatorischen Auswirkungen von DNA-Sequenzen im menschlichen Genom vorhersagt. Durch die Analyse von DNA-Sequenzen mit bis zu 1 Million Basenpaaren (1 MB) bei einer Auflösung von einer Base prognostiziert das Modell, wie sich genetische Variationen auf molekulare und biologische Mechanismen in 11 genomischen Modalitäten auswirken: Genexpression (RNA_SEQ, CAGE, PROCAP), Chromatinzugänglichkeit (ATAC, DNASE), Histonmodifikationen und Transkriptionsfaktorbindung (CHIP_HISTONE, CHIP_TF), RNA-Spleißen (SPLICE_SITES, SPLICE_SITE_USAGE, SPLICE_JUNCTIONS) und 3D-Chromatinkontaktkarten (CONTACT_MAPS).

In diesem Dokument werden die Hardware- und Bereitstellungsanforderungen für AlphaGenome beschrieben und es wird gezeigt, wie das Modell auf der Gemini Enterprise Agent Platform bereitgestellt und abgefragt wird.

Hardware- und Bereitstellungsanforderungen

Aufgrund der komplexen Architektur und des 1‑MB-Kontextfensters von AlphaGenome gelten für das Modell strenge Hardware- und Speicheranforderungen. In diesem Abschnitt werden die folgenden Themen behandelt:

Unterstützte VM- und GPU-Konfigurationen

AlphaGenome erfordert mindestens einen Knoten. Sie können das Modell auf Agent Platform-Endpunkten bereitstellen, indem Sie Maschinentypen mit NVIDIA A100- oder H100-Beschleunigern verwenden.

Wenn Sie zusätzliche Kapazität benötigen, um ein erhöhtes Anfragevolumen zu bewältigen, können Sie das Autoscaling auf Ihrem Agent Platform-Endpunkt konfigurieren, um automatisch Knoten hinzuzufügen. Weitere Informationen finden Sie unter Inferenzknoten mithilfe von Autoscaling skalieren.

Unterstützte Beschleuniger- und Maschinentypen

Wählen Sie einen der folgenden unterstützten Maschinentypen aus, die die erforderlichen 80 GB GPU-Speicher bieten:

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

Detaillierte Spezifikationen finden Sie unter Rechenressourcen für die Inferenz konfigurieren.

Kontingentanforderungen

Prüfen Sie vor dem Bereitstellen des Modells, ob Ihr Google Cloud -Projekt in der Zielregion ein ausreichendes GPU-Bereitstellungskontingent für die folgenden Messwerte hat:

  • 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

AlphaGenome bereitstellen

AlphaGenome ist als selbst bereitgestelltes Modell in Model Garden verfügbar. Eine ausführliche Anleitung zum Bereitstellen der Endpunktinfrastruktur und zum Bereitstellen des Modells in einem Google Cloud -Projekt finden Sie unter Offene Modelle aus Model Garden bereitstellen.

Model Garden bietet die folgenden Bereitstellungsversionen für AlphaGenome:

  • alphagenome-004 (Standard, einheitliches gRPC und HTTP): Stellt alle sieben DnaModelService-Methoden (predict_sequence, predict_interval, predict_variant, score_variant, score_interval, score_ism_variants und output_metadata) aus einem einheitlichen Container bereit, der sowohl HTTP/2-gRPC-Streaming auf Port 8081 als auch HTTP-Streaming (streamRawPredict) auf Port 8080 unterstützt:
    • Öffentlich (freigegebener Endpunkt) (gRPC): Wählen Sie bei der Bereitstellung in Model Garden unter Endpunktzugriff die Option Öffentlich (freigegebener Endpunkt) aus, um das Modell über gRPC-Streaming (PredictionService.StreamDirectRawPredict mit dna_client_grpc.create_vertex_client) abzufragen. Beim Aufrufen des Modells über gRPC werden komprimierte binäre Tensorblöcke direkt ohne JSON- oder Base64-Serialisierungsaufwand übertragen. Das reduziert die Latenz bei 1-MB-Track-Vorhersagen und vermeidet HTTP-Gateway-Zeitüberschreitungen bei hochgradig gleichzeitigen multivarianten Arbeitslasten wie der In-silico-Sättigungsmutagenese (score_ism_variants).
    • Öffentlich (dedizierter Endpunkt) (HTTP): Behalten Sie die Standardoption Öffentlich (dedizierter Endpunkt) bei, wenn Sie das Modell in Model Garden bereitstellen, um es über HTTP-Streaming (streamRawPredict mit dna_client_http.create_http_client) abzufragen. Dabei werden fragmentierte binäre Protobuf-Nutzlasten (proto_b64) ohne die 10-MB-HTTP-Antwortgrößenbeschränkung von freigegebenen Endpunkten gestreamt.
    • Fold-Auswahl: Sowohl gRPC- als auch HTTP-Clients auf alphagenome-004 unterstützen die Fold-Auswahl des Modells (standardmäßig ALL_FOLDS oder einzelne Folds FOLD_0 bis FOLD_3) mit dem Parameter model_version.
  • alphagenome-003 (Legacy-HTTP): Stellt Vorhersagen über HTTP/1.1-Streaming (streamRawPredict) auf Port 8080 bereit und bleibt für die Abwärtskompatibilität mit vorhandenen HTTP-Client-Bereitstellungen verfügbar.

AlphaGenome verwenden

Sie können programmatisch mit einem bereitgestellten AlphaGenome-Endpunkt interagieren, indem Sie das Python SDK verwenden (über gRPC auf freigegebenen Endpunkten oder HTTP auf dedizierten Endpunkten).

Die vollständige API-Referenz, Parameterdefinitionen und detaillierte Schemas finden Sie in der offiziellen AlphaGenome-Dokumentation.

Voraussetzungen und Authentifizierung

Die Agent Platform verwendet Identity and Access Management (IAM) zur Verwaltung des Zugriffs auf bereitgestellte Endpunkte. Achten Sie darauf, dass Ihre Ausführungsumgebung (z. B. ein lokales Terminal, eine VM oder Colaboratory) mit einem Dienstkonto oder Nutzeranmeldedaten authentifiziert ist, die die IAM-Rolle „Agent Platform User“ (roles/aiplatform.user) haben.

Nutzung (alphagenome-004)

Die folgenden Beispiele zeigen, wie Sie einen bereitgestellten alphagenome-004-Endpunkt mit dem Python SDK abfragen:

Python

SDK installieren

Die Wheel-Datei für das AlphaGenome Cloud SDK (alphagenome-004) ist im GoogleCloudPlatform-GitHub-Repository verfügbar. Laden Sie die Wheel-Datei herunter und installieren Sie sie mit den folgenden Befehlen:

# 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

Client initialisieren

Bevor Sie das Modell abfragen, initialisieren Sie den Client für den bereitgestellten alphagenome-004-Endpunkt. Sowohl der gRPC-Client (GrpcDnaClient) als auch der HTTP-Client (HttpDnaClient) implementieren die Standard-alphagenome.models.dna_model.DnaModel-Schnittstelle.

Wenn Sie über gRPC-Streaming eine Verbindung zu einem freigegebenen (Standard-)Endpunkt von alphagenome-004 herstellen möchten, übergeben Sie den Ressourcennamen Ihres Agent Platform-Endpunkts an 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,
)

Wenn Sie alphagenome-004 auf einem dedizierten Endpunkt bereitgestellt haben, verwenden Sie 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,
)

Tracks für eine DNA-Sequenz vorhersagen

Verwenden Sie predict_sequence, um genomische Modalitäten für einen Roh-DNA-String vorherzusagen:

# 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

Tracks für ein Referenzgenomintervall vorhersagen

Verwenden Sie predict_interval, um Modalitäten direkt aus einer bestimmten Chromosomenregion im Referenzgenom vorherzusagen:

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
)

Varianteneffekte auf genomischen Tracks vorhersagen

Verwenden Sie predict_variant, um paarweise Vorhersagen für Referenz- (reference) und mutierte (alternate) Tracks über ein Intervall zu generieren:

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

Variant Effect bewerten

Verwenden Sie score_variant, um die vorhergesagte Wirkung einer genetischen Variante zusammenzufassen, indem Sie eine Referenzsequenz (REF) mit einer alternativen (ALT) mutierten Sequenz vergleichen:

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)

Genomisches Intervall bewerten

Verwenden Sie score_interval, um die Intervalle für Genmasken in einer genomischen Region zu berechnen:

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)

In-silico-Sättigungsmutagenese ausführen

Verwenden Sie score_ism_variants, um alle möglichen Einzelnukleotidvarianten für ein Ziel-ism_interval zu bewerten:

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))

Nutzung (alphagenome-003)

Python

SDK installieren

Die Wheel-Datei für das AlphaGenome Cloud SDK ist im GoogleCloudPlatform-GitHub-Repository verfügbar. Sie können die Wheel-Datei mit dem folgenden Befehl herunterladen:

# 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

Client initialisieren

Bevor Sie das Modell verwenden können, müssen Sie den Client initialisieren:

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
)

Tracks für eine DNA-Sequenz vorhersagen

Verwenden Sie predict_sequence, um genomische Modalitäten für einen Roh-DNA-String vorherzusagen:

# 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

Tracks für ein Referenzgenomintervall vorhersagen

Verwenden Sie predict_interval, um Modalitäten direkt aus einer bestimmten Chromosomenregion im Referenzgenom vorherzusagen:

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
)

Variant Effect bewerten (In-silico-Mutagenese)

Verwenden Sie score_variant, um die vorhergesagte Expression einer Referenzsequenz (REF) mit einer alternativen mutierten Sequenz (ALT) zu vergleichen:

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)

Preise

Für AlphaGenome ist ein kostenpflichtiges Abo erforderlich. Informationen zu den Preisen für AlphaGenome erhalten Sie von einem Google Cloud -Vertriebsspezialisten oder von Ihrem Google CloudAccount-Management-Team.

Sie sind für die Kosten der Infrastruktur verantwortlich, die zum Hosten des Modells verwendet wird, einschließlich des Agent Platform-Endpunkts und der GPU-Instanzen, auf denen das Modell bereitgestellt wird. Weitere Informationen finden Sie unter Preise für die Agent-Plattform.

Beschränkungen

Für AlphaGenome gelten die folgenden Einschränkungen:

  • Nur für Forschungszwecke: AlphaGenome ist ein Recherchetool und nicht für die klinische Diagnostik vorgesehen oder zugelassen.
  • Kontexthorizont von 1 MB: Eine einzelne Vorhersageabfrage kann keine genomischen Interaktionen erfassen, die über Entfernungen von mehr als 1 MB auftreten.
  • Keine Unterstützung für Feinabstimmung: AlphaGenome unterstützt keine Feinabstimmung mit privaten Trainings-Datasets. Das Modell ist nur für die Inferenz verfügbar.

Wissenschaftliches Referenzverzeichnis

Zur Unterstützung der wissenschaftlichen und Entwickler-Communitys sind in der folgenden Tabelle primäre Referenzmaterialien, Literatur und Ressourcen für AlphaGenome aufgeführt:

Ressourcentyp Titel und Link Beschreibung
Von Kollegen geprüfter Artikel Advancing regulatory variant effect prediction with AlphaGenome, Nature (Januar 2026) Die wichtigste wissenschaftliche Publikation, in der die Architektur, die Bewertungen und die Leistungsbenchmarks des Modells beschrieben werden.
Preprint-Artikel AlphaGenome: advancing regulatory variant effect prediction with a unified DNA sequence model, bioRxiv (Juli 2025) Das ursprüngliche Manuskript vor der Peer-Review.
Ankündigung AlphaGenome: AI for better understanding the genome, Google DeepMind-Blog (Juni 2025) Der Blogpost zur Veröffentlichung, in dem die Auswirkungen des Modells auf die Genomik beschrieben werden.
API-Dokumentation AlphaGenome-Dokumentation Technische Dokumentation für das Python SDK und HTTP API-Schemas.
Videoanleitung AlphaGenome: KI für ein besseres Verständnis des Genoms Videoanleitung, in der die Funktionen des Modells und die grundlegenden Interaktionsabläufe beschrieben werden. (Videolänge: 30 Minuten)
Kurzanleitung für Notebooks Colab-Notebook für die AlphaGenome-Kurzanleitung Ein Notebook mit ausführbaren Beispielen für die SDK-Initialisierung und die Bewertung von Varianteneffekten.

Support und Feedback

Sie können auf folgende Weise Support für AlphaGenome erhalten:

  • Unterstützung für Genomik und Modellausgaben: Wenn Sie über Biologie, Modellvorhersagen oder Interpretierbarkeit diskutieren oder sich mit Google DeepMind austauschen möchten, können Sie dem öffentlichen AlphaGenome-Community-Forum unter alphagenomecommunity.com beitreten.
  • Infrastruktur- und Plattformsupport: Bei Fragen zu Kontingenten, Beschleunigern, Problemen mit Clientbibliotheken oder zur Abrechnung in Google Cloudwenden Sie sich an Ihr Account-Management-Team fürGoogle Cloud oder eröffnen Sie eine Anfrage beim Cloud Customer Care.