Cách tốt hơn để xáo trộn hai mảng numpy trong unison

Tôi có hai mảng numpy có hình dạng khác nhau, nhưng có cùng chiều dài (kích thước hàng đầu). Tôi muốn xáo trộn từng người trong số họ, sao cho các yếu tố tương ứng tiếp tục tương ứng - tức là trộn chúng lại với nhau theo các chỉ số hàng đầu của họ.

Mã này hoạt động và minh họa các mục tiêu của tôi:

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

Ví dụ:

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

Tuy nhiên, điều này cảm thấy cồng kềnh, không hiệu quả và chậm chạp, và nó đòi hỏi phải tạo một bản sao của các mảng - tôi muốn thay đổi chúng tại chỗ, vì chúng sẽ khá lớn.

Có cách nào tốt hơn để đi về điều này? Thực thi nhanh hơn và sử dụng bộ nhớ thấp hơn là mục tiêu chính của tôi, nhưng mã thanh lịch cũng sẽ rất tốt.

Một ý nghĩ khác mà tôi có là:

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)

Điều này hoạt động ... nhưng nó hơi đáng sợ, vì tôi thấy một chút đảm bảo rằng nó sẽ tiếp tục hoạt động - chẳng hạn như nó không phải là thứ được đảm bảo để tồn tại qua phiên bản numpy, chẳng hạn.

Giải pháp "đáng sợ" của bạn không có vẻ đáng sợ đối với tôi. Việc gọi shuffle()hai chuỗi có cùng độ dài dẫn đến cùng một số lượng cuộc gọi đến trình tạo số ngẫu nhiên và đây là các phần tử "ngẫu nhiên" duy nhất trong thuật toán xáo trộn. Bằng cách đặt lại trạng thái, bạn đảm bảo rằng các cuộc gọi đến trình tạo số ngẫu nhiên sẽ cho kết quả tương tự trong cuộc gọi thứ hai shuffle(), do đó toàn bộ thuật toán sẽ tạo ra cùng một hoán vị.

Nếu bạn không thích điều này, một giải pháp khác sẽ là lưu trữ dữ liệu của bạn trong một mảng thay vì hai ngay từ đầu và tạo hai chế độ xem vào mảng duy nhất mô phỏng hai mảng bạn có bây giờ. Bạn có thể sử dụng mảng duy nhất để xáo trộn và các khung nhìn cho tất cả các mục đích khác.

Ví dụ: Chúng ta hãy giả sử các mảng avà btrông như thế này:

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

Bây giờ chúng ta có thể xây dựng một mảng duy nhất chứa tất cả dữ liệu:

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

Bây giờ chúng tôi tạo các khung nhìn mô phỏng bản gốc avà b:

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

Dữ liệu của a2và b2được chia sẻ với c. Để xáo trộn cả hai mảng đồng thời, sử dụng numpy.random.shuffle(c).

Trong mã sản xuất, tất nhiên bạn sẽ cố gắng tránh tạo bản gốc avà hoàn btoàn và ngay lập tức tạo c, a2và b2.

Giải pháp này có thể được điều chỉnh cho phù hợp với trường hợp đó avà bcó các loại khác nhau.

Bạn có thể sử dụng lập chỉ mục mảng NumPy :

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

Điều này sẽ dẫn đến việc tạo ra các mảng không bị xáo trộn riêng biệt.

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)

Để tìm hiểu thêm, hãy xem http://scikit-learn.org/urdy/modules/generated/sklearn.utils.shuffle.html

Giải pháp rất đơn giản:

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

hai mảng x, y bây giờ đều được xáo trộn ngẫu nhiên theo cùng một cách

James đã viết vào năm 2015 một giải pháp sklearn rất hữu ích. Nhưng ông đã thêm một biến trạng thái ngẫu nhiên, không cần thiết. Trong đoạn mã dưới đây, trạng thái ngẫu nhiên từ numpy được tự động giả định.

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)

from np.random import permutation
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data #numpy array
y = iris.target #numpy array

# Data is currently unshuffled; we should shuffle 
# each X[i] with its corresponding y[i]
perm = permutation(len(X))
X = X[perm]
y = y[perm]

