paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/repo_manager/utils.py

@@ -0,0 +1,298 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+import json
+import platform
+import subprocess
+import contextlib
+
+from parsley import makeGrammar
+
+
+PLATFORM = platform.system()
+
+
+def _check_call(*args, **kwargs):
+    return subprocess.check_call(*args, **kwargs)
+
+
+def _check_output(*args, **kwargs):
+    return subprocess.check_output(*args, **kwargs)
+
+
+def check_installation_using_pip(pkg):
+    """check_installation_using_pip"""
+    out = _check_output(["pip", "list", "--format", "json"])
+    out = out.rstrip()
+    lst = json.loads(out)
+    return any(ele["name"] == pkg for ele in lst)
+
+
+def uninstall_package_using_pip(pkg):
+    """uninstall_package_using_pip"""
+    return _check_call([sys.executable, "-m", "pip", "uninstall", "-y", pkg])
+
+
+def install_packages_using_pip(
+    pkgs, editable=False, req_files=None, cons_files=None, no_deps=False, pip_flags=None
+):
+    """install_packages_using_pip"""
+    args = [sys.executable, "-m", "pip", "install"]
+    if editable:
+        args.append("-e")
+    if req_files is not None:
+        for req_file in req_files:
+            args.append("-r")
+            args.append(req_file)
+    if cons_files is not None:
+        for cons_file in cons_files:
+            args.append("-c")
+            args.append(cons_file)
+    if isinstance(pkgs, str):
+        pkgs = [pkgs]
+    args.extend(pkgs)
+    if pip_flags is not None:
+        args.extend(pip_flags)
+    return _check_call(args)
+
+
+def install_deps_using_pip():
+    """install requirements"""
+    current_file_path = os.path.dirname(os.path.abspath(__file__))
+    deps_path = os.path.join(current_file_path, "requirements.txt")
+    args = [sys.executable, "-m", "pip", "install", "-r", deps_path]
+    return _check_call(args)
+
+
+def clone_repo_using_git(url, branch=None):
+    """clone_repo_using_git"""
+    args = ["git", "clone", "--depth", "1"]
+    if isinstance(url, str):
+        url = [url]
+    args.extend(url)
+    if branch is not None:
+        args.extend(["-b", branch])
+    return _check_call(args)
+
+
+def fetch_repo_using_git(branch, url, depth=1):
+    """fetch_repo_using_git"""
+    args = ["git", "fetch", url, branch, "--depth", str(depth)]
+    _check_call(args)
+
+
+def reset_repo_using_git(pointer, hard=True):
+    """reset_repo_using_git"""
+    args = ["git", "reset", "--hard", pointer]
+    return _check_call(args)
+
+
+def remove_repo_using_rm(name):
+    """remove_repo_using_rm"""
+    if os.path.exists(name):
+        if PLATFORM == "Windows":
+            return _check_call(["rmdir", "/S", "/Q", name], shell=True)
+        else:
+            return _check_call(["rm", "-rf", name])
+
+
+def build_wheel_using_pip(pkg, dst_dir="./", with_deps=False, pip_flags=None):
+    """build_wheel_using_pip"""
+    args = [sys.executable, "-m", "pip", "wheel", "--wheel-dir", dst_dir]
+    if not with_deps:
+        args.append("--no-deps")
+    if pip_flags is not None:
+        args.extend(pip_flags)
+    args.append(pkg)
+
+    return _check_call(args)
+
+
+@contextlib.contextmanager
+def mute():
+    """mute"""
+    with open(os.devnull, "w") as f:
+        with contextlib.redirect_stdout(f), contextlib.redirect_stderr(f):
+            yield
+
+
+@contextlib.contextmanager
+def switch_working_dir(new_wd):
+    """switch_working_dir"""
+    cwd = os.getcwd()
+    os.chdir(new_wd)
+    try:
+        yield
+    finally:
+        os.chdir(cwd)
+
+
+def _build_dep_spec_pep508_grammar():
+    # Refer to https://peps.python.org/pep-0508/
+    grammar = """
+        wsp           = ' ' | '\t'
+        version_cmp   = wsp* <'<=' | '<' | '!=' | '==' | '>=' | '>' | '~=' | '==='>
+        version       = wsp* <(letterOrDigit | '-' | '_' | '.' | '*' | '+' | '!')+>
+        version_one   = version_cmp:op version:v wsp* -> (op, v)
+        version_many  = version_one:v1 (wsp* ',' version_one)*:v2 -> [v1] + v2
+        versionspec   = ('(' version_many:v ')' ->v) | version_many
+        urlspec       = '@' wsp* <uri_reference>
+        marker_op     = version_cmp | (wsp* 'in') | (wsp* 'not' wsp+ 'in')
+        python_str_c  = (wsp | letter | digit | '(' | ')' | '.' | '{' | '}' |
+                        '-' | '_' | '*' | '#' | ':' | ';' | ',' | '/' | '?' |
+                        '[' | ']' | '!' | '~' | '`' | '@' | '$' | '%' | '^' |
+                        '&' | '=' | '+' | '|' | '<' | '>' )
+        dquote        = '"'
+        squote        = '\\''
+        comment       = '#' <anything*>:s end -> s
+        python_str    = (squote <(python_str_c | dquote)*>:s squote |
+                        dquote <(python_str_c | squote)*>:s dquote) -> s
+        env_var       = ('python_version' | 'python_full_version' |
+                        'os_name' | 'sys_platform' | 'platform_release' |
+                        'platform_system' | 'platform_version' |
+                        'platform_machine' | 'platform_python_implementation' |
+                        'implementation_name' | 'implementation_version' |
+                        'extra' # ONLY when defined by a containing layer
+                        )
+        marker_var    = wsp* (env_var | python_str)
+        marker_expr   = marker_var:l marker_op:o marker_var:r -> (o, l, r)
+                    | wsp* '(' marker:m wsp* ')' -> m
+        marker_and    = marker_expr:l wsp* 'and' marker_expr:r -> ('and', l, r)
+                    | marker_expr:m -> m
+        marker_or     = marker_and:l wsp* 'or' marker_and:r -> ('or', l, r)
+                        | marker_and:m -> m
+        marker        = marker_or
+        quoted_marker = ';' wsp* marker
+        identifier_end = letterOrDigit | (('-' | '_' | '.' )* letterOrDigit)
+        identifier    = <letterOrDigit identifier_end* >
+        name          = identifier
+        extras_list   = identifier:i (wsp* ',' wsp* identifier)*:ids -> [i] + ids
+        extras        = '[' wsp* extras_list?:e wsp* ']' -> e
+        name_req      = (name:n wsp* extras?:e wsp* versionspec?:v wsp* quoted_marker?:m
+                        -> (n, e or [], v or [], m))
+        url_req       = (name:n wsp* extras?:e wsp* urlspec:v (wsp+ | end) quoted_marker?:m
+                        -> (n, e or [], v, m))
+        specification = wsp* (url_req | name_req):s wsp* comment? -> s
+        # The result is a tuple - name, list-of-extras,
+        # list-of-version-constraints-or-a-url, marker-ast or None
+
+
+        uri_reference = <uri | relative_ref>
+        uri           = scheme ':' hier_part ('?' query )? ('#' fragment)?
+        hier_part     = ('//' authority path_abempty) | path_absolute | path_rootless | path_empty
+        absolute_uri  = scheme ':' hier_part ('?' query )?
+        relative_ref  = relative_part ('?' query )? ('#' fragment )?
+        relative_part = '//' authority path_abempty | path_absolute | path_noscheme | path_empty
+        scheme        = letter (letter | digit | '+' | '-' | '.')*
+        authority     = (userinfo '@' )? host (':' port )?
+        userinfo      = (unreserved | pct_encoded | sub_delims | ':')*
+        host          = ip_literal | ipv4_address | reg_name
+        port          = digit*
+        ip_literal    = '[' (ipv6_address | ipvfuture) ']'
+        ipvfuture     = 'v' hexdig+ '.' (unreserved | sub_delims | ':')+
+        ipv6_address   = (
+                        (h16 ':'){6} ls32
+                        | '::' (h16 ':'){5} ls32
+                        | (h16 )?  '::' (h16 ':'){4} ls32
+                        | ((h16 ':')? h16 )? '::' (h16 ':'){3} ls32
+                        | ((h16 ':'){0,2} h16 )? '::' (h16 ':'){2} ls32
+                        | ((h16 ':'){0,3} h16 )? '::' h16 ':' ls32
+                        | ((h16 ':'){0,4} h16 )? '::' ls32
+                        | ((h16 ':'){0,5} h16 )? '::' h16
+                        | ((h16 ':'){0,6} h16 )? '::' )
+        h16           = hexdig{1,4}
+        ls32          = (h16 ':' h16) | ipv4_address
+        ipv4_address   = dec_octet '.' dec_octet '.' dec_octet '.' dec_octet
+        nz            = ~'0' digit
+        dec_octet     = (
+                        digit # 0-9
+                        | nz digit # 10-99
+                        | '1' digit{2} # 100-199
+                        | '2' ('0' | '1' | '2' | '3' | '4') digit # 200-249
+                        | '25' ('0' | '1' | '2' | '3' | '4' | '5') )# %250-255
+        reg_name = (unreserved | pct_encoded | sub_delims)*
+        path = (
+                path_abempty # begins with '/' or is empty
+                | path_absolute # begins with '/' but not '//'
+                | path_noscheme # begins with a non-colon segment
+                | path_rootless # begins with a segment
+                | path_empty ) # zero characters
+        path_abempty  = ('/' segment)*
+        path_absolute = '/' (segment_nz ('/' segment)* )?
+        path_noscheme = segment_nz_nc ('/' segment)*
+        path_rootless = segment_nz ('/' segment)*
+        path_empty    = pchar{0}
+        segment       = pchar*
+        segment_nz    = pchar+
+        segment_nz_nc = (unreserved | pct_encoded | sub_delims | '@')+
+                        # non-zero-length segment without any colon ':'
+        pchar         = unreserved | pct_encoded | sub_delims | ':' | '@'
+        query         = (pchar | '/' | '?')*
+        fragment      = (pchar | '/' | '?')*
+        pct_encoded   = '%' hexdig
+        unreserved    = letter | digit | '-' | '.' | '_' | '~'
+        reserved      = gen_delims | sub_delims
+        gen_delims    = ':' | '/' | '?' | '#' | '(' | ')?' | '@'
+        sub_delims    = '!' | '$' | '&' | '\\'' | '(' | ')' | '*' | '+' | ',' | ';' | '='
+        hexdig        = digit | 'a' | 'A' | 'b' | 'B' | 'c' | 'C' | 'd' | 'D' | 'e' | 'E' | 'f' | 'F'
+    """
+
+    compiled = makeGrammar(grammar, {})
+    return compiled
+
+
+_pep508_grammar = None
+
+
+def to_dep_spec_pep508(s):
+    """to_dep_spec_pep508"""
+    global _pep508_grammar
+    if _pep508_grammar is None:
+        _pep508_grammar = _build_dep_spec_pep508_grammar()
+    parsed = _pep508_grammar(s)
+    return parsed.specification()
+
+
+def env_marker_ast2expr(marker_ast):
+    """env_marker_ast2expr"""
+    MARKER_VARS = (
+        "python_version",
+        "python_full_version",
+        "os_name",
+        "sys_platform",
+        "platform_release",
+        "platform_system",
+        "platform_version",
+        "platform_machine",
+        "platform_python_implementation",
+        "implementation_name",
+        "implementation_version",
+        "extra",  # ONLY when defined by a containing layer
+    )
+    o, l, r = marker_ast
+    if isinstance(l, tuple):
+        l = env_marker_ast2expr(l)
+    else:
+        assert isinstance(l, str)
+        if l not in MARKER_VARS:
+            l = repr(l)
+    if isinstance(r, tuple):
+        r = env_marker_ast2expr(r)
+    else:
+        assert isinstance(r, str)
+        if r not in MARKER_VARS:
+            r = repr(r)
+    return f"{l} {o} {r}"

