kevin-toolbox-dev 1.2.7__py3-none-any.whl → 1.3.0__py3-none-any.whl

kevin_toolbox/nested_dict_list/serializer/read.py

@@ -3,7 +3,6 @@ import time
 from kevin_toolbox.patches import for_os
 from kevin_toolbox.data_flow.file import json_
 import kevin_toolbox.nested_dict_list as ndl
-from kevin_toolbox.nested_dict_list.serializer.variable import SERIALIZER_BACKEND
 
 
 def read(input_path, **kwargs):
@@ -13,6 +12,8 @@ def read(input_path, **kwargs):
         参数：
             input_path:             <path> 文件夹或者 .tar 文件，具体结构参考 write()
     """
+    from kevin_toolbox.nested_dict_list.serializer.variable import SERIALIZER_BACKEND
+
     assert os.path.exists(input_path)
 
     # 解压

kevin_toolbox/nested_dict_list/serializer/variable.py

@@ -1,5 +1,4 @@
 import os
-from enum import Enum
 from kevin_toolbox.computer_science.algorithm.registration import Registry
 
 SERIALIZER_BACKEND = Registry(uid="SERIALIZER_BACKEND")
@@ -7,14 +6,3 @@ SERIALIZER_BACKEND = Registry(uid="SERIALIZER_BACKEND")
 # 从 kevin_toolbox/nested_dict_list/serializer/backends 下收集被注册的 backend
 SERIALIZER_BACKEND.collect_from_paths(path_ls=[os.path.join(os.path.dirname(__file__), "backends"), ],
                                       b_execute_now=False)
-
-
-class Strictness_Level(Enum):
-    """
-        对于正确性与完整性的要求的严格程度
-    """
-    COMPLETE = "high"  # 所有节点均有一个或者多个匹配上的 backend，且第一个匹配上的 backend 就成功写入。
-    COMPATIBLE = "normal"  # 所有节点均有一个或者多个匹配上的 backend，但是首先匹配到的 backend 写入出错，使用其后再次匹配到的其他 backend 能够成功写入
-    # （这种情况更多应归咎于 backend 的 writable() 方法无法拒绝所有错误输入或者 backend 本身没有按照预期工作。一般而言这对最终写入内容的正确不会有太大影响。）
-    # 这个等级是默认等级
-    IGNORE_FAILURE = "low"  # 匹配不完整，或者某些节点尝试过所有匹配到的 backend 之后仍然无法写入

kevin_toolbox/nested_dict_list/serializer/write.py

@@ -6,7 +6,7 @@ from kevin_toolbox.data_flow.file import json_
 from kevin_toolbox.patches import for_os
 import kevin_toolbox.nested_dict_list as ndl
 from kevin_toolbox.nested_dict_list.traverse import Traversal_Mode
-from kevin_toolbox.nested_dict_list.serializer.variable import SERIALIZER_BACKEND, Strictness_Level
+from .enum_variable import Strictness_Level
 
 
 def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_pack_into_tar=True,
@@ -83,6 +83,7 @@ def write(var, output_dir, settings=None, traversal_mode=Traversal_Mode.BFS, b_p
                                                                                             的 backend 之后仍然无法写入
                                         默认是 "normal"
     """
+    from kevin_toolbox.nested_dict_list.serializer.variable import SERIALIZER_BACKEND
 
     #
     traversal_mode = Traversal_Mode(traversal_mode)

kevin_toolbox/nested_dict_list/set_value.py

@@ -52,11 +52,17 @@ def set_value(var, name, value, b_force=False):
             raise ValueError(f'The location pointed to by name {name} does not exist in var')
         else:
             if method_ls[-1] in "|:":
+                # 对于字符串默认使用 dict 构建
                 value = {raw_key: value}
             else:
+                # 对于需要eval的情况
                 key = eval(raw_key)
-                assert isinstance(key, (int,)) and key >= 0
-                value = [None] * key + [value]
+                if isinstance(key, (int,)) and key >= 0:
+                    # 只有当 key 为非负整数时，才会使用 list 构建
+                    value = [None] * key + [value]
+                else:
+                    # 其他，比如当 key 为元组、浮点数等等时，则使用 dict 构建
+                    value = {key: value}
             var = set_value(var=var, name=name[:-1 - len(node_ls[-1])], value=value, b_force=b_force)
 
     return var

kevin_toolbox/patches/for_numpy/__init__.py

@@ -0,0 +1 @@
+from . import linalg

kevin_toolbox/patches/for_numpy/linalg/softmax.py

@@ -1,11 +1,47 @@
 import numpy as np
 
 
