MolGpKa

https://github.com/xundrug/molgpka
Admin
MolGpKa is a tool for fast and accurate prediction of the pKa values of small molecules using a...
Tokens:1,335
Snippets:13
Trust Score:5.6
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Execute pKa Prediction Workflow

Source: https://github.com/xundrug/molgpka/blob/master/src/example.ipynb

Example usage of the prediction pipeline for a specific SMILES string.

```python
mol = Chem.MolFromSmiles("CN(C)CCCN1C2=CC=CC=C2SC2=C1C=C(C=C2)C(C)=O")
base_dict, acid_dict, m = predict(mol)
atom_idx = list(base_dict.keys()) + list(acid_dict.keys())
pkas = list(base_dict.values()) + list(acid_dict.values())
drawit(m, atom_idx, pkas)
```

--------------------------------

### Train AP-DNN Model

Source: https://github.com/xundrug/molgpka/blob/master/README.md

Scripts for constructing the AP-DNN model, including data preparation and training steps.

```text
src/baseline/prepare_dataset_ap.py
src/baseline/train_ap.py
```

--------------------------------

### Define pKa Prediction and Visualization Functions

Source: https://github.com/xundrug/molgpka/blob/master/src/example.ipynb

Contains core logic for loading models, predicting pKa values for specific ionization sites, and generating 3D molecular visualizations.

```python
from rdkit import Chem
from rdkit.Chem import AllChem
from rdkit import RDLogger
RDLogger.DisableLog('rdApp.*')
from rdkit.Chem.MolStandardize import rdMolStandardize

import os.path as osp
import numpy as np
import pandas as pd

import torch
from utils.ionization_group import get_ionization_aid
from utils.descriptor import mol2vec
from utils.net import GCNNet
import py3Dmol

root = osp.abspath("")

def load_model(model_file, device="cpu"):
    model= GCNNet().to(device)
    model.load_state_dict(torch.load(model_file, map_location=device))
    model.eval()
    return model

def model_pred(m2, aid, model, device="cpu"):
    data = mol2vec(m2, aid)
    with torch.no_grad():
        data = data.to(device)
        pKa = model(data)
        pKa = pKa.cpu().numpy()
        pka = pKa[0][0]
    return pka

def predict_acid(mol):
    model_file = osp.join(root, "../models/weight_acid.pth")
    model_acid = load_model(model_file)

    acid_idxs= get_ionization_aid(mol, acid_or_base="acid")
    acid_res = {}
    for aid in acid_idxs:
        apka = model_pred(mol, aid, model_acid)
        acid_res.update({aid:apka})
    return acid_res

def predict_base(mol):
    model_file = osp.join(root, "../models/weight_base.pth")
    model_base = load_model(model_file)

    base_idxs= get_ionization_aid(mol, acid_or_base="base")
    base_res = {}
    for aid in base_idxs:
        bpka = model_pred(mol, aid, model_base) 
        base_res.update({aid:bpka})
    return base_res

def predict(mol, uncharged=True):
    if uncharged:
        un = rdMolStandardize.Uncharger()
        mol = un.uncharge(mol)
        mol = Chem.MolFromSmiles(Chem.MolToSmiles(mol))
    mol = AllChem.AddHs(mol)
    base_dict = predict_base(mol)
    acid_dict = predict_acid(mol)
    AllChem.EmbedMolecule(mol)
    return base_dict, acid_dict, mol

def drawit(m, atom_idxs, pkas, p=None, confId=-1):
    mb = Chem.MolToMolBlock(m, confId=confId)
    if p is None:
        p = py3Dmol.view(width=600, height=400)
    p.removeAllModels()
    p.addModel(mb, 'sdf')
    for pka, idx in zip(pkas, atom_idxs):
        pos = m.GetConformer().GetAtomPosition(idx)
        label = "pKa={:.3}".format(round(pka, 1))
        p.addLabel(label, {"position": {"x": pos.x, "y":pos.y, "z": pos.z}, "fontSize":10})
    p.setStyle({'stick':{'colorscheme':'greenCarbon'}})
    p.setBackgroundColor('0xeeeeee')
    p.zoomTo()
    return p.show()
```

--------------------------------

### Display Molecule Object

Source: https://github.com/xundrug/molgpka/blob/master/src/example.ipynb

Displays the RDKit molecule object.

```python
mol
```
Tokens:
Raw