Mejor manera de barajar dos matrices numpy al unísono

Tengo dos matrices numpy de diferentes formas, pero con la misma longitud (dimensión principal). Quiero barajar cada uno de ellos, de modo que los elementos correspondientes sigan correspondiendo, es decir, barajarlos al unísono con respecto a sus índices principales.

Este código funciona e ilustra mis objetivos:

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

Por ejemplo:

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

Sin embargo, esto se siente torpe, ineficiente y lento, y requiere hacer una copia de los arreglos; prefiero mezclarlos en su lugar, ya que serán bastante grandes.

¿Hay una mejor manera de hacerlo? Mis objetivos principales son una ejecución más rápida y un menor uso de memoria, pero un código elegante también sería bueno.

Otro pensamiento que tuve fue este:

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)

Esto funciona ... pero da un poco de miedo, ya que veo pocas garantías de que continuará funcionando; no parece el tipo de cosa que se garantiza que sobrevivirá a través de la versión numpy, por ejemplo.

Su solución "aterradora" no me parece aterradora. Llamar shuffle()a dos secuencias de la misma longitud da como resultado la misma cantidad de llamadas al generador de números aleatorios, y estos son los únicos elementos "aleatorios" en el algoritmo aleatorio. Al restablecer el estado, se asegura de que las llamadas al generador de números aleatorios darán los mismos resultados en la segunda llamada a shuffle(), por lo que todo el algoritmo generará la misma permutación.

Si no le gusta esto, una solución diferente sería almacenar sus datos en una matriz en lugar de dos desde el principio, y crear dos vistas en esta matriz única simulando las dos matrices que tiene ahora. Puede usar la matriz única para barajar y las vistas para todos los demás fines.

Ejemplo: asumamos las matrices ay btengamos este aspecto:

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

Ahora podemos construir una matriz única que contenga todos los datos:

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

Ahora creamos vistas simulando el original ay b:

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

Los datos de a2y b2se comparten con c. Para barajar ambas matrices simultáneamente, use numpy.random.shuffle(c).

En el código de producción, por supuesto, tratará de evitar crear el original ay bcrearlo de inmediato c, a2y b2.

Esta solución podría adaptarse al caso ay btener diferentes tipos.

Puede usar la indexación de matriz de NumPy :

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

Esto dará como resultado la creación de matrices separadas mezcladas al unísono.

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)

Para obtener más información, consulte http://scikit-learn.org/stable/modules/generated/sklearn.utils.shuffle.html

Solución muy simple:

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

las dos matrices x, y ahora se mezclan aleatoriamente de la misma manera

James escribió en 2015 una solución sklearn que es útil. Pero agregó una variable de estado aleatorio, que no es necesaria. En el siguiente código, se supone automáticamente el estado aleatorio de 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)

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]

Mezcle cualquier número de matrices juntas, en el lugar, usando solo 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)

Y se puede usar así

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

Algunas cosas a tener en cuenta:

• La afirmación asegura que todas las matrices de entrada tengan la misma longitud a lo largo de su primera dimensión.
• Las matrices se barajaron en el lugar por su primera dimensión, nada regresó.
• Semilla aleatoria dentro del rango positivo int32.
• Si se necesita una combinación aleatoria repetible, se puede establecer el valor de inicialización.

Después de la combinación aleatoria, los datos se pueden dividir utilizando np.splito referenciados mediante sectores, según la aplicación.

puedes hacer una matriz como:

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

luego barajarlo:

np.random.shuffle(s)

ahora use esto como argumento de sus matrices. los mismos argumentos barajados devuelven los mismos vectores barajados.

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

Una forma de barajar en el lugar para listas conectadas es usar una semilla (podría ser aleatoria) y usar numpy.random.shuffle para barajar.

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

Eso es. Esto barajará tanto a como b exactamente de la misma manera. Esto también se hace en el lugar, lo que siempre es una ventaja.

EDITAR, no use np.random.seed () use np.random.RandomState en su lugar

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

Cuando lo llame, simplemente pase cualquier semilla para alimentar el estado aleatorio:

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

Salida:

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

Editar: código fijo para volver a sembrar el estado aleatorio

Hay una función bien conocida que puede manejar esto:

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

Solo establecer test_size en 0 evitará la división y le dará datos barajados. Aunque generalmente se usa para dividir el tren y probar datos, también los baraja.
De la documentación

Divide matrices o matrices en trenes aleatorios y subconjuntos de prueba

Utilidad rápida que envuelve la validación de entrada y la siguiente (ShuffleSplit (). Split (X, y)) y la aplicación para ingresar datos en una sola llamada para dividir (y opcionalmente submuestrear) datos en una línea.

Digamos que tenemos dos matrices: a y 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]]) 

Primero podemos obtener índices de fila permutando la primera dimensión

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

Luego use indexación avanzada. Aquí estamos usando los mismos índices para mezclar ambas matrices al unísono.

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

Esto es equivalente a

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

Si desea evitar copiar matrices, le sugiero que en lugar de generar una lista de permutación, revise todos los elementos de la matriz y lo cambie aleatoriamente a otra posición en la matriz.

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]

Esto implementa el algoritmo aleatorio Knuth-Fisher-Yates.

Esto parece una solución muy simple:

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

Con un ejemplo, esto es lo que estoy haciendo:

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)

Extendí random.shuffle () de python para tomar un segundo argumento:

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]

De esa manera, puedo estar seguro de que la mezcla se realiza en el lugar y que la función no es demasiado larga o complicada.

Solo usa numpy ...

Primero combine las dos matrices de entrada. La matriz 1D son etiquetas (y) y la matriz 2D son datos (x) y las baraja con el shufflemétodo NumPy . Finalmente sepárelos y regrese.

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)