-def softmax(v, axis=-1):
-    # 为了数值稳定，减去最大值
-    v = v - np.max(v)
-    return np.exp(v) / np.sum(np.exp(v), axis=axis, keepdims=True)
+def softmax(x, axis=-1, temperature=None, b_use_log_over_x=False):
+    """
+        一种将多个数值转换为概率分布的函数
+            softmax(x)[k] = e^{x_k/t} / sum_{i}( e^{x_i/t} )
+
+        参数：
+            axis:               <int> 要对将哪一个轴转为概率分布（亦即沿着该轴求和将得到1）
+                                    默认为最后一个轴
+            temperature:        <float> 温度系数，起到对输入中的相对小/大值的抑制/增强作用。
+                                    它是一个非负数。
+                                    它越大，输出的概率分布越平缓。当趋于无穷时，输出退化为均匀分布。
+                                    它越小，输出的概率分布越尖锐。当趋于0时，输出退化成狄拉克函数。
+            b_use_log_over_x:   <boolean> 对输入的概率分布首先进行一次 log() 操作。
+                                    默认为 False
+                                    当设为 True 开启后，该函数将从 softmax 变为：
+                                    softmax(log(x))[k] = x_k^{1/t} / sum_{i}( x_i^{1/t} )
+    """
+    x = np.asarray(x)
+
+    if temperature == 0:
+        # quick
+        res = np.zeros_like(x)
+        res = np.where(x == np.max(x, axis=axis), 1, res)
+    elif b_use_log_over_x:
+        # softmax(log(x))
+        res = x ** (1 / temperature)
+    else:
+        # softmax(x)
+        # 为了数值稳定，减去最大值
+        x = x - np.max(x)
+        #
+        if temperature is not None:
+            assert temperature > 0
+            x /= temperature
+        res = np.exp(x)
+    res = res / np.sum(res, axis=axis, keepdims=True)
+    return res
 
 
 if __name__ == '__main__':
     print(softmax(np.asarray([0, 0.1]) * 10))
+    print(softmax(np.asarray([0, 0.1]), temperature=0.1))
+    print(softmax(np.asarray([[[0], [0.1]]]), temperature=0.00001, axis=1))
+    print(softmax(np.asarray([[[0], [0.1]]]), temperature=0, axis=1))

kevin_toolbox/patches/for_optuna/sample_from_feasible_domain.py

@@ -2,14 +2,14 @@ import optuna
 import kevin_toolbox.nested_dict_list as ndl
 
 
-def sample_from_feasible_domain(var, trial: optuna.trial.BaseTrial, pre_name=""):
+def sample_from_feasible_domain(var, trial: optuna.trial.BaseTrial, f_p_name_builder=None, b_use_name_as_idx=True):
     """
         使用试验 trial 基于输入中的定义域 feasible_domain 部分进行参数采样和替换。
             遍历输入中的所有元素，找出符合 <feasible_domain> 格式要求的记录了参数定义域的元素，
             然后使用输入的试验实例 trial 结合参数定义域采样出对应的参数，最后用采样出来的参数替换掉原来的定义域。
 
         参数：
-            inputs:             <list/dict> 当其中的元素满足 <feasible_domain> 格式要求，将进行采样与替换。
+            var:                <list/dict> 当其中的元素满足 <feasible_domain> 格式要求，将进行采样与替换。
                                     <feasible_domain> 格式要求：
                                         1. 是一个 dictionary
                                         2. 包含 "p_type"  字段
@@ -20,15 +20,26 @@ def sample_from_feasible_domain(var, trial: optuna.trial.BaseTrial, pre_name="")
                                         更多参见 https://optuna.readthedocs.io/zh_CN/latest/reference/generated/optuna.trial.Trial.html#optuna.trial.Trial
                                         中的 suggest_xxx() 函数。
             trial:              <optuna.trial.BaseTrial> 试验
-            pre_name:           <string> 采样出的参数在试验 trial 中注册的名称的前缀
+            f_p_name_builder:   <callable> 对于采样出的参数，使用该函数构建其在试验 trial 中注册的名称。
+                                    函数类型为 def(idx, p_type): ...
+                                    其中：
+                                        idx             被采样的节点在 var 中的位置
+                                                            当 b_use_name_as_idx=False 时，
+                                                                对于列表是 index，对于字典是 key
+                                                            当为 True 时，传入的是元素在整体结构中的 name 位置，name的格式和含义参考
+                                                                name_handler.parse_name() 中的介绍
+                                        p_type          被采样的节点中的 "p_type" 字段
+                                    默认为：
+                                        lambda idx, p_type: idx
+            b_use_name_as_idx:  <boolean> 决定传入 f_p_name_builder 中的参数 idx 的形式。
 
         返回：
-            var, name_ls
+            var, node_vs_paras_s
                 var 是采样后的结果
-                name_ls 是被采样的节点名称，注意并不带 pre_name 前缀
+                node_vs_paras_s 是一个<dict>，以被采样的节点在 var 中位置的名称作为键，以对应节点在 trial 中注册的参数名为值。
 
         实例：
-            对于输入 inputs={
+            对于输入 var={
                             "thr":[
                                 "interval_thr": {
                                     "p_type": "categorical",
@@ -56,19 +67,33 @@ def sample_from_feasible_domain(var, trial: optuna.trial.BaseTrial, pre_name="")
                             ]
                         }
             可能返回的采样结果是 res={"thr":[{"interval_thr":1000}, {"iou_thr":0.6}, {"connection":lambda x:x} ], }。
-            当 pre_name="my" 时，这些参数在 trial 中注册的名称分别是 "my:thr@0:interval_thr"，"my:thr@1:iou_thr" 和 "my:thr@1:connection"。
+            当 f_p_name_builder=lambda idx, p_type: f'my{idx}' 时，
+            这些参数在 trial 中注册的名称分别是 "my:thr@0:interval_thr"，"my:thr@1:iou_thr" 和 "my:thr@1:connection"。
             特别地，
                 - 对于字典形式的 choices，其中保存在 trial 中的取值是其键 key 而非 value。
                 - 对于list形式，但含有非支持类型的  choices，其中保存在 trial 中的取值是元素的 index。
             这些名称的含义详见 get_value()。
     """
