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

Ваше «страшное» решение мне не кажется страшным. Вызов shuffle() для двух последовательностей одинаковой длины приводит к одинаковому количеству обращений к генератору случайных чисел, и это единственные «случайные» элементы в алгоритме перемешивания. Сбрасывая состояние, вы гарантируете, что вызовы генератора случайных чисел дадут те же результаты во втором вызове shuffle(), поэтому весь алгоритм будет генерировать ту же перестановку.

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

Пример: Предположим, что массивы 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.]])

Теперь мы создаем виды, имитирующие оригинальные 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).

В производственном коде вы, конечно, постараетесь вообще не создавать оригинальные a и b и сразу же создать c, a2 и b2.

Это решение можно адаптировать к случаю, когда a и b имеют разные типы dtyp.

Вы можете использовать индексирование массива NumPy:

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

Это приведет к созданию отдельных массивов с перетасовкой в ​​унисон.

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

Очень простое решение:

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

два массива x, y теперь случайным образом перемешиваются одинаково

Джеймс написал в 2015 году полезное решение sklearn. Но он добавил случайную переменную состояния, в которой нет необходимости. В приведенном ниже коде автоматически предполагается случайное состояние из numpy.

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)

Перемешайте любое количество массивов на месте, используя только NumPy.

import numpy as np


def shuffle_arrays(arrays, set_seed=-1):
    """Shuffles arrays in-place, in the same order, along axis=0

    Parameters:
    -----------
    arrays : List of NumPy arrays.
    set_seed : Seed value if int >= 0, else seed is random.
    """
    assert all(len(arr) == len(arrays[0]) for arr in arrays)
    seed = np.random.randint(0, 2**(32 - 1) - 1) if set_seed < 0 else set_seed

    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])

Несколько замечаний:

• Утверждение гарантирует, что все входные массивы имеют одинаковую длину по первому измерению.
• Массивы перетасовывались по первому измерению - ничего не возвращалось.
• Случайное начальное число в положительном диапазоне int32.
• Если требуется повторяющееся перемешивание, можно установить начальное значение.

После перемешивания данные могут быть разделены с помощью np.split или на них можно ссылаться с помощью фрагментов - в зависимости от приложения.

вы можете создать такой массив:

s = np.arange(0, len(a), 1)

затем перемешайте:

np.random.shuffle(s)

теперь используйте этот s как аргумент ваших массивов. те же перетасованные аргументы возвращают одинаковые перетасованные векторы.

x_data = x_data[s]
x_label = x_label[s]

Есть хорошо известная функция, которая может с этим справиться:

from sklearn.model_selection import train_test_split
X, _, Y, _ = train_test_split(X,Y, test_size=0.0)

Простая установка test_size на 0 позволит избежать разделения и даст вам перетасованные данные. Хотя обычно он используется для разделения обучающих и тестовых данных, он также их перемешивает.
Из документация

Разбивать массивы или матрицы на случайные обучающие и тестовые подмножества

Быстрая утилита, которая обертывает проверку ввода, а затем (ShuffleSplit (). Split (X, y)) и приложение для ввода данных в один вызов для разделения (и, возможно, субдискретизации) данных в единую строку.

Один из способов перетасовки на месте для связанных списков - использование начального числа (оно может быть случайным) и использование numpy.random.shuffle для перетасовки.

# Set seed to a random number if you want the shuffling to be non-deterministic.
def shuffle(a, b, seed):
   np.random.seed(seed)
   np.random.shuffle(a)
   np.random.seed(seed)
   np.random.shuffle(b)

Вот и все. Таким же образом будут перемешаны как a, так и b. Это тоже делается на месте, что всегда является плюсом.

ИЗМЕНИТЬ, не используйте np.random.seed (), вместо этого используйте np.random.RandomState

def shuffle(a, b, seed):
   rand_state = np.random.RandomState(seed)
   rand_state.shuffle(a)
   rand_state.seed(seed)
   rand_state.shuffle(b)

При его вызове просто передайте любое семя для подачи случайного состояния:

a = [1,2,3,4]
b = [11, 22, 33, 44]
shuffle(a, b, 12345)

Выход:

>>> a
[1, 4, 2, 3]
>>> b
[11, 44, 22, 33]

Изменить: исправлен код для повторного заполнения случайного состояния

Это кажется очень простым решением:

import numpy as np
def shuffle_in_unison(a,b):

    assert len(a)==len(b)
    c = np.arange(len(a))
    np.random.shuffle(c)

    return a[c],b[c]

a =  np.asarray([[1, 1], [2, 2], [3, 3]])
b =  np.asarray([11, 22, 33])

shuffle_in_unison(a,b)
Out[94]: 
(array([[3, 3],
        [2, 2],
        [1, 1]]),
 array([33, 22, 11]))

Скажем, у нас есть два массива: 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]]

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

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]

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

В качестве примера я делаю следующее:

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]

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

Просто используйте _1 _...

Сначала объедините два входных массива, 1D-массив - это метки (y), а 2D-массив - это данные (x), и перемешайте их с помощью метода NumPy shuffle. Наконец разделите их и вернитесь.

import numpy as np

def shuffle_2d(a, b):
    rows= a.shape[0]
    if b.shape != (rows,1):
        b = b.reshape((rows,1))
    S = np.hstack((b,a))
    np.random.shuffle(S)
    b, a  = S[:,0], S[:,1:]
    return a,b

features, samples = 2, 5
x, y = np.random.random((samples, features)), np.arange(samples)
x, y = shuffle_2d(train, test)