更好的方式来搅乱两个numpyarrays

我有两个不同形状的numpy数组,但长度相同(前导维数)。 我想把它们中的每一个都洗牌,以使相应的元素继续相应 – 即与它们的主要指数相一致地洗牌。

这个代码的作品,并说明了我的目标:

def shuffle_in_unison(a, b): assert len(a) == len(b) shuffled_a = numpy.empty(a.shape, dtype=a.dtype) shuffled_b = numpy.empty(b.shape, dtype=b.dtype) permutation = numpy.random.permutation(len(a)) for old_index, new_index in enumerate(permutation): shuffled_a[new_index] = a[old_index] shuffled_b[new_index] = b[old_index] return shuffled_a, shuffled_b 

例如:

 >>> a = numpy.asarray([[1, 1], [2, 2], [3, 3]]) >>> b = numpy.asarray([1, 2, 3]) >>> shuffle_in_unison(a, b) (array([[2, 2], [1, 1], [3, 3]]), array([2, 1, 3])) 

但是,这种方法感觉笨重,效率低下,速度慢,需要复制数组 – 我宁愿将它们混合就位,因为它们会很大。

有没有更好的方法去做这件事? 更快的执行和更低的内存使用是我的主要目标,但优雅的代码也会很好。

我还有一个想法是这样的:

 def shuffle_in_unison_scary(a, b): rng_state = numpy.random.get_state() numpy.random.shuffle(a) numpy.random.set_state(rng_state) numpy.random.shuffle(b) 

这个工作…但是有点吓人,因为我看不到保证它会继续工作 – 例如,它看起来不像是保证在numpy版本中生存的那种东西。

    你的“可怕的”解决scheme对我来说并不可怕。 对两个长度相同的序列调用shuffle()导致对随机数生成器的调用次数相同,这些都是shufflealgorithm中唯一的“随机”元素。 通过重置状态,可以确保对随机数生成器的调用在第二次调用shuffle()会得到相同的结果,因此整个algorithm将生成相同的置换。

    如果你不喜欢这个,一个不同的解决scheme就是将你的数据存储在一个数组中,而不是从头开始两个,并且创build两个视图到这个单个数组中,模拟你现在拥有的两个数组。 您可以使用单个数组进行混洗,并将视图用于所有其他目的。

    例子:假设数组ab看起来像这样:

     a = numpy.array([[[ 0., 1., 2.], [ 3., 4., 5.]], [[ 6., 7., 8.], [ 9., 10., 11.]], [[ 12., 13., 14.], [ 15., 16., 17.]]]) b = numpy.array([[ 0., 1.], [ 2., 3.], [ 4., 5.]]) 

    现在我们可以构造一个包含所有数据的单个数组:

     c = numpy.c_[a.reshape(len(a), -1), b.reshape(len(b), -1)] # array([[ 0., 1., 2., 3., 4., 5., 0., 1.], # [ 6., 7., 8., 9., 10., 11., 2., 3.], # [ 12., 13., 14., 15., 16., 17., 4., 5.]]) 

    现在我们创build模拟原始ab视图:

     a2 = c[:, :a.size//len(a)].reshape(a.shape) b2 = c[:, a.size//len(a):].reshape(b.shape) 

    a2b2的数据与c共享。 要同时混洗两个数组,请使用numpy.random.shuffle(c)

    在生产代码中,您当然会尽量避免创build原始的ab ,并立即创buildca2b2

    这个解决scheme可以适用于ab具有不同dtype的情况。

    你可以使用NumPy的数组索引 :

     def unison_shuffled_copies(a, b): assert len(a) == len(b) p = numpy.random.permutation(len(a)) return a[p], b[p] 

    这将导致创build单独的unison-shuffle数组。

     X = np.array([[1., 0.], [2., 1.], [0., 0.]]) y = np.array([0, 1, 2]) from sklearn.utils import shuffle X, y = shuffle(X, y, random_state=0) 

    要了解更多信息,请参阅http://scikit-learn.org/stable/modules/generated/sklearn.utils.shuffle.html

    很简单的解决scheme

     randomize = np.arange(len(x)) np.random.shuffle(randomize) x = x[randomize] y = y[randomize] 

    两个数组x,y现在都是以相同的方式随机洗牌的

    如果你想避免复制数组,那么我会build议,而不是生成一个排列列表,你会遍历数组中的每个元素,并随机交换到数组中的另一个位置

     for old_index in len(a): new_index = numpy.random.randint(old_index+1) a[old_index], a[new_index] = a[new_index], a[old_index] b[old_index], b[new_index] = b[new_index], b[old_index] 

    这实现了Knuth-Fisher-Yates shufflealgorithm。

    举个例子,这就是我正在做的事情:

     combo = [] for i in range(60000): combo.append((images[i], labels[i])) shuffle(combo) im = [] lab = [] for c in combo: im.append(c[0]) lab.append(c[1]) images = np.asarray(im) labels = np.asarray(lab) 

    我扩展python的random.shuffle()采取第二个参数:

     def shuffle_together(x, y): assert len(x) == len(y) for i in reversed(xrange(1, len(x))): # pick an element in x[:i+1] with which to exchange x[i] j = int(random.random() * (i+1)) x[i], x[j] = x[j], x[i] y[i], y[j] = y[j], y[i] 

    这样我就可以确定洗牌发生在原地,而且function也不是太长或太复杂。