Python Numpy：使用不同的种子将数组同步洗牌多次

我有多个numpy数组，它们的行数（axis_0）与我想同步洗牌的行数相同。在一次洗牌之后，我想用不同的随机种子再次洗牌

---

到目前为止，我一直在使用 :

但是，这不适用于多个unison混洗，因为

rng_状态

总是相同的。

---

我曾尝试使用

RandomState

为每个调用获取不同的种子，但这甚至不适用于单个unison shuffle：

a = np.array([1,2,3,4,5])
b = np.array([10,20,30,40,50])

def shuffle_in_unison(a, b):
    r = np.random.RandomState() # different state from /dev/urandom for each call
    state = r.get_state()
    np.random.shuffle(a) # array([4, 2, 1, 5, 3])
    np.random.set_state(state)
    np.random.shuffle(b) # array([40, 20, 50, 10, 30])
    # -> doesn't work
    return a,b

for i in xrange(10):
    a,b = shuffle_in_unison(a,b)
    print a,b

我做错了什么

---

---

编辑：

对于像我这样没有大型阵列的人，只需使用Francesco（）的解决方案：

---

唯一的缺点是，这不是就地操作，这对于像我这样的大型阵列（500G）来说是一个遗憾。

我不知道您设置状态的方式有什么问题。然而，我找到了另一种解决方案：与其洗牌

n

数组，不如只洗牌它们的索引一次，然后对所有数组重新排序

a = np.array([1,2,3,4,5])
b = np.array([10,20,30,40,5])

def shuffle_in_unison(a, b):
     n_elem = a.shape[0]
     indeces = np.random.choice(n_elem, size=n_elem, replace=False)
     return a[indeces], b[indeces]

 for i in xrange(5):
     a, b = shuffle_in_unison(a ,b)
     print(a, b)

我得到：

[5 2 4 3 1] [50 20 40 30 10]
[1 3 4 2 5] [10 30 40 20 50]
[1 2 5 4 3] [10 20 50 40 30]
[3 2 1 4 5] [30 20 10 40 50]
[1 2 5 3 4] [10 20 50 30 40]

编辑

感谢@Divakar的建议。 下面是一种更可读的方法，可以使用

---

我不知道你到底在做什么，但你没有选择该页面上投票最多或第二多的解决方案。试试看：

输出：

X -  [3 5 1 4 2] Y -  [30 50 10 40 20]
X -  [1 5 2 3 4] Y -  [10 50 20 30 40]
X -  [2 4 5 3 1] Y -  [20 40 50 30 10]
X -  [3 1 4 2 5] Y -  [30 10 40 20 50]
X -  [3 2 1 5 4] Y -  [30 20 10 50 40]
X -  [4 3 2 1 5] Y -  [40 30 20 10 50]
X -  [1 5 4 3 2] Y -  [10 50 40 30 20]
X -  [1 3 4 5 2] Y -  [10 30 40 50 20]
X -  [2 4 3 1 5] Y -  [20 40 30 10 50]
X -  [1 2 4 3 5] Y -  [10 20 40 30 50]

---

我通常不必一次多次洗牌数据。但是这个函数可以容纳任意数量的输入数组，也可以容纳任意数量的随机洗牌，并且可以在适当的位置进行洗牌

import numpy as np


def shuffle_arrays(arrays, shuffle_quant=1):
    assert all(len(arr) == len(arrays[0]) for arr in arrays)
    max_int = 2**(32 - 1) - 1

    for i in range(shuffle_quant):
        seed = np.random.randint(0, max_int)
        for arr in arrays:
            rstate = np.random.RandomState(seed)
            rstate.shuffle(arr)

可以这样使用

a = np.array([1, 2, 3, 4, 5])
b = np.array([10,20,30,40,50])
c = np.array([[1,10,11], [2,20,22], [3,30,33], [4,40,44], [5,50,55]])

shuffle_arrays([a, b, c], shuffle_quant=5)

需要注意的几点：

• 方法使用NumPy而不使用其他包
• 断言可确保所有输入数组沿方向具有相同的长度 他们的第一维度
• max_int将随机种子保持在int32范围内
• 数组按其第一维度在适当的位置移动-没有返回任何内容

---

洗牌后，可以使用

np拆分数据。拆分
或使用切片引用数据-具体取决于应用程序。
您的解决方案虽然有效，但有一个缺点，即单个功能需要完整的scikit lear包。公平评论，虽然我不确定scikit learn是否比numpy占用更多硬盘空间。只有
shuffle
被导入，解决方案使用更少的代码行这应该是可以接受的答案。这是惯用的numpy——即，对整数索引执行一次洗牌，然后使用此1D数组索引对两个2D数组重新排序。打个比方，很明显，这就是对一个数组进行排序，然后根据相同的顺序对第二个数组重新排序的方法。
np.random.permutation（）
在性能和紧凑的表达方式上稍好一些。@Divakar:对，我没有注意到输入可以是一个数字。谢谢你指出这一点。我会编辑我的答案非常感谢你的解决方案！它似乎比set_state方法（使用100MB阵列）慢10%左右，但这没关系。
a[indeces]
是返回数组的无序副本还是提供视图（->内存中没有无序）？为了确保这一点，如果我使用h5py和chunked存储来保存无序数组，磁盘上的行顺序应该与
a[indes]
中的行顺序相同，对吗？
np.random.shuffle
已经就绪，因此如果有一个大数组要重新排序，可能会更好。但是，如果您无法使其适用于多个阵列，就地奖励也无济于事。记录如下：@cardamom的解决方案也未到位。
from sklearn.utils import shuffle
for i in range(10):
    X, Y = shuffle(X, Y, random_state=i)
    print ("X - ", X, "Y - ", Y)

X -  [3 5 1 4 2] Y -  [30 50 10 40 20]
X -  [1 5 2 3 4] Y -  [10 50 20 30 40]
X -  [2 4 5 3 1] Y -  [20 40 50 30 10]
X -  [3 1 4 2 5] Y -  [30 10 40 20 50]
X -  [3 2 1 5 4] Y -  [30 20 10 50 40]
X -  [4 3 2 1 5] Y -  [40 30 20 10 50]
X -  [1 5 4 3 2] Y -  [10 50 40 30 20]
X -  [1 3 4 5 2] Y -  [10 30 40 50 20]
X -  [2 4 3 1 5] Y -  [20 40 30 10 50]
X -  [1 2 4 3 5] Y -  [10 20 40 30 50]

import numpy as np


def shuffle_arrays(arrays, shuffle_quant=1):
    assert all(len(arr) == len(arrays[0]) for arr in arrays)
    max_int = 2**(32 - 1) - 1

    for i in range(shuffle_quant):
        seed = np.random.randint(0, max_int)
        for arr in arrays:
            rstate = np.random.RandomState(seed)
            rstate.shuffle(arr)

a = np.array([1, 2, 3, 4, 5])
b = np.array([10,20,30,40,50])
c = np.array([[1,10,11], [2,20,22], [3,30,33], [4,40,44], [5,50,55]])

shuffle_arrays([a, b, c], shuffle_quant=5)