İki numpy dizisini birlikte karıştırmanın daha iyi yolu

Farklı şekillerde, ancak aynı uzunlukta (önde gelen boyut) iki numpy dizim var. Her birini karıştırmak istiyorum, böylece karşılık gelen elemanlar karşılık gelmeye devam ediyor - yani önde gelen endekslerine göre bunları birlikte karıştırın.

Bu kod işe yarar ve hedeflerimi gösterir:

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

Örneğin:

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

Bununla birlikte, bu tıknaz, verimsiz ve yavaş hissediyor ve dizilerin bir kopyasını almayı gerektiriyor - oldukça büyük olacakları için onları yerinde karıştırmayı tercih ederim.

Bununla ilgili daha iyi bir yol var mı? Daha hızlı yürütme ve daha az bellek kullanımı birincil hedeflerimdir, ancak zarif kod da iyi olurdu.

Başka bir düşünce vardı:

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)

Bu işe yarıyor ... ama biraz korkutucu, çalışmaya devam edeceğine dair çok az garanti görüyorum - örneğin, numpy sürümünde hayatta kalmayı garanti eden bir şey gibi görünmüyor.

"Korkunç" çözümün bana korkutucu gelmiyor. shuffle()Aynı uzunlukta iki dizinin çağrılması , rasgele sayı üretecine aynı sayıda çağrı ile sonuçlanır ve bunlar, karıştırma algoritmasındaki tek "rastgele" öğelerdir. Durumu sıfırlayarak, rasgele sayı üretecine yapılan çağrıların ikinci çağrıda aynı sonuçları vermesini sağlarsınız shuffle(), böylece tüm algoritma aynı permütasyonu üretecektir.

Bunu beğenmezseniz, verilerinizi en başından iki yerine bir dizide depolamak ve şu anda sahip olduğunuz iki diziyi simüle eden bu tek dizide iki görünüm oluşturmak farklı bir çözüm olacaktır. Karıştırma için tek diziyi ve diğer tüm amaçlar için görünümleri kullanabilirsiniz.

Örnek: Biraz sert geçebilir diziler üstlenecek ave bbunun gibi bir görünüm:

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

Artık tüm verileri içeren tek bir dizi oluşturabiliriz:

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

Şimdi orijinali simüle eden görünümler oluşturuyoruz ave b:

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

Verileri a2ve b2ile paylaşılıyor c. Her iki diziyi aynı anda karıştırmak için kullanın numpy.random.shuffle(c).

Üretim kodunda, elbette orijinalini yaratmaktan kaçınmak için çalışacağını söyledi ave boluşturmak hemen hiç ve c, a2ve b2.

Bu çözelti halinde adapte olabilir ave bfarklı dtypes sahiptir.

NumPy'nin dizi indekslemesini kullanabilirsiniz :

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

Bu, ayrı bir tekli karışık dizilerin oluşturulmasına neden olacaktır.

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)

Daha fazla bilgi için http://scikit-learn.org/stable/modules/generated/sklearn.utils.shuffle.html adresine bakın.

Çok basit bir çözüm:

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

iki x, y dizisi şimdi aynı şekilde rastgele karıştırılır

James, 2015 yılında faydalı bir sklearn çözümü yazdı . Ancak, gerekli olmayan rastgele bir durum değişkeni ekledi. Aşağıdaki kodda, numpy'den rastgele durum otomatik olarak kabul edilir.

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]

Yalnızca NumPy kullanarak istediğiniz sayıda diziyi yerinde karıştırın.

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)

Ve böyle kullanılabilir

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

Unutulmaması gereken birkaç nokta:

• Bu iddia tüm girdi dizilerinin ilk boyutları boyunca aynı uzunlukta olmasını sağlar.
• Diziler ilk boyutlarına göre yerinde karıştırıldı - hiçbir şey geri gelmedi.
• Pozitif int32 aralığında rastgele tohum.
• Tekrarlanabilir bir karıştırmaya ihtiyaç duyulursa, tohum değeri ayarlanabilir.

Karıştırma işleminden sonra veriler np.split, uygulamaya bağlı olarak dilimler kullanılarak bölünebilir veya dilimler kullanılarak başvurulabilir.

şöyle bir dizi oluşturabilirsiniz:

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

sonra karıştırın:

np.random.shuffle(s)

şimdi bu dizileri dizilerinizin argümanı olarak kullanın. aynı karıştırılmış argümanlar aynı karıştırılmış vektörleri döndürür.

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

Bağlı listeler için yerinde karıştırmanın bir yolu, bir tohum kullanmak (rastgele olabilir) ve karıştırmayı yapmak için numpy.random.shuffle kullanmaktır.

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

Bu kadar. Bu hem a hem de b'yi aynı şekilde karıştırır. Bu da her zaman bir artı olan yerinde yapılır.

DÜZENLE, np.random.seed () kullanmayın, bunun yerine np.random.RandomState kullanın

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

Arama yaparken rastgele durumu beslemek için herhangi bir tohumdan geçin:

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

Çıktı:

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

Düzenleme: Rastgele durumu yeniden tohumlamak için sabit kod

Bunun üstesinden gelebilecek iyi bilinen bir işlev vardır:

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

Test_size değerini 0 olarak ayarlamak, bölünmeyi önler ve karıştırılmış veriler verir. Genellikle tren ve test verilerini bölmek için kullanılsa da, bunları da karıştırır.
Gönderen dokümantasyon

Dizileri veya matrisleri rastgele tren ve test alt kümelerine ayırın

Bir onelinerdaki verileri bölmek (ve isteğe bağlı olarak alt örnekleme) için tek bir çağrıya veri girmek için giriş doğrulamasını ve sonraki (ShuffleSplit (). Bölünmüş (X, y)) ve uygulamayı saran hızlı yardımcı program.

Diyelim ki iki dizimiz var: a ve 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]]) 

İlk olarak ilk boyuta izin vererek satır indeksleri elde edebiliriz

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

Ardından gelişmiş dizinleme kullanın. Burada her iki diziyi birlikte karıştırmak için aynı indeksleri kullanıyoruz.

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

Bu şuna eşdeğerdir:

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

Dizileri kopyalamaktan kaçınmak istiyorsanız, bir permütasyon listesi oluşturmak yerine dizideki her öğeden geçmenizi ve dizideki başka bir konuma rastgele değiştirmenizi öneririm

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]

Bu, Knuth-Fisher-Yates shuffle algoritmasını uygular.

Bu çok basit bir çözüm gibi görünüyor:

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

Bir örnekle, bunu yapıyorum:

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)

İkinci bir arg almak için python's random.shuffle () genişletilmiş:

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]

Bu şekilde karıştırma işleminin yerinde gerçekleştiğinden ve işlevin çok uzun veya karmaşık olmadığından emin olabilirim.

Sadece kullanın numpy...

İlk olarak iki giriş dizisini birleştirin 1D dizisi etiketler (y) ve 2D dizisi veri (x) 'dir ve bunları NumPy shuffleyöntemiyle karıştırır . Sonunda onları ayır ve geri dön.

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)