+    if f_p_name_builder is None:
+        f_p_name_builder = lambda idx, p_type: idx
+    if not b_use_name_as_idx:
+        p_name_builder = lambda idx, p_type: f_p_name_builder(ndl.name_handler.parse_name(idx)[-1][-1], p_type)
+    else:
+        p_name_builder = f_p_name_builder
 
-    name_ls=[]
+    node_vs_paras_s = dict()
+    p_name_set = set()
 
     def func(idx, v):
-        nonlocal name_ls
+        nonlocal node_vs_paras_s, p_name_builder
+
         p_type = v.pop("p_type")
+        p_name = v.pop("p_name") if "p_name" in v else f'{p_name_builder(idx, p_type)}'
+        assert p_name not in p_name_set, \
+            f"p_name={p_name} is duplicated!"
+        p_name_set.add(p_name)
         kwargs = v
+        #
         choice_values = None
         if p_type == "categorical":
             # optuna 目前的类别元素仅支持 None, bool, int, float 和 str 类型
@@ -83,14 +108,15 @@ def sample_from_feasible_domain(var, trial: optuna.trial.BaseTrial, pre_name="")
                 choice_values = kwargs["choices"]
                 kwargs["choices"] = list(kwargs["choices"].keys())
 
-        v = eval(f'trial.suggest_{p_type}(name=name, **kwargs)',
-                 {"trial": trial, "name": f'{pre_name}{idx}', "kwargs": kwargs})
+        v = eval(f'trial.suggest_{p_type}(name=name, **kwargs)', {"trial": trial, "name": p_name, "kwargs": kwargs})
         if choice_values is not None:
             v = choice_values[v]
-        name_ls.append(idx)
+
+        #
+        node_vs_paras_s[idx] = p_name
         return v
 
     var = ndl.traverse(var=var, match_cond=lambda _, __, v: isinstance(v, (dict,)) and "p_type" in v,
                        action_mode="replace", converter=func, b_use_name_as_idx=True)
 
-    return var, name_ls
+    return var, node_vs_paras_s

kevin_toolbox/patches/for_os/__init__.py

@@ -1,3 +1,4 @@
 from .remove import remove
 from .pack import pack
 from .unpack import unpack
+from .walk import walk, Path_Ignorer, Ignore_Scope

kevin_toolbox/patches/for_os/remove.py

@@ -4,13 +4,15 @@ import shutil
 
 def remove(path, ignore_errors=False):
     """
-        移除文件/文件夹
+        移除文件/文件夹/软连接
 
         返回:
             boolean 是否成功
     """
     try:
-        if os.path.isfile(path):  # 移除文件
+        if os.path.islink(path):  # 移除软连接
+            os.unlink(path)
+        elif os.path.isfile(path):  # 移除文件
             os.remove(path)
         elif os.path.isdir(path):  # 移除文件夹
             shutil.rmtree(path=path, ignore_errors=False)

kevin_toolbox/patches/for_os/walk.py

