Analyze
Evaluate and characterize a set of generated SMILES across multiple quality dimensions (physicochemical, druglikeness, scaffold diversity, structural alerts, similarity to reference). Use after sampling or RL to assess molecule quality.From its SKILL.md
npx -y skills add pregHosh/Solitarius-mcp --skill analyzeAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
7.9 KB, as published. Nobody here has run it
REINVENT4 Molecule Analysis
Evaluate generated molecules using Python/RDKit/pandas directly. No MCP server needed — requires RDKit, pandas, and optionally umap-learn.
Workflow
1. Resolve paths
readlink -f <relative_path>
2. Identify inputs
smiles_file(required): sampling CSV or.smifile. Use$0if provided. SMILES column auto-detected from CSV headers (first column containing "smiles", case-insensitive).ref_smiles_file(optional): reference / known-active SMILES for novelty and similarity. Use$1if provided.output_dir: default<stem>_analysis/next to the input file.
3. Load molecules
import pandas as pd
from rdkit import Chem
from pathlib import Path
path = Path("/absolute/path/to/sampling.csv")
if path.suffix == ".csv":
df = pd.read_csv(path)
smi_col = next((c for c in df.columns if "smiles" in c.lower()), df.columns[0])
raw_smiles = df[smi_col].dropna().astype(str).tolist()
else:
raw_smiles = [l.split()[0] for l in path.read_text().splitlines() if l.strip()]
mols, valid_smiles = [], []
for smi in raw_smiles:
mol = Chem.MolFromSmiles(smi)
if mol:
mols.append(mol)
valid_smiles.append(Chem.MolToSmiles(mol))
print(f"Total: {len(raw_smiles)}, Valid: {len(mols)} ({100*len(mols)/max(len(raw_smiles),1):.1f}%)")
4. Physicochemical properties
from rdkit.Chem import Descriptors, rdMolDescriptors
import numpy as np
props = []
for mol in mols:
props.append({
"mw": Descriptors.MolWt(mol),
"logp": Descriptors.MolLogP(mol),
"tpsa": Descriptors.TPSA(mol),
"hbd": rdMolDescriptors.CalcNumHBD(mol),
"hba": rdMolDescriptors.CalcNumHBA(mol),
"rotbonds":rdMolDescriptors.CalcNumRotatableBonds(mol),
"rings": rdMolDescriptors.CalcNumRings(mol),
})
df_props = pd.DataFrame(props)
print(df_props.describe().round(2))
5. Druglikeness
from rdkit.Chem import QED
qeds = [QED.qed(mol) for mol in mols]
# Lipinski RO5
def lipinski(mol):
return (Descriptors.MolWt(mol) <= 500 and Descriptors.MolLogP(mol) <= 5 and
rdMolDescriptors.CalcNumHBD(mol) <= 5 and rdMolDescriptors.CalcNumHBA(mol) <= 10)
ro5_pass = sum(1 for mol in mols if lipinski(mol))
print(f"QED — mean: {np.mean(qeds):.3f}, median: {np.median(qeds):.3f}")
print(f"Lipinski RO5 pass: {ro5_pass}/{len(mols)} ({100*ro5_pass/max(len(mols),1):.1f}%)")
6. Synthetic accessibility and structural alerts
# SAScore (requires sascorer from rdkit-contrib or SA_Score.py)
try:
from rdkit.Chem import RDConfig
import os, sys
sa_path = os.path.join(RDConfig.RDContribDir, "SA_Score")
if sa_path not in sys.path:
sys.path.append(sa_path)
import sascorer
sa_scores = [sascorer.calculateScore(mol) for mol in mols]
print(f"SAScore — mean: {np.mean(sa_scores):.2f} (1=easy, 10=hard to synthesize)")
hard_synth = sum(1 for s in sa_scores if s > 6)
print(f"Hard to synthesize (SA>6): {hard_synth}/{len(mols)} ({100*hard_synth/max(len(mols),1):.1f}%)")
except Exception as e:
print(f"SAScore not available: {e}")
# Structural alerts: PAINS and Brenk
from rdkit.Chem.FilterCatalog import FilterCatalog, FilterCatalogParams
pains_params = FilterCatalogParams()
pains_params.AddCatalog(FilterCatalogParams.FilterCatalogs.PAINS)
pains_cat = FilterCatalog(pains_params)
brenk_params = FilterCatalogParams()
brenk_params.AddCatalog(FilterCatalogParams.FilterCatalogs.BRENK)
brenk_cat = FilterCatalog(brenk_params)
n_pains = sum(1 for mol in mols if pains_cat.HasMatch(mol))
n_brenk = sum(1 for mol in mols if brenk_cat.HasMatch(mol))
print(f"PAINS alerts: {n_pains}/{len(mols)} ({100*n_pains/max(len(mols),1):.1f}%)")
print(f"Brenk alerts: {n_brenk}/{len(mols)} ({100*n_brenk/max(len(mols),1):.1f}%)")
7. Scaffold diversity
from rdkit.Chem.Scaffolds import MurckoScaffold
scaffolds = set()
for mol in mols:
try:
scaffolds.add(Chem.MolToSmiles(MurckoScaffold.GetScaffoldForMol(mol)))
except Exception:
pass
print(f"Unique Murcko scaffolds: {len(scaffolds)}/{len(mols)} ({100*len(scaffolds)/max(len(mols),1):.1f}%)")
8. Internal diversity
from rdkit.Chem import DataStructs
from rdkit.Chem import rdMolDescriptors as rdmd
import random
fps = [rdmd.GetMorganFingerprintAsBitVect(mol, 2, 2048) for mol in mols]
# Sample up to 1000 pairs for speed
sample = random.sample(fps, min(len(fps), 200))
sims = []
for i in range(len(sample)):
for j in range(i+1, len(sample)):
sims.append(DataStructs.TanimotoSimilarity(sample[i], sample[j]))
diversity = 1 - np.mean(sims) if sims else 0.0
print(f"Internal diversity (1 - mean Tanimoto): {diversity:.3f}")
9. Similarity and novelty vs reference (if ref provided)
ref_path = Path("/absolute/path/to/reference.smi")
ref_smiles = [l.split()[0] for l in ref_path.read_text().splitlines() if l.strip()]
ref_mols = [Chem.MolFromSmiles(s) for s in ref_smiles if Chem.MolFromSmiles(s)]
ref_fps = [rdmd.GetMorganFingerprintAsBitVect(m, 2, 2048) for m in ref_mols]
ref_canon = set(Chem.MolToSmiles(m) for m in ref_mols)
nn_sims = []
for fp in fps:
sims = DataStructs.BulkTanimotoSimilarity(fp, ref_fps)
nn_sims.append(max(sims) if sims else 0.0)
novelty = sum(1 for s in valid_smiles if s not in ref_canon) / max(len(valid_smiles), 1)
print(f"Mean NN Tanimoto to reference: {np.mean(nn_sims):.3f}")
print(f"Novelty (not in reference): {100*novelty:.1f}%")
10. Generate plots
import matplotlib.pyplot as plt
from pathlib import Path
out_dir = Path("/absolute/workdir_analysis")
out_dir.mkdir(exist_ok=True)
# Physicochemical distributions
fig, axes = plt.subplots(2, 4, figsize=(16, 8))
for ax, col in zip(axes.flat, ["mw", "logp", "tpsa", "hbd", "hba", "rotbonds", "rings"]):
ax.hist(df_props[col].dropna(), bins=30, edgecolor="k", alpha=0.7)
ax.set_title(col.upper())
plt.tight_layout()
fig.savefig(out_dir / "physicochemical_dist.png", dpi=150)
plt.close(fig)
print(f"Saved: {out_dir}/physicochemical_dist.png")
# UMAP (requires umap-learn)
try:
import umap
import numpy as np
mat = np.array([list(fp.ToBitString()) for fp in fps], dtype=float)
emb = umap.UMAP(n_components=2, random_state=42).fit_transform(mat)
fig, ax = plt.subplots(figsize=(8, 6))
ax.scatter(emb[:,0], emb[:,1], s=5, alpha=0.5, label="generated")
ax.set_title("ECFP4 UMAP")
fig.savefig(out_dir / "umap_projection.png", dpi=150)
plt.close(fig)
print(f"Saved: {out_dir}/umap_projection.png")
except ImportError:
print("umap-learn not installed — skipping UMAP (pip install umap-learn)")
11. Report results and flag issues
Always report:
- Validity rate, unique molecule count
- MW / LogP / TPSA / QED means
- Lipinski RO5 pass rate
- SAScore mean (if available) and hard-to-synthesize rate
- PAINS and Brenk alert rates
- Scaffold diversity %
- Internal diversity score
If reference provided: mean NN Tanimoto, novelty %.
Flag actionable issues:
- Validity < 90% → check sampling config or SMILES source
- Lipinski pass < 70% → consider adding MW/LogP/HBD/HBA components to RL
- Scaffold diversity < 20% → tighten RL diversity filter
- Internal diversity < 0.5 → mode collapse risk
- Mean NN Tanimoto > 0.7 with low novelty → model may need more TL diversity
- SAScore mean > 5 → add SAScore reverse_sigmoid component to RL scoring
- PAINS rate > 20% → add
custom_alertsfilter to RL config
Example
/analyze reinvent_runs/sampling_20240412/sampling.csv data/known_actives.smi
/analyze reinvent_runs/sampling_20240412/sampling.csv