Instructions to use Delower/herg-best-deployment with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Keras
How to use Delower/herg-best-deployment with Keras:
# !pip install -U keras tensorflow huggingface_hub # Keras needs TensorFlow installed to read "hf://" paths, so the tensorflow backend is selected here; # "jax" and "torch" also work for computation once TensorFlow is installed. import os os.environ["KERAS_BACKEND"] = "tensorflow" import keras model = keras.saving.load_model("hf://Delower/herg-best-deployment") - Notebooks
- Google Colab
- Kaggle
Download predict_herg.py from Delower/herg-best-deployment: direct link, hf CLI and curl.
- Browser
- Download file 4.71 kB
-
https://huggingface.co/Delower/herg-best-deployment/resolve/main/predict_herg.py
- Command line
-
hf download hf://Delower/herg-best-deployment/predict_herg.py
-
curl -L -o predict_herg.py https://huggingface.co/Delower/herg-best-deployment/resolve/main/predict_herg.py
4.71 kB
| """Inference for Delower/herg-best-deployment (DEPLOYMENT REFIT). | |
| Predicts hERG blocker probability (10 uM, classification winner) and pIC50 | |
| (regression winner) from SMILES. Feature stack: Morgan ECFP4 bits+counts, | |
| RDKit 2D descriptors + QED + hERG-targeted physchem, ChemBERTa-77M pretrained | |
| embeddings (mean-pooled; downloads seyonec/ChemBERTa-zinc-base-v1 on first use). | |
| CDK/PaDEL descriptors are NOT used: a time-boxed PaDEL attempt stalled and the | |
| CDK slot was substituted by the RDKit 2D descriptor block (see FEATURE_NOTES.md). | |
| Requires: rdkit, numpy, scikit-learn, xgboost (if a tree is in a winner), | |
| tensorflow (if the LTN is in a winner), transformers + torch (embeddings). | |
| Usage: python predict_herg.py "CCOc1ccc..." ["SMILES2" ...] | |
| """ | |
| import sys, os, json, pickle | |
| import numpy as np | |
| HERE = os.path.dirname(os.path.abspath(__file__)) | |
| sys.path.insert(0, HERE) | |
| import feature_extraction as FE | |
| from feature_extraction import featurize_smiles | |
| CFG = json.load(open(os.path.join(HERE, "config.json"))) | |
| BLOCKS = CFG["blocks"] | |
| class ContPrep: | |
| def __init__(self, s): | |
| self.keep_ = np.array(s["keep"]); self.med_ = np.array(s["med"]) | |
| self.mu_ = np.array(s["mu"]); self.sd_ = np.array(s["sd"]); self.log1p = s["log1p"] | |
| def transform(self, X): | |
| X = np.where(np.isfinite(X), X, np.nan) | |
| if self.log1p: | |
| X = np.log1p(np.clip(X, 0, None)) | |
| X = X[:, self.keep_] | |
| X = np.where(np.isnan(X), self.med_, X) | |
| return ((X - self.mu_) / self.sd_).astype(np.float32) | |
| _CB = {} | |
| def chemberta_embed(smiles): | |
| if "model" not in _CB: | |
| import torch | |
| from transformers import AutoModel, AutoTokenizer | |
| _CB["tok"] = AutoTokenizer.from_pretrained("seyonec/ChemBERTa-zinc-base-v1") | |
| _CB["model"] = AutoModel.from_pretrained("seyonec/ChemBERTa-zinc-base-v1") | |
| _CB["model"].eval() | |
| _CB["torch"] = torch | |
| torch = _CB["torch"] | |
| enc = _CB["tok"](smiles, padding=True, truncation=True, max_length=160, return_tensors="pt") | |
| with torch.no_grad(): | |
| h = _CB["model"](**enc).last_hidden_state | |
| mask = enc["attention_mask"].unsqueeze(-1).float() | |
| return ((h * mask).sum(1) / mask.sum(1).clamp(min=1.0)).numpy().astype(np.float32) | |
| def featurize(smiles_list): | |
| raw = {b: [] for b in ["morgan", "morgan_counts", "desc", "physchem_extra", "herg"]} | |
| for smi in smiles_list: | |
| _, bl = featurize_smiles(smi) | |
| assert bl is not None, f"unparseable SMILES: {smi}" | |
| for b in raw: | |
| raw[b].append(np.asarray(bl[b], dtype=np.float32)) | |
| raw = {b: np.vstack(v) for b, v in raw.items()} | |
| raw["chemberta"] = chemberta_embed(smiles_list) | |
| return raw | |
| def assemble(raw, prep_states): | |
| preps = {b: ContPrep(s) for b, s in prep_states.items()} | |
| parts = [] | |
| for b in BLOCKS: | |
| X = np.asarray(raw[b], dtype=np.float32) | |
| if b in preps: | |
| X = preps[b].transform(X) | |
| parts.append(np.asarray(X, dtype=np.float32)) | |
| return np.hstack(parts) | |
| def predict(smiles_list): | |
| raw = featurize(smiles_list) | |
| out = {} | |
| for task in ("cls", "reg"): | |
| entry = CFG["tasks"][task] | |
| cand = entry["winner"] | |
| preds = {} | |
| if cand in ("tree", "ensemble"): | |
| with open(os.path.join(HERE, f"tree_{task}.pkl"), "rb") as fh: | |
| bundle = pickle.load(fh) | |
| X = assemble(raw, bundle["prep_states"]) | |
| mdl = bundle["model"] | |
| if task == "cls": | |
| preds["tree"] = mdl.predict_proba(X)[:, 1] | |
| elif mdl.__class__.__name__ == "Booster": | |
| import xgboost as xgb | |
| preds["tree"] = mdl.predict(xgb.DMatrix(X)) | |
| else: | |
| preds["tree"] = mdl.predict(X) | |
| if cand in ("ltn", "ensemble"): | |
| import tensorflow as tf | |
| meta = json.load(open(os.path.join(HERE, f"ltn_{task}_preps.json"))) | |
| X = assemble(raw, meta["prep_states"]) | |
| model = tf.keras.models.load_model(os.path.join(HERE, f"ltn_{task}.keras")) | |
| if task == "cls": | |
| preds["ltn"] = tf.nn.softmax(model(X, training=False), axis=1).numpy()[:, 1] | |
| else: | |
| preds["ltn"] = model(X, training=False).numpy()[:, 0] * meta["target_sd"] + meta["target_mu"] | |
| if cand == "ensemble": | |
| w = entry["ensemble_weight_on_tree"] | |
| out[task] = w * preds["tree"] + (1 - w) * preds["ltn"] | |
| else: | |
| out[task] = preds[cand] | |
| return out | |
| if __name__ == "__main__": | |
| smis = sys.argv[1:] | |
| res = predict(smis) | |
| for i, s in enumerate(smis): | |
| print(f"{s}\tprob_blocker={res['cls'][i]:.4f}\tpred_pIC50={res['reg'][i]:.3f}") | |