esm

Par mkurman · zorai

Boîte à outils complète pour les modèles de langage protéiques, incluant ESM3 (conception multimodale générative de protéines à partir de séquences, structures et fonctions) et ESM C (embeddings et représentations protéiques efficaces). Utilisez cette skill pour travailler avec des séquences, structures ou prédictions de fonctions protéiques ; concevoir de nouvelles protéines ; générer des embeddings protéiques ; effectuer de l'inverse folding ; ou réaliser des tâches d'ingénierie des protéines. Prend en charge l'utilisation de modèles locaux et l'API Forge cloud pour une inférence à grande échelle.

npx skills add https://github.com/mkurman/zorai --skill esm

ESM : Evolutionary Scale Modeling

Aperçu

ESM fournit des modèles de langage protéique de pointe pour comprendre, générer et concevoir des protéines. Cette skill permet de travailler avec deux familles de modèles : ESM3 pour la conception générative de protéines sur les séquences, structures et fonctions, et ESM C pour l'apprentissage efficace de représentations protéiques et les embeddings.

Capacités principales

1. Génération de séquences protéiques avec ESM3

Générez de nouvelles séquences protéiques avec les propriétés souhaitées en utilisant la modélisation générative multimodale.

Quand l'utiliser :

  • Concevoir des protéines avec des propriétés fonctionnelles spécifiques
  • Compléter des séquences protéiques partielles
  • Générer des variantes de protéines existantes
  • Créer des protéines avec les caractéristiques structurelles désirées

Utilisation basique :

from esm.models.esm3 import ESM3
from esm.sdk.api import ESM3InferenceClient, ESMProtein, GenerationConfig

# Load model locally
model: ESM3InferenceClient = ESM3.from_pretrained("esm3-sm-open-v1").to("cuda")

# Create protein prompt
protein = ESMProtein(sequence="MPRT___KEND")  # '_' represents masked positions

# Generate completion
protein = model.generate(protein, GenerationConfig(track="sequence", num_steps=8))
print(protein.sequence)

Pour une utilisation distante/cloud via l'API Forge :

from esm.sdk.forge import ESM3ForgeInferenceClient
from esm.sdk.api import ESMProtein, GenerationConfig

# Connect to Forge
model = ESM3ForgeInferenceClient(model="esm3-medium-2024-08", url="https://forge.evolutionaryscale.ai", token="<token>")

# Generate
protein = model.generate(protein, GenerationConfig(track="sequence", num_steps=8))

Consultez references/esm3-api.md pour les spécifications détaillées du modèle ESM3, les configurations de génération avancées et les exemples de prompting multimodal.

2. Prédiction de structure et repliement inverse

