dyMEAN
checkpoints
Este repositorio contiene los códigos de nuestro artículo Diseño de anticuerpos de átomo completo de extremo a extremo.
Hay 3 requisitos previos necesarios y 1 opcional: configurar el entorno conda (necesario), obtener puntajes (necesario), preparar datos pdb de anticuerpos (necesario) y descargar líneas de base (opcional).
1. Medio ambiente
Hemos proporcionado env.yml para crear el entorno de ejecución conda simplemente ejecutando:
conda env create -f env.yml2. Goleadores
Primero prepare a los anotadores para TMscore y DockQ de la siguiente manera:
El código fuente para evaluar TMscore se encuentra en evaluation/TMscore.cpp . Compílelo mediante:
g++ -static -O3 -ffast-math -lm -o evaluation/TMscore evaluation/TMscore.cpp Para preparar el anotador DockQ, clone su github oficial y compile los requisitos previos de acuerdo con sus instrucciones. Después de eso, revise la variable DOCKQ_DIR en configs.py para que apunte al directorio que contiene el proyecto DockQ (por ejemplo, ./DockQ).
El anotador lDDT está en el entorno conda y el
3. datos del AP
Descargue todos los datos estructurales de los anticuerpos desde la página de descarga de SAbDab. Ingrese a la pestaña Descargas a la izquierda de la página web y descargue el archivo zip archivado para las estructuras, luego descomprímalo:
wget https://opig.stats.ox.ac.uk/webapps/newsabdab/sabdab/archive/all/ -O all_structures.zip
unzip all_structures.zipDebería obtener una carpeta llamada all_structures con la siguiente jerarquía:
├── all_structures
│ ├── chothia
│ ├── imgt
│ ├── raw
Cada subcarpeta contiene los archivos pdb renumerados con el esquema correspondiente. Usamos IMGT en el artículo, por lo que lo que nos importa es la subcarpeta imgt.
Dado que los archivos pdb son difíciles de procesar, normalmente las personas generarán un archivo de resumen para la base de datos estructural que registra la información básica sobre cada estructura para un acceso rápido. Proporcionamos el resumen del conjunto de datos recuperado el 12 de noviembre de 2022 ( summaries/sabdab_summary.tsv ). Dado que el conjunto de datos se actualiza semanalmente, si desea utilizar la última versión, descárguela del sitio web oficial.
(Opcional) 4. Líneas de base
Si está interesado en las líneas base del pipeline, incluya los siguientes proyectos e integre sus dependencias según sus necesidades:
Después de agregar estos proyectos, recuerde también revisar las rutas correspondientes en ./configs.py . También proporcionamos los scripts para conectar en cascada los módulos en ./scripts/pipeline_inference.sh .
Los puntos de control entrenados para cada tarea se proporcionan en la página de lanzamiento de github. Para usarlos, descargue los que le interesen y guárdelos en la carpeta ./checkpoints . Proporcionamos los nombres, las configuraciones de entrenamiento (en ./scripts/train/configs ) y las descripciones de los puntos de control de la siguiente manera:
| punto(s) de control | configurar | descripción |
|---|---|---|
| cdrh3_design.ckpt | single_cdr_design.json | Diseño CDR-H3 de unión a epítopo |
| struct_prediction.ckpt | struct_prediction.json | Predicción de estructuras complejas |
| affinity_opt.ckpt y ddg_predictor.ckp | single_cdr_opt.json | Optimización de afinidad en CDR-H3 |
| multi_cdr_design.ckpt | multi_cdr_design.json | Diseñe los 6 CDR simultáneamente |
| multi_cdr_opt.ckpt y multi_cdr_ddg_predictor | multi_cdr_opt.json | Optimice la afinidad en los 6 CDR simultáneamente |
| diseño_completo.ckpt | diseño_completo.json | Diseñar todo el dominio variable, incluida la región del marco. |
Datos
Para preprocesar los datos sin procesar, primero debemos generar resúmenes para cada punto de referencia en formato json, luego dividir los conjuntos de datos en conjuntos de entrenamiento/validación/prueba y, finalmente, transformar los datos de pdb en objetos de Python. Hemos proporcionado el script para todos estos procedimientos en scripts/data_preprocess.sh . Supongamos que los datos pdb renumerados por IMGT se encuentran en all_structures/imgt/ y que desea almacenar los datos procesados (~5G) en all_data , simplemente puede ejecutar:
bash scripts/data_preprocess.sh all_structures/imgt all_datalo que tarda aproximadamente 1 hora en procesar SAbDab, RAbD, conjunto de pruebas Igfold y SKEMPI V2.0. Es normal ver errores informados en este proceso porque algunas estructuras de anticuerpos están anotadas incorrectamente o tienen un formato incorrecto, lo que se eliminará en la fase de limpieza de datos.
(Opcional) Plantilla conservada
Proporcionamos la plantilla conservada de SAbDab en ./data/template.json . Si está interesado en el proceso de extracción, también es posible extraer una plantilla conservada de un conjunto de datos específico (por ejemplo, el conjunto de entrenamiento para la tarea de diseño CDR-H3) ejecutando el siguiente comando:
python -m data.framework_templates
--dataset ./all_data/RAbD/train.json
--out ./data/new_template.json Usamos SAbDab para capacitación y RAbD para pruebas. Primero revise la configuración en scripts/train/configs/cdr_design.json (ruta a los conjuntos de datos y otros hiperparámetros) y luego ejecute el siguiente comando para la capacitación:
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/single_cdr_design.json Normalmente, el procedimiento de formación dura unas 7 horas en 2 GPU GeForce RTX 2080 Ti. También proporcionamos el punto de control capacitado en checkpoints/cdrh3_design.ckpt . Luego revise la ruta al conjunto de prueba en scripts/test/test.sh y ejecute el siguiente comando para realizar la prueba:
GPU=0 bash scripts/test/test.sh ./checkpoints/cdrh3_design.ckpt ./all_data/RAbD/test.json ./results que guardará los resultados generados en ./results .
Usamos SAbDab para capacitación e IgFold para pruebas. El procedimiento de entrenamiento y prueba es similar al del diseño CDR-H3. Después de revisar la configuración en scripts/train/configs/cdr_design.json y scripts/test/test.sh como se mencionó anteriormente, ejecute el siguiente comando para la capacitación:
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/struct_prediction.json Normalmente, el procedimiento de formación dura unas 8 horas en 2 GPU GeForce RTX 2080 Ti. También proporcionamos el punto de control capacitado en checkpoints/struct_prediction.ckpt . Luego ejecute el siguiente comando para realizar pruebas:
GPU=0 bash scripts/test/test.sh ./checkpoints/struct_prediction.ckpt ./all_data/IgFold/test.json ./results Usamos SAbDab para el entrenamiento y los anticuerpos en SKEMPI V2.0 para las pruebas. De manera similar, primero revise la configuración en scripts/train/configs/affinity_opt.json , scripts/test/optimize_test.sh y, además, scripts/train/train_predictor.sh . Luego realice una capacitación de dyMEANOpt (~ 5 h):
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/single_cdr_opt.jsonLuego necesitamos entrenar un predictor de ddg en las representaciones del complejo generado (~ 40 min):
GPU=0 bash scripts/train/train_predictor.sh checkpoints/cdrh3_opt.ckpt Proporcionamos los puntos de control entrenados en checkpoints/cdrh3_opt.ckpt y checkpoints/cdrh3_ddg_predictor.ckpt . La prueba de optimización se puede realizar mediante:
GPU=0 bash scripts/test/optimize_test.sh checkpoints/cdrh3_opt.ckpt checkpoints/cdrh3_ddg_predictor.ckpt ./all_data/SKEMPI/test.json 0 50 que realizará 50 pasos de búsqueda de gradiente sin restricciones en el número máximo de residuos modificados (cambie 0 a cualquier número para restringir el límite superior de
También proporcionamos API de inferencia y demostraciones in silico para aplicaciones comunes en problemas del mundo real, que se encuentran en ./api y ./demos .
Proporcionamos la API de diseño y la API de optimización en ./api , que se pueden integrar fácilmente en códigos Python.
La API de diseño ( ./api/design.py ) se puede utilizar para generar CDR dadas las secuencias de la región marco, el archivo PDB del antígeno y las definiciones de epítopo. Usaremos un escenario interesante para ilustrar el uso de la API de diseño .
Queremos diseñar un anticuerpo que se combine con el estado abierto del miembro 1 de la subfamilia V del canal catiónico potencial del receptor transitorio (TRPV1), que desempeña un papel fundamental en el dolor agudo y persistente. En lugar de crear manualmente el epítopo de TRPV1, intentamos imitar un aglutinante existente que es una toxina de doble nudo (DkTx). Por lo tanto, primero debemos extraer la definición del epítopo analizando el patrón de unión de la toxina y luego diseñar un anticuerpo con secuencias determinadas de las regiones estructurales.
1. Extraiga la definición del epítopo
Proporcionamos el archivo PDB del complejo del miembro 1 de la subfamilia V del canal catiónico potencial del receptor transitorio (TRPV1, cadena ABCD) y la toxina de doble nudo (DkTx, cadena EF) en ./demos/data/7l2m.pdb . El PDB original tiene 4 unidades simétricas, por lo que dividimos manualmente las dos toxinas (cadena EF) por la mitad para formar 4 cadenas simétricas e,f,E,F. Cada anticuerpo solo necesita centrarse en una unidad. Aquí elegimos la cadena E como ejemplo.
Generamos la definición del epítopo analizando la interfaz de unión de la cadena E al TRPV1:
python -m api.binding_interface
--pdb ./demos/data/7l2m.pdb
--receptor A B C D
--ligand E
--out ./demos/data/E_epitope.json Ahora la definición del epítopo (es decir, los residuos de TRPV1 en la interfaz de enlace) se guarda en ./demos/data/E_epitope.json . Al cambiar el valor del argumento "ligando" a e, f y F, podemos obtener las definiciones de epítopos para otras unidades (no olvide revisar también la ruta de salida).
2. Obtener las Secuencias de las Regiones Marco
Dependiendo de los propósitos finales del diseño del anticuerpo, pueden desearse regiones estructurales con diferentes propiedades fisicoquímicas. Dado que aquí solo proporcionamos un caso de prueba de concepto, seleccionamos uno al azar del conjunto de datos existente:
heavy chain (H): ' QVQLKESGPGLLQPSQTLSLTCTVSGISLSDYGVHWVRQAPGKGLEWMGIIGHAGGTDYNSNLKSRVSISRDTSKSQVFLKLNSLQQEDTAMYFC----------WGQGIQVTVSSA '
light chain (L): ' YTLTQPPLVSVALGQKATITCSGDKLSDVYVHWYQQKAGQAPVLVIYEDNRRPSGIPDHFSGSNSGNMATLTISKAQAGDEADYYCQSWDGTNSAWVFGSGTKVTVLGQ 'El CDR-H3 original está enmascarado por "-". También se admite el diseño de múltiples CDR, lo que se ilustrará más adelante.
3. Diseñar los CDR
El último paso es diseñar los CDR con la API de diseño :
from api . design import design
ckpt = './checkpoints/cdrh3_design.ckpt'
root_dir = './demos/data'
pdbs = [ os . path . join ( root_dir , '7l2m.pdb' ) for _ in range ( 4 )]
toxin_chains = [ 'E' , 'e' , 'F' , 'f' ]
remove_chains = [ toxin_chains for _ in range ( 4 )]
epitope_defs = [ os . path . join ( root_dir , c + '_epitope.json' ) for c in toxin_chains ]
identifiers = [ f' { c } _antibody' for c in toxin_chains ]
# use '-' for masking amino acids
frameworks = [
(
( 'H' , 'QVQLKESGPGLLQPSQTLSLTCTVSGISLSDYGVHWVRQAPGKGLEWMGIIGHAGGTDYNSNLKSRVSISRDTSKSQVFLKLNSLQQEDTAMYFC----------WGQGIQVTVSSA' ),
( 'L' , 'YTLTQPPLVSVALGQKATITCSGDKLSDVYVHWYQQKAGQAPVLVIYEDNRRPSGIPDHFSGSNSGNMATLTISKAQAGDEADYYCQSWDGTNSAWVFGSGTKVTVLGQ' )
)
for _ in pdbs
] # the first item of each tuple is heavy chain, the second is light chain
design ( ckpt = ckpt , # path to the checkpoint of the trained model
gpu = 0 , # the ID of the GPU to use
pdbs = pdbs , # paths to the PDB file of each antigen (here antigen is all TRPV1)
epitope_defs = epitope_defs , # paths to the epitope definitions
frameworks = frameworks , # the given sequences of the framework regions
out_dir = root_dir , # output directory
identifiers = identifiers , # name of each output antibody
remove_chains = remove_chains , # remove the original ligand
enable_openmm_relax = True , # use openmm to relax the generated structure
auto_detect_cdrs = False ) # manually use '-' to represent CDR residues Estos códigos también se agregan como ejemplo en ./api/design.py , por lo que puedes ejecutarlo directamente de la siguiente manera:
python -m api.design Aquí usamos "-" para marcar el CDR-H3 manualmente, pero también puede configurar auto_detect_cdrs=True para permitir que el sistema de numeración IMGT decida automáticamente el CDR. Los tipos de CDR a diseñar se derivarán automáticamente del punto de control dado. Actualmente, la API admite el rediseño de CDR únicas o múltiples, así como el diseño del anticuerpo completo (pasando "-" * length como entrada).
Habilitar Openmm Relax ralentizará mucho el proceso de generación, pero rectificará las longitudes y ángulos de los enlaces para ajustarse a las limitaciones físicas.
La API de optimización ( ./api/optimize.py ) es sencilla. Optimizamos ./demos/data/1nca.pdb como ejemplo:
from api . optimize import optimize , ComplexSummary
ckpt = './checkpoints/cdrh3_opt.ckpt'
predictor_ckpt = './checkpoints/cdrh3_ddg_predictor.ckpt'
root_dir = './demos/data/1nca_opt'
summary = ComplexSummary (
pdb = './demos/data/1nca.pdb' ,
heavy_chain = 'H' ,
light_chain = 'L' ,
antigen_chains = [ 'N' ]
)
optimize (
ckpt = ckpt , # path to the checkpoint of the trained model
predictor_ckpt = predictor_ckpt , # path to the checkpoint of the trained ddG predictor
gpu = 0 , # the ID of the GPU to use
cplx_summary = summary , # summary of the complex as well as its PDB file
num_residue_changes = [ 1 , 2 , 3 , 4 , 5 ], # generate 5 samples, changing at most 1, 2, 3, 4, and 5 residues, respectively
out_dir = root_dir , # output directory
batch_size = 16 , # batch size
num_workers = 4 , # number of workers to use
optimize_steps = 50 # number of steps for gradient desend
) Los códigos para este ejemplo también se agregan a ./api/optimize.py , por lo que puedes ejecutarlos directamente de la siguiente manera:
python -m api.optimizeEntonces obtendrás los siguientes resultados:
├── demos/data/1nca_opt
│ ├── 1nca_0_1.pdb
│ ├── 1nca_1_2.pdb
│ ├── 1nca_2_3.pdb
│ ├── 1nca_3_4.pdb
│ ├── 1nca_4_5.pdb
│ ├── 1nca_original.pdb
donde 1nca_original.pdb es el complejo original y 1nca_a_b.pdb significa el
La API de predicción de estructuras complejas ( ./api/structure_prediction.py ) predice la estructura compleja dado el antígeno, las secuencias de la cadena pesada y la cadena ligera, y la definición del epítopo. El atraque global sigue siendo un gran desafío, por lo que limitamos el alcance al epítopo de interés. Predecimos ./demos/data/1nca.pdb como ejemplo:
from api . structure_prediction import structure_prediction
ckpt = './checkpoints/struct_prediction.ckpt'
root_dir = './demos/data'
n_sample = 10 # sample 10 conformations
pdbs = [ os . path . join ( root_dir , '1nca_antigen.pdb' ) for _ in range ( n_sample )]
epitope_defs = [ os . path . join ( root_dir , '1nca_epitope.json' ) for _ in range ( n_sample )]
identifiers = [ f'1nca_model_ { i } ' for i in range ( n_sample )]
seqs = [
(
( 'H' , 'QIQLVQSGPELKKPGETVKISCKASGYTFTNYGMNWVKQAPGKGLKWMGWINTNTGEPTYGEEFKGRFAFSLETSASTANLQINNLKNEDTATFFCARGEDNFGSLSDYWGQGTTVTVSS' ),
( 'L' , 'DIVMTQSPKFMSTSVGDRVTITCKASQDVSTAVVWYQQKPGQSPKLLIYWASTRHIGVPDRFAGSGSGTDYTLTISSVQAEDLALYYCQQHYSPPWTFGGGTKLEIK' )
)
for _ in pdbs
] # the first item of each tuple is heavy chain, the second is light chain
structure_prediction (
ckpt = ckpt , # path to the checkpoint of the trained model
gpu = 0 , # the ID of the GPU to use
pdbs = pdbs , # paths to the PDB file of each antigen (here antigen is all TRPV1)
epitope_defs = epitope_defs , # paths to the epitope definitions
seqs = seqs , # the given sequences of the framework regions
out_dir = root_dir , # output directory
identifiers = identifiers , # name of each output antibody
enable_openmm_relax = True ) # use openmm to relax the generated structure Los códigos para este ejemplo también se agregan a ./api/structure_prediction.py , por lo que puedes ejecutarlos directamente de la siguiente manera:
python -m api.structure_predictionEntonces obtendrás los siguientes resultados:
├── demos/data
│ ├── 1nca_model_0.pdb
│ ├── 1nca_model_1.pdb
│ ├── 1nca_model_2.pdb
│ ├── ...
donde deberá haber un total de 10 conformaciones muestreadas. Tenga en cuenta que los primeros o los últimos residuos pueden descartarse en los resultados si están fuera del dominio variable según el sistema de numeración IMGT.
La visualización in vitro se utiliza habitualmente para seleccionar mutantes de unión de bibliotecas de anticuerpos. Aquí implementamos una versión in silico con la API de diseño generando y filtrando candidatos del conjunto de datos existente contra el antígeno con una definición de epítopo. Además, necesitamos una métrica para evaluar qué tan bien se une el anticuerpo generado al objetivo. Aquí usamos FoldX como predictor de afinidad, por lo que para ejecutar esta demostración, es posible que primero deba descargarla del sitio web oficial y revisar la ruta en ./configs.py correspondientemente. Seguimos usando el ejemplo de TRPV1 en la sección anterior y usamos el punto de referencia RAbD como biblioteca de anticuerpos que proporciona las regiones estructurales:
python -m demos.display
--ckpt checkpoints/multi_cdr_design.ckpt
--pdb demos/data/7l2m.pdb
--epitope_def demos/data/E_epitope.json
--library ./all_data/rabd_all.json
--n_sample 30
--save_dir demos/display
--gpu 0lo que dará como resultado 30 candidatos con su afinidad predicha por FoldX.
¡Gracias por su interés en nuestro trabajo!
No dude en preguntar cualquier pregunta sobre los algoritmos, los códigos y los problemas encontrados al ejecutarlos para que podamos hacerlo más claro y mejor. Puede crear un problema en el repositorio de github o contactarnos en [email protected].
Los archivos siguientes se han tomado prestados de repositorios existentes:
evaluation/TMscore.cpp : https://zhanggroup.org/TM-score/evaluation/ddg : https://github.com/HeliXonProtein/binding-ddg-predictor