@@ -0,0 +1,167 @@
+import os
+from collections import defaultdict
+from enum import Enum
+
+
+class Ignore_Scope(Enum):
+    ROOT = "root"
+    DIRS = "dirs"
+    FILES = "files"
+
+
+class Path_Ignorer:
+    def __init__(self, ignore_s=None):
+        self.ignore_s = defaultdict(list)
+        try:
+            if isinstance(ignore_s, (list, tuple)):
+                for it in ignore_s:
+                    for scope in it["scope"]:
+                        scope = Ignore_Scope(scope)
+                        self.ignore_s[scope].append(it["func"])
+            elif isinstance(ignore_s, (dict,)):
+                for k, v in ignore_s.items():
+                    self.ignore_s[Ignore_Scope(k)].extend(v)
+        except:
+            raise ValueError(f'invalid ignore_s, got a {ignore_s}')
+
+    def __call__(self, scope, *args, **kwargs):
+        for func in self.ignore_s[scope]:
+            if func(*args, **kwargs):
+                return True
+        return False
+
+    def __len__(self):
+        return len(self.ignore_s)
+
+
+def walk(top, topdown=True, onerror=None, followlinks=False, ignore_s=None):
+    """
+        在 os.walk() 的基础上增加了以下功能
+            - 可以通过 ignore_s 参数来排除特定的目录和文件
+
+        参数：
+            （对于参数 top,topdown,onerror,followlinks，其用法与 os.walk() 完全相同）
+            top:                <path> 要遍历的目录
+            topdown:            <boolean> 是否从浅到深遍历
+                                    默认为 True，优先遍历完浅层目录
+            onerror:            <callable> 当遇到异常时，会调用该函数
+            followlinks:        <boolean> 是否遍历软链接目录
+                                    默认为 False，不对软链接进行进一步遍历
+            ignore_s:           <list/tuple of dict or dict> 排除规则
+                                    有两种输入方式：
+
+                                    方式 1 <list/tuple of dict>：
+                                        列表中每个字典需要具有以下键值对：
+                                            "scope":    <list/tuple of str> 该规则的作用范围
+                                                            可选值，及（满足规则时）对应效果：
+                                                                "root":         不遍历满足规则的目录
+                                                                "dirs":         将返回的三元组中第二个 dirs 部分中满足规则的部分移除
+                                                                "files":        将返回的三元组中第三个 files 部分中满足规则的部分移除
+                                            "func":     <callable> 排除规则
+                                                            当调用该函数的返回值为 True 时，执行排除。
+                                                            函数类型为 def(b_is_dir, b_is_symlink, path): ...
+                                                            其中：
+                                                                b_is_dir        是否是目录
+                                                                b_is_symlink    是否是软链接
+                                                                path            输入是对于作用范围 "root"，输入的直接就是 root，
+                                                                                对于作用范围 "dirs"，输入是 dirs 中的每个元素和 root 组成的绝对路径，
+                                                                                对于作用范围 "files"，输入是 files 中的每个元素和 root 组成的绝对路径。
+                                            注意：
+                                                - 当有多个规则时，只要满足其一即会进行排除。
+                                                - 任何规则都不会对 top 目录进行过滤，亦即对 top 的遍历是必然的。不能通过设定某个 top 满足的规则来停止对 top 的遍历。
+                                        比如，通过下面的规则就可以实现不对 basename 为 "test" 和 "temp" 的目录进行遍历和输出，
+                                        同时只保留非软连接的 .png 和 .jpg 文件：
+                                            [
+                                                {
+                                                    "func": lambda _, __, path: os.path.basename(path) in ["temp", "test"],
+                                                    "scope": ["root", "dirs"]
+                                                },
+                                                {
+                                                    "func": lambda _, b_is_symlink, path: b_is_symlink or not path.endswith((".png",".jpg")),
+                                                    "scope": ["files", ]
+                                                }
+                                            ]
+
+                                    方式 2 <dict>:
+                                        一个以 scope 为键，func 为值的字典。
+                                        延续上面的例子，其另一种等效形式为：
+                                            {
+                                                "root": [
+                                                    lambda _, __, path: os.path.basename(path) in ["temp", "test"],
+                                                ],
+                                                "dirs": [
+                                                    lambda _, __, path: os.path.basename(path) in ["temp", "test"],
+                                                ],
+                                                "files": [
+                                                    lambda _, b_is_symlink, path: b_is_symlink or not path.endswith((".png",".jpg")),
+                                                ]
+                                            }
+
+                                    方式 3 <Path_Ignorer>:
+                                        根据 ignore_s 构建的 Path_Ignorer
+
+    """
+    # 根据 ignore_s 构建 Path_Ignorer
+    path_ignorer = ignore_s if isinstance(ignore_s, (Path_Ignorer,)) else Path_Ignorer(ignore_s=ignore_s)
+
+    #
+    yield from __walk(top, topdown, onerror, followlinks, path_ignorer)
+
+
+def __walk(top, topdown, onerror, followlinks, path_ignorer):
+    #
+    top = os.fspath(top)
+    dirs, files = [], []
+    walk_dirs = []
+
+    try:
+        scandir_it = os.scandir(top)
+    except OSError as error:
+        if onerror is not None:
+            onerror(error)
+        return
+
+    with scandir_it:
+        while True:
+            try:
+                try:
+                    entry = next(scandir_it)
+                except StopIteration:
+                    break
+            except OSError as error:
+                if onerror is not None:
+                    onerror(error)
+                return
+
+            try:
+                is_dir = entry.is_dir()
+            except OSError:
+                is_dir = False
+
+            if is_dir:
+                dirs.append(entry.name)
+                walk_dirs.append(os.path.join(top, entry.name))
+            else:
+                files.append(entry.name)
+
+    # 过滤
+    if len(path_ignorer) > 0:
+        for it_ls, scope in zip([walk_dirs, dirs, files], [Ignore_Scope.ROOT, Ignore_Scope.DIRS, Ignore_Scope.FILES]):
+            for i in reversed(range(len(it_ls))):
+                path = os.path.join(top, it_ls[i]) if scope != Ignore_Scope.ROOT else it_ls[i]
+                if path_ignorer(scope, scope != Ignore_Scope.FILES, os.path.islink(path), path):
+                    it_ls.pop(i)
+
+    #
+    if topdown:
+        yield top, dirs, files
+        #
+        for new_path in walk_dirs:
+            if followlinks or not os.path.islink(new_path):
+                yield from __walk(new_path, topdown, onerror, followlinks, path_ignorer)
+    else:
+        for new_path in walk_dirs:
+            if followlinks or not os.path.islink(new_path):
+                yield from __walk(new_path, topdown, onerror, followlinks, path_ignorer)
+        #
+        yield top, dirs, files

