dyMEAN
checkpoints
Dieses Repo enthält die Codes für unseren Artikel „End-to-End Full-Atom Antibody Design“.
Es gibt 3 notwendige und 1 optionale Voraussetzungen: Einrichten der Conda-Umgebung (erforderlich), Erhalten von Scorern (erforderlich), Vorbereiten von Antikörper-PDB-Daten (erforderlich) und Herunterladen von Basislinien (optional).
1. Umwelt
Wir haben die env.yml zum Erstellen der Laufzeit-Conda-Umgebung bereitgestellt, indem wir einfach Folgendes ausführen:
conda env create -f env.yml2. Torschützen
Bitte bereiten Sie zunächst die Scorer für TMscore und DockQ wie folgt vor:
Der Quellcode zur Bewertung von TMscore befindet sich unter evaluation/TMscore.cpp . Bitte kompilieren Sie es durch:
g++ -static -O3 -ffast-math -lm -o evaluation/TMscore evaluation/TMscore.cpp Um den DockQ-Scorer vorzubereiten, klonen Sie bitte seinen offiziellen Github und kompilieren Sie die Voraussetzungen gemäß seinen Anweisungen. Danach überarbeiten Sie bitte die Variable DOCKQ_DIR in der configs.py um auf das Verzeichnis zu verweisen, das das DockQ-Projekt enthält (z. B. ./DockQ).
Der lDDT-Scorer befindet sich in der Conda-Umgebung und der
3. PDB-Daten
Bitte laden Sie alle Strukturdaten der Antikörper von der Download-Seite von SAbDab herunter. Bitte gehen Sie auf die Registerkarte „Downloads“ links auf der Webseite, laden Sie die archivierte ZIP-Datei für die Strukturen herunter und entpacken Sie sie anschließend:
wget https://opig.stats.ox.ac.uk/webapps/newsabdab/sabdab/archive/all/ -O all_structures.zip
unzip all_structures.zipSie sollten einen Ordner namens all_structures mit der folgenden Hierarchie erhalten:
├── all_structures
│ ├── chothia
│ ├── imgt
│ ├── raw
Jeder Unterordner enthält die PDB-Dateien, die mit dem entsprechenden Schema neu nummeriert sind. Wir verwenden IMGT in der Arbeit, daher ist uns der Unterordner imgt wichtig.
Da PDB-Dateien schwer zu verarbeiten sind, erstellen Benutzer normalerweise eine Zusammenfassungsdatei für die Strukturdatenbank, in der die grundlegenden Informationen zu jeder Struktur für einen schnellen Zugriff aufgezeichnet werden. Wir haben die Zusammenfassung des am 12. November 2022 abgerufenen Datensatzes bereitgestellt ( summaries/sabdab_summary.tsv ). Da der Datensatz wöchentlich aktualisiert wird, laden Sie ihn bitte von der offiziellen Website herunter, wenn Sie die neueste Version verwenden möchten.
(Optional) 4. Grundlinien
Wenn Sie an den Pipeline-Baselines interessiert sind, einschließlich der folgenden Projekte, integrieren Sie deren Abhängigkeiten entsprechend Ihren Anforderungen:
Bitte denken Sie nach dem Hinzufügen dieser Projekte auch daran, die entsprechenden Pfade in ./configs.py zu überarbeiten. Wir haben auch die Skripte zur Kaskadierung der Module in ./scripts/pipeline_inference.sh bereitgestellt.
Die trainierten Prüfpunkte für jede Aufgabe werden auf der Github-Release-Seite bereitgestellt. Um sie zu verwenden, laden Sie bitte diejenigen herunter, die Sie interessieren, und speichern Sie sie im Ordner ./checkpoints . Wir stellen die Namen, Trainingskonfigurationen (unter ./scripts/train/configs ) und Beschreibungen der Prüfpunkte wie folgt bereit:
| Kontrollpunkt(e) | konfigurieren | Beschreibung |
|---|---|---|
| cdrh3_design.ckpt | single_cdr_design.json | Epitop-bindendes CDR-H3-Design |
| struct_prediction.ckpt | struct_prediction.json | Vorhersage komplexer Strukturen |
| affinity_opt.ckpt & ddg_predictor.ckp | single_cdr_opt.json | Affinitätsoptimierung auf CDR-H3 |
| multi_cdr_design.ckpt | multi_cdr_design.json | Entwerfen Sie alle 6 CDRs gleichzeitig |
| multi_cdr_opt.ckpt & multi_cdr_ddg_predictor | multi_cdr_opt.json | Optimieren Sie die Affinität auf allen 6 CDRs gleichzeitig |
| full_design.ckpt | full_design.json | Entwerfen Sie den gesamten Variablenbereich, einschließlich der Framework-Region |
Daten
Um die Rohdaten vorzuverarbeiten, müssen wir zunächst Zusammenfassungen für jeden Benchmark im JSON-Format generieren, dann die Datensätze in Trainings-/Validierungs-/Testsätze aufteilen und schließlich die PDB-Daten in Python-Objekte umwandeln. Wir haben das Skript für alle diese Prozeduren in scripts/data_preprocess.sh bereitgestellt. Angenommen, die im IMGT neu nummerierten PDF-Daten befinden sich unter all_structures/imgt/ und Sie möchten die verarbeiteten Daten (~5G) unter all_data speichern, dann können Sie einfach Folgendes ausführen:
bash scripts/data_preprocess.sh all_structures/imgt all_dataDie Verarbeitung von SAbDab, RAbD, Igfold-Testsatz und SKEMPI V2.0 dauert etwa 1 Stunde. Es ist normal, dass in diesem Prozess gemeldete Fehler angezeigt werden, da einige Antikörperstrukturen falsch annotiert sind oder ein falsches Format haben, das in der Datenbereinigungsphase gelöscht wird.
(Optional) Konservierte Vorlage
Wir haben die konservierte Vorlage von SAbDab in ./data/template.json bereitgestellt. Wenn Sie am Extraktionsprozess interessiert sind, ist es auch möglich, eine konservierte Vorlage aus einem bestimmten Datensatz (z. B. dem Trainingssatz für die CDR-H3-Entwurfsaufgabe) zu extrahieren, indem Sie den folgenden Befehl ausführen:
python -m data.framework_templates
--dataset ./all_data/RAbD/train.json
--out ./data/new_template.json Wir verwenden SAbDab zum Training und RAbD zum Testen. Bitte überarbeiten Sie zunächst die Einstellungen in scripts/train/configs/cdr_design.json (Pfad zu Datensätzen und anderen Hyperparametern) und führen Sie dann den folgenden Befehl zum Training aus:
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/single_cdr_design.json Normalerweise dauert der Trainingsvorgang auf 2 GeForce RTX 2080 Ti-GPUs etwa 7 Stunden. Wir haben auch den trainierten Checkpoint unter checkpoints/cdrh3_design.ckpt bereitgestellt. Anschließend überarbeiten Sie bitte den Pfad zum Testsatz in scripts/test/test.sh und führen Sie zum Testen den folgenden Befehl aus:
GPU=0 bash scripts/test/test.sh ./checkpoints/cdrh3_design.ckpt ./all_data/RAbD/test.json ./results Dadurch werden die generierten Ergebnisse in ./results gespeichert.
Wir verwenden SAbDab zum Training und IgFold zum Testen. Das Trainings- und Testverfahren ähnelt dem des CDR-H3-Designs. Nachdem Sie die Einstellungen in scripts/train/configs/cdr_design.json und scripts/test/test.sh wie zuvor erwähnt überarbeitet haben, führen Sie bitte den folgenden Befehl zum Training aus:
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/struct_prediction.json Normalerweise dauert der Trainingsvorgang auf 2 GeForce RTX 2080 Ti-GPUs etwa 8 Stunden. Wir haben auch den trainierten Prüfpunkt unter checkpoints/struct_prediction.ckpt bereitgestellt. Führen Sie dann bitte zum Testen den folgenden Befehl aus:
GPU=0 bash scripts/test/test.sh ./checkpoints/struct_prediction.ckpt ./all_data/IgFold/test.json ./results Wir verwenden SAbDab zum Training und die Antikörper in SKEMPI V2.0 zum Testen. Bitte überarbeiten Sie ebenfalls zunächst die Einstellungen in scripts/train/configs/affinity_opt.json , scripts/test/optimize_test.sh und zusätzlich scripts/train/train_predictor.sh . Dann führen Sie bitte ein Training von dyMEANOpt durch (~ 5h):
GPU=0,1 bash scripts/train/train.sh scripts/train/configs/single_cdr_opt.jsonDann müssen wir einen Prädiktor von ddg auf die Darstellungen des generierten Komplexes trainieren (~ 40 Minuten):
GPU=0 bash scripts/train/train_predictor.sh checkpoints/cdrh3_opt.ckpt Wir haben die trainierten Prüfpunkte unter checkpoints/cdrh3_opt.ckpt und checkpoints/cdrh3_ddg_predictor.ckpt bereitgestellt. Der Optimierungstest kann durchgeführt werden durch:
GPU=0 bash scripts/test/optimize_test.sh checkpoints/cdrh3_opt.ckpt checkpoints/cdrh3_ddg_predictor.ckpt ./all_data/SKEMPI/test.json 0 50 Dadurch werden 50 Schritte der Gradientensuche ohne Einschränkungen hinsichtlich der maximalen Anzahl geänderter Reste durchgeführt (ändern Sie 0 in eine beliebige Zahl, um die Obergrenze einzuschränken).
Wir bieten auch Inferenz-APIs und In-Silico- Demos für gängige Anwendungen in realen Problemen an, die sich in ./api und ./demos befinden.
Wir stellen die Design- API und die Optimierungs -API in ./api bereit, die einfach in Python-Codes integriert werden können.
Die Design- API ( ./api/design.py ) kann zum Generieren von CDRs unter Berücksichtigung der Sequenzen der Framework-Region, der PDB-Datei des Antigens sowie der Epitopdefinitionen verwendet werden. Wir werden ein interessantes Szenario verwenden, um die Verwendung der Design- API zu veranschaulichen.
Wir wollen einen Antikörper entwickeln, der sich mit dem offenen Zustand des transienten Rezeptor-Potenzial-Kationenkanal-Subfamilie-V-Mitglieds 1 (TRPV1) verbindet, der eine entscheidende Rolle bei akuten und anhaltenden Schmerzen spielt. Anstatt das Epitop auf TRPV1 manuell herzustellen, versuchen wir, einen vorhandenen Binder nachzuahmen, bei dem es sich um ein Doppelknoten-Toxin (DkTx) handelt. Daher müssen wir zunächst die Epitopdefinition durch Analyse des Bindungsmusters des Toxins extrahieren und dann einen Antikörper mit vorgegebenen Sequenzen der Gerüstregionen entwerfen.
1. Extrahieren Sie die Epitopdefinition
Wir stellen die PDB-Datei des Komplexes des transienten Rezeptorpotential-Kationenkanal-Subfamilie-V-Mitglieds 1 (TRPV1, Kette ABCD) und des Doppelknotentoxins (DkTx, Kette EF) in ./demos/data/7l2m.pdb zur Verfügung. Die ursprüngliche PDB hat 4 symmetrische Einheiten, daher haben wir die beiden Toxine (Kette EF) manuell in der Mitte aufgeteilt, um 4 symmetrische Ketten e,f,E,F zu bilden. Jeder Antikörper muss sich nur auf eine Einheit konzentrieren. Hier wählen wir als Beispiel die Kette E.
Wir generieren die Epitopdefinition, indem wir die Bindungsschnittstelle der Kette E zum TRPV1 analysieren:
python -m api.binding_interface
--pdb ./demos/data/7l2m.pdb
--receptor A B C D
--ligand E
--out ./demos/data/E_epitope.json Jetzt wird die Epitopdefinition (d. h. die Reste von TRPV1 an der Bindungsschnittstelle) unter ./demos/data/E_epitope.json gespeichert. Indem wir den Wert des Arguments „ligand“ in e, f und F ändern, können wir die Epitopdefinitionen für andere Einheiten erhalten (vergessen Sie nicht, auch den Ausgabepfad zu überarbeiten).
2. Ermitteln Sie die Sequenzen der Rahmenregionen
Abhängig vom Endzweck des Antikörperdesigns können Gerüstregionen mit unterschiedlichen physiochemischen Eigenschaften erwünscht sein. Da wir hier nur einen Proof-of-Concept-Fall bereitstellen, wählen wir zufällig einen aus dem vorhandenen Datensatz aus:
heavy chain (H): ' QVQLKESGPGLLQPSQTLSLTCTVSGISLSDYGVHWVRQAPGKGLEWMGIIGHAGGTDYNSNLKSRVSISRDTSKSQVFLKLNSLQQEDTAMYFC----------WGQGIQVTVSSA '
light chain (L): ' YTLTQPPLVSVALGQKATITCSGDKLSDVYVHWYQQKAGQAPVLVIYEDNRRPSGIPDHFSGSNSGNMATLTISKAQAGDEADYYCQSWDGTNSAWVFGSGTKVTVLGQ 'Der ursprüngliche CDR-H3 ist durch „-“ maskiert. Das Entwerfen mehrerer CDRs wird ebenfalls unterstützt, was später erläutert wird.
3. Entwerfen Sie die CDRs
Der letzte Schritt besteht darin, die CDRs mit der Design -API zu entwerfen:
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 Diese Codes werden auch als Beispiel in ./api/design.py hinzugefügt, sodass Sie sie direkt ausführen können:
python -m api.design Hier verwenden wir „-“, um den CDR-H3 manuell zu markieren, aber Sie können auch auto_detect_cdrs=True festlegen, damit der CDR automatisch vom IMGT-Nummerierungssystem entschieden wird. Die zu entwerfenden CDR-Typen werden automatisch vom angegebenen Prüfpunkt abgeleitet. Derzeit unterstützt die API die Neugestaltung einzelner oder mehrerer CDRs sowie die Gestaltung des vollständigen Antikörpers (durch Übergabe "-" * length als Eingabe).
Durch die Aktivierung von Openmm relax wird der Generierungsprozess erheblich verlangsamt, aber die Bindungslängen und -winkel werden korrigiert, um den physikalischen Einschränkungen zu entsprechen.
Die Optimierungs -API ( ./api/optimize.py ) ist unkompliziert. Wir optimieren ./demos/data/1nca.pdb als Beispiel:
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
) Codes für dieses Beispiel werden auch zu ./api/optimize.py hinzugefügt, sodass Sie sie direkt ausführen können:
python -m api.optimizeDann erhalten Sie folgende Ergebnisse:
├── 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
wobei 1nca_original.pdb der ursprüngliche Komplex ist und 1nca_a_b.pdb das bedeutet
Die komplexe Strukturvorhersage -API ( ./api/structure_prediction.py ) sagt die komplexe Struktur anhand des Antigens, der Sequenzen der schweren Kette und der leichten Kette sowie der Definition des Epitops voraus. Das globale Andocken ist immer noch eine große Herausforderung, daher beschränken wir den Anwendungsbereich auf das interessierende Epitop. Wir sagen ./demos/data/1nca.pdb als Beispiel voraus:
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 Codes für dieses Beispiel werden auch zu ./api/structure_prediction.py hinzugefügt, sodass Sie sie direkt ausführen können:
python -m api.structure_predictionDann erhalten Sie folgende Ergebnisse:
├── demos/data
│ ├── 1nca_model_0.pdb
│ ├── 1nca_model_1.pdb
│ ├── 1nca_model_2.pdb
│ ├── ...
wobei es insgesamt 10 abgetastete Konformationen geben sollte. Beachten Sie, dass die ersten oder letzten Reste möglicherweise in den Ergebnissen verworfen werden, wenn sie gemäß dem IMGT-Nummerierungssystem außerhalb der variablen Domäne liegen.
In-vitro- Displays werden häufig zur Auswahl von Bindungsmutanten aus Antikörperbibliotheken verwendet. Hier implementieren wir eine In-silico -Version mit der Design- API, indem wir Kandidaten aus einem vorhandenen Datensatz gegen das Antigen mit einer Epitopdefinition generieren und filtern. Darüber hinaus benötigen wir eine Metrik, um zu bewerten, wie gut der erzeugte Antikörper an das Ziel bindet. Hier verwenden wir FoldX als Affinitätsprädiktor. Um diese Demo auszuführen, müssen Sie sie möglicherweise zuerst von der offiziellen Website herunterladen und den Pfad in ./configs.py entsprechend ändern. Wir verwenden immer noch das TRPV1-Beispiel im vorherigen Abschnitt und verwenden den RAbD-Benchmark als Antikörperbibliothek, die die Gerüstregionen bereitstellt:
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 0Dies führt zu 30 Kandidaten, deren Affinität von FoldX vorhergesagt wird.
Vielen Dank für Ihr Interesse an unserer Arbeit!
Bitte zögern Sie nicht, Fragen zu den Algorithmen und Codes sowie zu Problemen bei deren Ausführung zu stellen, damit wir es klarer und besser machen können. Sie können entweder ein Problem im Github-Repo erstellen oder uns unter [email protected] kontaktieren.
Die folgenden Dateien stammen aus vorhandenen Repositorys:
evaluation/TMscore.cpp : https://zhanggroup.org/TM-score/evaluation/ddg : https://github.com/HeliXonProtein/binding-ddg-predictor
