omnigenome 0.3.0a0__py3-none-any.whl

omnigenome/auto/auto_bench/auto_bench_cli.py

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+# file: auto_bench_cli.py
+# time: 19:18 05/02/2025
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# Homepage: https://yangheng95.github.io
+# github: https://github.com/yangheng95
+# huggingface: https://huggingface.co/yangheng
+# google scholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# Copyright (C) 2019-2025. All Rights Reserved.
+
+import argparse
+import os
+import platform
+import sys
+import time
+
+from typing import Optional
+from omnigenome import AutoBench
+from omnigenome.src.misc.utils import fprint
+
+
+def bench_command(args: Optional[list] = None):
+    """
+    Entry point for the OmniGenome benchmark command-line interface.
+
+    This function parses command-line arguments, initializes the AutoBench,
+    and runs the evaluation.
+
+    :param args: A list of command-line arguments. If None, `sys.argv` is used.
+    """
+
+    parser = create_parser()
+    parsed_args = parser.parse_args(args)
+
+    model_path = parsed_args.model
+    fprint(f"\n>> Starting evaluation for model: {model_path}")
+
+    # Special handling for multimolecule models
+    if "multimolecule" in model_path:
+        from multimolecule import RnaTokenizer, AutoModelForTokenPrediction
+
+        tokenizer = RnaTokenizer.from_pretrained(model_path)
+        model = AutoModelForTokenPrediction.from_pretrained(
+            model_path, trust_remote_code=True
+        ).base_model
+    else:
+        tokenizer = parsed_args.tokenizer
+        model = model_path
+
+    # Initialize benchmark
+    autobench = AutoBench(
+        benchmark=parsed_args.benchmark,
+        model_name_or_path=model,
+        tokenizer=tokenizer,
+        overwrite=parsed_args.overwrite,
+        trainer=parsed_args.trainer,
+    )
+
+    # Run evaluation
+    autobench.run(**vars(parsed_args))
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """
+    Creates the argument parser for the benchmark CLI.
+
+    :return: An `argparse.ArgumentParser` instance.
+    """
+    parser = argparse.ArgumentParser(
+        description="Genomic Foundation Model Benchmark Suite (Single Model)",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    # Required argument
+    parser.add_argument(
+        "-b",
+        "--benchmark",
+        type=str,
+        default="RGB",
+        # choices=["RGB", "PGB", "GUE", "GB", "BEACON"],
+        help="Path to the BEACON benchmark root directory.",
+    )
+    parser.add_argument(
+        "-t",
+        "--tokenizer",
+        type=str,
+        default=None,
+        help="Path to the tokenizer to use (HF tokenizer ID or local path).",
+    )
+
+    parser.add_argument(
+        "-m",
+        "--model",
+        type=str,
+        required=True,
+        help="Path to the model to evaluate (HF model ID or local path).",
+    )
+
+    # Optional arguments
+    parser.add_argument(
+        "--overwrite",
+        type=bool,
+        default=False,
+        help="Overwrite existing bench results, otherwise resume from benchmark checkpoint.",
+    )
+    parser.add_argument(
+        "--bs_scale",
+        type=int,
+        default=1,
+        help="Batch size scale factor. To increase GPU memory utilization, set to 2 or 4, etc.",
+    )
+    parser.add_argument(
+        "--trainer",
+        type=str,
+        default="accelerate",
+        choices=["native", "accelerate", "hf_trainer"],
+        help="Trainer to use for training. \n"
+        "Use 'accelerate' for distributed training. Set to false to disable. "
+        "You can use 'accelerate config' to customize behavior.\n"
+        "Use 'hf_trainer' for Hugging Face Trainer. \n"
+        "Set to 'native' to use native PyTorch training loop.\n",
+    )
+    parser.add_argument(
+        "--autocast",
+        type=str,
+        default="fp16",
+        choices=["fp16", "fp32", "bf16", "fp8", "no"],
+        help="Automatic mixed precision training mode.",
+    )
+
+    return parser
+
+
+def run_bench():
+    """
+    Wrapper function to run the benchmark command.
+
+    This function sets up logging, constructs the command to execute
+    (potentially with `accelerate launch`), and runs it.
+    """
+    fprint("Running benchmark, this may take a while, please be patient...")
+    fprint("You can find the logs in the 'autobench_logs' directory.")
+    fprint("You can find the metrics in the 'autobench_evaluations' directory.")
+    fprint(
+        "If you don't intend to use accelerate, please add '--trainer native' false' to the command."
+    )
+    fprint(
+        "If you want to alter accelerate's behavior, please refer to 'accelerate config' command."
+    )
+    fprint("If you encounter any issues, please report them on the GitHub repository.")
+    os.makedirs("autobench_logs", exist_ok=True)
+    time_str = time.strftime("%Y-%m-%d-%H-%M-%S")
+    log_file = f"autobench_logs/AutoBench-{time_str}.log"
+    from pathlib import Path
+
+    try:
+        mixed_precision = sys.argv[sys.argv.index("--autocast") + 1].lower()
+    except ValueError:
+        mixed_precision = "fp16"
+    file_path = Path(__file__).resolve()
+    if (
+        "--trainer" in sys.argv
+        and sys.argv[sys.argv.index("--trainer") + 1].lower() == "native"
+    ):
+        cmd_base = f'python "{file_path}" ' + " ".join(sys.argv[1:])
+    else:
+        cmd_base = (
+            f'accelerate launch --mixed_precision "{mixed_precision}" "{file_path}" '
+            + " ".join(sys.argv[1:])
+        )
+
+    # Use platform-specific tee commands:
+    if platform.system() == "Windows":
+        # On Windows, use PowerShell's tee-object.
+        # The command below launches PowerShell and passes the tee-object command.
+        # try:
+        #     cmd = f"{cmd_base} 2>&1 | powershell -Command Get-Content {log_file} -Wait"
+        # except Exception as e:
+        #     fprint(f"The log file cannot be saved due to Error: {e}")
+        #     fprint(
+        #         "If commands not allowed in PowerShell, "
+        #         "please run 'Set-ExecutionPolicy RemoteSigned' in PowerShell with Admin."
+        #     )
+        cmd = f"{cmd_base} 2>&1"
+    else:
+        # On Unix-like systems, use the standard tee command.
+        cmd = f"{cmd_base} 2>&1 | tee '{log_file}'"
+
+    # Execute the command.
+    sys.exit(os.system(cmd))
+
+    # # 匹配tqdm进度条的正则表达式（根据实际输出调整）
+    # tqdm_pattern = re.compile(r'^.*\d+%\|.*\|\s+\d+/\d+\s+\[.*\]\s*$')
+    #
+    # last_tqdm_line = ''
+    #
+    # with open(log_file, 'w', encoding='utf-8') as log_file:
+    #     # 执行命令并捕获输出流
+    #     proc = subprocess.Popen(
+    #         cmd_base,
+    #         shell=True,
+    #         stdout=subprocess.PIPE,
+    #         stderr=subprocess.STDOUT,
+    #         bufsize=1,
+    #         universal_newlines=True
+    #     )
+    #
+    #     # 实时处理输出流
+    #     for line in proc.stdout:
+    #         line = line.rstrip()  # 移除行尾换行符
+    #         if tqdm_pattern.match(line):
+    #             # 更新最后一行tqdm输出
+    #             last_tqdm_line = line + '\n'  # 换行符需要手动添加
+    #             # 实时显示进度条（覆盖模式）
+    #             sys.stdout.write('\r' + line)
+    #             sys.stdout.flush()
+    #         else:
+    #             # 写入日志并正常打印
+    #             log_file.write(line + '\n')
+    #             print(line)
+    #
+    #     # 命令执行完毕后写入最后一个tqdm进度条
+    #     if last_tqdm_line:
+    #         log_file.write(last_tqdm_line)
+    #         sys.stdout.write('\n')  # 最后换行避免覆盖
+    #
+    # sys.exit(proc.returncode)
+
+
+if __name__ == "__main__":
+    bench_command()

omnigenome/auto/auto_bench/auto_bench_config.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+# file: auto_bench_config.py
+# time: 14:58 29/04/2024
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# github: https://github.com/yangheng95
+# huggingface: https://huggingface.co/yangheng
+# google scholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# Copyright (C) 2019-2024. All Rights Reserved.
+from argparse import Namespace
+
+from transformers import PretrainedConfig
+
+from .config_check import config_check
+
+
+class AutoBenchConfig(PretrainedConfig):
+    """
+    A configuration class for AutoBench, extending `transformers.PretrainedConfig`.
+
+    This class holds the configuration parameters for a benchmark run. It behaves
+    like a dictionary and also tracks how many times each parameter is accessed.
+    """
+
+    def __init__(self, args=None, **kwargs):
+        """
+        Initializes the AutoBenchConfig.
+
+        :param args: A dictionary or `argparse.Namespace` of parameters.
+        :param kwargs: Additional keyword arguments for `PretrainedConfig`.
+        """
+        if not args:
+            args = {}
+        super().__init__(**kwargs)
+
+        if isinstance(args, Namespace):
+            self.args = vars(args)
+            self.args_call_count = {arg: 0 for arg in vars(args)}
+        else:
+            self.args = args
+            self.args_call_count = {arg: 0 for arg in args}
+
+    def __getattribute__(self, arg_name):
+        """
+        Get the value of an argument and increment its call count.
+
+        :param arg_name: The name of the argument.
+        :return: The value of the argument.
+        """
+        if arg_name == "args" or arg_name == "args_call_count":
+            return super().__getattribute__(arg_name)
+        try:
+            value = super().__getattribute__("args")[arg_name]
+            args_call_count = super().__getattribute__("args_call_count")
+            args_call_count[arg_name] += 1
+            super().__setattr__("args_call_count", args_call_count)
+            return value
+
+        except Exception as e:
+            return super().__getattribute__(arg_name)
+
+    def __setattr__(self, arg_name, value):
+        """
+        Set the value of an argument and add it to the argument dict and call count dict.
+
+        :param arg_name: The name of the argument.
+        :param value: The value of the argument.
+        """
+        if arg_name == "args" or arg_name == "args_call_count":
+            super().__setattr__(arg_name, value)
+            return
+        try:
+            args = super().__getattribute__("args")
+            args[arg_name] = value
+            super().__setattr__("args", args)
+            args_call_count = super().__getattribute__("args_call_count")
+
+            if arg_name in args_call_count:
+                super().__setattr__("args_call_count", args_call_count)
+
+            else:
+                args_call_count[arg_name] = 0
+                super().__setattr__("args_call_count", args_call_count)
+
+        except Exception as e:
+            super().__setattr__(arg_name, value)
+
+    def get(self, key, default=None):
+        """
+        Get the value of a key from the parameter dict. If the key is found, increment its call frequency.
+        :param key: The key to look for in the parameter dict.
+        :param default: The default value to return if the key is not found.
+        :return: The value of the key in the parameter dict, or the default value if the key is not found.
+        """
+        if key in self.args_call_count:
+            self.args_call_count[key] += 1
+        return self.args.get(key, default)
+
+    def update(self, *args, **kwargs):
+        """
+        Update the parameter dict with the given arguments and keyword arguments, and check if the updated configuration is valid.
+        :param args: Positional arguments to update the parameter dict.
+        :param kwargs: Keyword arguments to update the parameter dict.
+        """
+        self.args.update(*args, **kwargs)
+        config_check(self.args)
+
+    def pop(self, *args):
+        """
+        Pop a value from the parameter dict.
+        :param args: Arguments to pop from the parameter dict.
+        :return: The value popped from the parameter dict.
+        """
+        return self.args.pop(*args)
+
+    def keys(self):
+        """
+        Get a list of all keys in the parameter dict.
+        :return: A list of all keys in the parameter dict.
+        """
+        return self.args.keys()
+
+    def values(self):
+        """
+        Get a list of all values in the parameter dict.
+        :return: A list of all values in the parameter dict.
+        """
+        return self.args.values()
+
+    def items(self):
+        """
+        Get a list of all key-value pairs in the parameter dict.
+        :return: A list of all key-value pairs in the parameter dict.
+        """
+        return self.args.items()
+
+    def __str__(self):
+        """
+        Get a string representation of the parameter dict.
+        :return: A string representation of the parameter dict.
+        """
+        return str(self.args)
+
+    def __repr__(self):
+        """
+        Return a detailed string representation of the configuration,
+        including all parameters and the frequency of their access.
+        """
+        param_list = []
+        for key, value in self.args.items():
+            count = self.args_call_count.get(key, 0)
+            param_list.append(f"{key}={value!r} (accessed {count} times)")
+        params_str = ", ".join(param_list)
+        return f"{self.__class__.__name__}({params_str})"
+
+    def __len__(self):
+        """
+        Return the number of items in the parameter dict.
+        """
+        return len(self.args)
+
+    def __iter__(self):
+        """
+        Return an iterator over the keys of the parameter dict.
+        """
+        return iter(self.args)
+
+    def __contains__(self, item):
+        """
+        Check if the given item is in the parameter dict.
+        :param item: The item to check.
+        :return: True if the item is in the parameter dict, False otherwise.
+        """
+        return item in self.args
+
+    def __getitem__(self, item):
+        """
+        Get the value of a key from the parameter dict.
+        :param item: The key to look for in the parameter dict.
+        :return: The value of the key in the parameter dict.
+        """
+        return self.args[item]
+
+    def __setitem__(self, key, value):
+        """
+        Set the value of a key in the parameter dict. Also set the call frequency of the key to 0 and check if the updated
+        configuration is valid.
+        :param key: The key to set the value for in the parameter dict.
+        :param value: The value to set for the key in the parameter dict.
+        """
+        self.args[key] = value
+        self.args_call_count[key] = 0
+        config_check(self.args)
+
+    def __delitem__(self, key):
+        """
+        Delete a key-value pair from the parameter dict and check if the updated configuration is valid.
+        :param key: The key to delete from the parameter dict.
+        """
+        del self.args[key]
+        config_check(self.args)
+
+    def __eq__(self, other):
+        """
+        Check if the parameter dict is equal to another object.
+        :param other: The other object to compare with the parameter dict.
+        :return: True if the parameter dict is equal to the other object, False otherwise.
+        """
+        return self.args == other
+
+    def __ne__(self, other):
+        """
+        Check if the parameter dict is not equal to another object.
+        :param other: The other object to compare with the parameter dict.
+        :return: True if the parameter dict is not equal to the other object, False otherwise.
+        """
+        return self.args != other

omnigenome/auto/auto_bench/config_check.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# file: config_verification.py
+# time: 02/11/2022 17:05
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# github: https://github.com/yangheng95
+# GScholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# ResearchGate: https://www.researchgate.net/profile/Heng-Yang-17/research
+# Copyright (C) 2022. All Rights Reserved.
+
+one_shot_messages = set()
+
+
+def config_check(args):
+    """
+    Performs a basic check on the configuration arguments.
+
+    This function can be expanded to include more complex validation logic
+    for the benchmark configuration.
+
+    :param args: A dictionary of configuration arguments.
+    :raises RuntimeError: If a configuration check fails.
+    """
+    try:
+        if "use_amp" in args:
+            assert args["use_amp"] in {True, False}
+        # if "patience" in args:
+        #     assert args["patience"] > 0
+
+    except AssertionError as e:
+        raise RuntimeError(
+            "Exception: {}. Some parameters are not valid, please see the main example.".format(
+                e
+            )
+        )

omnigenome/auto/auto_train/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+# file: __init__.py
+# time: 15:36 13/02/2025
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# Homepage: https://yangheng95.github.io
+# github: https://github.com/yangheng95
+# huggingface: https://huggingface.co/yangheng
+# google scholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# Copyright (C) 2019-2025. All Rights Reserved.
+"""
+This package contains modules for automated training of models.
+"""
+