Xáo trộn bất kỳ số lượng mảng nào với nhau, tại chỗ, chỉ sử dụng 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)

Và có thể được sử dụng như thế này

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

Một số điều cần lưu ý:

• Khẳng định đảm bảo rằng tất cả các mảng đầu vào có cùng độ dài dọc theo chiều thứ nhất của chúng.
• Mảng xáo trộn tại chỗ bởi chiều thứ nhất của chúng - không có gì trở lại.
• Hạt ngẫu nhiên trong phạm vi int32 tích cực.
• Nếu cần trộn ngẫu nhiên lặp lại, giá trị hạt giống có thể được đặt.

Sau khi xáo trộn, dữ liệu có thể được phân chia bằng cách sử dụng np.splithoặc được tham chiếu bằng các lát - tùy thuộc vào ứng dụng.

bạn có thể tạo một mảng như:

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

sau đó xáo trộn nó:

np.random.shuffle(s)

bây giờ sử dụng s này làm đối số của mảng của bạn. các đối số xáo trộn giống nhau trả về các vectơ xáo trộn giống nhau.

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

Một cách mà việc xáo trộn tại chỗ có thể được thực hiện cho các danh sách được kết nối là sử dụng một hạt giống (có thể là ngẫu nhiên) và sử dụng numpy.random.shuffle để thực hiện xáo trộn.

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

Đó là nó. Điều này sẽ xáo trộn cả a và b theo cùng một cách chính xác. Điều này cũng được thực hiện tại chỗ luôn luôn là một điểm cộng.

EDIT, không sử dụng np.random.seed () sử dụng np.random.RandomState thay thế

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

Khi gọi nó chỉ cần vượt qua trong bất kỳ hạt giống nào để cung cấp trạng thái ngẫu nhiên:

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

Đầu ra:

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

Chỉnh sửa: Đã sửa mã để chọn lại trạng thái ngẫu nhiên

Có một chức năng nổi tiếng có thể xử lý việc này:

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

Chỉ cần đặt test_size thành 0 sẽ tránh bị chia tách và cung cấp cho bạn dữ liệu bị xáo trộn. Mặc dù nó thường được sử dụng để phân chia dữ liệu đào tạo và kiểm tra, nhưng nó cũng xáo trộn chúng.
Từ tài liệu

Tách các mảng hoặc ma trận thành các tập con thử nghiệm và thử nghiệm ngẫu nhiên

Tiện ích nhanh bao bọc xác thực đầu vào và tiếp theo (ShuffleSplit (). Split (X, y)) và ứng dụng để nhập dữ liệu vào một lệnh gọi để tách dữ liệu (và tùy chọn lấy mẫu con) trong một oneliner.

Nói rằng chúng ta có hai mảng: a và 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]]) 

Trước tiên chúng ta có thể có được các chỉ số hàng bằng cách hoán vị kích thước đầu tiên

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

Sau đó sử dụng lập chỉ mục nâng cao. Ở đây chúng tôi đang sử dụng cùng một chỉ mục để trộn lẫn cả hai mảng.

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

Điều này tương đương với

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

Nếu bạn muốn tránh sao chép mảng, thì tôi sẽ đề nghị thay vì tạo danh sách hoán vị, bạn đi qua mọi phần tử trong mảng và hoán đổi ngẫu nhiên nó sang vị trí khác trong mảng

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]

Điều này thực hiện thuật toán xáo trộn Knuth-Fisher-Yates.

Đây có vẻ là một giải pháp rất đơn giản:

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

Với một ví dụ, đây là những gì tôi đang làm:

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)

Tôi đã mở rộng Random.shuffle () của python để lấy một đối số thứ hai:

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]

Bằng cách đó tôi có thể chắc chắn rằng việc xáo trộn xảy ra tại chỗ và chức năng không quá dài hoặc phức tạp.

Chỉ cần sử dụng numpy...

Đầu tiên hợp nhất hai mảng đầu vào mảng 1D là nhãn (y) và mảng 2D là dữ liệu (x) và trộn chúng với shufflephương thức NumPy . Cuối cùng tách chúng ra và trở về.

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)