dyMEAN
checkpoints
Este repositório contém os códigos para nosso artigo Design de anticorpo de átomo completo de ponta a ponta.
Existem 3 pré-requisitos necessários e 1 opcional: configurar o ambiente conda (necessário), obter marcadores (necessário), preparar dados de pdb de anticorpos (necessário) e baixar linhas de base (opcional).
1. Meio Ambiente
Fornecemos o env.yml para criar o ambiente conda de tempo de execução apenas executando:
conda env create -f env.yml2. Artilheiros
Primeiro, prepare os marcadores para TMscore e DockQ da seguinte forma:
O código-fonte para avaliar o TMscore está em evaluation/TMscore.cpp . Por favor, compile-o por:
g++ -static -O3 -ffast-math -lm -o evaluation/TMscore evaluation/TMscore.cpp Para preparar o marcador DockQ, clone seu github oficial e compile os pré-requisitos de acordo com suas instruções. Depois disso, revise a variável DOCKQ_DIR em configs.py para apontar para o diretório que contém o projeto DockQ (por exemplo, ./DockQ).
O marcador lDDT está no ambiente conda, e o
3. Dados do APO
Faça download de todos os dados estruturais dos anticorpos na página de download do SAbDab. Entre na guia Downloads à esquerda da página da web e baixe o arquivo zip arquivado para as estruturas e descompacte-o:
wget https://opig.stats.ox.ac.uk/webapps/newsabdab/sabdab/archive/all/ -O all_structures.zip
unzip all_structures.zipVocê deve obter uma pasta chamada all_structures com a seguinte hierarquia:
├── all_structures
│ ├── chothia
│ ├── imgt
│ ├── raw
Cada subpasta contém os arquivos pdb renumerados com o esquema correspondente. Usamos IMGT no artigo, então a subpasta imgt é o que nos interessa.
Como os arquivos pdb são difíceis de processar, normalmente as pessoas geram um arquivo de resumo para o banco de dados estrutural que registra as informações básicas sobre cada estrutura para acesso rápido. Fornecemos o resumo do conjunto de dados recuperado em 12 de novembro de 2022 ( summaries/sabdab_summary.tsv ). Como o conjunto de dados é atualizado semanalmente, se você quiser usar a versão mais recente, faça o download no site oficial.
(Opcional) 4. Linhas de base
Se você estiver interessado nas linhas de base do pipeline, inclua os seguintes projetos e integre suas dependências de acordo com suas necessidades:
Depois de adicionar esses projetos, lembre-se também de revisar os caminhos correspondentes em ./configs.py . Também fornecemos os scripts para cascata dos módulos em ./scripts/pipeline_inference.sh .
Os pontos de verificação treinados para cada tarefa são fornecidos na página de lançamento do github. Para utilizá-los, baixe aqueles de seu interesse e salve-os na pasta ./checkpoints . Fornecemos os nomes, configurações de treinamento (em ./scripts/train/configs ) e descrições dos pontos de verificação da seguinte forma:
| pontos de verificação | configurar | descrição |
|---|---|---|
| cdrh3_design.ckpt | single_cdr_design.json | Design CDR-H3 de ligação a epítopos |
| struct_prediction.ckpt | struct_prediction.json | Previsão de estrutura complexa |
| affinity_opt.ckpt & ddg_predictor.ckp | single_cdr_opt.json | Otimização de afinidade em CDR-H3 |
| multi_cdr_design.ckpt | multi_cdr_design.json | Projete todos os 6 CDRs simultaneamente |
| multi_cdr_opt.ckpt e multi_cdr_ddg_predictor | multi_cdr_opt.json | Otimize a afinidade em todos os 6 CDRs simultaneamente |
| full_design.ckpt | full_design.json | Projete todo o domínio variável, incluindo a região da estrutura |
Dados
Para pré-processar os dados brutos, precisamos primeiro gerar resumos para cada benchmark no formato json, depois dividir os conjuntos de dados em conjuntos de treinamento/validação/teste e, finalmente, transformar os dados pdb em objetos python. Fornecemos o script para todos esses procedimentos em scripts/data_preprocess.sh . Suponha que os dados pdb renumerados pelo IMGT estejam localizados em all_structures/imgt/ e que você queira armazenar os dados processados (~5G) em all_data , você pode simplesmente executar:
bash scripts/data_preprocess.sh all_structures/imgt all_dataque leva cerca de 1 hora para processar SAbDab, RAbD, conjunto de testes Igfold e SKEMPI V2.0. É normal ver erros relatados neste processo porque algumas estruturas de anticorpos estão anotadas incorretamente ou têm formato errado, que serão descartadas na fase de limpeza de dados.
(Opcional) Modelo Conservado
Fornecemos o modelo conservado do SAbDab em ./data/template.json . Se você estiver interessado no processo de extração, também é possível extrair um modelo conservado de um conjunto de dados especificado (por exemplo, o conjunto de treinamento para a tarefa de design CDR-H3) executando o seguinte comando:
python -m data.framework_templates
--dataset ./all_data/RAbD/train.json
--out ./data/new_template.json Usamos SAbDab para treinamento e RAbD para testes. Primeiro revise as configurações em scripts/train/configs/cdr_design.json (caminho para conjuntos de dados e outros hiperparâmetros) e, em seguida, execute o comando abaixo para treinamento:
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/single_cdr_design.json Normalmente, o procedimento de treinamento leva cerca de 7 horas em 2 GPUs GeForce RTX 2080 Ti. Também fornecemos o ponto de verificação treinado em checkpoints/cdrh3_design.ckpt . Em seguida, revise o caminho para o conjunto de testes em scripts/test/test.sh e execute o seguinte comando para teste:
GPU=0 bash scripts/test/test.sh ./checkpoints/cdrh3_design.ckpt ./all_data/RAbD/test.json ./results que salvará os resultados gerados em ./results .
Usamos SAbDab para treinamento e IgFold para testes. O procedimento de treinamento e teste é semelhante ao do projeto CDR-H3. Depois de revisar as configurações em scripts/train/configs/cdr_design.json e scripts/test/test.sh conforme mencionado anteriormente, execute o seguinte comando para treinamento:
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/struct_prediction.json Normalmente, o procedimento de treinamento leva cerca de 8 horas em 2 GPUs GeForce RTX 2080 Ti. Também fornecemos o ponto de verificação treinado em checkpoints/struct_prediction.ckpt . Em seguida, execute o seguinte comando para teste:
GPU=0 bash scripts/test/test.sh ./checkpoints/struct_prediction.ckpt ./all_data/IgFold/test.json ./results Usamos SAbDab para treinamento e os anticorpos do SKEMPI V2.0 para teste. Da mesma forma, primeiro revise as configurações em scripts/train/configs/affinity_opt.json , scripts/test/optimize_test.sh e, adicionalmente, scripts/train/train_predictor.sh . Então, por favor, conduza o treinamento do dyMEANOpt (~ 5h):
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/single_cdr_opt.jsonEntão precisamos treinar um preditor de ddg nas representações do complexo gerado (~ 40min):
GPU=0 bash scripts/train/train_predictor.sh checkpoints/cdrh3_opt.ckpt Fornecemos os pontos de verificação treinados em checkpoints/cdrh3_opt.ckpt e checkpoints/cdrh3_ddg_predictor.ckpt . O teste de otimização pode ser realizado através de:
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 fará 50 etapas de pesquisa gradiente sem restrições no número máximo de resíduos alterados (altere 0 para qualquer número para restringir o limite superior de
Também fornecemos API de inferência e demonstrações in silico para aplicações comuns em problemas do mundo real, que estão localizadas em ./api e ./demos .
Fornecemos a API de design e a API de otimização em ./api , que podem ser facilmente integradas em códigos python.
A API de design ( ./api/design.py ) pode ser usada para gerar CDRs dadas as sequências da região estrutural, o arquivo PDB do antígeno, bem como as definições do epítopo. Usaremos um cenário interessante para ilustrar o uso da API de design .
Queremos projetar um anticorpo que se combine com o estado aberto do membro 1 da subfamília V do canal catiônico do potencial receptor transitório (TRPV1), que desempenha um papel crítico na dor aguda e persistente. Em vez de criar manualmente o epítopo do TRPV1, tentamos imitar um aglutinante existente que é uma toxina de nó duplo (DkTx). Portanto, precisamos primeiro extrair a definição do epítopo analisando o padrão de ligação da toxina e, em seguida, projetar um anticorpo com determinadas sequências das regiões estruturais.
1. Extraia a definição do epítopo
Fornecemos o arquivo PDB do complexo do canal catiônico de potencial receptor transitório subfamília V membro 1 (TRPV1, cadeia ABCD) e a toxina de nó duplo (DkTx, cadeia EF) em ./demos/data/7l2m.pdb . O PDB original possui 4 unidades simétricas, então dividimos manualmente as duas toxinas (cadeia EF) no meio para formar 4 cadeias simétricas e,f,E,F. Cada anticorpo só precisa se concentrar em uma unidade. Aqui escolhemos a cadeia E como exemplo.
Geramos a definição do epítopo analisando a interface de ligação da cadeia E ao TRPV1:
python -m api.binding_interface
--pdb ./demos/data/7l2m.pdb
--receptor A B C D
--ligand E
--out ./demos/data/E_epitope.json Agora a definição do epítopo (ou seja, os resíduos de TRPV1 na interface de ligação) é salva em ./demos/data/E_epitope.json . Alterando o valor do argumento "ligante" para e, f e F, podemos obter as definições de epítopo para outras unidades (não se esqueça de revisar também o caminho de saída).
2. Obtenha as sequências das regiões-quadro
Dependendo dos objectivos finais da concepção do anticorpo, podem ser desejadas regiões estruturais com diferentes propriedades físico-químicas. Como aqui estamos apenas fornecendo um caso de prova de conceito, escolhemos aleatoriamente um do conjunto de dados existente:
heavy chain (H): ' QVQLKESGPGLLQPSQTLSLTCTVSGISLSDYGVHWVRQAPGKGLEWMGIIGHAGGTDYNSNLKSRVSISRDTSKSQVFLKLNSLQQEDTAMYFC----------WGQGIQVTVSSA '
light chain (L): ' YTLTQPPLVSVALGQKATITCSGDKLSDVYVHWYQQKAGQAPVLVIYEDNRRPSGIPDHFSGSNSGNMATLTISKAQAGDEADYYCQSWDGTNSAWVFGSGTKVTVLGQ 'O CDR-H3 original está mascarado por "-". O projeto de vários CDRs também é suportado, o que será ilustrado posteriormente.
3. Projete os CDRs
A última etapa é projetar os CDRs com a API de design :
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 Esses códigos também são adicionados como exemplo em ./api/design.py , para que você possa executá-los diretamente:
python -m api.design Aqui usamos "-" para marcar o CDR-H3 manualmente, mas você também pode definir auto_detect_cdrs=True para permitir que o CDR seja automaticamente decidido pelo sistema de numeração IMGT. Os tipos de CDRs a serem projetados serão automaticamente derivados do ponto de verificação determinado. Atualmente, a API suporta o redesenho de CDRs únicos ou múltiplos, bem como o projeto do anticorpo completo (passando "-" * length como entrada).
Ativar o relaxamento do Openmm irá desacelerar bastante o processo de geração, mas retificará os comprimentos e ângulos das ligações para se adequar às restrições físicas.
A API de otimização ( ./api/optimize.py ) é direta. Otimizamos ./demos/data/1nca.pdb como exemplo:
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
) Os códigos para este exemplo também são adicionados a ./api/optimize.py , para que você possa executá-los diretamente:
python -m api.optimizeEntão você obterá os seguintes 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
onde 1nca_original.pdb é o complexo original e 1nca_a_b.pdb significa o
A API de previsão de estrutura complexa ( ./api/structure_prediction.py ) prevê a estrutura complexa dada ao antígeno, as sequências da cadeia pesada e da cadeia leve e a definição do epítopo. A ancoragem global ainda é muito desafiadora, por isso restringimos o escopo ao epítopo de interesse. Prevemos ./demos/data/1nca.pdb como exemplo:
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 Os códigos para este exemplo também são adicionados a ./api/structure_prediction.py , para que você possa executá-los diretamente:
python -m api.structure_predictionEntão você obterá os seguintes resultados:
├── demos/data
│ ├── 1nca_model_0.pdb
│ ├── 1nca_model_1.pdb
│ ├── 1nca_model_2.pdb
│ ├── ...
onde deve haver um total de 10 conformações amostradas. Observe que os primeiros ou últimos resíduos podem ser descartados nos resultados se estiverem fora do domínio variável de acordo com o sistema de numeração IMGT.
A exibição in vitro é comumente usada para selecionar mutantes de ligação de bibliotecas de anticorpos. Aqui implementamos uma versão in silico com a API de design , gerando e filtrando candidatos do conjunto de dados existente contra o antígeno com uma definição de epítopo. Além disso, precisamos de uma métrica para avaliar quão bem o anticorpo gerado se liga ao alvo. Aqui usamos o FoldX como preditor de afinidade, portanto, para executar esta demonstração, pode ser necessário primeiro baixá-lo do site oficial e revisar o caminho em ./configs.py correspondentemente. Ainda usamos o exemplo TRPV1 na seção anterior e usamos o benchmark RAbD como a biblioteca de anticorpos que fornece as regiões estruturais:
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 0o que resultará em 30 candidatos com afinidade prevista pelo FoldX.
Obrigado pelo seu interesse em nosso trabalho!
Fique à vontade para perguntar qualquer dúvida sobre os algoritmos, códigos, bem como problemas encontrados na execução deles para que possamos torná-los mais claros e melhores. Você pode criar um problema no repositório do github ou entrar em contato conosco pelo e-mail [email protected].
Os arquivos abaixo foram emprestados de repositórios existentes:
evaluation/TMscore.cpp : https://zhanggroup.org/TM-score/evaluation/ddg : https://github.com/HeliXonProtein/binding-ddg-predictor
