我可以在numpy.random.seed()中输入什么数字？

Question

我注意到,你可以把不同数量的内部numpy.random.seed(),例如numpy.random.seed(1),numpy.random.seed(101).不同的数字是什么意思？你如何选择这些数字？

Answer 1

考虑一个非常基本的随机数生成器:

Z[i] = (a*Z[i-1] + c) % m

这里,Z[i]是ith随机数a是倍频和c是增量-不同的a,c和m组合你有不同的发电机.这被称为Lehmer引入的线性同余发生器.该除法的余数或模数(%)将生成一个介于零之间的数字,m-1并通过设置U[i] = Z[i] / m得到0到1之间的随机数.

你可能已经注意到,为了开始这个生成过程 - 为了让Z[1]你需要一个Z[0]- 一个初始值.启动该过程的初始值称为种子.看看这个例子:

初始值,种子被确定为7以开始该过程.但是,该值不用于生成随机数.相反,它用于生成第一个Z.

伪随机数发生器最重要的特征是它的不可预测性.一般来说,只要你不分享你的种子,你对所有种子都没问题,因为今天的发电机比这更复杂.但是,作为进一步的步骤,您也可以随机生成种子.您可以跳过第一个n数字作为另一种选择.

主要来源:Law,AM(2007).仿真建模和分析.塔塔麦格劳 - 希尔.

Answer 2

简短的回答：

有三种方法可以seed()在 中生成随机数numpy.random：

• 不使用参数或使用None——RNG 从操作系统的随机数生成器（通常是加密随机的）初始化自己

• 使用一些 32 位整数 N——RNG 将使用它来根据确定性函数（相同种子→相同状态）初始化其状态

• 使用由 32 位整数 n ₀、 n ₁、 n ₂等组成的类似数组的序列——同样，RNG 将使用它来基于确定性函数初始化其状态（相同值的种子 → 相同状态）。尽管源代码中存在幻数并且不清楚为什么他们正在做他们正在做的事情，但这是打算通过各种散列函数来完成的。

如果您想做一些可重复且简单的事情，请使用单个整数。

如果您想做一些可重复但第三方不太可能猜到的事情，请使用包含某些 32 位整数序列的元组或列表或 numpy 数组。例如，您可以使用numpy.randomof 的种子None从操作系统的 RNG 生成一堆 32 位整数（例如，其中 32 个，将生成总共 1024 位），存储在一些种子中S，然后保存在一些秘密位置，然后使用该种子生成您希望的任何伪随机数序列 R。然后您可以稍后通过再次重新播种来重新创建该序列S，并且只要您保持S秘密（以及生成的数字 R），没有人能够重现该序列 R。如果您只使用一个整数，那么只有 40 亿种可能性，有人可能会尝试所有这些。这可能有点偏执，但你可以做到。

更长的答案

该numpy.random模块使用Mersenne Twister算法，您可以通过以下两种方式之一进行确认：

• 通过查看 的文档numpy.random.RandomState，其中numpy.random使用numpy.random.*函数的实例（但您也可以使用隔离的独立实例）

• 查看mtrand.pyx中的源代码，它使用一种叫做 Pyrex 的东西来包装一个快速的 C 实现，以及randomkit.c和initarray.c。

无论如何，这就是 numpy.random.RandomState文档所说的内容seed()：

兼容性保证RandomState使用相同参数的固定种子和固定系列方法调用将始终产生相同的结果，直到舍入误差，除非值不正确。将修复不正确的值，并在相关文档字符串中注明进行修复的 NumPy 版本。只要先前的行为保持不变，就允许扩展现有参数范围和添加新参数。

参数：
种子 ：{None，int，array_like}，可选

用于初始化伪随机数生成器的随机种子。可以是 0 到 2**32 - 1 之间的任何整数，包括此类整数的数组（或其他序列），或None（默认值）。如果 seed 是None，则 RandomState 将尝试从/dev/urandom（或 Windows 模拟）读取数据（如果可用）或从时钟中读取数据，否则。

它没有说明种子是如何使用的，但是如果您深入研究源代码，它会引用该init_by_array函数：（文档字符串已省略）

def seed(self, seed=None):
    cdef rk_error errcode
    cdef ndarray obj "arrayObject_obj"
    try:
        if seed is None:
            with self.lock:
                errcode = rk_randomseed(self.internal_state)
        else:
            idx = operator.index(seed)
            if idx > int(2**32 - 1) or idx < 0:
                raise ValueError("Seed must be between 0 and 2**32 - 1")
            with self.lock:
                rk_seed(idx, self.internal_state)
    except TypeError:
        obj = np.asarray(seed).astype(np.int64, casting='safe')
        if ((obj > int(2**32 - 1)) | (obj < 0)).any():
            raise ValueError("Seed must be between 0 and 2**32 - 1")
        obj = obj.astype('L', casting='unsafe')
        with self.lock:
            init_by_array(self.internal_state, <unsigned long *>PyArray_DATA(obj),
                PyArray_DIM(obj, 0))

这是init_by_array函数的样子：

extern void
init_by_array(rk_state *self, unsigned long init_key[], npy_intp key_length)
{
    /* was signed in the original code. RDH 12/16/2002 */
    npy_intp i = 1;
    npy_intp j = 0;
    unsigned long *mt = self->key;
    npy_intp k;

    init_genrand(self, 19650218UL);
    k = (RK_STATE_LEN > key_length ? RK_STATE_LEN : key_length);
    for (; k; k--) {
        /* non linear */
        mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >> 30)) * 1664525UL))
            + init_key[j] + j;
        /* for > 32 bit machines */
        mt[i] &= 0xffffffffUL;
        i++;
        j++;
        if (i >= RK_STATE_LEN) {
            mt[0] = mt[RK_STATE_LEN - 1];
            i = 1;
        }
        if (j >= key_length) {
            j = 0;
        }
    }
    for (k = RK_STATE_LEN - 1; k; k--) {
        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
             - i; /* non linear */
        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
        i++;
        if (i >= RK_STATE_LEN) {
            mt[0] = mt[RK_STATE_LEN - 1];
            i = 1;
        }
    }

    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
    self->gauss = 0;
    self->has_gauss = 0;
    self->has_binomial = 0;
}

这本质上是使用提供的种子值序列中的每个值，以非线性、类似散列的方法“调整”随机数状态。

Answer 3

实际上，通常称为“随机数序列”的是“伪随机”数序列，因为这些值是使用确定性算法计算的，而概率没有实际作用。

“种子”是序列的起点，并且保证的是，如果您从同一种子开始，则将获得相同的数字序列。例如，这对于调试非常有用（当您在程序中查找错误时，您需要能够重现问题并进行研究，非确定性程序将很难调试，因为每次运行都会不同） 。

Answer 4

基本上这个数字每次都保证相同的“随机性”。

更准确地说，该数字是一个种子，它可以是整数、任意长度的整数数组（或其他序列）或默认值（无）。如果没有种子，则 random 将尝试从 /dev/urandom 读取数据（如果可用），否则从时钟生成种子。

编辑：老实说，只要您的程序不需要超级安全，那么您选择什么就无关紧要。如果是这种情况，请不要使用这些方法 -如果您需要加密安全的伪随机数生成器，请使用os.urandom()或。SystemRandom

这里要理解的最重要的概念是伪随机性。一旦你理解了这个想法，你就可以确定你的程序是否真的需要种子等。我建议阅读这里。