Utilisez la piste structure d'ESM3 pour la prédiction de structure à partir d'une séquence ou le repliement inverse (conception de séquence à partir d'une structure).

Prédiction de structure :

from esm.sdk.api import ESM3InferenceClient, ESMProtein, GenerationConfig

# Predict structure from sequence
protein = ESMProtein(sequence="MPRTKEINDAGLIVHSP...")
protein_with_structure = model.generate(
    protein,
    GenerationConfig(track="structure", num_steps=protein.sequence.count("_"))
)

# Access predicted structure
coordinates = protein_with_structure.coordinates  # 3D coordinates
pdb_string = protein_with_structure.to_pdb()

Repliement inverse (séquence à partir de la structure) :

# Design sequence for a target structure
protein_with_structure = ESMProtein.from_pdb("target_structure.pdb")
protein_with_structure.sequence = None  # Remove sequence

# Generate sequence that folds to this structure
designed_protein = model.generate(
    protein_with_structure,
    GenerationConfig(track="sequence", num_steps=50, temperature=0.7)
)

3. Embeddings protéiques avec ESM C

Générez des embeddings de haute qualité pour des tâches aval comme la prédiction de fonction, la classification ou l'analyse de similarité.

Quand l'utiliser :

  • Extraire des représentations protéiques pour le machine learning
  • Calculer les similarités de séquences
  • Extraction de features pour la classification de protéines
  • Apprentissage par transfert pour les tâches liées aux protéines

Utilisation basique :

from esm.models.esmc import ESMC
from esm.sdk.api import ESMProtein

# Load ESM C model
model = ESMC.from_pretrained("esmc-300m").to("cuda")

# Get embeddings
protein = ESMProtein(sequence="MPRTKEINDAGLIVHSP...")
protein_tensor = model.encode(protein)

# Generate embeddings
embeddings = model.forward(protein_tensor)

Traitement par batch :

# Encode multiple proteins
proteins = [
    ESMProtein(sequence="MPRTKEIND..."),
    ESMProtein(sequence="AGLIVHSPQ..."),
    ESMProtein(sequence="KTEFLNDGR...")
]

embeddings_list = [model.logits(model.forward(model.encode(p))) for p in proteins]

Consultez references/esm-c-api.md pour les détails du modèle ESM C, les comparaisons d'efficacité et les stratégies avancées d'embedding.

4. Conditionnement par fonction et annotation

Utilisez la piste fonction d'ESM3 pour générer des protéines avec des annotations fonctionnelles spécifiques ou prédire la fonction à partir d'une séquence.

Génération conditionnée par fonction :

from esm.sdk.api import ESMProtein, FunctionAnnotation, GenerationConfig

# Create protein with desired function
protein = ESMProtein(
    sequence="_" * 200,  # Generate 200 residue protein
    function_annotations=[
        FunctionAnnotation(label="fluorescent_protein", start=50, end=150)
    ]
)

# Generate sequence with specified function
functional_protein = model.generate(
    protein,
    GenerationConfig(track="sequence", num_steps=200)
)

5. Génération avec chaîne de pensée

Affinez itérativement les conceptions protéiques en utilisant l'approche de génération par chaîne de pensée d'ESM3.

from esm.sdk.api import GenerationConfig

# Multi-step refinement
protein = ESMProtein(sequence="MPRT" + "_" * 100 + "KEND")

# Step 1: Generate initial structure
config = GenerationConfig(track="structure", num_steps=50)
protein = model.generate(protein, config)

# Step 2: Refine sequence based on structure
config = GenerationConfig(track="sequence", num_steps=50, temperature=0.5)
protein = model.generate(protein, config)

# Step 3: Predict function
config = GenerationConfig(track="function", num_steps=20)
protein = model.generate(protein, config)

6. Traitement par batch avec l'API Forge

Traitez plusieurs protéines efficacement en utilisant l'executor asynchrone de Forge.

from esm.sdk.forge import ESM3ForgeInferenceClient
import asyncio

client = ESM3ForgeInferenceClient(model="esm3-medium-2024-08", token="<token>")

# Async batch processing
async def batch_generate(proteins_list):
    tasks = [
        client.async_generate(protein, GenerationConfig(track="sequence"))
        for protein in proteins_list
    ]
    return await asyncio.gather(*tasks)

# Execute
proteins = [ESMProtein(sequence=f"MPRT{'_' * 50}KEND") for _ in range(10)]
results = asyncio.run(batch_generate(proteins))

Consultez references/forge-api.md pour la documentation détaillée de l'API Forge, l'authentification, les limites de débit et les patterns de traitement par batch.

Guide de sélection des modèles

Modèles ESM3 (Génératifs) :

  • esm3-sm-open-v1 (1,4B) - Poids ouverts, utilisation locale, bon pour l'expérimentation
  • esm3-medium-2024-08 (7B) - Meilleur équilibre qualité/vitesse (Forge uniquement)
  • esm3-large-2024-03 (98B) - Qualité maximale, plus lent (Forge uniquement)

Modèles ESM C (Embeddings) :

  • esmc-300m (30 couches) - Léger, inférence rapide
  • esmc-600m (36 couches) - Performance équilibrée
  • esmc-6b (80 couches) - Qualité de représentation maximale

Critères de sélection :

  • Développement/test local : Utilisez esm3-sm-open-v1 ou esmc-300m
  • Qualité production : Utilisez esm3-medium-2024-08 via Forge
  • Précision maximale : Utilisez esm3-large-2024-03 ou esmc-6b
  • Haut débit : Utilisez l'API Forge avec executor batch
  • Optimisation des coûts : Utilisez des modèles plus petits, implémentez des stratégies de cache

Installation

Installation basique :

uv pip install esm

Avec Flash Attention (recommandé pour une inférence plus rapide) :

uv pip install esm
uv pip install flash-attn --no-build-isolation

Pour l'accès à l'API Forge :

uv pip install esm  # SDK includes Forge client

Aucune dépendance supplémentaire requise. Obtenez le token de l'API Forge sur https://forge.evolutionaryscale.ai

Workflows courants

Pour des exemples détaillés et des workflows complets, consultez references/workflows.md qui comprend :

  • Conception novel de GFP avec chaîne de pensée
  • Génération et criblage de variantes protéiques
  • Optimisation de séquence basée sur la structure
  • Pipelines de prédiction de fonction
  • Clustering et analyse basés sur embeddings

Références

Cette skill comprend une documentation de référence complète :

  • references/esm3-api.md - Architecture du modèle ESM3, référence API, paramètres de génération et prompting multimodal
  • references/esm-c-api.md - Détails du modèle ESM C, stratégies d'embedding et optimisation des performances
  • references/forge-api.md - Documentation de la plateforme Forge, authentification, traitement par batch et déploiement
  • references/workflows.md - Exemples complets et patterns de workflows courants

Ces références contiennent les spécifications API détaillées, les descriptions des paramètres et les patterns d'utilisation avancée. Chargez-les selon vos besoins pour des tâches spécifiques.

Bonnes pratiques

Pour les tâches de génération :

  • Commencez par des modèles plus petits pour le prototypage (esm3-sm-open-v1)
  • Utilisez le paramètre de température pour contrôler la diversité (0,0 = déterministe, 1,0 = diversifié)
  • Implémentez l'affinage itératif avec la chaîne de pensée pour les conceptions complexes
  • Validez les séquences générées avec la prédiction de structure ou des expériences en laboratoire

Pour les tâches d'embedding :

  • Traitez les séquences par batch si possible pour l'efficacité
  • Mettez en cache les embeddings pour les analyses répétées
  • Normalisez les embeddings lors du calcul de similarités
  • Utilisez la taille de modèle appropriée en fonction des exigences de la tâche aval

Pour le déploiement en production :

  • Utilisez l'API Forge pour l'extensibilité et les modèles les plus récents
  • Implémentez la gestion des erreurs et la logique de retry pour les appels API
  • Surveillez l'utilisation des tokens et implémentez la limitation de débit
  • Considérez le déploiement AWS SageMaker pour une infrastructure dédiée

Ressources et documentation

Utilisation responsable

ESM est conçu pour des applications bénéfiques en ingénierie protéique, découverte de médicaments et recherche scientifique. Suivez le Responsible Biodesign Framework (https://responsiblebiodesign.ai/) lors de la conception de nouvelles protéines. Considérez les implications de biosécurité et d'éthique des conceptions protéiques avant la validation expérimentale.

Skills similaires

claude-api
anthropics / skills

Construire des applications LLM avec Claude via le SDK officiel adapté au langage.

146 952
ad-model-onboard
nvidia / skills

Automatiser l'intégration de modèles HuggingFace dans AutoDeploy avec tests et rapport.

1 033
eval-bootstrap
datadog-labs / agent-skills

Générer du code d'évaluation Python à partir de traces de production LLM Datadog.

126
trtllm-moe-develop
nvidia / skills

Auditer et aligner le code MoE TensorRT-LLM avec l'architecture de référence.

1 033
openai-docs
openai / skills

Consulter la documentation officielle OpenAI pour guider développeurs, migrations et sélection de modèles.

21 423