paddlex/utils/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,14 +11,3 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
-from . import logging
-from . import utils
-from .utils import (seconds_to_hms, get_encoding, get_single_card_bs, dict2str,
-                    EarlyStop, path_normalization, is_pic, MyEncoder,
-                    DisablePrint, Timer)
-from .checkpoint import get_pretrain_weights, load_pretrain_weights, load_checkpoint
-from .env import get_environ_info, get_num_workers, init_parallel_env
-from .download import download_and_decompress, decompress
-from .stats import SmoothedValue, TrainingStats
-from .shm import _get_shared_memory_size_in_M

paddlex/utils/cache.py

@@ -0,0 +1,148 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+import os.path as osp
+from pathlib import Path
+import inspect
+import functools
+import pickle
+import hashlib
+import tempfile
+import atexit
+import filelock
+
+from . import logging
+
+
+DEFAULT_CACHE_DIR = osp.abspath(osp.join(os.path.expanduser("~"), ".paddlex"))
+CACHE_DIR = os.environ.get("PADDLE_PDX_CACHE_HOME", DEFAULT_CACHE_DIR)
+FUNC_CACHE_DIR = osp.join(CACHE_DIR, "func_ret")
+FILE_LOCK_DIR = osp.join(CACHE_DIR, "locks")
+TEMP_DIR = osp.join(CACHE_DIR, "temp")
+
+
+def create_cache_dir(*args, **kwargs):
+    """create cache dir"""
+    # `args` and `kwargs` reserved for extension
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    os.makedirs(FUNC_CACHE_DIR, exist_ok=True)
+    os.makedirs(FILE_LOCK_DIR, exist_ok=True)
+    # TODO: Ensure permission
+
+
+def get_cache_dir(*args, **kwargs):
+    """get cache dir"""
+    # `args` and `kwargs` reserved for extension
+    return CACHE_DIR
+
+
+def persist(cond=None):
+    """persist"""
+    # FIXME: Current implementation creates files in cache dir and we do
+    # not set a limit on number of files
+    # TODO: Faster implementation and support more arg types
+    FILENAME_PATTERN = "persist_{key}.pkl"
+    SUPPORTED_ARG_TYPES = (str, int, float)
+
+    if cond is None:
+        cond = lambda ret: ret is not None
+
+    def _to_bytes(obj):
+        return str(obj).encode("utf-8")
+
+    def _make_key(func, bnd_args):
+        # Use MD5 algorithm to make deterministic hashing
+        # Note that the object-to-bytes conversion should be deterministic,
+        # we ensure this by restricting types of arguments.
+        m = hashlib.md5()
+        m.update(_to_bytes(osp.realpath(inspect.getsourcefile(func))))
+        m.update(_to_bytes(func.__name__))
+        for k, v in bnd_args.arguments.items():
+            if not isinstance(v, SUPPORTED_ARG_TYPES):
+                raise TypeError(
+                    f"{repr(k)}: {v}, {type(v)} is unhashable or not a supported type."
+                )
+            m.update(_to_bytes(k))
+            m.update(_to_bytes(v))
+        hash_ = m.hexdigest()
+        return hash_
+
+    def _deco(func):
+        @functools.wraps(func)
+        def _wrapper(*args, **kwargs):
+            sig = inspect.signature(func)
+            bnd_args = sig.bind(*args, **kwargs)
+            bnd_args.apply_defaults()
+            key = _make_key(func, bnd_args)
+            cache_file_path = osp.join(
+                FUNC_CACHE_DIR, FILENAME_PATTERN.format(key=str(key))
+            )
+            lock = filelock.FileLock(osp.join(FILE_LOCK_DIR, f"{key}.lock"))
+            with lock:
+                if osp.exists(cache_file_path):
+                    with open(cache_file_path, "rb") as f:
+                        ret = pickle.load(f)
+                else:
+                    ret = func(*args, **kwargs)
+                    if cond(ret):
+                        with open(cache_file_path, "wb") as f:
+                            pickle.dump(ret, f)
+            return ret
+
+        return _wrapper
+
+    return _deco
+
+
+class TempFileManager:
+    def __init__(self):
+        self.temp_files = []
+        Path(TEMP_DIR).mkdir(parents=True, exist_ok=True)
+        atexit.register(self.cleanup)
+
+    def create_temp_file(self, **kwargs):
+        temp_file = tempfile.NamedTemporaryFile(delete=False, dir=TEMP_DIR, **kwargs)
+        self.temp_files.append(temp_file)
+        return temp_file
+
+    def cleanup(self):
+        for temp_file in self.temp_files:
+            try:
+                temp_file.close()
+                os.remove(temp_file.name)
+            except FileNotFoundError as e:
+                pass
+        self.temp_files = []
+
+    class TempFileContextManager:
+        def __init__(self, manager, **kwargs):
+            self.manager = manager
+            self.kwargs = kwargs
+            self.temp_file = None
+
+        def __enter__(self):
+            self.temp_file = self.manager.create_temp_file(**self.kwargs)
+            return self.temp_file
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            if self.temp_file:
+                self.temp_file.close()
+
+    def temp_file_context(self, **kwargs):
+        return self.TempFileContextManager(self, **kwargs)
+
+
+temp_file_manager = TempFileManager()

