python - random.seed(seed) 是否在多个进程中生成相同的序列？

Question

2017 年 7 月 19 日更新

在这里找到解决方案:https://stackoverflow.com/a/10021912/5729266

如果您不想读到最后，请快速得出结论。

我之前的代码中随机数不一致的原因是线程不安全造成的，因为 random 模块被视为全局变量，即使每个线程处理包含 random 模块的一个单独实例。

要解决这个问题，您必须使用线程锁或生成一个独立的随机实例，如上面的链接所述。请参阅下面的测试代码。

import threading
import random

class do_threads:

    def __init__(self):
        # Using random directly is thread-unsafe
        # self.random = random 

        # instead of using random, create a local random instance
        self.random = random.Random()

    def __call__(self, n):
        self.n = n
        self.run_thread()

    def get_balance(self, e):
        self.random.seed(self.n)
        return self.random.uniform(0, 1)


    def run_thread(self):
        total = []
        for i in range(100000):
           total.append(self.get_balance())
        print(sum(total) / 100000)

a = do_threads()
b = do_threads()

t1 = threading.Thread(target=a, args=(5,))
t2 = threading.Thread(target=b, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()

旧帖子:

在我的 Python 程序中，我需要使用 multiprocessing.pool 运行 N 个子进程。每个子进程都会生成 M 个线程，每个线程都需要为数据帧的 'ID' 列中的 ID 生成哈希码。

哈希码需要遵循uniform(0,1)分布。为此，我使用 ID 作为种子 (random.seed(ID)) 来设置随机状态，然后从 random.uniform(0, 1) 生成随 secret 钥。但 ID 具有不同随机数的可能性约为 0.01%。例如，ID“200300”在所有这些线程/子进程中出现 10000 次，但它有 9999 次有一个随 secret 钥，1 次有另一个随 secret 钥。

所以，我的问题是:random.seed(seed) 是否始终在并行程序中生成相同的序列？如果不是，如何修复随机状态以确保 random.uniform(0, 1) 在给定相同 ID 的情况下弹出相同的数字？我也欢迎其他可以将 ID 哈希为具有均匀(0,1)分布的随机变量的方法。

请注意，我想在工作中使用进程和线程，并且无法在程序期间连接这些数据帧以一次性生成随 secret 钥。

我尝试使用 multiprocessing.Manager 共享随机状态或在父进程中导入随机，或将 random_generator() 作为实例或对象从父进程传递到子环境。但事情似乎并没有按预期进行。

这是我的代码的简单版本:

#mythreads.py
from foo import Foo

class TaskWorker(Thread):
        def __init__(self, queue):
            Thread.__init__(self)
            self.queue = queue
        def run(self):
            while True:
                Foo, task = self.queue.get()
                Foo(task).generate_data(df)

def mythreads():
    queue = Queue()
    for x in range(10):
        worker = TaskWorker(queue)
        worker.daemon = True
        worker.start()
    for task in sub_list:
        queue.put((Foo, task))
    queue.join()

# foo.py
import random
class Foo:
    def __init__(self, task):
        ...

    def random_generator(self, e):
        random.seed(e)
        randomkey = random.uniform(0, 1)

    def generate_data(self, df):
        df['RK'] = df[‘ID’].apply(self.random_generator)
        ...

#main.py
from multiprocessing.pool import Pool
from mythreads import mythreads
with Pool(N) as p:
    p.map(mythreads, list_of_sublists)

注意:我使用 Python 3.6

Answer 1

摘要

问 random.seed(seed) 是否始终在并行程序中生成相同的序列？

答。是的。

随机数生成器保证在给定相同的起始种子的情况下重现相同系列的随机值。

另一种想法:使用 random.random() 而不是 random.uniform(0, 1)。两者都给出相同范围的随机变量，但前者更快、更惯用。

示例

演示从相同种子开始运行不同生成器的单独进程:

from multiprocessing.pool import Pool
from pprint import pprint
import random

def make_seq(identifier):
    random.seed(8675309)
    seq = [random.random() for i in range(4)]
    return identifier, seq

p = Pool(10)
pprint(list(p.map(make_seq, range(10))), width=100)

输出:

[(0, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (1, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (2, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (3, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (4, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (5, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (6, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (7, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (8, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507]),
 (9, [0.40224696110279223, 0.5102471779215914, 0.6637431122665531, 0.8607166923395507])]

请注意，所有进程都生成相同的值。