更好的方式来搅乱两个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两个视图到这个单个数组中，模拟你现在拥有的两个数组。 您可以使用单个数组进行混洗，并将视图用于所有其他目的。
例子：假设数组a和b看起来像这样：
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模拟原始a和b视图：
a2 = c[:, :a.size//len(a)].reshape(a.shape) b2 = c[:, a.size//len(a):].reshape(b.shape)
a2和b2的数据与c共享。 要同时混洗两个数组，请使用numpy.random.shuffle(c) 。
在生产代码中，您当然会尽量避免创build原始的a和b ，并立即创buildc ， a2和b2 。
这个解决scheme可以适用于a和b具有不同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也不是太长或太复杂。
