Лучший способ перетасовать два массива в унисон - PullRequest
Новая
       43

Лучший способ перетасовать два массива в унисон

192 голосов
/ 05 января 2011

У меня есть два массива разной формы, но одинаковой длины (начальный размер). Я хочу перетасовать каждый из них так, чтобы соответствующие элементы продолжали соответствовать - т.е. перетасовывать их в унисон по отношению к их ведущим индексам.

Этот код работает и иллюстрирует мои цели: 

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)

Это работает ... но это немного страшно, так как я вижу мало гарантий, что оно продолжит работать - это не похоже на то, что гарантированно выживет, например, в простой версии.

Ответы [ 14 ]

2 голосов
/ 05 декабря 2018

Скажем, у нас есть два массива: a и b.

a = np.array([[1,2,3],[4,5,6],[7,8,9]])
b = np.array([[9,1,1],[6,6,6],[4,2,0]])

Сначала мы можем получить индексы строк, переставив первое измерение 

indices = np.random.permutation(a.shape[0])
[1 2 0]

Затем воспользуйтесь расширенным индексированием.Здесь мы используем одни и те же индексы, чтобы перетасовать оба массива в унисон.

a_shuffled = a[indices[:,np.newaxis], np.arange(a.shape[1])]
b_shuffled = b[indices[:,np.newaxis], np.arange(b.shape[1])]

Это эквивалентно 

np.take(a, indices, axis=0)
[[4 5 6]
 [7 8 9]
 [1 2 3]]

np.take(b, indices, axis=0)
[[6 6 6]
 [4 2 0]
 [9 1 1]]
0 голосов
/ 30 октября 2017

Я расширил 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]

Таким образом, я могу быть уверен, что перетасовка происходит на месте, и функция не слишком длинная или сложная.

0 голосов
/ 10 февраля 2016

На примере вот что я делаю: 

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)
0 голосов
/ 05 января 2011

Если вы хотите избежать копирования массивов, я бы посоветовал вместо создания списка перестановок просмотреть каждый элемент массива и случайным образом поменять его на другую позицию в массиве 

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]

Это реализует алгоритм перемешивания Кнута-Фишера-Йейтса.

Страница:
...