kevin_toolbox_dev-1.3.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: kevin-toolbox-dev
+Version: 1.3.0
+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
+Requires-Dist: torch (>=1.2.0)
+Requires-Dist: numpy (>=1.19.0)
+Provides-Extra: plot
+Requires-Dist: matplotlib (>=3.0) ; extra == 'plot'
+Provides-Extra: rest
+Requires-Dist: pytest (>=6.2.5) ; extra == 'rest'
+Requires-Dist: line-profiler (>=3.5) ; 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.3.0 （2023-12-13）【bug fix】【new feature】【incompatible change】
+  - nested_dict_list
+    - serializer
+      - 【bug fix】fix bug in read() and write()，解除这两个函数中出现的 nested_dict_list 和 kevin_toolbox.computer_science.algorithm.registration.Registry 模块之间的交叉引用。
+    - 【bug fix】fix bug in set_value()，对于使用method=@，但是node不为正整数的name进行强制写入的情况，未修复前表现为错误地尝试使用list进行构建并报错，现修复为使用 dict 进行构建。在新的策略下，对于强制写入，只有 method=@ 且 node 为非负正整数的情况下才会使用 list 进行构建，其他一律用 dict。
+      - 添加了对应的测试用例。
+  - patches.for_os
+    - 【new feature】add walk()，该方法在 os.walk() 的基础上增加了 ignore_s 参数，用于设定规则排除特定的目录和文件。相较于先使用 os.walk() 递归遍历这个目录，再对内容进行逐个过滤筛选的这种方式，本方法在遍历过程中就可以使用规则进行过滤并决定是否要继续深入遍历，更加高效。
+      - 补充了对应的测试用例。
+    - 【new feature】add Path_Ignorer，该类用于解释 ignore_s 参数，并进行基于规则的判断。
+    - 【new feature】modify remove()，支持对软连接的删除。
+  - computer_science.algorithm.registration
+    - 【new feature】【incompatible change】modify Registry.collect_from_paths()，将原有的通过目录前缀匹配来排除目录的 path_ls_to_exclude 参数，替换成通过规则匹配待排除目录的 ignore_s 参数，更加自由灵活。ignore_s 参数的设定方式与 for_os.walk() 中的 ignore_s 参数相同。
+      - 添加了对应的测试用例。
+  - patches.for_optuna
+    - 【new feature】【incompatible change】modify sample_from_feasible_domain()，进行了以下改变：
+      - 允许在 <feasible_domain> 中通过 "p_name" 字段来强制指定该参数在 trial 中的注册名称。
+      - 支持通过 f_p_name_builder 和 b_use_name_as_idx 决定如何从 <feasible_domain> 的位置生成参数的注册名称。
+      - 删去了 pre_name 参数，如果要实现原 pre_name 的效果，可以等效使用：
+        - `f_p_name_builder =lambda idx, p_type: f'{pre_name}{idx}'`
+      - 原来返回 var, node_name_ls 改为返回 var, node_vs_paras_s，其中 node_vs_paras_s 是一个`<dict>`，以被采样的节点在 var 中位置的名称作为键，以对应节点在 trial 中注册的参数名为值。

