kevin-toolbox-dev 1.1.1__tar.gz → 1.1.3__tar.gz

kevin-toolbox-dev-1.1.3/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.1.3
+Summary: 一个常用的工具代码包集合
+Home-page: https://github.com/cantbeblank96/kevin_toolbox
+Download-URL: https://github.com/username/your-package/archive/refs/tags/v1.0.0.tar.gz
+Author: kevin hsu
+Author-email: xukaiming1996@163.com
+License: MIT
+Keywords: mathematics,pytorch,numpy,machine-learning,algorithm
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: plot
+Provides-Extra: rest
+
+# kevin_toolbox
+
+一个通用的工具代码包集合
+
+
+
+环境要求
+
+```shell
+numpy>=1.19
+pytorch>=1.2
+```
+
+安装方法：
+
+```shell
+pip install kevin-toolbox  --no-dependencies
+```
+
+
+
+[项目地址 Repo](https://github.com/cantbeblank96/kevin_toolbox)
+
+[使用指南 User_Guide](./notes/User_Guide.md)
+
+[免责声明 Disclaimer](./notes/Disclaimer.md)
+
+[版本更新记录](./notes/Release_Record.md)：
+
+- v 1.1.3（2023-06-30）
+  - computer_science.algorithm.for_nested_dict_list
+    - 在 traverse() 中新增了traversal_mode 参数用于控制遍历的顺序，目前支持三种模式： "dfs_pre_order" 深度优先-先序遍历、"dfs_post_order" 深度优先-后序遍历、以及 "bfs" 宽度优先。
+      - 在单元测试中新增了对 traverse() 中 traversal_mode 参数的测试项目。
+    - value_parser
+      - 修改 eval_references() 中 converter_for_ref 参数的行为，从原来只是作为计算结果前对算式中引用节点值的预处理，变成直接改变被引用节点的值。亦即原来不会修改原被引用节点的值，现在变为会修改原节点的值了。
+  - computer_science.algorithm.scheduler
+    - 改进 Strategy_Manager
+      - 使用 `<eval>` 来标记需要使用 eval() 函数读取的字符串。相对于旧版通过 `<eval>` 来标记需要被读取为函数的字符串，使用 `<eval>` 不仅可以读取函数，也可以读取更多的数据结构。
+      - 在通过 add() 添加策略时即对 strategy 中被 `<eval>` 标记的键值进行解释，而非等到后续每次 cal() 时再进行解释，提高了效率。
+      - 修改了对应的单元测试。

kevin-toolbox-dev-1.1.3/README.md

@@ -0,0 +1,40 @@
+# kevin_toolbox
+
+一个通用的工具代码包集合
+
+
+
+环境要求
+
+```shell
+numpy>=1.19
+pytorch>=1.2
+```
+
+安装方法：
+
+```shell
+pip install kevin-toolbox  --no-dependencies
+```
+
+
+
+[项目地址 Repo](https://github.com/cantbeblank96/kevin_toolbox)
+
+[使用指南 User_Guide](./notes/User_Guide.md)
+
+[免责声明 Disclaimer](./notes/Disclaimer.md)
+
+[版本更新记录](./notes/Release_Record.md)：
+
+- v 1.1.3（2023-06-30）
+  - computer_science.algorithm.for_nested_dict_list
+    - 在 traverse() 中新增了traversal_mode 参数用于控制遍历的顺序，目前支持三种模式： "dfs_pre_order" 深度优先-先序遍历、"dfs_post_order" 深度优先-后序遍历、以及 "bfs" 宽度优先。
+      - 在单元测试中新增了对 traverse() 中 traversal_mode 参数的测试项目。
+    - value_parser
+      - 修改 eval_references() 中 converter_for_ref 参数的行为，从原来只是作为计算结果前对算式中引用节点值的预处理，变成直接改变被引用节点的值。亦即原来不会修改原被引用节点的值，现在变为会修改原节点的值了。
+  - computer_science.algorithm.scheduler
+    - 改进 Strategy_Manager
+      - 使用 `<eval>` 来标记需要使用 eval() 函数读取的字符串。相对于旧版通过 `<eval>` 来标记需要被读取为函数的字符串，使用 `<eval>` 不仅可以读取函数，也可以读取更多的数据结构。
+      - 在通过 add() 添加策略时即对 strategy 中被 `<eval>` 标记的键值进行解释，而非等到后续每次 cal() 时再进行解释，提高了效率。
+      - 修改了对应的单元测试。

{kevin-toolbox-dev-1.1.1 → kevin-toolbox-dev-1.1.3}/kevin_toolbox/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.1.1"
+__version__ = "1.1.3"
 
 
 import os
@@ -12,5 +12,5 @@ os.system(
 os.system(
     f'python {os.path.split(__file__)[0]}/env_info/check_validity_and_uninstall.py '
     f'--package_name kevin-toolbox-dev '
-    f'--expiration_timestamp 1702873414 --verbose 0'
+    f'--expiration_timestamp 1703667553 --verbose 0'
 )

{kevin-toolbox-dev-1.1.1 → kevin-toolbox-dev-1.1.3}/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/copy_.py

@@ -16,7 +16,8 @@ def copy_(var, b_deepcopy=False):
         return copy.deepcopy(var)
 
     return traverse(var=[var], match_cond=lambda _, __, value: isinstance(value, (list, dict,)),
-                    action_mode="replace", converter=lambda _, value: value.copy(), b_traverse_matched_element=True)[0]
+                    action_mode="replace", converter=lambda _, value: value.copy(),
+                    traversal_mode="dfs_pre_order", b_traverse_matched_element=True)[0]
 
 
 if __name__ == '__main__':

kevin-toolbox-dev-1.1.3/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/get_value_by_name.py

@@ -0,0 +1,48 @@
+from kevin_toolbox.computer_science.algorithm.for_nested_dict_list.name_handler import parse_name
+
+
+def get_value_by_name(var, name, b_pop=False, **kwargs):
+    """
+        通过解释名字得到取值方式，然后到 var 中获取对应部分的值。
+
+        参数：
+            var:            任意支持索引取值的变量
+            name:           <str> 名字
+                                名字 name 的具体介绍参见函数 name_handler.parse_name()
+                                假设 var=dict(acc=[0.66,0.78,0.99])，如果你想读取 var["acc"][1] => 0.78，那么可以将 name 写成：
+                                    ":acc@1" 或者 "|acc|1" 等。
+                                注意，在 name 的开头也可以添加任意非解释方式的字符，本函数将直接忽略它们，比如下面的:
+                                    "var:acc@1" 和 "xxxx|acc|1" 也能正常读取。
+            b_pop:          <boolean> 是否将值从 var 中移除
+                                默认为 False
+            default:        默认值
+                                - 不设置（默认）。当取值失败时将报错。
+                                - 设置为任意值。取值失败时将返回该值。
+    """
+    _, method_ls, node_ls = parse_name(name=name, b_de_escape_node=True)
+
+    try:
+        pre, cur = None, var
+        node = None
+        for method, node in zip(method_ls, node_ls):
+            pre, cur = cur, None
+            if method == "@":
+                node = eval(node)
+            elif method == "|":
+                try:
+                    _ = pre[node]
+                except:
+                    node = eval(node)
+            cur = pre[node]
+
+        if b_pop and len(node_ls) > 0:
+            assert isinstance(pre, (dict, list,)), \
+                f'pop is only supported when the parent node type is list or dict, but got a {type(pre)}'
+            pre.pop(node)
+    except:
+        if "default" in kwargs:
+            cur = kwargs["default"]
+        else:
+            raise IndexError(f'invalid name {name}')
+
+    return cur

{kevin-toolbox-dev-1.1.1 → kevin-toolbox-dev-1.1.3}/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/set_value_by_name.py

@@ -16,7 +16,7 @@ def set_value_by_name(var, name, value, b_force=False):
                                     "var:acc@1" 和 "xxxx|acc|1" 也能正常写入。
             value:          待赋给的值
             b_force:        <boolean> 当无法设置时，是否尝试创建或者修改节点
-                                默认为 False，
+                                默认为 False，此时若无法设置，则报错
                                 当设置为 True，可能会对 var 的结构产生不可逆的改变，请谨慎使用。
                                     - 根据取值方式的不同，新创建或者修改的节点的类型可能是 dict 或者 list，
                                         对于 list，其中缺省值填充 None。

kevin-toolbox-dev-1.1.3/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/traverse.py

@@ -0,0 +1,148 @@
+from enum import Enum
+from kevin_toolbox.computer_science.algorithm.for_nested_dict_list.name_handler import escape_node
+
+
+class ACTION_MODE(Enum):
+    remove = 1
+    replace = 2
+    skip = 3
+
+
+class TRAVERSAL_MODE(Enum):
+    dfs_pre_order = 1
+    dfs_post_order = 2
+    bfs = 3
+
+
+def traverse(var, match_cond, action_mode="remove", converter=None,
+             b_use_name_as_idx=False, traversal_mode="dfs_pre_order", b_traverse_matched_element=False):
+    """
+        遍历 var 找到符合 match_cond 的元素，将其按照 action_mode 指定的操作进行处理
+
+        参数：
+            var:                待处理数据
+                                    当 var 不是 dict 或者 list 时，将直接返回 var 而不做处理
+            match_cond:         <func> 元素的匹配条件
+                                    函数类型为 def(parent_type, idx, value): ...
+                                    其中：
+                                        parent_type     该元素源自哪种结构体，有两个可能传入的值： list，dict
+                                        idx             该元素在结构体中的位置
+                                                            当 b_use_name_as_idx=False 时，
+                                                                对于列表是 index，对于字典是 key
+                                                            当为 True 时，传入的是元素在整体结构中的 name 位置，name的格式和含义参考
+                                                                name_handler.parse_name() 中的介绍
+                                        value           元素的值
+            action_mode:        <str> 如何对匹配上的元素进行处理
+                                    目前支持：
+                                        "remove"        将该元素移除
+                                        "replace"       将该元素替换为 converter() 处理后的结果
+                                        "skip":         不进行任何操作
+            converter:          <func> 参见 action_mode 中的 "replace" 模式
+                                    函数类型为 def(idx, value): ...
+                                    其中 idx 和 value 的含义参见参数 match_cond 介绍
+            traversal_mode:     <str> 遍历的模式、顺序
+                                    目前支持：
+                                        "dfs_pre_order"         深度优先、先序遍历
+                                        "dfs_post_order"        深度优先、后序遍历
+                                        "bfs"                   宽度优先
+                                    默认为 "dfs_pre_order"
+            b_use_name_as_idx:  <boolean> 对于 match_cond/converter 中的 idx 参数，是传入整体的 name 还是父节点的 index 或 key。
+                                    默认为 False
+            b_traverse_matched_element  <boolean> 对于匹配上的元素，经过处理后，是否继续遍历该元素的内容
+                                    默认为 False
+    """
+    assert callable(match_cond)
+    assert action_mode in ACTION_MODE.__members__.keys()
+    action_mode = ACTION_MODE.__members__[action_mode]
+    if action_mode is ACTION_MODE.replace:
+        assert callable(converter)
+    #
+    assert traversal_mode in TRAVERSAL_MODE.__members__.keys()
+    traversal_mode = TRAVERSAL_MODE.__members__[traversal_mode]
+
+    if traversal_mode is TRAVERSAL_MODE.bfs:
+        return _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element)
+    else:
+        return _dfs(var, match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
+                    b_traverse_matched_element, "")
+
+
+def _bfs(var, match_cond, action_mode, converter, b_use_name_as_idx, b_traverse_matched_element):
+    temp = [("", var)]
+
+    while len(temp):
+        pre_name, i = temp.pop(0)
+        if isinstance(i, (list, dict)):
+            keys = list(range(len(i)) if isinstance(i, list) else i.keys())
+            keys.reverse()  # 反过来便于 列表 弹出元素
+            idx_ls = _gen_idx(i, keys, b_use_name_as_idx, pre_name)
+
+            # 匹配&处理
+            for k, idx in zip(keys, idx_ls):
+                b_matched, b_popped = _deal(i, k, idx, match_cond, converter, action_mode)
+                if b_popped or (b_matched and not b_traverse_matched_element):
+                    continue
+                # 添加到队尾
+                temp.append((idx, i[k]))
+
+    return var
+
+
+def _dfs(var, match_cond, action_mode, converter,
+         b_use_name_as_idx, traversal_mode, b_traverse_matched_element, pre_name):
+    if isinstance(var, (list, dict)):
+        keys = list(range(len(var)) if isinstance(var, list) else var.keys())
+        keys.reverse()  # 反过来便于 列表 弹出元素
+        idx_ls = _gen_idx(var, keys, b_use_name_as_idx, pre_name)
+
+        #
+        if traversal_mode is TRAVERSAL_MODE.dfs_pre_order:
+            # 先序
+            # 匹配&处理
+            deal_res_ls = []
+            for k, idx in zip(keys, idx_ls):
+                deal_res_ls.append(_deal(var, k, idx, match_cond, converter, action_mode))
+            # 递归遍历
+            for (b_matched, b_popped), k, idx in zip(deal_res_ls, keys, idx_ls):
+                if b_popped or (b_matched and not b_traverse_matched_element):
+                    continue
+                var[k] = _dfs(var[k], match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
+                              b_traverse_matched_element, idx)
+        else:
+            # 后序
+            # 递归遍历
+            for k, idx in zip(keys, idx_ls):
+                var[k] = _dfs(var[k], match_cond, action_mode, converter, b_use_name_as_idx, traversal_mode,
+                              b_traverse_matched_element, idx)
+            # 匹配&处理
+            for k, idx in zip(keys, idx_ls):
+                _deal(var, k, idx, match_cond, converter, action_mode)
+    else:
+        pass
+    return var
+
+
+def _deal(var, k, idx, match_cond, converter, action_mode):
+    """处理节点"""
+    # 匹配
+    b_matched = match_cond(type(var), idx, var[k])
+    b_popped = False
+    # 处理
+    if b_matched:
+        if action_mode is ACTION_MODE.remove:
+            var.pop(k)
+            b_popped = True
+        elif action_mode is ACTION_MODE.replace:
+            var[k] = converter(idx, var[k])
+        else:
+            pass
+    return b_matched, b_popped
+
+
+def _gen_idx(var, keys, b_use_name_as_idx, pre_name):
+    if b_use_name_as_idx:
+        method = "@" if isinstance(var, list) else ":"
+        idx_ls = [f'{pre_name}{method}{escape_node(node=k, b_reversed=False, times=1)}' for k in keys]
+    else:
+        idx_ls = keys
+    return idx_ls

{kevin-toolbox-dev-1.1.1 → kevin-toolbox-dev-1.1.3}/kevin_toolbox/computer_science/algorithm/for_nested_dict_list/value_parser/eval_references.py

@@ -9,8 +9,12 @@ def eval_references(var, node_s, order, converter_for_ref=None, converter_for_re
             var:
             node_s:                 <dict> 引用节点，parse_references() 返回的结果
             order:                  <list of name> 计算顺序，cal_relation_between_references() 返回的结果
-            converter_for_ref:      <callable> 对引用值施加何种处理
-                                        形如 def(idx, v): ... 的函数，其中 idx 是被引用节点的名字，v是其值
+            converter_for_ref:      <callable> 对被引用节点施加何种处理
+                                        形如 def(idx, v): ... 的函数，其中 idx 是被引用节点的名字，v是其值，
+                                        返回的结果将替换掉被引用节点中原来的值。
+                                        注意：
+                                            - 处理后得到的结果将替换掉原引用节点的值。（重要所以说两次）
+                                            - 当同一节点被多次引用时，仅会被处理、替换一次。
             converter_for_res:      <callable> 对计算结果施加何种处理
                                         形如 def(idx, v): ... 的函数，其中 idx 是节点的名字，v是计算结果
     """
@@ -18,13 +22,18 @@ def eval_references(var, node_s, order, converter_for_ref=None, converter_for_re
     assert converter_for_ref is None or callable(converter_for_ref)
     assert converter_for_res is None or callable(converter_for_res)
 
+    processed_ref_nodes = set()
+
     for name in order:
         details = node_s[name]
         # 获取依赖值
-        for k, v in details["paras"].items():
-            v_new = get_value_by_name(var=var, name=v)
-            if converter_for_ref is not None:
-                v_new = converter_for_ref(v, v_new)
+        for k, idx in details["paras"].items():
+            v_new = get_value_by_name(var=var, name=idx)
+            if converter_for_ref is not None and idx not in processed_ref_nodes:
+                v_new = converter_for_ref(idx, v_new)
+                # 赋值
+                set_value_by_name(var=var, name=idx, value=v_new, b_force=False)
+                processed_ref_nodes.add(idx)
             details["paras"][k] = v_new
         # 计算
         res = eval(details["expression"], details["paras"])

{kevin-toolbox-dev-1.1.1 → kevin-toolbox-dev-1.1.3}/kevin_toolbox/computer_science/algorithm/registration/registry.py

@@ -57,7 +57,12 @@ class Registry:
             __new__函数返回的实例，将作为self参数被传入到__init__函数。
                 如果__new__函数返回一个已经存在的实例（不论是哪个类的），__init__还是会被调用的，所以要特别注意__init__中对变量的赋值。
         """
-        uid = kwargs.get("uid", cls.__counter)
+        if "uid" in kwargs:
+            uid = kwargs["uid"]
+        else:
+            while cls.__counter in cls.__instances:
+                cls.__counter += 1
+            uid = cls.__counter
 
         # 获取实例
         if uid in cls.__instances:
@@ -72,8 +77,13 @@ class Registry:
         """
             参数：
                 uid:                <hashable> 实例的唯一标识符
-                                        默认置空，此时将新建一个实例，并将此时已有实例的数量作为 uid
-                                        当为非空，则根据 uid 到已有实例中寻找相同的实例，并返回（使用该特性可以构造单例模式）
+                                        - 不设置。新建一个实例，并自动分配一个整数作为 uid（一般是此时已有实例的数量-1），
+                                            并将该实例记录到类变量 instances_of_Registry 中。
+                                        - 设置为 None。新建一个实例，但不记录到类变量 instances_of_Registry 中。
+                                        - 设置为其他值。根据 uid 到类变量 instances_of_Registry 的已有实例中寻找相同的实例，
+                                            若命中则返回已有实例，若无则以该 uid 新建一个实例并添加到 instances_of_Registry 中。
+                                            （使用该特性可以构造单例模式）
+                                        默认为不设置。
         """
         try:
             getattr(self, "uid")
@@ -87,8 +97,8 @@ class Registry:
         self._path_to_collect = []
         self._item_to_add = []
         # 记录到 __instances 中
-        Registry.__instances[self.uid] = self
-        Registry.__counter += 1
+        if self.uid is not None:
+            Registry.__instances[self.uid] = self
 
     def add(self, obj, name=None, b_force=False, b_execute_now=True):
         """
@@ -140,7 +150,7 @@ class Registry:
                                       b_force=True)
         # check
         if not b_force:
-            inc_node_nums = fndl.count_leaf_node_nums(var=obj) if isinstance(obj, (list, dict)) else 1  # 增加的节点数量
+            inc_node_nums = fndl.count_leaf_node_nums(var=obj) if isinstance(obj, (list, dict)) else 1  # 应该增加的节点数量
             if fndl.count_leaf_node_nums(var=temp) != fndl.count_leaf_node_nums(var=self.database) + inc_node_nums:
                 # print(f'registration failed, name {name} may be a conflict with an '
                 #       f'existing member in {[i for i, j in fndl.get_nodes(var=self.database)]}')
@@ -149,13 +159,15 @@ class Registry:
         self.database = temp
         return True
 
-    def get(self, name, **kwargs):
+    def get(self, name, b_pop=False, **kwargs):
         """
             获取
 
             参数：
-                name：           <str> 成员名称
-                default:          默认值
+                name:           <str> 成员名称
+                b_pop:          <boolean> 取值的同时移除该成员
+                                    默认为 False
+                default:        默认值
                                     找不到时，若无默认值则报错，否则将返回默认值
         """
         # 加载待注册成员
@@ -168,46 +180,7 @@ class Registry:
                 self.collect_from_paths(**i)
             self._path_to_collect.clear()
 
-        try:
-            return fndl.get_value_by_name(var=self.database, name=name)
-        except:
-            if "default" in kwargs:
-                return kwargs["default"]
-            else:
-                raise AssertionError(f'element {name} not exists')
-
-    def pop(self, name, **kwargs):
-        """
-            弹出
-
-            参数：
-                name：           <str> 成员名称
-                                    名称一定要准确，不能含有模糊的 | 字符
-                default:          默认值
-                                    找不到时，若无默认值则报错，否则将返回默认值
-        """
-        assert "|" not in name, \
-            f'to pop up a specific member needs to give the exact name, ' \
-            f'does not support the "|" character with automatic deduction, invalid name: {name}, ' \
-            f'what you probably want to pop is {name.replace("|", ":")}'
-        res, b_found = None, False
-
-        def func(_, idx, value):
-            nonlocal res, b_found
-            if res is None and idx == name:
-                res, b_found = value, True
-                return True
-            else:
-                return False
-
-        fndl.traverse(var=self.database, match_cond=func, action_mode="remove", b_use_name_as_idx=True)
-        if b_found:
-            return res
-        else:
-            if "default" in kwargs:
-                return kwargs["default"]
-            else:
-                raise AssertionError(f'element {name} not exists')
+        return fndl.get_value_by_name(var=self.database, name=name, b_pop=b_pop, **kwargs)
 
     def clear(self):
         self.database.clear()
@@ -236,7 +209,7 @@ class Registry:
 
         return wrapper
 
-    # -------------------- 其他 --------------------- #
+    # -------------------- 通过路径添加 --------------------- #
 
     def collect_from_paths(self, path_ls=None, path_ls_to_exclude=None, b_execute_now=False):
         """
@@ -298,5 +271,11 @@ class Registry:
         if temp is not None:
             self.database = temp.database
 
+    # -------------------- 其他 --------------------- #
+
+    @property
+    def instances_of_Registry(self):
+        return dict(Registry.__instances)
+
 
 UNIFIED_REGISTRY = Registry(uid="UNIFIED_REGISTRY")

{kevin-toolbox-dev-1.1.1 → kevin-toolbox-dev-1.1.3}/kevin_toolbox/computer_science/algorithm/scheduler/strategy_manager.py

@@ -2,7 +2,7 @@ import random
 import torch
 import numpy as np
 import copy
-from kevin_toolbox.computer_science.algorithm.for_nested_dict_list import set_value_by_name, get_value_by_name
+from kevin_toolbox.computer_science.algorithm.for_nested_dict_list import set_value_by_name, get_value_by_name, traverse
 
 
 class Strategy_Manager:
@@ -20,9 +20,9 @@ class Strategy_Manager:
                         ":lr": {
                             # 当 key 满足 trigger_value 时，将 ":lr" 指向的部分替换为 value
                             0: 0.1,
-                            # 如果是以 <f> 为开头的字符串，则视为函数并将 value 解释为函数执行后的结果
+                            # 如果是以 <eval> 为开头的字符串，则视为函数并将 value 解释为函数执行后的结果
                             #       函数中 t, p 参数将被分别传入 trigger_value 和 para_value
-                            "<f>lambda t: t%100==0": "<f>lambda p, t: p*0.1",
+                            "<eval>lambda t: t%100==0": "<eval>lambda p, t: p*0.1",
                         },
                     },
                     override=False,
@@ -93,10 +93,11 @@ class Strategy_Manager:
                                                 300: {
                                                     ":ratio_ls@1": 1e-5,
                                                 },  # 在 epoch=300 时，将 ratio_ls[1] 设置为 1e-5
-                                                "<f>lambda t: t%100==0": {
-                                                    ":lr": "<f>lambda p, t: p*0.1",
-                                                },  # 当键为 string 且 开头带有 <f> 标记时候，将以函数的方式读取该字符串，
-                                                    # 并在匹配过程中向该函数输入触发值 t 和当前元素的值 p，当函数返回True视为匹配成功。
+                                                "<eval>lambda t: t%100==0": {
+                                                    ":lr": "<eval>lambda p, t: p*0.1",
+                                                },  # 当键为 string 且 开头带有 <eval> 标记时候，将使用 eval() 函数读取该字符串，
+                                                    # 当键为 callable 的函数时，在匹配过程中向该函数输入触发值 t 和当前元素的值 p，
+                                                    # 当函数返回True视为匹配成功。
                                                     # 比如上式表示的是：每经过 100 epoch，也就是当 epoch%100==0 时，lr 在原来的基础上乘上0.1。
                                                     # 函数匹配的的优先级低于直接的值匹配。
                                                 ...
@@ -109,7 +110,7 @@ class Strategy_Manager:
                                                 "__trigger_name": "epoch",
                                                 ":lr": {
                                                     0: 0.1,
-                                                    "<f>lambda t: t%100==0": "<f>lambda p, t: p*0.1",
+                                                    "<eval>lambda t: t%100==0": "<eval>lambda p, t: p*0.1",
                                                 },
                                                 ":ratio_ls": {
                                                     0: [1e-3, 1e-2],
@@ -146,6 +147,21 @@ class Strategy_Manager:
                     temp[t_key][p_key] = strategy[p_key][t_key]
             strategy = temp
 
+        def deal_eval_str(x):
+            return eval(x[6:]) if isinstance(x, (str,)) and x.startswith("<eval>") else x
+
+        # 使用 eval() 读取带 "<eval>" 标签的键or值
+        def converter(_, value):
+            if isinstance(value, (dict,)):
+                res = {deal_eval_str(k): deal_eval_str(v) for k, v in value.items()}
+            else:
+                res = deal_eval_str(value)
+            return res
+
+        strategy = traverse(var=[strategy], match_cond=lambda _, __, value: isinstance(value, (dict, str,)),
+                            action_mode="replace", converter=converter, traversal_mode="dfs_post_order",
+                            b_use_name_as_idx=False, b_traverse_matched_element=True)[0]
+
         # 将策略添加到 database
         old_strategy = self.database.get(_trigger_name, dict())
         for t_key, item in strategy.items():
@@ -187,7 +203,7 @@ class Strategy_Manager:
             action_s = dict()  # {p_name: p_value, ...}
             # 使用匹配函数
             for key, p_s in strategy.items():
-                if isinstance(key, (str,)) and key.startswith("<f>") and eval(key[3:])(t_value):
+                if callable(key) and key(t_value):
                     action_s.update({i: j for i, j in p_s.items() if i not in action_s})
             # 直接匹配
             if t_value in strategy:
@@ -200,9 +216,9 @@ class Strategy_Manager:
         for t_name, action_s in sorted(action_s_all.items(), key=lambda x: x[0]):
             t_value = trigger_state[t_name]
             for name, p_value in copy.deepcopy(action_s):
-                if isinstance(p_value, (str,)) and p_value.startswith("<f>"):
+                if callable(p_value):
                     raw_value = get_value_by_name(var=var, name=name)
-                    p_value = eval(p_value[3:])(raw_value, t_value)
+                    p_value = p_value(raw_value, t_value)
                 set_value_by_name(var=var, name=name, value=p_value)
 
         return var, action_s_all
@@ -217,7 +233,7 @@ if __name__ == '__main__':
         "__trigger_name": "epoch",
         ":lr": {
             # 0: 0.1,
-            "<f>lambda t: t%100==0": "<f>lambda p, t: p*0.1",
+            "<eval>lambda t: t%100==0": "<eval>lambda p, t: p*0.1",
         },
     })
     sm.add(strategy={
@@ -230,8 +246,8 @@ if __name__ == '__main__':
         300: {
             ":ratio_ls@1": 1e-5,
         },
-        # "<f>lambda t: t%100==0": {
-        #     ":lr": "<f>lambda p, t: p*0.1",
+        # "<eval>lambda t: t%100==0": {
+        #     ":lr": "<eval>lambda p, t: p*0.1",
         # },
     }, override=False)