种子时间

时间永远不会停止。

使用时间作为随机种子数是一个好主意。
每次我们执行代码时，当前时间都会发生变化，因此种子值会发生变化，每次执行都会得到不同的随机数。

import numpy as np
import time 
np.random.seed(int(time.time()))
np.random.randint(low = 1, high = 10, size = 10)

1000 次后的随机种子

当我们运行同一个种子超过 1000 次时会发生什么？

import numpy as np
for i in range(1100):
    np.random.seed(int(time.time()))
    print(np.random.randint(low = 1, high = 10, size = 10))
    i=i+1

使用种子值“100”运行 numpy.random.seed 超过 1000 次，伪随机值每次都相同。

随机种子二维数组

使用 NumPy 随机函数生成二维数组。
使用相同的种子，将生成具有相同随机数的相同二维数组。

import numpy as np
np.random.seed(24)
np.random.random((3,3))

在上面的例子中，我们创建了一个 3*3 大小的二维数组。
多次执行后，使用相同的种子，生成相同的数组。

如何更改随机种子？

有三种方法可以生成随机种子数。

• 第一种方法是不传递任何种子值。正如我们在上面的部分中详细描述的那样，它会自己随机选择种子值。
• 第二种方法是将当前时间作为种子编号传递。时间总是在变化，所以会产生一个随机的种子数。
• 第三种方法是使用 random.randint() 随机生成种子数。请参阅下面的示例。

import numpy as np
seed_value=np.random.randint(0,100)
print("seed value: ", seed_value)
np.random.seed(seed_value)
np.random.randint(low = 1, high = 10, size = 10)

随机种子多进程

执行多进程以提高系统的性能。
每个线程执行不同的进程，或者我们可以说多个进程独立执行。

想象一下，我们正在使用相同的种子值实现多线程，每个线程的输出都相同。
那么运行多个进程有什么用。
这将是多进程的完整灾难实现。

让我们实现两个具有相同种子值的进程：

import numpy as np
from multiprocessing import Process
def square_num():
	"""
	function to print square of random number
	"""
	np.random.seed(101)
	num = np.random.random()
	print("Square of "+ str(num) + " is: " + str(num*num))
if __name__ == '__main__':	  
	p1 = Process(target=square_num) #Process 1
	p2 = Process(target=square_num) #Process 2

	#Start Process
	p1.start()
	p2.start()
	p1.join()	
	p2.join()

	#Both process finished
	print("Done")

从上面的例子中，我们可以看到我们使用相同的种子值生成了相同的随机数，并且两个过程都给出了相同的输出。

因此，为不同线程设置随机种子值是关键。
我们可以通过为每个处理器显式设置不同的种子编号来做到这一点。
通过这样做，它会自己随机选择。

""" 
 	function to print square of random number
	"""
	np.random.seed()
	num = np.random.random()
	print("Square of "+ str(num) + " is: " + str(num*num))
if __name__ == '__main__':	  
	p1 = Process(target=square_num) #Process 1
	p2 = Process(target=square_num) #Process 2

	#Start Process
	p1.start()
	p2.start()
	p1.join()	
	p2.join()

	#Both process finished
	print("Done")

为了实现多处理，随机选择种子值非常有效。
进程 p1 和 p2 生成不同的随机数，因此两个进程的输出不同。

在计算机之间使用相同种子数

具有相同值的NumPy随机种子在计算机上的工作方式类似。使用相同的Python版本和相同的操作系统Numpy.random.seed()时，如果它采用相同的种子值，则会在不同的计算机上生成相同的值。

NumPy.random.seed(0)

NumPy.random.seed(0) 将随机种子设置为“0”。
生成的种子值为 0 的伪随机数每次都会从同一点开始。
NumPy.random.seed(0) 在某些情况下被广泛用于调试。

import numpy as np
np.random.seed(0)
np.random.randint(low = 1, high = 10, size = 10)

在两次执行中，我们将得到了相同的随机数集，具有相同的种子值“0”。

什么是 NumPy 随机种子？

顾名思义，随机种子的目的与随机数有关。

主要使用的语法是：

import numpy as np
np.random.seed()

random() 是 Python 中的 NumPy 库提供的用于处理随机数的模块。

NumPy random() 函数不会生成“真正的”随机数，但我们用它来生成伪随机数。