{kevin_toolbox_dev-1.2.7.dist-info → kevin_toolbox_dev-1.3.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kevin_toolbox/__init__.py,sha256=2_ntSVYDatiXtpDCOlmtORdDEtjh7diI0smSuFtn-34,410
+kevin_toolbox/__init__.py,sha256=W_CLt--CjnjEw_hvNoQ6sNjhKqIx6otWbRWTAdprkh0,410
 kevin_toolbox/computer_science/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kevin_toolbox/computer_science/algorithm/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 kevin_toolbox/computer_science/algorithm/combinatorial_optimization/__init__.py,sha256=fBMX0_WiV8kfHLWZNfVe2uL67gsN_oHfpbuHaHUOiys,142
@@ -25,16 +25,19 @@ kevin_toolbox/computer_science/algorithm/parallel_and_concurrent/multi_thread_ex
 kevin_toolbox/computer_science/algorithm/pareto_front/__init__.py,sha256=LbeaSzG0hkx8NHAlzvEalrGi2WufaXguVfeBRzaw-MA,57
 kevin_toolbox/computer_science/algorithm/pareto_front/get_pareto_points_idx.py,sha256=a-8Js-dpkuVu9MsImW9hwHp9OTC278xo9oJP96oX0Io,2712
 kevin_toolbox/computer_science/algorithm/registration/__init__.py,sha256=teEd9HkrB6baLpwNwae5c4wn0QRwV3KtBv-2V9-Z7cc,49
-kevin_toolbox/computer_science/algorithm/registration/registry.py,sha256=_4s3u3hpg0jPmOv9UldzHe2Oa_XGQErjl9xTEwSCTwk,13842
+kevin_toolbox/computer_science/algorithm/registration/registry.py,sha256=rAs7kG_f6P9AL264TuUin_8-jgYnQNo7EB8axgtCxkk,15383
 kevin_toolbox/computer_science/algorithm/scheduler/__init__.py,sha256=ENzZsNaMu6ISilTxeE3_EP_L0dNi8SI7IYdTdxic2nw,76
 kevin_toolbox/computer_science/algorithm/scheduler/strategy_manager.py,sha256=yLh2GBEsedJhqvB90zEmAOdZ8IF7nn1r9lSE95BbnEQ,12194
 kevin_toolbox/computer_science/algorithm/scheduler/trigger.py,sha256=YlqTX2TE44BwcQI0jfvcBCJhouhdAYuhwu2QJhuBWP0,4470
 kevin_toolbox/computer_science/algorithm/search/__init__.py,sha256=zja7FXLTNd2dSVzzGp1TbBp4i3TDY8S9tcJ9pqc684A,41
 kevin_toolbox/computer_science/algorithm/search/binary_search.py,sha256=FcOdgxfuNews_AhPF_CoQDr2vBPqpUpifF7Fmgml1p4,1013
-kevin_toolbox/computer_science/algorithm/statistician/__init__.py,sha256=zW1zesXYNjh6cAZPz_gsXd2LEEPlvA7SNB0huCb9WCg,120
-kevin_toolbox/computer_science/algorithm/statistician/_init_var.py,sha256=-u9RFiiPFlCLwdVfVZslYq9jNyDz4r_A9kRSH05sExw,904
-kevin_toolbox/computer_science/algorithm/statistician/average_accumulator.py,sha256=hdgpnMtvBQri-_ZxEAkSwyK6_qy4sJdqEeYauOBgLMI,3101
-kevin_toolbox/computer_science/algorithm/statistician/exponential_moving_average.py,sha256=P5E1EL1ioRAz_vlI-Ls9gZFhxVA83eTNjUppb2WqdlM,5571
+kevin_toolbox/computer_science/algorithm/statistician/__init__.py,sha256=_ZAqOf9yUcGzn0ByVYhj9xZMdljzQj1mZNXGfHOFb4k,167
+kevin_toolbox/computer_science/algorithm/statistician/accumulator_base.py,sha256=1JgznVWBLOn4dXkiMJphhyj6HPLFzXIe98jxc_rTzJg,6098
+kevin_toolbox/computer_science/algorithm/statistician/average_accumulator.py,sha256=dxWg8B3APM7Y9qRtFLP2CNbmPivpSzln-VdSVh0xykA,2570
+kevin_toolbox/computer_science/algorithm/statistician/exponential_moving_average.py,sha256=t5MxoCFVRz9qnRncdGQEIDKAKtMTqijv2n6gHaMLeRM,5363
+kevin_toolbox/computer_science/algorithm/statistician/init_var/__init__.py,sha256=LrrLKilP-LqkNeLEqClZN4wMl9TvEaDktgbmw7CN1mY,121
+kevin_toolbox/computer_science/algorithm/statistician/init_var/init_by_data_format.py,sha256=vCLguGS7het-gwPZ5uR2KDxnHV4gPaNbzJflocLbmLQ,769
+kevin_toolbox/computer_science/algorithm/statistician/init_var/init_by_like.py,sha256=8QfvltiNDqZUYiNW6Ebt0UIuYvyqhSpsCYn99T2q70c,572
 kevin_toolbox/computer_science/algorithm/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kevin_toolbox/computer_science/data_structure/__init__.py,sha256=_esL73v9Gi40xb5N7UGxslIk8yHM6idQlXbzELR7XhA,31
 kevin_toolbox/computer_science/data_structure/executor.py,sha256=i-2zQj4lj597BvkarCMT-gYxhoRe8cHyQyO98X7m-9E,6206
@@ -50,7 +53,7 @@ kevin_toolbox/data_flow/core/reader/unified_reader.py,sha256=k1-I4rj5bjPix-_jni7
 kevin_toolbox/data_flow/core/reader/unified_reader_base.py,sha256=P7uqkjfHwc_KHUpAdOy-sCwCSM8lzF_8ZtDmg6FhiX0,11929
 kevin_toolbox/data_flow/file/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 kevin_toolbox/data_flow/file/json_/__init__.py,sha256=VAt8COS2tO3PJRuhSc43i35fEOlArFM_YahdTmEBaHE,85
-kevin_toolbox/data_flow/file/json_/read_json.py,sha256=kjaf9tkROOLTJwICHRHmn_BID9Jyz7wXjR43IIpmtrs,1753
+kevin_toolbox/data_flow/file/json_/read_json.py,sha256=XzygeWCxDeO95Q0Wl2Z8lXgfVUCdEyLMph4NpN-nh44,1784
 kevin_toolbox/data_flow/file/json_/write_json.py,sha256=F7wkolZkggAh6H8YExcVxmy-109BliYTtNYmr0JI_-E,2355
 kevin_toolbox/data_flow/file/json_/converter/__init__.py,sha256=jQoEaS57dl33O0XguHBEilkVmn0q-LiStKWSiqXZNLc,369
 kevin_toolbox/data_flow/file/json_/converter/convert_dict_key_to_number.py,sha256=SuSZj_HCqKZutHAJ5AttABnGBRZplPGQhMxJBt2Wlgc,559
@@ -75,7 +78,7 @@ kevin_toolbox/data_flow/file/kevin_notation/test/test_data/data_all.py,sha256=cv
 kevin_toolbox/data_flow/file/markdown/__init__.py,sha256=iTZTBvcEUehBdcWxzFQEW4iEcXbAQkdkEmENiGtBjqs,125
 kevin_toolbox/data_flow/file/markdown/generate_link.py,sha256=9okSyCFIDQW5T35a6-epVyoCkCL1vFH5215P5MRXfYk,304
 kevin_toolbox/data_flow/file/markdown/generate_list.py,sha256=Gv5BcqWE4M4w8ADN8NX5LyD9DxILXTQtJvcazi_NuyE,1006
-kevin_toolbox/data_flow/file/markdown/generate_table.py,sha256=dWtsKVu8wxVJVRLJ1jzeB-OjzAc9I_f_1DVKOHEZkRM,1236
+kevin_toolbox/data_flow/file/markdown/generate_table.py,sha256=Xh9IRqLaeVoXDoFF1u6temMgf4MRng6pawJiUDknEdg,7209
 kevin_toolbox/developing/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 kevin_toolbox/developing/general_matrix_multiplication.py,sha256=Ie9c8mYBYR-Bg7CjU4L1dsOxXsxnx1jz-rA7_ez7vjg,2089
 kevin_toolbox/developing/test.py,sha256=6Y23SY3FJVrvZmiiXKNPKv84lhVRW-XyjNeecj9lLYA,241
@@ -194,21 +197,22 @@ kevin_toolbox/math/utils/get_function_table_for_array_and_tensor.py,sha256=hZrXb
 kevin_toolbox/math/utils/set_crop_by_box.py,sha256=NzW7M26Av097RchLUAhaO84ETLV121uxsNot_U6otLw,1775
 kevin_toolbox/math/utils/spilt_integer_most_evenly.py,sha256=H0H7FixHsYtPVElIfVpuH7s7kaQ0JQI0r0Eu_HCvfwY,345
 kevin_toolbox/nested_dict_list/__init__.py,sha256=dYhc3G6DqaV-BfHY8JUfXLOIbYsWpR8mgbpgdv4emC4,296
-kevin_toolbox/nested_dict_list/copy_.py,sha256=GTO3D55DSlGONAChLHllWGPa2dxM52yzEcmN7xay2Ww,6161
+kevin_toolbox/nested_dict_list/copy_.py,sha256=MvzNRKm8htYpMe7Td1ao2-ZoaYVC_iNTG7O2SBVrJKE,6144
 kevin_toolbox/nested_dict_list/count_leaf_node_nums.py,sha256=l67u47EvO1inoGinUqH6RZ7cHXwN0VcBQPUvSheqAvA,614
 kevin_toolbox/nested_dict_list/get_hash.py,sha256=Ygadnn5dnvIeE-9t39p2EwNKNRLzomL37ZsRD5daXxo,1286
 kevin_toolbox/nested_dict_list/get_nodes.py,sha256=MrWc08K_-hdaoaFRrUP_y2to3afUclf39BCfKnRCOGs,3457
 kevin_toolbox/nested_dict_list/get_value.py,sha256=isvUhqSQyUNHBXgNuZX6_o2c84UV_SpjNjAYm2M3gd4,2083
-kevin_toolbox/nested_dict_list/set_value.py,sha256=PaNQNsfz0_2evJmKHdF4saqIUPOYScAfC8wQJKwe3w4,3122
+kevin_toolbox/nested_dict_list/set_value.py,sha256=pmSWzC0y0jBxk7yritsjKU2Q-PPMar0X3A9bF6uWvoQ,3470
 kevin_toolbox/nested_dict_list/traverse.py,sha256=5_EirnYVy34JLfXxuTvb-mMjDeO1veyfLOcaVYcuGF8,6846
 kevin_toolbox/nested_dict_list/name_handler/__init__.py,sha256=P_pWq78oN6NdvWg2h6AduW_sUqbeaaVyoWWbW9kbgmU,107
 kevin_toolbox/nested_dict_list/name_handler/build_name.py,sha256=Hj8Bz-90DBezfQgbzThR1-C206dqY13KmEguFECQWMY,1020
 kevin_toolbox/nested_dict_list/name_handler/escape_node.py,sha256=niT9MxmsyrSZYhKXlWzdoKXVYhWRCR-kmQBkZopznpA,1163
 kevin_toolbox/nested_dict_list/name_handler/parse_name.py,sha256=QpF8y7OuI4G6pS6sH_EXAV2TzJXYRu45bcIGJpVjiZc,2311
-kevin_toolbox/nested_dict_list/serializer/__init__.py,sha256=Fn38vJkHXdcvMc83VzCZBqVIyjFblmR7T5d49o7RvC0,48
-kevin_toolbox/nested_dict_list/serializer/read.py,sha256=2tT0yn3qq_cXxC5380el-RpY3ONM4QhZ0RrcHcmfcLk,2572
-kevin_toolbox/nested_dict_list/serializer/variable.py,sha256=K4xGehjnRoLbb5321-QXQkSH5UnPo9dExrVtPmt6xE4,1239
-kevin_toolbox/nested_dict_list/serializer/write.py,sha256=KdMq3QocIoGEKSQcG09GxPuieU4pvRGv0TeQk21mGtw,18115
+kevin_toolbox/nested_dict_list/serializer/__init__.py,sha256=xLDfzSZIDNBssHArUEK84gF6WZFR64qJy0iOpM8LbP8,92
+kevin_toolbox/nested_dict_list/serializer/enum_variable.py,sha256=RWPydtXI4adOJYGo_k5CWHSL0Odzj_bsahb24p1ranY,847
+kevin_toolbox/nested_dict_list/serializer/read.py,sha256=8196AZW3y1eZNguw5fDi5gQmOtpJ0MdqhRNHZ5EWYHI,2577
+kevin_toolbox/nested_dict_list/serializer/variable.py,sha256=ZywG6obipRBCGY1cY42gdvsuWk8GLZXr6eCYcW7ZJ9c,392
+kevin_toolbox/nested_dict_list/serializer/write.py,sha256=sQtryi7NbVWynOMWpKKkqxoTf9dxSGE4yC4ReIAxT8U,18145
 kevin_toolbox/nested_dict_list/serializer/backends/__init__.py,sha256=8g7y-L3cmctxao616dVkGiot00FJzKNmNl_69V2bSmE,39
 kevin_toolbox/nested_dict_list/serializer/backends/_json_.py,sha256=oJXIc28yjxsD9ZJuw120pVHTVsTzCdaXEhVUSQeydq4,2145
 kevin_toolbox/nested_dict_list/serializer/backends/_ndl.py,sha256=QMF4DFAnt1sp35atds6t44nfCYuIOeGgW1-SPfJq6KM,1652
@@ -230,17 +234,18 @@ kevin_toolbox/patches/for_matplotlib/__init__.py,sha256=VNY4dGXSaB87HWek85xDRGOf
 kevin_toolbox/patches/for_matplotlib/add_trajectory_2d.py,sha256=mKXRUNJiEZBcff3pAkwL_gcKGn55CLRhYCTSd3fj1Go,1837
 kevin_toolbox/patches/for_matplotlib/add_trajectory_3d.py,sha256=VGlZfVY0xhUBOUzWJVPxZZNHHRvWLR0HZzhADA_cbsU,1696
 kevin_toolbox/patches/for_matplotlib/arrow3d.py,sha256=JSnNMr1hU2N4FUX526I4MDr04mksDgu4VuegYFDxk1Q,1361
-kevin_toolbox/patches/for_numpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kevin_toolbox/patches/for_numpy/__init__.py,sha256=SNjZGxTRBn-uzkyZi6Jcz-9juhhZKT8TI70qH-fhGGc,21
 kevin_toolbox/patches/for_numpy/linalg/__init__.py,sha256=qRoO08nCQJyodtdH8S-ZRhWZvW4qyVnWQL6Ok7iXpjY,99
 kevin_toolbox/patches/for_numpy/linalg/cos_similar.py,sha256=bFkfDwrW3maXq5i9ZABidKfg8ZdEdXfFgNzW_uygrM4,423
 kevin_toolbox/patches/for_numpy/linalg/normalize.py,sha256=7qstt__rwUkk3jRJOQoneBp9YdfhYQtWfh6PZoWbvaA,625
-kevin_toolbox/patches/for_numpy/linalg/softmax.py,sha256=Wdyvu7SwtQ7IUuhb_6YJijW3N99JKE6GumuhjZWJ5Rg,253
+kevin_toolbox/patches/for_numpy/linalg/softmax.py,sha256=5ukhay9SvQoOch6czEXuJXqXg47Q1fokrv_zZTDHRjI,2035
 kevin_toolbox/patches/for_optuna/__init__.py,sha256=w7FuRlbX4rqVlpwOSAGQ2Y3ZhCglW81n2_4usHzIyJU,69
-kevin_toolbox/patches/for_optuna/sample_from_feasible_domain.py,sha256=zZcM7v1kAgEQGtN8oXVe0V2GiyGPUV16SujczF7ruxM,5325
-kevin_toolbox/patches/for_os/__init__.py,sha256=Gt9psQWmC5zt8DazalHnWk9IAy9CFdCRn9FV0m2dgu4,77
+kevin_toolbox/patches/for_optuna/sample_from_feasible_domain.py,sha256=-Ckwo2N4vhWr08F7ROLfwLWIx4ERwdwn4Q5Ft2JRm7g,7071
+kevin_toolbox/patches/for_os/__init__.py,sha256=Q6GzEPWggV4EovJdrertlL2l__W7k0zUEpuQIQDcA7A,128
 kevin_toolbox/patches/for_os/pack.py,sha256=A6u4g3dfwXPtlU4gBcThNrktz6dO4DVi2wmQXytqfDI,656
-kevin_toolbox/patches/for_os/remove.py,sha256=ji71D3BQA8g-xZr7IMRD9ANXfdsszS9QXDopAfVHfnw,658
+kevin_toolbox/patches/for_os/remove.py,sha256=PmwqzVJbyfdqwXn_T1F9d4Oar8CwQ2YFaqcZQkfnrnI,750
 kevin_toolbox/patches/for_os/unpack.py,sha256=d_fO7nPmExy1VIg7ADIMayCzjBBeFxvJLhIsulIRlzI,1047
+kevin_toolbox/patches/for_os/walk.py,sha256=LrtEeRUDwzZgu_zGZ-kPsFJd4D-8R8ECHW6WNdEsDSw,8376
 kevin_toolbox/patches/for_test/__init__.py,sha256=sFr2VZD1zk8Vtjq2_F8uE4xNovJF6yDY8j1YND5XAw0,49
 kevin_toolbox/patches/for_test/check_consistency.py,sha256=5zwjHc0M3A-RTYcgZpIugm6-L-m2pDSG496dCkg8Q4Q,5038
 kevin_toolbox/patches/for_torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -258,7 +263,7 @@ kevin_toolbox/patches/for_torch/math/get_y_at_x.py,sha256=bfoVcasZ_tMdhR_1Me0Jli
 kevin_toolbox/patches/for_torch/math/my_around.py,sha256=ptpU3ids50gwf663EpHbw7raj9tNrDGBFZ5t_uMNH14,1378
 kevin_toolbox/patches/for_torch/nn/__init__.py,sha256=aJs3RMqRzQmd8KKDmQW9FxwCqS5yfPqEdg-m0PwlQro,39
 kevin_toolbox/patches/for_torch/nn/lambda_layer.py,sha256=KUuLiX_Dr4bvRmpAaCW5QTDWDcnMPRnw0jg4NNXTFhM,223
-kevin_toolbox_dev-1.2.7.dist-info/METADATA,sha256=3Uz7Am_zWp3g0DfPQm1wJa55sikzRDML4VxCwIEVkjo,3104
-kevin_toolbox_dev-1.2.7.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-kevin_toolbox_dev-1.2.7.dist-info/top_level.txt,sha256=S5TeRGF-PwlhsaUEPTI-f2vWrpLmh3axpyI6v-Fi75o,14
-kevin_toolbox_dev-1.2.7.dist-info/RECORD,,
+kevin_toolbox_dev-1.3.0.dist-info/METADATA,sha256=Lv7LGBtCfRboHibUCT2EhwceSzrBneAbK7vwo5IJFss,3843
+kevin_toolbox_dev-1.3.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+kevin_toolbox_dev-1.3.0.dist-info/top_level.txt,sha256=S5TeRGF-PwlhsaUEPTI-f2vWrpLmh3axpyI6v-Fi75o,14
+kevin_toolbox_dev-1.3.0.dist-info/RECORD,,