paddlex/utils/config.py

@@ -0,0 +1,214 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import copy
+import argparse
+import yaml
+from . import logging
+from .errors import raise_key_not_found_error
+
+__all__ = ["get_config"]
+
+
+class AttrDict(dict):
+    """Attr Dict"""
+
+    def __getattr__(self, key):
+        if key in self:
+            return self[key]
+        else:
+            raise raise_key_not_found_error(key, self)
+
+    def __setattr__(self, key, value):
+        if key in self.__dict__:
+            self.__dict__[key] = value
+        else:
+            self[key] = value
+
+    def __deepcopy__(self, content):
+        return copy.deepcopy(dict(self))
+
+
+def create_attr_dict(yaml_config):
+    """create attr dict"""
+    from ast import literal_eval
+
+    for key, value in yaml_config.items():
+        if type(value) is dict:
+            yaml_config[key] = value = AttrDict(value)
+        if isinstance(value, str):
+            try:
+                value = literal_eval(value)
+            except BaseException:
+                pass
+        if isinstance(value, AttrDict):
+            create_attr_dict(yaml_config[key])
+        else:
+            yaml_config[key] = value
+
+
+def parse_config(cfg_file):
+    """Load a config file into AttrDict"""
+    with open(cfg_file, "r") as fopen:
+        yaml_config = AttrDict(yaml.load(fopen, Loader=yaml.SafeLoader))
+    create_attr_dict(yaml_config)
+    return yaml_config
+
+
+def print_dict(d, delimiter=0):
+    """
+    Recursively visualize a dict and
+    indenting acrrording by the relationship of keys.
+    """
+    placeholder = "-" * 60
+    for k, v in sorted(d.items()):
+        if isinstance(v, dict):
+            logging.info("{}{} : ".format(delimiter * " ", k))
+            print_dict(v, delimiter + 4)
+        elif isinstance(v, list) and len(v) >= 1 and isinstance(v[0], dict):
+            logging.info("{}{} : ".format(delimiter * " ", k))
+            for value in v:
+                print_dict(value, delimiter + 4)
+        else:
+            logging.info("{}{} : {}".format(delimiter * " ", k, v))
+        if k.isupper():
+            logging.info(placeholder)
+
+
+def print_config(config):
+    """
+    visualize configs
+    Arguments:
+        config: configs
+    """
+    logging.advertise()
+    print_dict(config)
+
+
+def override(dl, ks, v):
+    """
+    Recursively replace dict of list
+    Args:
+        dl(dict or list): dict or list to be replaced
+        ks(list): list of keys
+        v(str): value to be replaced
+    """
+
+    def parse_str(s):
+        """convert str type value
+        to None type if it is "None",
+        to bool type if it means True or False,
+        to int type if it can be eval().
+        """
+        if s in ("None"):
+            return None
+        elif s in ("TRUE", "True", "true", "T", "t"):
+            return True
+        elif s in ("FALSE", "False", "false", "F", "f"):
+            return False
+        try:
+            return eval(v)
+        except Exception:
+            return s
+
+    assert isinstance(dl, (list, dict)), "{} should be a list or a dict"
+    assert len(ks) > 0, "lenght of keys should larger than 0"
+    if isinstance(dl, list):
+        k = parse_str(ks[0])
+        if len(ks) == 1:
+            assert k < len(dl), "index({}) out of range({})".format(k, dl)
+            dl[k] = parse_str(v)
+        else:
+            override(dl[k], ks[1:], v)
+    else:
+        if len(ks) == 1:
+            # assert ks[0] in dl, ('{} is not exist in {}'.format(ks[0], dl))
+            if not ks[0] in dl:
+                logging.warning(f"A new field ({ks[0]}) detected!")
+            dl[ks[0]] = parse_str(v)
+        else:
+            if ks[0] not in dl.keys():
+                dl[ks[0]] = {}
+                logging.warning(f"A new Series field ({ks[0]}) detected!")
+            override(dl[ks[0]], ks[1:], v)
+
+
+def override_config(config, options=None):
+    """
+    Recursively override the config
+    Args:
+        config(dict): dict to be replaced
+        options(list): list of pairs(key0.key1.idx.key2=value)
+            such as: [
+                'topk=2',
+                'VALID.transforms.1.ResizeImage.resize_short=300'
+            ]
+    Returns:
+        config(dict): replaced config
+    """
+    if options is not None:
+        for opt in options:
+            assert isinstance(opt, str), "option({}) should be a str".format(opt)
+            assert "=" in opt, (
+                "option({}) should contain a ="
+                "to distinguish between key and value".format(opt)
+            )
+            pair = opt.split("=")
+            assert len(pair) == 2, "there can be only a = in the option"
+            key, value = pair
+            keys = key.split(".")
+            override(config, keys, value)
+    return config
+
+
+def get_config(fname, overrides=None, show=False):
+    """
+    Read config from file
+    """
+    assert os.path.exists(fname), "config file({}) is not exist".format(fname)
+    config = parse_config(fname)
+    override_config(config, overrides)
+    if show:
+        print_config(config)
+    # check_config(config)
+    return config
+
+
+def parse_args():
+    """parse args"""
+    parser = argparse.ArgumentParser("PaddleX script")
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        default="configs/config.yaml",
+        help="config file path",
+    )
+    parser.add_argument(
+        "-o",
+        "--override",
+        action="append",
+        default=[],
+        help="config options to be overridden",
+    )
+    parser.add_argument(
+        "-p",
+        "--profiler_options",
+        type=str,
+        default=None,
+        help='The option of profiler, which should be in format "key1=value1;key2=value2;key3=value3".',
+    )
+    args = parser.parse_args()
+    return args