Unimol Fine-Tuning : Praktischer Leitfaden für ein besseres molekulares Verständnis
Als ML-Ingenieur habe ich mit eigenen Augen die Leistungsfähigkeit von vortrainierten Modellen erlebt. In der Arzneimittelentdeckung und Materialwissenschaft ist die molekulare Modellierung entscheidend. Unimol, ein leistungsstarkes vortrainiertes Modell für molekulare Repräsentation, bietet einen signifikanten Fortschritt. Sein wahres Potenzial entfaltet sich jedoch durch das Fine-Tuning. Dieser Artikel bietet einen praktischen und konkreten Leitfaden zum Fine-Tuning von unimol und hilft Ihnen, diese Technologie für Ihre spezifischen molekularen Aufgaben zu nutzen.
Was ist Unimol und warum das Fine-Tuning?
Unimol steht für UNIversal MOLecular representation. Es ist ein tiefes Lernmodell, das auf einem umfangreichen Datensatz von Strukturen und molekularen Eigenschaften trainiert wurde. Dieses Vortraining ermöglicht es Unimol, allgemeine Merkmale und Beziehungen innerhalb von Molekülen zu lernen, was es hervorragend macht, um chemische Intuition zu erfassen.
Obwohl die vortrainierten Gewichte von Unimol von guter Qualität sind, sind sie allgemein. Ihre spezifische Aufgabe – Vorhersage der Bindungsaffinität, Löslichkeit oder Reaktions Ergebnisse – hat einzigartige Nuancen. Das Fine-Tuning passt diese allgemeinen Repräsentationen von Unimol an Ihren spezifischen Bereich und Datensatz an. Dieser Prozess verfeinert das Verständnis des Modells und führt zu signifikant verbesserten prädiktiven Leistungen im Vergleich zur Verwendung von Unimol als festem Merkmalsextraktor oder zum Training eines Modells von Grund auf. Das Fine-Tuning von unimol dreht sich um die Spezialisierung.
Voraussetzungen für das Fine-Tuning von Unimol
Bevor Sie den Code erkunden, stellen Sie sicher, dass Sie Folgendes haben:
* **Eine gut definierte Aufgabe:** Was möchten Sie genau vorhersagen oder klassifizieren? Klare Ziele sind entscheidend.
* **Ein qualitativ hochwertiger Datensatz:** Dies ist von größter Bedeutung. Ihr Datensatz sollte relevant für Ihre Aufgabe, sauber und groß genug sein. Für molekulare Aufgaben bedeutet dies SMILES-Stränge, molekulare Graphen oder 3D-Koordinaten, zusammen mit den entsprechenden Zielwerten (z. B. experimentellen Messungen, Etiketten).
* **Rechenressourcen:** Das Fine-Tuning großer Modelle wie Unimol erfordert GPUs. Die spezifischen Anforderungen hängen von der Größe Ihres Datensatzes und der Modellarchitektur ab, aber erwarten Sie, mindestens eine moderne GPU (z. B. NVIDIA V100, A100) zu benötigen.
* **Vertrautheit mit Deep-Learning-Frameworks:** PyTorch wird häufig für Unimol verwendet. Grundlegendes Verständnis des Ladens von Daten, der Modellerstellung und der Trainingsschleifen ist hilfreich.
* **Unimol-Bibliothek:** Sie müssen die Unimol-Bibliothek und ihre Abhängigkeiten installieren. Dies beinhaltet in der Regel `pip install unimol`.
Vorbereitung Ihrer molekularen Daten für das Fine-Tuning
Die Datenvorbereitung ist oft der zeitaufwendigsten Teil eines jeden maschinellen Lernprojekts. Für das Fine-Tuning von unimol umfasst dies mehrere Schritte:
1. Datensammlung und -bereinigung
Versammeln Sie Ihre experimentellen oder simulierten Daten. Stellen Sie Einheitlichkeit sicher, entfernen Sie Ausreißer und behandeln Sie fehlende Werte angemessen. Bei molekularen Strukturen validieren Sie die SMILES-Stränge oder stellen Sie sicher, dass die 3D-Koordinaten chemisch sinnvoll sind.
2. Molekulare Repräsentation
Unimol verwendet hauptsächlich 3D-molekulare Graphrepräsentationen. Obwohl Sie oft 3D-Koordinaten aus SMILES generieren können, ist es in der Regel besser, hochwertige experimentelle oder optimierte Strukturen zu verwenden (z. B. aus PDB, PubChem 3D). Die Unimol-Bibliothek bietet Hilfsprogramme zur Umwandlung verschiedener molekularer Formate in ihr internes Format.
* **SMILES nach 3D:** Verwenden Sie RDKit oder ähnliche Bibliotheken, um Konformer zu generieren. Optimieren Sie diese Konformer dann mit einem Kraftfeld (z. B. MMFF94, UFF), um stabilere Strukturen zu erhalten.
* **Umgang mit mehreren Konformern:** Für flexible Moleküle haben Sie möglicherweise mehrere niederenergie-Konformer. Entscheiden Sie, ob Sie einen repräsentativen Konformer (z. B. den mit der geringsten Energie) verwenden oder Informationen aus mehreren Konformern einbeziehen möchten (z. B. Durchschnittsbildung der Vorhersagen oder Verwendung einer Konformer-Ensemble).
3. Aufteilung des Datensatzes
Teilen Sie Ihre Daten in Trainings-, Validierungs- und Testmengen auf. Eine gängige Aufteilung ist 80/10/10 oder 70/15/15. Stellen Sie sicher, dass Ihre Aufteilungen die gesamte Verteilung der Daten gut darstellen. Für molekulare Daten sollten Sie eine stratifizierte Aufteilung in Betracht ziehen, wenn Sie unausgeglichene Klassen oder Eigenschaften haben. Die Scaffold-Aufteilung kann ebenfalls wichtig sein, um sicherzustellen, dass das Modell auf einen neuen chemischen Raum verallgemeinert, nicht nur auf neue Beispiele bestehender Scaffolds.
4. Erstellen eines PyTorch-Datensatzes und DataLoader
Die Unimol-Bibliothek erwartet Daten in einem bestimmten Format. Sie werden in der Regel einen benutzerdefinierten `Dataset` PyTorch erstellen, der Ihre molekularen Strukturen und Zielwerte lädt. Die Methode `__getitem__` Ihres Datensatzes sollte die Graphdaten (häufig in Form eines Diktats, das Knoteneigenschaften, Bindungseigenschaften und Nachbarinformationen enthält) sowie das entsprechende Label/Wert zurückgeben.
“`python
import torch
from torch.utils.data import Dataset, DataLoader
from unimol.data import MoleculeDataset # Beispiel, die tatsächliche Klasse kann variieren
from rdkit import Chem
from rdkit.Chem import AllChem
class CustomMolDataset(Dataset):
def __init__(self, smiles_list, targets_list):
self.smiles_list = smiles_list
self.targets_list = targets_list
def __len__(self):
return len(self.smiles_list)
def __getitem__(self, idx):
smiles = self.smiles_list[idx]
target = self.targets_list[idx]
# Generiere 3D-Koordinaten (vereinfacht zur Veranschaulichung)
mol = Chem.MolFromSmiles(smiles)
if mol:
mol = Chem.AddHs(mol)
AllChem.EmbedMolecule(mol, AllChem.ETKDG())
AllChem.MMFFOptimizeMolecule(mol)
# Konvertiere das RDKit-Molekül in das von Unimol erwartete Graphformat
# Dieser Teil hängt stark von den spezifischen Hilfsprogrammen der Unimol-Bibliothek ab.
# Dies beinhaltet in der Regel das Extrahieren von atomaren Eigenschaften, Bindungsmerkmalen und 3D-Koordinaten.
unimol_graph_data = self._mol_to_unimol_format(mol) # Ersetzungsfunktion
return unimol_graph_data, torch.tensor(target, dtype=torch.float)
def _mol_to_unimol_format(self, mol):
# Ersetzung: Implementieren Sie die tatsächliche Umwandlung mithilfe der unimol.data-Hilfsprogramme
# Dies wird beinhalten, Knoteneigenschaften (Atomtypen, Ladungen),
# Bindungsmerkmale (Bindungstypen) und 3D-Koordinaten zu extrahieren.
# unimol.data.data_utils.get_graph_from_mol ist ein wahrscheinlicher Kandidat.
return {“coords”: torch.rand(mol.GetNumAtoms(), 3), # Beispiel
“atom_features”: torch.rand(mol.GetNumAtoms(), 10), # Beispiel
“bond_features”: torch.rand(mol.GetNumBonds(), 5), # Beispiel
“edges”: torch.randint(0, mol.GetNumAtoms(), (mol.GetNumBonds(), 2))} # Beispiel
# Beispiel für die Verwendung (ersetzen Sie durch Ihre echten Daten)
smiles_data = [“CCO”, “CC(=O)O”, “c1ccccc1”]
target_data = [1.2, 3.4, 5.6]
train_dataset = CustomMolDataset(smiles_data, target_data)
train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True)
# Sie benötigen auch einen collate_fn für die Verarbeitung unterschiedlich großer Graphen.
# Die Unimol-Bibliothek bietet in der Regel einen Standard-collate_fn oder erwartet ein bestimmtes Eingabeformat.
“`
Den Unimol-Modell für das Fine-Tuning konfigurieren
Der Kern des Fine-Tuning von unimol besteht darin, das vortrainierte Unimol-Modell zu laden und eine neue, für Ihre Aufgabe geeignete „Kopf“-Schicht anzubringen.
1. Laden des vortrainierten Unimol-Encoders
Die Unimol-Bibliothek bietet Funktionen zum Laden der vortrainierten Gewichte. Diese Gewichte stellen den molekularen Encoder dar.
“`python
from unimol.models import UnimolModel
from unimol.config import UnimolConfig # Oder ein ähnliches Konfigurationsobjekt
# Lade die vortrainierte Konfiguration (passen Sie den Pfad bei Bedarf an)
config = UnimolConfig.from_pretrained(“path/to/unimol_base_config.json”)
# Lade das vortrainierte Unimol-Modell
# Sie müssen möglicherweise den Pfad zu den tatsächlichen vortrainierten Gewichten (.pt oder .bin) angeben
unimol_encoder = UnimolModel.from_pretrained(
“path/to/unimol_base_weights.pt”, # Beispielpfad
config=config
)
unimol_encoder.eval() # In den Evaluierungsmodus wechseln, wenn Sie die Schichten des Encoders nicht initial trainieren
“`
2. Eine spezifische Köpfchen für die Aufgabe anbringen
Der Ausgang des Unimol-Encoders ist eine molekulare Darstellung (zum Beispiel ein Vektor fester Größe oder Node-Embeddings). Sie müssen ein kleines neuronales Netzwerk über dieser Darstellung hinzufügen, um Ihre spezifische Vorhersage durchzuführen.
* **Regression:** Um kontinuierliche Werte vorherzusagen (zum Beispiel die Bindungsaffinität), ist eine einfache lineare Schicht oder ein kleines MLP (Multi-Layer Perceptron) üblich.
* **Klassifikation:** Um diskrete Klassen vorherzusagen (zum Beispiel aktiv/inaktiv), verwenden Sie eine lineare Schicht, gefolgt von einer Sigmoid-Aktivierung (für binär) oder softmax (für Mehrklassen).
“`python
import torch.nn as nn
class UnimolFineTuneModel(nn.Module):
def __init__(self, unimol_encoder, num_output_features, task_type=”regression”):
super().__init__()
self.unimol_encoder = unimol_encoder
self.task_type = task_type
# Die Ausgabedimension des Unimol-Encoders hängt von seiner Konfiguration ab.
# Sie wird oft als `hidden_size` oder `embedding_dim` bezeichnet.
encoder_output_dim = self.unimol_encoder.args.encoder_embed_dim # Beispiel für den Zugriff
if task_type == “regression”:
self.prediction_head = nn.Sequential(
nn.Linear(encoder_output_dim, 256),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(256, num_output_features) # num_output_features ist 1 für die Regression mit einem einzigen Wert
)
elif task_type == “classification”:
self.prediction_head = nn.Sequential(
nn.Linear(encoder_output_dim, 256),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(256, num_output_features) # num_output_features ist die Anzahl der Klassen
)
else:
raise ValueError(“Nicht unterstützter Aufgabentyp”)
def forward(self, unimol_graph_data):
# Der Unimol-Encoder gibt in der Regel ein Wörterbuch zurück. Wir benötigen die aggregierte Darstellung.
# Der genaue Schlüssel für die aggregierte Darstellung kann variieren (zum Beispiel ‘mol_embedding’, ‘graph_embedding’).
encoder_output = self.unimol_encoder(
coords=unimol_graph_data[“coords”],
atom_features=unimol_graph_data[“atom_features”],
bond_features=unimol_graph_data[“bond_features”],
edges=unimol_graph_data[“edges”]
# Fügen Sie weitere benötigte Eingaben gemäß der forward-Methode von UnimolModel hinzu
)
# Angenommen, ‘mol_embedding’ ist die aggregierte Darstellung für das gesamte Molekül
pooled_representation = encoder_output[‘mol_embedding’]
prediction = self.prediction_head(pooled_representation)
return prediction
# Instanziieren Sie das feinabgestimmte Modell
fine_tuned_model = UnimolFineTuneModel(unimol_encoder, num_output_features=1, task_type=”regression”)
“`
Der Feinabstimmungsprozess von Unimol
Nun kombinieren Sie Ihre Daten und Ihr Modell für das Training.
1. Verlustfunktion und Optimierer definieren
* **Regression:** Die mittlere quadratische Abweichung (MSE) oder die mittlere absolute Abweichung (MAE) sind gängig.
* **Klassifikation:** Der Verlust der binären Kreuzentropie (BCE) für die binäre Klassifikation, die Kreuzentropie für die Mehrklassenklassifikation.
* **Optimierer:** AdamW ist eine gute Standardwahl, oft mit einem Lernratenplaner.
“`python
optimizer = torch.optim.AdamW(fine_tuned_model.parameters(), lr=1e-5) # Beginnen Sie mit einer niedrigen Lernrate
criterion = nn.MSELoss() # Für die Regression
“`
2. Schichten einfrieren (optional, aber empfohlen)
Zu Beginn ist es oft vorteilhaft, die Schichten des vorab trainierten Unimol-Encoders einzufrieren und nur den neu hinzugefügten Vorhersagekopf zu trainieren. Dies verhindert, dass große Gradientenaktualisierungen wertvolle vorab trainierte Gewichte verderben. Nach einigen Epochen können Sie einige oder alle Schichten des Encoders entsperren und mit einer sehr niedrigen Lernrate trainieren.
“`python
# Um die Parameter von unimol_encoder einzufrieren
for param in fine_tuned_model.unimol_encoder.parameters():
param.requires_grad = False
# Nur die Parameter im prediction_head werden aktualisiert
# Sie entsperren später:
# for param in fine_tuned_model.unimol_encoder.parameters():
# param.requires_grad = True
“`
3. Trainingsschleife
Die Trainingsschleife folgt den Standardpraktiken von PyTorch. Iterieren Sie über die Epochen, verarbeiten Sie die Chargen, berechnen Sie den Verlust, führen Sie die Rückpropagation durch und aktualisieren Sie die Gewichte.
“`python
device = torch.device(“cuda” if torch.cuda.is_available() else “cpu”)
fine_tuned_model.to(device)
num_epochs = 10
for epoch in range(num_epochs):
fine_tuned_model.train()
total_loss = 0
for batch_idx, (unimol_graph_data_batch, targets_batch) in enumerate(train_loader):
# Daten auf das Gerät verschieben
# unimol_graph_data_batch muss bearbeitet werden, um seine Tensoren auf das Gerät zu verschieben
# Beispiel: batch_coords = unimol_graph_data_batch[“coords”].to(device)
# batch_atom_features = unimol_graph_data_batch[“atom_features”].to(device)
# …
# Dies erfordert eine angemessene collate_fn in Ihrem DataLoader.
# Vereinfacht zur Veranschaulichung, in der Annahme, dass unimol_graph_data_batch bereits verschoben wurde
# oder behandeln Sie die Verschiebung in der Schleife für jeden Tensor im Dict.
# Bewegen Sie die einzelnen Tensoren im Dict auf das Gerät
processed_graph_data = {k: v.to(device) for k, v in unimol_graph_data_batch.items()}
targets_batch = targets_batch.to(device)
optimizer.zero_grad()
predictions = fine_tuned_model(processed_graph_data)
loss = criterion(predictions.squeeze(), targets_batch) # .squeeze() für die Regression mit einem einzelnen Wert
loss.backward()
optimizer.step()
total_loss += loss.item()
avg_train_loss = total_loss / len(train_loader)
print(f”Epoche {epoch+1}, Trainingsverlust: {avg_train_loss:.4f}”)
# Validierungsschritt (ähnlich implementieren)
fine_tuned_model.eval()
val_loss = 0
with torch.no_grad():
for batch_idx, (unimol_graph_data_batch, targets_batch) in enumerate(val_loader):
# Daten auf das Gerät verschieben
processed_graph_data = {k: v.to(device) for k, v in unimol_graph_data_batch.items()}
targets_batch = targets_batch.to(device)
predictions = fine_tuned_model(processed_graph_data)
loss = criterion(predictions.squeeze(), targets_batch)
val_loss += loss.item()
avg_val_loss = val_loss / len(val_loader)
print(f”Epoche {epoch+1}, Validierungsverlust: {avg_val_loss:.4f}”)
# Speichern Sie das beste Modell basierend auf dem Validierungsverlust
# …
“`
4. Hyperparameter-Tuning
* **Lernrate:** Entscheidend. Experimentieren Sie mit Werten wie 1e-4, 5e-5, 1e-5, 5e-6. Ein Lernratenplaner (zum Beispiel, cosinusbasiertes Abkühlen, ReduceLROnPlateau) ist oft nützlich.
* **Batch-Größe:** Durch den GPU-Speicher begrenzt. Größere Batch-Größen können stabilere Gradienten bieten, erfordern aber mehr Speicher.
* **Anzahl der Epochen:** Überwachen Sie den Validierungsverlust, um Überanpassung zu vermeiden. Frühes Stoppen ist wichtig.
* **Dropout:** Wenden Sie Dropout im Vorhersagekopf an, um zu regulieren.
* **Gewichtsabwurf:** Fügen Sie dem Optimierer eine L2-Regularisierung hinzu.
Bewertung und Bereitstellung
Nach dem Feinabstimmen von unimol bewerten Sie Ihr Modell anhand des noch nicht gesehenen Testdatensatzes unter Verwendung geeigneter Metriken:
* **Regression:** R-Quadrat, MAE, RMSE.
* **Klassifikation:** Genauigkeit, Präzision, Recall, F1-Score, ROC-AUC.
Sobald Sie mit der Leistung zufrieden sind, speichern Sie Ihr feinabgestimmtes Modell. Für die Bereitstellung können Sie das gespeicherte Modell laden und zur Inferenz auf neuen molekularen Daten verwenden.
“`python
# Modell speichern
torch.save(fine_tuned_model.state_dict(), “fine_tuned_unimol_model.pt”)
# Laden für Inferenz
loaded_model = UnimolFineTuneModel(unimol_encoder, num_output_features=1, task_type=”regression”)
loaded_model.load_state_dict(torch.load(“fine_tuned_unimol_model.pt”))
loaded_model.to(device)
loaded_model.eval()
# Beispiel für Inferenz
with torch.no_grad():
sample_mol_data = … # Bereiten Sie neue molekulare Daten vor
processed_sample_mol_data = {k: v.to(device) for k, v in sample_mol_data.items()}
prediction = loaded_model(processed_sample_mol_data)
print(“Vorhersage:”, prediction.item())
“`
Tipps für eine erfolgreiche Feinabstimmung von Unimol
* **Starten Sie einfach:** Beginnen Sie mit einer niedrigen Lernrate und einem eingefrorenen Encoder. Entsperren Sie schrittweise die Schichten und erhöhen Sie die Lernrate, während sich das Modell stabilisiert.
* **Überwachen Sie die Metriken:** Behalten Sie die Trainings- und Validierungsverluste/Metriken im Auge. Achten Sie auf Anzeichen von Überanpassung (der Trainingsverlust nimmt ab, der Validierungsverlust nimmt zu).
* **Datenaugmentation:** Bei molekularen Daten kann dies bedeuten, verschiedene Konformer zu generieren, Moleküle zu rotieren oder kleine Störungen anzuwenden. Das hilft dem Modell, robustere Darstellungen zu lernen.
* **Transfer-Lernstrategien:**
* **Merkmalextraktion:** Verwenden Sie Unimol, um Embeddings zu generieren, und trainieren Sie dann ein einfacheres separates Modell (z. B. SVM, XGBoost) auf diesen Embeddings. Das dient oft als gute Referenz.
* **Vollständiges Fine-Tuning:** Trainieren Sie das gesamte Unimol-Modell (Encoder + Kopf) mit einer sehr niedrigen Lernrate. Das bietet das größte Leistungspotenzial, erfordert jedoch mehr Rechenressourcen und sorgfältige Anpassung.
* **Schicht-für-Schicht-Fine-Tuning:** Entsperren und trainieren Sie zunächst die äußeren Schichten, dann entsperren Sie schrittweise die inneren Schichten.
* **Experimentieren Sie mit Architekturen:** Während ein einfacher linearer Kopf ein guter Ausgangspunkt ist, probieren Sie leicht komplexere MLPs für den Vorhersagekopf aus.
* **Nutzen Sie die Hilfsprogramme von Unimol:** Die Unimol-Bibliothek bietet verschiedene Werkzeuge für die Datenverarbeitung, den Bau von Graphen und das Laden von Modellen. Machen Sie sich mit der API vertraut, um Ihren Arbeitsablauf zu optimieren.
* **Vorberechnung:** Wenn die Generierung von 3D-Konformern langsam ist, ziehen Sie in Betracht, sie vor dem Training zu generieren und auf der Festplatte zu speichern.
Das Fine-Tuning von Unimol ist ein leistungsstarker Ansatz, um hochmoderne molekulare Darstellungen an Ihre spezifischen Aufgaben anzupassen. Wenn Sie diese praktischen Schritte befolgen, können Sie bessere Vorhersagemodelle in der Arzneimittelentdeckung, Materialwissenschaft und anderen molekularen Bereichen erzielen.
FAQ zum Fine-Tuning von Unimol
**Q1: Wie viele Daten benötige ich für das Fine-Tuning von Unimol?**
A1: Je mehr, desto besser. Obwohl das Pre-Training von Unimol bei Datenknappheit hilfreich ist, profitiert das Fine-Tuning immer noch erheblich von größeren und vielfältigeren Datensätzen. Für Regressionsaufgaben sind Hunderte bis Tausende von Datenpunkten oft ein guter Ausgangspunkt. Bei Klassifikationen, insbesondere mit mehreren Klassen, werden in der Regel mehr Daten benötigt, um klare Entscheidungsgrenzen zu lernen. Wenn Ihr Datensatz sehr klein ist (Dutzende von Proben), ziehen Sie in Betracht, Unimol als festen Merkmalsgenerator zu nutzen, anstatt das gesamte Modell zu fine-tunen.
**Q2: Was ist der Unterschied zwischen der Nutzung von Unimol als Merkmalsgenerator und dem vollständigen Fine-Tuning?**
A2: Als Merkmalsgenerator verwenden Sie das vortrainierte Unimol-Modell, um molekulare Embeddings (Vektoren fester Größe) für Ihre Moleküle zu erzeugen. Dann trainieren Sie ein einfacheres separates Modell (wie eine lineare Regression, SVM oder ein kleines MLP) auf diesen Embeddings. Die Gewichte von Unimol bleiben fix. Beim vollständigen Fine-Tuning laden Sie das vortrainierte Unimol-Modell und trainieren dessen Schichten (mit einem neuen, auf die Aufgabe zugeschnittenen Kopf) weiter mit Ihrem Datensatz. Das vollständige Fine-Tuning führt in der Regel zu besseren Leistungen, wenn Sie genügend Daten und Rechenressourcen haben, da es die internen Darstellungen von Unimol an Ihre spezifische Aufgabe anpasst.
**Q3: Wie gehe ich mit 3D-Molekülstrukturen für Unimol um?**
A3: Unimol ist darauf ausgelegt, Informationen über 3D-molekulare Graphen zu verwenden. Wenn Sie nur SMILES-Ketten haben, müssen Sie 3D-Konformer generieren. Tools wie RDKit können dies erledigen (z. B. `Chem.AllChem.EmbedMolecule`). Es wird empfohlen, diese Konformer anschließend mit einem Kraftfeld (z. B. `AllChem.MMFFOptimizeMolecule`) zu optimieren, um chemisch plausiblere Strukturen zu erhalten. Für kritische Aufgaben ist es am besten, experimentell bestimmte 3D-Strukturen (aus Datenbanken wie PDB) oder hochgradig optimierte Strukturen aus quantenchemischen Berechnungen zu verwenden. Die Unimol-Bibliothek wird dann diese 3D-Koordinaten sowie die Merkmale von Atomen und Bindungen verwenden, um ihre interne graphische Darstellung aufzubauen.
🕒 Published: