kevin-toolbox-dev 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

kevin_toolbox/data_flow/file/kevin_notation/test/test_kevin_notation.py

@@ -134,11 +134,23 @@ def test_writer_1(expected_metadata, expected_content, file_path):
                          zip(metadata_ls, content_ls, file_path_ls))
 def test_read(expected_metadata, expected_content, file_path):
     print("test read()")
-    # 读取
+    # 使用 file_path 读取
     metadata, content = kevin_notation.read(file_path=file_path)
+
+    # 使用 file_obj 读取
+    file_obj = open(file_path, "r")
+    metadata_1, content_1 = kevin_notation.read(file_obj=file_obj)
+    assert len(file_obj.read()) > 0  # 不影响输入的 file_obj
+
+    # 使用字符串构造 file_obj 读取
+    from io import StringIO
+    file_obj = StringIO(initial_value=open(file_path, "r").read())
+    metadata_2, content_2 = kevin_notation.read(file_obj=file_obj)
+    assert len(file_obj.read()) > 0
+
     # 检验
-    check_consistency(expected_metadata, metadata)
-    check_consistency(expected_content, content)
+    check_consistency(expected_metadata, metadata, metadata_1, metadata_2)
+    check_consistency(expected_content, content, content_1, content_2)
 
 
 @pytest.mark.parametrize("expected_metadata, expected_content, file_path",

kevin_toolbox/data_flow/file/markdown/generate_table.py

@@ -1,4 +1,4 @@
-from kevin_toolbox.math.utils import spilt_integer_most_evenly
+from kevin_toolbox.math.utils import split_integer_most_evenly
 
 
 def generate_table(content_s, orientation="vertical", chunk_nums=None, chunk_size=None, b_allow_misaligned_values=False,
@@ -60,7 +60,7 @@ def generate_table(content_s, orientation="vertical", chunk_nums=None, chunk_siz
     # 按照 chunk_nums 或者 chunk_size 对表格进行分割
     if chunk_nums is not None or chunk_size is not None:
         if chunk_nums is not None:
-            split_len_ls = spilt_integer_most_evenly(x=max_length, group_nums=chunk_nums)
+            split_len_ls = split_integer_most_evenly(x=max_length, group_nums=chunk_nums)
         else:
             split_len_ls = [chunk_size] * (max_length // chunk_size)
             if max_length % chunk_size != 0:

kevin_toolbox/math/utils/__init__.py

@@ -2,4 +2,4 @@ from .get_function_table_for_array_and_tensor import get_function_table_for_arra
 from .convert_dtype import convert_dtype
 from .get_crop_by_box import get_crop_by_box
 from .set_crop_by_box import set_crop_by_box
-from .spilt_integer_most_evenly import spilt_integer_most_evenly
+from .split_integer_most_evenly import split_integer_most_evenly

kevin_toolbox/math/utils/{spilt_integer_most_evenly.py → split_integer_most_evenly.py}

@@ -1,7 +1,7 @@
 import numpy as np
 
 
-def spilt_integer_most_evenly(x, group_nums):
+def split_integer_most_evenly(x, group_nums):
     assert isinstance(x, (int, np.integer,)) and x >= 0 and group_nums > 0
 
     res = np.ones(group_nums, dtype=int) * (x // group_nums)
@@ -10,4 +10,4 @@ def spilt_integer_most_evenly(x, group_nums):
 
 
 if __name__ == '__main__':
-    print(spilt_integer_most_evenly(x=100, group_nums=7))
+    print(split_integer_most_evenly(x=100, group_nums=7))

kevin_toolbox/nested_dict_list/get_nodes.py

@@ -25,21 +25,26 @@ def get_nodes(var, level=-1, b_strict=True):
     assert isinstance(level, (int,))
     if level == 0:
         return [("", var)]
+
+    # 首先找出所有叶节点 level=-1，以及空的 level=-2 的节点
     res = []
+    res_empty = set()
 
-    # 首先找出所有叶节点 level=-1
     def func(_, idx, v):
         nonlocal res
         if not isinstance(v, (list, dict,)):
             res.append((idx, v))
+        elif len(v) == 0:
+            res_empty.add(idx + "@None")  # 添加哨兵，表示空节点，并不会被实际解释
         return False
 
     traverse(var=var, match_cond=func, action_mode="skip", b_use_name_as_idx=True)
 
     if level != -1:
         names = set()
+        leaf_node_names = res_empty.union(set(i for i, _ in res))
         if level < -1:
-            for name, _ in res:
+            for name in leaf_node_names:
                 root_node, _, node_ls = parse_name(name=name, b_de_escape_node=False)
                 node_ls.insert(0, root_node)
                 temp = [len(i) for i in node_ls[level + 1:]]
@@ -50,7 +55,7 @@ def get_nodes(var, level=-1, b_strict=True):
                     temp = max(temp, 0)
                 names.add(name[:temp])
         elif level > 0:
-            for name, _ in res:
+            for name in leaf_node_names:
                 root_node, _, node_ls = parse_name(name=name, b_de_escape_node=False)
                 node_ls.insert(0, root_node)
                 temp = [len(i) for i in node_ls[:level + 1]]
@@ -61,7 +66,7 @@ def get_nodes(var, level=-1, b_strict=True):
         else:
             raise ValueError
         res.clear()
-        for name in names:
+        for name in names.difference(res_empty):
             res.append((name, get_value(var=var, name=name)))
 
     return res

kevin_toolbox/nested_dict_list/name_handler/build_name.py

@@ -1,5 +1,5 @@
 import re
-from kevin_toolbox.nested_dict_list.name_handler import escape_node
+from .escape_node import escape_node
 
 
 def build_name(root_node, method_ls, node_ls, b_escape_node=True):

kevin_toolbox/nested_dict_list/name_handler/parse_name.py

@@ -1,5 +1,5 @@
 import re
-from kevin_toolbox.nested_dict_list.name_handler import escape_node
+from .escape_node import escape_node
 
 
 def parse_name(name, b_de_escape_node=True):

kevin_toolbox/nested_dict_list/set_default.py

@@ -1,40 +1,56 @@
 from kevin_toolbox.nested_dict_list import get_value, set_value
 
 
-def set_default(var, name, default, b_force=False, cache_for_verified_names=None):
+def set_default(var, name, default, b_force=False, cache_for_verified_names=None, b_return_var=False):
     """
         当 name 指向的位置在 var 中不存在时，将会把 default 插入到对应的位置。
             （类似于 dict.setdefault() 的行为）
 
         参数：
-            var:            任意支持索引赋值的变量
-            name:           <string> 名字（位置）
-                                名字 name 的具体介绍参见函数 name_handler.parse_name()
-            default:        默认值
-            b_force:        <boolean> 当无法将 default 设置到 name 指定的位置时，是否尝试创建或者修改 var 中的节点
-                                默认为 False，此时若无法设置，则报错
-                                当设置为 True，可能会对 var 的结构产生不可逆的改变，请谨慎使用。
-                注意：
-                    若 b_force 为 True 有可能不会在 var 的基础上进行改变，而是返回一个新的ndl结构，
-                    因此建议使用赋值 var = ndl.set_default(var) 来避免可能的错误。
+            var:                任意支持索引赋值的变量
+            name:               <string> 名字（位置）
+                                    名字 name 的具体介绍参见函数 name_handler.parse_name()
+            default:            默认值
+            b_force:            <boolean> 当无法将 default 设置到 name 指定的位置时，是否尝试创建或者修改 var 中的节点
+                                    默认为 False，此时若无法设置，则报错
+                                    当设置为 True，可能会对 var 的结构产生不可逆的改变，请谨慎使用。
+                    注意：
+                        若 b_force 为 True 有可能不会在 var 的基础上进行改变，而是返回一个新的ndl结构，
+                        因此建议使用赋值 var = ndl.set_default(var) 来避免可能的错误。
 
             cache_for_verified_names:   <set> 用于缓存已检验的 name
-                                默认为 None，不使用缓存。
-                                当设为某个集合时，将开启缓存。此时将首先判断 name 是否在缓存中，若在，则视为之前已经对该 name 成功进行过 set_default()
-                                    操作，没有必要再重复执行，因此直接跳过后续流程；若不在，则执行 set_default() 操作，并在成功执行之后将该 name
-                                    补充到缓存中。
-                                合理利用该缓存机制将可以避免对同一个 name 反复进行 set_default() 操作，从而提高效率。
-    """
-    if cache_for_verified_names is not None:
-        assert isinstance(cache_for_verified_names, (set,))
-        if name in cache_for_verified_names:
-            return var
+                                    默认为 None，不使用缓存。
+                                    当设为某个集合时，将开启缓存。此时将首先判断 name 是否在缓存中，若在，则视为之前已经对该 name 成功进行过 set_default()
+                                        操作，没有必要再重复执行，因此直接跳过后续流程；若不在，则执行 set_default() 操作，并在成功执行之后将该 name
+                                        补充到缓存中。
+                                    合理利用该缓存机制将可以避免对同一个 name 反复进行 set_default() 操作，从而提高效率。
+            b_return_var:       <boolean> 是否将 var 也添加到返回值中
+                                    默认为 False
+                                    由于本函数内调用的 set_value() 函数有可能不会在 var 的基础上进行改变，而是返回一个新的ndl结构，因此可以通过该参数，
+                                    将 var 通过返回以获取新的ndl。
+
+        返回：
+            res:                返回指定位置的值，或者默认值（与 dict.setdefault() 的行为一致）
 
-    temp = list()
-    if id(temp) == id(get_value(var=var, name=name, default=temp)):
-        # 获取失败，说明 name 指向的位置不存在，则尝试创建
-        var = set_value(var=var, name=name, value=default, b_force=b_force)
+            特别地，当 b_return_var=True 时，返回的是一个元组 res, var。
+    """
+    assert isinstance(cache_for_verified_names, (set, type(None)))
+    if cache_for_verified_names is not None and name in cache_for_verified_names:
+        try:
+            res = get_value(var=var, name=name)
+        except :
+            raise Exception(f'name {name} is in the cache, but it cannot be found in var')
+    else:
+        temp = list()
+        res = get_value(var=var, name=name, default=temp)
+        if id(temp) == id(res):
+            # 获取失败，说明 name 指向的位置不存在，则尝试创建
+            var = set_value(var=var, name=name, value=default, b_force=b_force)
+            res = default
+        if cache_for_verified_names is not None:
+            cache_for_verified_names.add(name)
 
-    if cache_for_verified_names is not None:
-        cache_for_verified_names.add(name)
-    return var
+    if b_return_var:
+        return res, var
+    else:
+        return res

kevin_toolbox/patches/for_matplotlib/__init__.py

@@ -1,3 +1,4 @@
 from .arrow3d import Arrow3D
 from .add_trajectory_2d import add_trajectory_2d
 from .add_trajectory_3d import add_trajectory_3d
+from .generate_color_list import generate_color_list

kevin_toolbox/patches/for_matplotlib/generate_color_list.py

@@ -0,0 +1,33 @@
+import random
+
+PREDEFINED = ['blue', 'red', 'green', 'orange', 'purple', 'yellow', "brown", "pink", "gray", "olive", "cyan"]
+
+
+def generate_color_list(nums, seed=None, exclude_ls=None):
+    """
+        参数:
+            nums:           <int> 生成颜色的数量
+            seed:           随机种子
+            exclude:        <list of str> 需要排除的颜色
+    """
+    global PREDEFINED
+    if exclude_ls is None:
+        exclude_ls = []
+    assert isinstance(exclude_ls, (list, tuple))
+
+    colors = [i for i in PREDEFINED if i not in exclude_ls][:nums]  # 优先输出预定义的颜色
+
+    # 随机生成剩余数量的颜色
+    if seed is not None:
+        random.seed(seed)
+    while len(colors) < nums:
+        c = "#" + ''.join(random.choices('0123456789ABCDEF', k=6))
+        if c not in colors and c not in exclude_ls:
+            colors.append(c)
+
+    return colors
+
+
+if __name__ == '__main__':
+    color_list = generate_color_list(20)
+    print(color_list)

kevin_toolbox/patches/for_numpy/linalg/__init__.py

@@ -1,3 +1,4 @@
 from .normalize import normalize
 from .softmax import softmax
 from .cos_similar import cos_similar
+from .entropy import entropy

kevin_toolbox/patches/for_numpy/linalg/entropy.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+
+def entropy(pdf, b_need_normalize=False):
+    """
+        参数：
+            pdf:                    <list/array> 概率分布
+            b_need_normalize:       <boolean> 是否将输出的熵归一化到 0~1 区间
+                                        默认为 False，此时输出的熵遵从原始定义，其大小范围与输出概率分布的维度 n 有关，为 0 ~ log_{2}(n)
+                                        当设置为 True，将会除以 log_{2}(n) 以进行归一化。
+    """
+    pdf = np.asarray(pdf, dtype=float).reshape(-1)
+    # 将概率分布数组中小于等于0的元素设为1，避免出现log(0)的情况
+    pdf = np.maximum(pdf, 1e-15)
+    #
+    pdf /= np.sum(pdf)
+    # 计算熵值
+    res = -np.sum(pdf * np.log2(pdf))
+    if b_need_normalize:
+        res /= np.log2(len(pdf))
+    return res
+
+
+if __name__ == '__main__':
+    print(entropy(pdf=[0.1, 0.1, 0.7, 0.1], b_need_normalize=True))  # 0.6783898247235198
+    print(entropy(pdf=[0.05, 0.05, 0.05, 0.05, 0.8], b_need_normalize=True))  # 0.4831881303119284

kevin_toolbox/patches/for_numpy/random/__init__.py

@@ -0,0 +1,3 @@
+from .get_rng import get_rng
+from .truncated_normal import truncated_normal
+from .truncated_multivariate_normal import truncated_multivariate_normal

kevin_toolbox/patches/for_numpy/random/get_rng.py

@@ -0,0 +1,64 @@
+import numpy as np
+
+
+class DEFAULT_RNG:
+    pass
+
+
+for name in np.random.__all__:
+    setattr(DEFAULT_RNG, name, getattr(np.random, name))
+
+func_map_s = {
+    'rand': lambda rng, *arg, **kwargs: rng.random(size=arg, **kwargs),
+    'randint': 'integers',
+    'randn': lambda rng, *arg, **kwargs: rng.normal(size=arg, **kwargs),
+    'random_integers': 'integers',
+    'random_sample': 'random',
+    'ranf': 'random'
+}
+
+
+class My_RNG:
+    def __init__(self, rng):
+        self._rng = rng
+
+        for name in np.random.__all__:
+            setattr(DEFAULT_RNG, name, getattr(np.random, name))
+
+    # self.key
+    def __getattr__(self, key):
+        if "_rng" not in self.__dict__:
+            # _rng 未被设置，未完成初始化。
+            return super().__getattr__(key)
+        else:
+            res = getattr(self._rng, key, None)
+            if res is None and key in func_map_s:
+                if callable(func_map_s[key]):
+                    res = lambda *arg, **kwargs: func_map_s[key](self._rng, *arg, **kwargs)
+                else:
+                    res = getattr(self._rng, func_map_s[key], None)
+            #
+            if res is None:
+                raise AttributeError(f"attribute '{key}' not found in {type(self)}")
+            else:
+                return res
+
+
+def get_rng(seed=None, rng=None, **kwargs):
+    if seed is not None:
+        # 注意，随机生成器相较于 numpy.random 有部分属性缺失：
+        #   ['get_state', 'rand', 'randint', 'randn', 'random_integers', 'random_sample', 'ranf', 'sample', 'seed',
+        #   'set_state', 'Generator', 'RandomState', 'SeedSequence', 'MT19937', 'Philox', 'PCG64', 'PCG64DXSM',
+        #   'SFC64', 'default_rng', 'BitGenerator']
+        rng = My_RNG(rng=np.random.default_rng(seed=seed))
+    if rng is not None:
+        return rng
+    else:
+        return DEFAULT_RNG
+
+
+if __name__ == '__main__':
+    a = get_rng(seed=2)
+
+    # 尝试访问随机生成器中缺失的部分方法
+    print(a.randn(2, 3))

kevin_toolbox/patches/for_numpy/random/truncated_multivariate_normal.py

@@ -0,0 +1,129 @@
+import numpy as np
+from scipy.stats import chi2
+from kevin_toolbox.patches.for_numpy.linalg import normalize
+from kevin_toolbox.patches.for_numpy.random import get_rng
+from kevin_toolbox.patches.for_numpy.random.variable import DEFAULT_SETTINGS
+from kevin_toolbox.computer_science.algorithm.cache_manager import Cache_Manager
+
+cache_for_cov = Cache_Manager(upper_bound=20, refactor_size=0.5)
+
+
+def truncated_multivariate_normal(
+        mean, cov=None, low_radius=None, high_radius=None, size=None, b_check_cov=False,
+        hit_ratio_threshold=DEFAULT_SETTINGS["truncated_multivariate_normal"]["hit_ratio_threshold"],
+        expand_ratio=DEFAULT_SETTINGS["truncated_multivariate_normal"]["expand_ratio"],
+        **kwargs):
+    """
+        从截断的多维高斯分布中进行随机采样
+
+        参数：
+            mean:                   <list of float> 均值
+            cov:                    <matrix> 协方差矩阵
+            low_radius,high_radius: <float> 截断边界
+                                        注意：
+                                            - 是截断多少倍 sigma 以内的部分。
+                                            - low_radius 是指排除该半径距离内的点
+                                            - high_radius 是指包含该半径距离内的点
+                                            - 区间为左闭右开，亦即 [low_radius, high_radius)
+            size:                   <tuple/list/int/None> 输出的形状
+            b_check_cov:            <boolean> 是否检查 cov 是正半定矩阵。
+                                        默认为 False 此时不检查
+                                        当设置为 True 时，若不通过检查将报错。
+
+        用于调节采样效率的超参数（与设备情况有关）：
+            hit_ratio_threshold:    <float> 决定采样方式的阈值
+                                        当 hit_ratio 小于该阈值时，使用方式 2 （重要性采样）来生成，
+                                        当大于阈值时，使用方式 1 采样 expand_ratio * size 个样本再挑选符合落在截断区间内的样本
+            expand_ratio:           <float> 方式1的系数
+                                        要求大于 1
+
+        其他参数：
+            seed:                   <int> 随机种子
+            rng:                    <Random Generator> 给定的随机采样器
+                            以上参数二选一
+
+        返回:
+            res:                    当 shape 为 None 时，返回的是与mean大小相同的 n 维向量
+                                    否则返回的是 shape+[len(mean)] 维度的张量
+    """
+    # 检查参数
+    assert len(mean) > 1
+    assert high_radius is None or 0 < high_radius
+    assert low_radius is None or 0 <= low_radius
+    if high_radius is not None and low_radius is not None:
+        assert low_radius < high_radius
+    if b_check_cov and cov is not None:
+        cov = np.asarray(cov)
+        assert np.allclose(cov, cov.T) and np.all(np.linalg.eig(cov)[0] > 0)
+    #
+    rng = get_rng(**kwargs)
+    low = None if low_radius is None else low_radius ** 2
+    high = None if high_radius is None else high_radius ** 2
+
+    # quick return
+    if (low is None or low == 0) and high is None:
+        return rng.multivariate_normal(mean, cov, size=size, check_valid="warn" if b_check_valid else "ignore")
+
+    # 因为标准高维高斯分布的采样点的方向服从均匀分布，而距离服从自由度为k的卡方分布
+    #   因此可以把方向和距离分开来进行采样
+    raw_size = 1 if size is None else np.prod([size])
+
+    # 对方向进行采样
+    theta = rng.normal(0, 1, size=[raw_size, len(mean)])
+    theta = normalize(v=theta, ord=2, axis=-1)
+
+    # 对距离进行采样
+    # 计算命中概率
+    cdf_high = chi2.cdf(high, df=len(mean)) if high is not None else 1
+    cdf_low = chi2.cdf(low, df=len(mean)) if low is not None else 0
+    hit_prob = cdf_high - cdf_low
+    if hit_prob >= hit_ratio_threshold:
+        # 采样方式1
+        delta = np.empty(raw_size)
+        count = 0
+        while count < raw_size:
+            temp = rng.chisquare(len(mean), int((raw_size - count) / hit_prob * expand_ratio) + 1)
+            if low is not None:
+                temp = temp[temp >= low]
+            if high is not None:
+                temp = temp[temp < high]
+            delta[count:count + len(temp)] = temp[:raw_size - count]
+            count += len(temp)
+    else:
+        # 采样方式2（重要性采样）
+        # 从均匀分布中采样
+        delta = rng.uniform(cdf_low, cdf_high, raw_size)
+        # 对均匀分布的样本进行逆变换得到截断正态分布的样本
+        delta = chi2.ppf(delta, df=len(mean))
+
+    # 整合方向和距离
+    res = theta * delta[:, None] ** 0.5
+
+    # 根据协方差矩阵进行缩放
+    if cov is not None:
+        A = cache_for_cov.get(cov.tobytes(), default_factory=lambda: np.linalg.cholesky(cov), b_add_if_not_found=True)
+        res = (A @ res.T).T
+    res += mean
+
+    if size is None:
+        res = res[0]
+    else:
+        size = [size] if isinstance(size, int) else list(size)
+        res = res.reshape(size + [len(mean)])
+
+    return res
+
+
+if __name__ == '__main__':
+    print(truncated_multivariate_normal(mean=[0, 0], cov=np.array([[1, 0.5], [0.5, 1]]),
+                                        high_radius=2, seed=114, size=[2, 5]))
+
+    # 可视化
+    import matplotlib.pyplot as plt
+
+    res_ = truncated_multivariate_normal(mean=[0, 0], cov=np.array([[1, 0.5], [0.5, 1]]), low_radius=0.5,
+                                         high_radius=1.5, seed=114, b_check_cov=True,
+                                         size=10000)
+    plt.scatter(res_[:, 0], res_[:, 1], c='r', s=1)
+
+    plt.show()

kevin_toolbox/patches/for_numpy/random/truncated_normal.py

@@ -0,0 +1,89 @@
+import math
+import torch
+import numpy as np
+from kevin_toolbox.patches.for_numpy.random import get_rng
+from kevin_toolbox.patches.for_numpy.random.variable import DEFAULT_SETTINGS
+
+
+def cdf(x, mean=0, sigma=1):
+    return (1 + math.erf((x - mean) / (sigma * 2 ** 0.5))) * 0.5
+
+
+def truncated_normal(mean=0, sigma=1, low=None, high=None, size=None,
+                     hit_ratio_threshold=DEFAULT_SETTINGS["truncated_normal"]["hit_ratio_threshold"],
+                     expand_ratio=DEFAULT_SETTINGS["truncated_normal"]["expand_ratio"],
+                     **kwargs):
+    """
+        从截断的高斯分布中进行随机采样
+
+        参数：
+            mean,sigma              <float> 均值、标准差
+            low,high                <float> 截断边界
+            size:                   <tuple/list/int/None> 输出的形状
+
+        用于调节采样效率的超参数（与设备情况有关）：
+            hit_ratio_threshold:    <float> 决定采样方式的阈值
+                                        我们称 截断内的部分的概率和/1 为命中概率 hit_ratio ，亦即进行一次全区间的采样，有多大概率落在截断区间内
+                                            当 hit_ratio 小于该阈值时，使用方式 2 （重要性采样）来生成，
+                                            当大于阈值时，使用方式 1 采样 expand_ratio * size 个样本再挑选符合落在截断区间内的样本
+                                        该参数应该根据实际情况下方式1和2的耗时差异来进行调整。
+            expand_ratio:           <float> 方式1的系数
+                                        要求大于 1
+
+        其他参数：
+            seed:                   <int> 随机种子
+            rng:                    <Random Generator> 给定的随机采样器
+                            以上参数二选一
+    """
+    if high is not None and low is not None:
+        assert high > low
+    assert expand_ratio > 1 and 0 <= hit_ratio_threshold <= 1
+    rng = get_rng(**kwargs)
+
+    raw_size = 1 if size is None else np.prod([size])
+    # 计算命中概率
+    cdf_high = cdf(x=high, mean=mean, sigma=sigma) if high is not None else 1
+    cdf_low = cdf(x=low, mean=mean, sigma=sigma) if low is not None else 0
+    hit_prob = cdf_high - cdf_low
+
+    if hit_prob >= hit_ratio_threshold:
+        # 采样方式1
+        res = np.empty(raw_size)
+        count = 0
+        while count < raw_size:
+            temp = rng.normal(mean, sigma, int((raw_size - count) / hit_prob * expand_ratio) + 1)
+            if low is not None:
+                temp = temp[temp >= low]
+            if high is not None:
+                temp = temp[temp < high]
+            res[count:count + len(temp)] = temp[:raw_size - count]
+            count += len(temp)
+    else:
+        # 采样方式2（重要性采样）
+        # 从均匀分布中采样
+        res = rng.uniform(cdf_low, cdf_high, raw_size)
+        # 对均匀分布的样本进行逆变换得到截断正态分布的样本
+        res = mean + sigma * (2 ** 0.5) * torch.erfinv(torch.from_numpy(2 * res - 1))
+        res = res.numpy()
+
+    if size is None:
+        res = res[0]
+    else:
+        res = res.reshape(size)
+
+    return res
+
+
+if __name__ == '__main__':
+    points = truncated_normal(mean=0, sigma=2, low=-3, high=None, size=10000, hit_ratio_threshold=0.01,
+                              expand_ratio=1.5)
+
+    import numpy as np
+    import matplotlib.pyplot as plt
+
+    # 绘制概率分布图
+    plt.hist(points, bins=20, density=True, alpha=0.7)
+    plt.xlabel('Value')
+    plt.ylabel('Probability Density')
+    plt.title('Uniform Distribution')
+    plt.show()

kevin_toolbox/patches/for_numpy/random/variable.py

@@ -0,0 +1,10 @@
+DEFAULT_SETTINGS = {
+    "truncated_normal": {
+        "hit_ratio_threshold": 0.3,
+        "expand_ratio": 1.5,
+    },
+    "truncated_multivariate_normal": {
+        "hit_ratio_threshold": 0.3,
+        "expand_ratio": 1.5,
+    }
+}

kevin_toolbox/patches/for_optuna/serialize/for_study/dump.py

@@ -23,7 +23,13 @@ def dump(study: optuna.study.Study):
     keys = ['best_params', 'best_trial', 'best_trials', 'best_value', 'direction', 'directions', 'trials', 'user_attrs']
     if version.compare(optuna.__version__, "<", "3.1.0"):
         keys.append('system_attrs')
-    res_s = {k: getattr(study, k, None) for k in keys}
+    # 【bug fix】不能直接用 res_s = {k: getattr(study, k, None) for k in keys} 以免在获取某些属性时，比如 best_trials，产生错误
+    res_s = dict()
+    for k in keys:
+        try:
+            res_s[k] = getattr(study, k)
+        except:
+            res_s[k] = None
 
     # 其他信息
     res_s["__dict__"] = dict()
@@ -35,7 +41,9 @@ def dump(study: optuna.study.Study):
         res_s["__dict__"][k] = v
 
     # 序列化
-    res_s = ndl.traverse(var=res_s, match_cond=lambda _, __, v: not isinstance(v, (list, dict,)),
+    # 【bug fix】不能对原始的 res_s 进行遍历和替换，以免意外修改 study 中的属性。
+    res_s = ndl.traverse(var=ndl.copy_(var=res_s, b_deepcopy=True),
+                         match_cond=lambda _, __, v: not isinstance(v, (list, dict,)),
                          action_mode="replace", converter=__converter, b_use_name_as_idx=False,
                          b_traverse_matched_element=False)