bayesianflow-for-chem 2.1.0__tar.gz → 2.2.2__tar.gz

{bayesianflow_for_chem-2.1.0 → bayesianflow_for_chem-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bayesianflow_for_chem
-Version: 2.1.0
+Version: 2.2.2
 Summary: Bayesian flow network framework for Chemistry
 Home-page: https://augus1999.github.io/bayesian-flow-network-for-chemistry/
 Author: Nianze A. Tao
@@ -54,12 +54,14 @@ This is the repository of the PyTorch implementation of ChemBFN model.
 
 [![PyPI](https://img.shields.io/pypi/v/bayesianflow-for-chem?color=ff69b4)](https://pypi.org/project/bayesianflow-for-chem/)
 ![pytest](https://github.com/Augus1999/bayesian-flow-network-for-chemistry/actions/workflows/pytest.yml/badge.svg)
+[![document](https://github.com/Augus1999/bayesian-flow-network-for-chemistry/actions/workflows/pages/pages-build-deployment/badge.svg)](https://augus1999.github.io/bayesian-flow-network-for-chemistry/)
 
 ## Features
 
 ChemBFN provides the state-of-the-art functionalities of
 * SMILES or SELFIES-based *de novo* molecule generation
 * Protein sequence *de novo* generation
+* Template optimisation (mol2mol)
 * Classifier-free guidance conditional generation (single or multi-objective optimisation)
 * Context-guided conditional generation (inpaint)
 * Outstanding out-of-distribution chemical space sampling
@@ -71,6 +73,7 @@ in an all-in-one-model style.
 
 ## News
 
+* [09/10/2025] A web app [`chembfn_webui`](https://github.com/Augus1999/ChemBFN-WebUI) for hosting ChemBFN models is available on [PyPI](https://pypi.org/project/chembfn-webui/).
 * [30/01/2025] The package `bayesianflow_for_chem` is available on [PyPI](https://pypi.org/project/bayesianflow-for-chem/).
 * [21/01/2025] Our first paper has been accepted by [JCIM](https://pubs.acs.org/doi/10.1021/acs.jcim.4c01792).
 * [17/12/2024] The second paper of out-of-distribution generation is available on [arxiv.org](https://arxiv.org/abs/2412.11439).
@@ -93,7 +96,7 @@ You can find pretrained models on our [🤗Hugging Face model page](https://hugg
 
 ## Dataset Handling
 
-We provide a Python class [`CSVData`](https://github.com/Augus1999/bayesian-flow-network-for-chemistry/blob/main/bayesianflow_for_chem/data.py#L152) to handle data stored in CSV or similar format containing headers to identify the entities. The following is a quickstart.
+We provide a Python class [`CSVData`](https://github.com/Augus1999/bayesian-flow-network-for-chemistry/blob/main/bayesianflow_for_chem/data.py#L153) to handle data stored in CSV or similar format containing headers to identify the entities. The following is a quickstart.
 
 1. Download your dataset file (e.g., ESOL from [MoleculeNet](https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/delaney-processed.csv)) and split the file:
 ```python

{bayesianflow_for_chem-2.1.0 → bayesianflow_for_chem-2.2.2}/README.md

@@ -9,12 +9,14 @@ This is the repository of the PyTorch implementation of ChemBFN model.
 
 [![PyPI](https://img.shields.io/pypi/v/bayesianflow-for-chem?color=ff69b4)](https://pypi.org/project/bayesianflow-for-chem/)
 ![pytest](https://github.com/Augus1999/bayesian-flow-network-for-chemistry/actions/workflows/pytest.yml/badge.svg)
+[![document](https://github.com/Augus1999/bayesian-flow-network-for-chemistry/actions/workflows/pages/pages-build-deployment/badge.svg)](https://augus1999.github.io/bayesian-flow-network-for-chemistry/)
 
 ## Features
 
 ChemBFN provides the state-of-the-art functionalities of
 * SMILES or SELFIES-based *de novo* molecule generation
 * Protein sequence *de novo* generation
+* Template optimisation (mol2mol)
 * Classifier-free guidance conditional generation (single or multi-objective optimisation)
 * Context-guided conditional generation (inpaint)
 * Outstanding out-of-distribution chemical space sampling
@@ -26,6 +28,7 @@ in an all-in-one-model style.
 
 ## News
 
+* [09/10/2025] A web app [`chembfn_webui`](https://github.com/Augus1999/ChemBFN-WebUI) for hosting ChemBFN models is available on [PyPI](https://pypi.org/project/chembfn-webui/).
 * [30/01/2025] The package `bayesianflow_for_chem` is available on [PyPI](https://pypi.org/project/bayesianflow-for-chem/).
 * [21/01/2025] Our first paper has been accepted by [JCIM](https://pubs.acs.org/doi/10.1021/acs.jcim.4c01792).
 * [17/12/2024] The second paper of out-of-distribution generation is available on [arxiv.org](https://arxiv.org/abs/2412.11439).

{bayesianflow_for_chem-2.1.0 → bayesianflow_for_chem-2.2.2}/bayesianflow_for_chem/__init__.py

@@ -3,10 +3,8 @@
 """
 ChemBFN package.
 """
-import colorama
 from . import data, tool, train, scorer, spectra
 from .model import ChemBFN, MLP, EnsembleChemBFN
-from .cli import main_script
 
 __all__ = [
     "data",
@@ -18,7 +16,7 @@ __all__ = [
     "MLP",
     "EnsembleChemBFN",
 ]
-__version__ = "2.1.0"
+__version__ = "2.2.2"
 __author__ = "Nianze A. Tao (Omozawa Sueno)"
 
 
@@ -29,6 +27,9 @@ def main() -> None:
     :return:
     :rtype: None
     """
+    import colorama
+    from bayesianflow_for_chem.cli import main_script
+
     colorama.just_fix_windows_console()
     main_script(__version__)
     colorama.deinit()

{bayesianflow_for_chem-2.1.0 → bayesianflow_for_chem-2.2.2}/bayesianflow_for_chem/cli.py

@@ -12,22 +12,17 @@ from pathlib import Path
 from functools import partial
 from typing import List, Tuple, Dict, Union, Callable
 import torch
-import lightning as L
 from rdkit.Chem import MolFromSmiles, CanonSmiles
-from torch.utils.data import DataLoader
-from lightning.pytorch import loggers
-from lightning.pytorch.callbacks import ModelCheckpoint
 from bayesianflow_for_chem import ChemBFN, MLP
-from bayesianflow_for_chem.train import Model
 from bayesianflow_for_chem.scorer import smiles_valid, Scorer
 from bayesianflow_for_chem.data import (
     VOCAB_COUNT,
     VOCAB_KEYS,
-    AA_VOCAB_COUNT,
-    AA_VOCAB_KEYS,
+    FASTA_VOCAB_COUNT,
+    FASTA_VOCAB_KEYS,
     load_vocab,
     smiles2token,
-    aa2token,
+    fasta2token,
     split_selfies,
     collate,
     CSVData,
@@ -90,6 +85,7 @@ checkpoint_save_path = "home/user/project/ckpt"
 train_strategy = "auto"  # or any strategy supported by Lightning, e.g., "ddp"
 accumulate_grad_batches = 1
 enable_progress_bar = false
+plugin_script = ""  # define customised behaviours of dataset, datasetloader, etc in a python script
 
 # Remove this table if inference is unnecessary
 [inference]
@@ -120,6 +116,49 @@ madmadmadmadmadmadmadmadmadmadmadmadmadmadmad
 madmadmadmadmadmadmadmadmadmadmadmadmadmadmad
 """
 
+_END_MESSAGE = r"""
+If you find this project helpful, please cite us:
+1. N. Tao, and M. Abe, J. Chem. Inf. Model., 2025, 65, 1178-1187.
+2. N. Tao, 2024, arXiv:2412.11439.
+"""
+
+_ERROR_MESSAGE = r"""
+Some who believe in inductive logic are anxious to point out, with
+Reichenbach, that 'the principle of induction is unreservedly accepted
+by the whole of science and that no man can seriously doubt this
+principle in everyday life either'. Yet even supposing this were the
+case—for after all, 'the whole of science' might err—I should still
+contend that a principle of induction is superfluous, and that it must
+lead to logical inconsistencies.  
+                        -- Karl Popper --
+"""
+
+_ALLOWED_PLUGINS = [
+    "collate_fn",
+    "num_workers",
+    "max_sequence_length",
+    "shuffle",
+    "CustomData",
+]
+
+
+def _load_plugin(plugin_file: str) -> Dict[str, Union[int, Callable, object, None]]:
+    if not plugin_file:
+        return {n: None for n in _ALLOWED_PLUGINS}
+    from importlib import util as iutil
+
+    spec = iutil.spec_from_file_location(Path(plugin_file).stem, plugin_file)
+    plugins = iutil.module_from_spec(spec)
+    spec.loader.exec_module(plugins)
+    plugin_names: List[str] = plugins.__all__
+    plugin_dict = {}
+    for n in _ALLOWED_PLUGINS:
+        if n in plugin_names:
+            plugin_dict[n] = getattr(plugins, n)
+        else:
+            plugin_dict[n] = None
+    return plugin_dict
+
 
 def parse_cli(version: str) -> argparse.Namespace:
     """
@@ -267,6 +306,14 @@ def load_runtime_config(
                     f"\033[0;31mCritical\033[0;0m in {config_file}: Restart checkpoint file {ckpt_file} does not exist."
                 )
                 flag_critical += 1
+        # ↓ added in v2.2.0; need to be compatible with old versions.
+        plugin_script: str = config["train"].get("plugin_script", "")
+        if plugin_script:
+            if not os.path.exists(plugin_script):
+                print(
+                    f"\033[0;31mCritical\033[0;0m in {config_file}: Plugin script {plugin_script} does not exist."
+                )
+                flag_critical += 1
     if "inference" in config:
         if not "train" in config:
             if not isinstance(config["inference"]["sequence_length"], int):
@@ -335,14 +382,15 @@ def main_script(version: str) -> None:
                 )
                 flag_warning += 1
         if not os.path.exists(runtime_config["train"]["checkpoint_save_path"]):
-            os.makedirs(runtime_config["train"]["checkpoint_save_path"])
+            if not parser.dryrun:  # only create it in real tasks
+                os.makedirs(runtime_config["train"]["checkpoint_save_path"])
     else:
         if not model_config["ChemBFN"]["base_model"]:
             print(
                 f"\033[0;33mWarning\033[0;0m in {parser.model_config}: You should load a pretrained ChemBFN model."
             )
             flag_warning += 1
-        if not model_config["MLP"]["base_model"]:
+        if "MLP" in model_config and not model_config["MLP"]["base_model"]:
             print(
                 f"\033[0;33mWarning\033[0;0m in {parser.model_config}: You should load a pretrained MLP."
             )
@@ -350,18 +398,22 @@ def main_script(version: str) -> None:
     if "inference" in runtime_config:
         if runtime_config["inference"]["guidance_objective"]:
             if not "MLP" in model_config:
-                print(f"Warning in {parser.model_config}: Oh no, you don't have a MLP.")
+                print(
+                    f"\033[0;33mWarning\033[0;0m in {parser.model_config}: Oh no, you don't have a MLP."
+                )
                 flag_warning += 1
     if parser.dryrun:
         if flag_critical != 0:
             print("Configuration check failed!")
         elif flag_warning != 0:
-            print("Your job will probably run, but it may not follow your expectation.")
+            print(
+                "Your job will probably run, but it may not follow your expectations."
+            )
         else:
             print("Configuration check passed.")
         return
     if flag_critical != 0:
-        raise RuntimeError
+        raise RuntimeError(_ERROR_MESSAGE)
     print(_MESSAGE.format(version))
     # ####### build tokeniser #######
     tokeniser_config = runtime_config["tokeniser"]
@@ -371,9 +423,9 @@ def main_script(version: str) -> None:
         vocab_keys = VOCAB_KEYS
         tokeniser = smiles2token
     if tokeniser_name == "fasta":
-        num_vocab = AA_VOCAB_COUNT
-        vocab_keys = AA_VOCAB_KEYS
-        tokeniser = aa2token
+        num_vocab = FASTA_VOCAB_COUNT
+        vocab_keys = FASTA_VOCAB_KEYS
+        tokeniser = fasta2token
     if tokeniser_name == "selfies":
         vocab_data = load_vocab(tokeniser_config["vocab"])
         num_vocab = vocab_data["vocab_count"]
@@ -415,6 +467,15 @@ def main_script(version: str) -> None:
         mlp = None
     # ------- train -------
     if "train" in runtime_config:
+        import lightning as L
+        from torch.utils.data import DataLoader
+        from lightning.pytorch import loggers
+        from lightning.pytorch.callbacks import ModelCheckpoint
+        from bayesianflow_for_chem.train import Model
+
+        # ####### get plugins #######
+        plugin_file = runtime_config["train"].get("plugin_script", "")
+        plugins = _load_plugin(plugin_file)
         # ####### build scorer #######
         if (tokeniser_name == "smiles" or tokeniser_name == "safe") and runtime_config[
             "train"
@@ -428,30 +489,43 @@ def main_script(version: str) -> None:
         mol_tag = runtime_config["train"]["molecule_tag"]
         obj_tag = runtime_config["train"]["objective_tag"]
         dataset_file = runtime_config["train"]["dataset"]
-        with open(dataset_file, "r") as db:
-            _data = db.readlines()
-        header = _data[0]
-        mol_idx = []
-        for i, tag in enumerate(header.replace("\n", "").split(",")):
-            if tag == mol_tag:
-                mol_idx.append(i)
-        _data_len = []
-        for i in _data[1:]:
-            i = i.replace("\n", "").split(",")
-            _mol = ".".join([i[j] for j in mol_idx])
-            _data_len.append(tokeniser(_mol).shape[-1])
-        lmax = max(_data_len)
-        dataset = CSVData(dataset_file)
+        if plugins["max_sequence_length"]:
+            lmax = plugins["max_sequence_length"]
+        else:
+            with open(dataset_file, "r") as db:
+                _data = db.readlines()
+            _header = _data[0]
+            _mol_idx = []
+            for i, tag in enumerate(_header.replace("\n", "").split(",")):
+                if tag == mol_tag:
+                    _mol_idx.append(i)
+            _data_len = []
+            for i in _data[1:]:
+                i = i.replace("\n", "").split(",")
+                _mol = ".".join([i[j] for j in _mol_idx])
+                _data_len.append(tokeniser(_mol).shape[-1])
+            lmax = max(_data_len)
+            del _data, _data_len, _header, _mol_idx  # clear memory
+        if plugins["CustomData"] is not None:
+            dataset = plugins["CustomData"](dataset_file)
+        else:
+            dataset = CSVData(dataset_file)
         dataset.map(
             partial(_encode, mol_tag=mol_tag, obj_tag=obj_tag, tokeniser=tokeniser)
         )
         dataloader = DataLoader(
             dataset,
             runtime_config["train"]["batch_size"],
-            True,
-            num_workers=4,
-            collate_fn=collate,
-            persistent_workers=True,
+            True if plugins["shuffle"] is None else plugins["shuffle"],
+            num_workers=4 if plugins["num_workers"] is None else plugins["num_workers"],
+            collate_fn=(
+                collate if plugins["collate_fn"] is None else plugins["collate_fn"]
+            ),
+            persistent_workers=(
+                True
+                if (plugins["num_workers"] is None or plugins["num_workers"] > 0)
+                else False
+            ),
         )
         # ####### build trainer #######
         logger_name = runtime_config["train"]["logger_name"].lower()
@@ -530,6 +604,7 @@ def main_script(version: str) -> None:
         if "train" in runtime_config:
             bfn = model.model
             mlp = model.mlp
+        # ↓ added in v2.1.0; need to be compatible with old versions
         lora_scaling = runtime_config["inference"].get("lora_scaling", 1.0)
         # ####### strat inference #######
         bfn.semi_autoregressive = runtime_config["inference"]["semi_autoregressive"]
@@ -622,6 +697,7 @@ def main_script(version: str) -> None:
             f.write("\n".join(mols))
     # ------- finished -------
     print(" ####### job finished #######")
+    print(_END_MESSAGE)
 
 
 if __name__ == "__main__":

{bayesianflow_for_chem-2.1.0 → bayesianflow_for_chem-2.2.2}/bayesianflow_for_chem/data.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # Author: Nianze A. TAO (Omozawa SUENO)
 """
-Tokenise SMILES/SAFE/SELFIES/protein-sequence strings.
+Tokenise SMILES/SAFE/SELFIES/FASTA strings.
 """
 import os
 import re
@@ -14,7 +14,7 @@ from torch.utils.data import Dataset
 
 __filedir__ = Path(__file__).parent
 
-SMI_REGEX_PATTERN = (
+_SMI_REGEX_PATTERN = (
     r"(\[|\]|H[e,f,g,s,o]?|"
     r"L[i,v,a,r,u]|"
     r"B[e,r,a,i,h,k]?|"
@@ -31,11 +31,11 @@ SMI_REGEX_PATTERN = (
     r"\(|\)|\.|=|#|-|\+|\\|\/|:|"
     r"~|@|\?|>>?|\*|\$|\%[0-9]{2}|[0-9])"
 )
-SEL_REGEX_PATTERN = r"(\[[^\]]+]|\.)"
-AA_REGEX_PATTERN = r"(A|B|C|D|E|F|G|H|I|K|L|M|N|P|Q|R|S|T|V|W|Y|Z|-|.)"
-smi_regex = re.compile(SMI_REGEX_PATTERN)
-sel_regex = re.compile(SEL_REGEX_PATTERN)
-aa_regex = re.compile(AA_REGEX_PATTERN)
+_SEL_REGEX_PATTERN = r"(\[[^\]]+]|\.)"
+_FAS_REGEX_PATTERN = r"(A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|-|\*|\.)"
+_smi_regex = re.compile(_SMI_REGEX_PATTERN)
+_sel_regex = re.compile(_SEL_REGEX_PATTERN)
+_fas_regex = re.compile(_FAS_REGEX_PATTERN)
 
 
 def load_vocab(
@@ -61,15 +61,16 @@ def load_vocab(
     }
 
 
-_DEFUALT_VOCAB = load_vocab(__filedir__ / "vocab.txt")
+_DEFUALT_VOCAB = load_vocab(__filedir__ / "_data/vocab.txt")
 VOCAB_KEYS: List[str] = _DEFUALT_VOCAB["vocab_keys"]
 VOCAB_DICT: Dict[str, int] = _DEFUALT_VOCAB["vocab_dict"]
 VOCAB_COUNT: int = _DEFUALT_VOCAB["vocab_count"]
-AA_VOCAB_KEYS = (
-    VOCAB_KEYS[0:3] + "A B C D E F G H I K L M N P Q R S T V W Y Z - .".split()
+FASTA_VOCAB_KEYS = (
+    VOCAB_KEYS[0:3]
+    + "A B C D E F G H I K L M N P Q R S T V W Y Z - . J O U X *".split()
 )
-AA_VOCAB_COUNT = len(AA_VOCAB_KEYS)
-AA_VOCAB_DICT = dict(zip(AA_VOCAB_KEYS, range(AA_VOCAB_COUNT)))
+FASTA_VOCAB_COUNT = len(FASTA_VOCAB_KEYS)
+FASTA_VOCAB_DICT = dict(zip(FASTA_VOCAB_KEYS, range(FASTA_VOCAB_COUNT)))
 
 
 def smiles2vec(smiles: str) -> List[int]:
@@ -81,21 +82,21 @@ def smiles2vec(smiles: str) -> List[int]:
     :return: tokens w/o `<start>` and `<end>`
     :rtype: list
     """
-    tokens = [token for token in smi_regex.findall(smiles)]
+    tokens = [token for token in _smi_regex.findall(smiles)]
     return [VOCAB_DICT[token] for token in tokens]
 
 
-def aa2vec(aa_seq: str) -> List[int]:
+def fasta2vec(fasta: str) -> List[int]:
     """
-    Protein sequence tokenisation using a dataset-independent regex pattern.
+    FASTA sequence tokenisation using a dataset-independent regex pattern.
 
-    :param aa_seq: protein (amino acid) sequence
-    :type aa_seq: str
+    :param fasta: protein (amino acid) sequence
+    :type fasta: str
     :return: tokens w/o `<start>` and `<end>`
     :rtype: list
     """
-    tokens = [token for token in aa_regex.findall(aa_seq)]
-    return [AA_VOCAB_DICT[token] for token in tokens]
+    tokens = [token for token in _fas_regex.findall(fasta)]
+    return [FASTA_VOCAB_DICT[token] for token in tokens]
 
 
 def split_selfies(selfies: str) -> List[str]:
@@ -107,7 +108,7 @@ def split_selfies(selfies: str) -> List[str]:
     :return: SELFIES vocab
     :rtype: list
     """
-    return [token for token in sel_regex.findall(selfies)]
+    return [token for token in _sel_regex.findall(selfies)]
 
 
 def smiles2token(smiles: str) -> Tensor:
@@ -115,9 +116,9 @@ def smiles2token(smiles: str) -> Tensor:
     return torch.tensor([1] + smiles2vec(smiles) + [2], dtype=torch.long)
 
 
-def aa2token(aa_seq: str) -> Tensor:
+def fasta2token(fasta: str) -> Tensor:
     # start token: <start> = 1; end token: <end> = 2
-    return torch.tensor([1] + aa2vec(aa_seq) + [2], dtype=torch.long)
+    return torch.tensor([1] + fasta2vec(fasta) + [2], dtype=torch.long)
 
 
 def collate(batch: List[Dict[str, Tensor]]) -> Dict[str, Tensor]: