Examples

Handling large batches

"""In this example, we open a large fasta file with thousands of sequence
(could be millions) and send it little batch by little batch to the API, and save
the outputs (here embeddings) to disk."""

from pathlib import Path
import json

from ginkgo_ai_client import GinkgoAIClient, MeanEmbeddingQuery

input_file = Path(__file__).parent / "data" / "100_dna_sequences.fasta"
output_folder = Path(__file__).parent / "outputs" / "large_batches"
output_folder.mkdir(parents=True, exist_ok=True)

client = GinkgoAIClient()
model = "ginkgo-maskedlm-3utr-v1"
queries = MeanEmbeddingQuery.iter_from_fasta(input_file, model=model)
for batch_result in client.send_requests_by_batches(queries, batch_size=10):
    for query_result in batch_result:
        with open(output_folder / f"{query_result.query_name}.json", "w") as f:
            json.dump(query_result.dict(), f)

Example by application

ESM model

"""In this example we compute embedding and run masked inference
 on the ESM2 language model."""

from ginkgo_ai_client import (
    GinkgoAIClient,
    MaskedInferenceQuery,
    MeanEmbeddingQuery,
)

client = GinkgoAIClient()
model = "esm2-650M"

# SIMPLE QUERY FOR EMBEDDING COMPUTATION

query = MeanEmbeddingQuery(sequence="MLYLRRL", model=model)
prediction = client.send_request(query)
# prediction.embedding == [1.05, -2.34, ...]


# SIMPLE QUERY FOR MASKED INFERENCE

query = MaskedInferenceQuery(sequence="MLY<mask>RRL", model=model)
prediction = client.send_request(query)
# prediction.sequence == "MLYRRL"

# BATCH REQUEST

queries = [
    MeanEmbeddingQuery(sequence=sequence, model=model)
    for sequence in ["MLYLRRL", "MLL", "MLYLLRRL"]
]
predictions = client.send_batch_request(queries)
# predictions[0].embedding == [1.05, -2.34, ...]

AA0 model

"""In this example we compute embedding and run masked inference
 on the aa0 language model."""

from ginkgo_ai_client import (
    GinkgoAIClient,
    MaskedInferenceQuery,
    MeanEmbeddingQuery,
)

client = GinkgoAIClient()
model = "ginkgo-aa0-650M"

# SIMPLE QUERY FOR EMBEDDING COMPUTATION

query = MeanEmbeddingQuery(sequence="MLYLRRL", model=model)
prediction = client.send_request(query)
# prediction.embedding == [1.05, -2.34, ...]


# SIMPLE QUERY FOR MASKED INFERENCE

query = MaskedInferenceQuery(sequence="MLY<mask>RRL", model=model)
prediction = client.send_request(query)
# prediction.sequence == "MLYRRL"

# BATCH REQUEST

queries = [
    MeanEmbeddingQuery(sequence=sequence, model=model)
    for sequence in ["MLYLRRL", "MLL", "MLYLLRRL"]
]
predictions = client.send_batch_request(queries)
# predictions[0].embedding == [1.05, -2.34, ...]

3’UTR model

"""In this example we compute embedding and run masked inference
 on Ginkgo's 3'UTR language model."""

from ginkgo_ai_client import (
    GinkgoAIClient,
    MaskedInferenceQuery,
    MeanEmbeddingQuery,
)

client = GinkgoAIClient()
model = "ginkgo-maskedlm-3utr-v1"

# SIMPLE QUERY FOR EMBEDDING COMPUTATION

query = MeanEmbeddingQuery(sequence="ATTGCG", model=model)
prediction = client.send_request(query)
# prediction.embedding == [1.05, -2.34, ...]


# SIMPLE QUERY FOR MASKED INFERENCE

query = MaskedInferenceQuery(sequence="ATT<mask>TAC", model=model)
prediction = client.send_request(query)

# BATCH REQUEST

queries = [
    MeanEmbeddingQuery(sequence=sequence, model=model)
    for sequence in ["AGCGC", "ATTGCG", "TACCGCA"]
]
predictions = client.send_batch_request(queries)
# predictions[0].embedding == [1.05, -2.34, ...]

Promoter activity with Promoter-0

"""
This example shows how to use the PromoterActivityQuery to predict the activity of a
promoter in different tissues, based on the Borzoi model.
"""

from pathlib import Path
from ginkgo_ai_client import GinkgoAIClient, PromoterActivityQuery

client = GinkgoAIClient()
orf_sequence = "tgccagccatctgttgtttgcc"
promoter_sequence = "GTCCCACTGATGAACTGTGCT"


query = PromoterActivityQuery(
    promoter_sequence=promoter_sequence,
    orf_sequence=orf_sequence,
    source="expression",
    tissue_of_interest={
        "heart": ["CNhs10608+", "CNhs10612+"],
        "liver": ["CNhs10608+", "CNhs10612+"],
    },
)

response = client.send_request(query)
print("Single-query response:", response)


# In this next example we pull the promoter files from a fasta file and send them
# in batches, writing the results to a JSONL, as they arrive.

fasta_path = Path(__file__).parent / "data" / "100_dna_sequences.fasta"
queries = PromoterActivityQuery.iter_with_promoter_from_fasta(
    fasta_path=fasta_path,
    orf_sequence=orf_sequence,
    source="expression",
    tissue_of_interest={
        "heart": ["CNhs10608+", "CNhs10612+"],
        "liver": ["CNhs10608+", "CNhs10612+"],
    },
)

print("Now sending 100 requests, by batches of 10")
print("Writing results to promoter_activity.jsonl...")
output_file = Path(__file__).parent / "outputs" / "promoter_activity.jsonl"
for batch_result in client.send_requests_by_batches(queries, batch_size=10):
    for query_result in batch_result:
        query_result.write_to_jsonl(output_file)

Boltz structure inference

Structure inference with a simple (single-chain) protein sequence:

"""Simple example where we predict the 3D structure of the GFP protein."""

from ginkgo_ai_client import GinkgoAIClient, BoltzStructurePredictionQuery

client = GinkgoAIClient()
sequence = (
    "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTL"
    "VTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLV"
    "NRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLAD"
    "HYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK"
)

query = BoltzStructurePredictionQuery.from_protein_sequence(sequence)
response = client.send_request(query)
response.download_structure("GFP.pdb")

Structure inference with a multimer protein sequence and ligand(s):

"""We predict the structure of the multimer protein with ligand(s)."""

from ginkgo_ai_client import GinkgoAIClient, BoltzStructurePredictionQuery

client = GinkgoAIClient()
query = BoltzStructurePredictionQuery.from_yaml_file("with_ligand.yaml")
print("Sending the request, it might take a hot minute...")
response = client.send_request(query, timeout=1000)
response.download_structure("with_ligand.cif")