我们所说的伪随机数是指它们可以被确定，而不是完全随机生成。
我们将在下一节详细解释伪随机数。

random() 函数根据种子值生成伪随机数。

随机种子重要性

NumPy random() 函数根据某个值生成伪随机数。
该值称为种子值。

Numpy.random.seed() 方法初始化了一个随机状态。
每次调用此模块时，生成器都会重新播种。

对于特定的种子值，保存种子函数的随机状态。
因此，即使在多次执行时，特定的种子值也会产生相同的随机数。

即使在环境相同的情况下，即使在不同的机器上，相同的种子值也会导致相同的随机数生成。

import numpy as np
np.random.seed(101) #Here, 101 is seed value
np.random.randint(low = 1, high = 10, size = 10)

种子值为 101 时，上述随机函数每次生成相同的输出。

在这里，我们可以使用不同的种子值。
例如，种子值 100，每次为相同的随机函数生成以下输出。

import numpy as np
np.random.seed(100) #Here, 100 is seed value
np.random.randint(low = 1, high = 10, size = 10)

随机种子范围

如果我们改变随机种子范围会发生什么？
让我们用一个例子来试试。

import numpy as np
np.random.seed(242)
print("random 1: ", np.random.randint(0, 10, 5))
print("random 2: ", np.random.randint(0, 10, 5))
np.random.seed(242)
print("random 3: ", np.random.randint(0, 10, 5))

‘random 1’和‘random 2’的输出是不同的。
种子值“242”仅适用于“random1”。

对于“random 2”数组，随机选取种子值。
当我们再次将“random 3”的种子值设置为“242”时，会出现与“random 1”相同的值。

NumPy 随机种子与 Python 随机种子

有两种方法可以初始化种子。
一种是使用 Python 伪随机生成器 random.seed() 像这样：

# Python pseudo-random generator at a fixed value
import random
random.seed(101)
for i in range(10):
    print(random.randint(1,10))

第二种方法是使用 NumPy 伪随机生成器 np.random.seed() 像这样：

# NumPy pseudo-random generator at a fixed value
import numpy as np
np.random.seed(101)
np.random.randint(low = 1, high = 10, size = 10)

这两个函数在内部都适用于伪随机生成器算法。
但是，对于相同的种子值，两个函数从不同的随机值开始给出不同的输出。

NumPy.random 没有种子数

现在的问题是，如果我们不提供任何种子数，会发生什么。
让我们尝试执行没有种子数的代码。

import numpy as np
np.random.seed()
np.random.randint(low = 1, high = 10, size = 10)

执行了两次代码，两次输出都不同。
没有种子数，它选择随机种子和每次生成的不同随机数。

实际上，当我们不分配种子数时，随机种子总是使用当前系统的时间作为种子值。

NumPy 随机种子洗牌

我们可以使用 NumPy random.shuffle() 对数字序列进行洗牌。
在不使用种子的情况下使用 shuffle，每次我们执行命令时，它都会随机打乱序列。

使用相同的种子值，我们可以在每次执行命令时按特定顺序打乱序列。

import numpy as np
arr = np.arange(10)
print("array: ", arr)
np.random.seed(99)
np.random.shuffle(arr)
print("array 1: ",arr)
np.random.seed(199)
np.random.shuffle(arr)
print("array 2: ",arr)

在上面的代码中，使用具有相同值的 seed() 函数，每次执行都会产生相同的值，如上所示。

不使用 seed() 函数，它会在每次执行时随机洗牌。

NumPy.random.seed(101)

NumPy.random.seed(101) 将随机种子设置为“101”。
用种子值“101”生成的伪随机数每次都会从同一点开始。

import numpy as np
np.random.seed(101)
np.random.randint(low = 1, high = 10, size = 10)

在两次执行中，我们将得到了相同的一组随机数，种子值为 101.

什么是伪随机数？

顾名思义，伪随机数不是“真正的”随机数，而是部分随机数。
伪随机数是计算机生成的数字，看起来像是随机的，但实际上是预先确定的。

我们的计算机系统基于算法工作。
如果我们为算法提供相同的输入，则输出保持不变。

由计算机科学家创建的一组算法，用于生成近似随机数特性的伪随机数。
这些算法被称为“伪随机数生成器”。

NumPy 随机种子函数基于“伪随机数生成器”算法生成随机数。