Быстрая перетасовка столбцов каждой строки numpy

у меня есть большой массив длиной 10,000,000+, который содержит строки. Мне нужно индивидуально перетасовать эти строки. Например:

[[1,2,3]
 [1,2,3]
 [1,2,3]
 ...
 [1,2,3]]

to

[[3,1,2]
 [2,1,3]
 [1,3,2]
 ...
 [1,2,3]]

в настоящее время я использую

map(numpy.random.shuffle, array)

но это цикл python (не NumPy), и он занимает 99% моего времени выполнения. К сожалению, PyPy JIT не реализует numpypy.random, Так что мне не повезло. Есть ли более быстрый способ? Я готов использовать любую библиотеку (pandas, scikit-learn, scipy, theano, etc. как долго, как это использует библиотеки numpy ndarray или его производные.)

если нет, я полагаю, я прибегну к Cython или c++.

10
numpy python random vectorization

4 ответов

вот некоторые идеи:

In [10]: a=np.zeros(shape=(1000,3))

In [12]: a[:,0]=1

In [13]: a[:,1]=2

In [14]: a[:,2]=3

In [17]: %timeit map(np.random.shuffle, a)
100 loops, best of 3: 4.65 ms per loop

In [21]: all_perm=np.array((list(itertools.permutations([0,1,2]))))

In [22]: b=all_perm[np.random.randint(0,6,size=1000)]

In [25]: %timeit (a.flatten()[(b+3*np.arange(1000)[...,np.newaxis]).flatten()]).reshape(a.shape)
1000 loops, best of 3: 393 us per loop

Если есть только несколько столбцов, то количество всех возможных перестановок намного меньше, чем количество строк в массиве (в этом случае, когда есть только 3 столбца, есть только 6 возможных перестановок). Способ сделать это быстрее-сначала сделать все перестановки сразу, а затем переставить каждую строку, случайным образом выбрав одну перестановку из всех возможных перестановок.

Он по-прежнему будет в 10 раз быстрее даже с большим размером:

#adjust a accordingly
In [32]: b=all_perm[np.random.randint(0,6,size=1000000)]

In [33]: %timeit (a.flatten()[(b+3*np.arange(1000000)[...,np.newaxis]).flatten()]).reshape(a.shape)
1 loops, best of 3: 348 ms per loop

In [34]: %timeit map(np.random.shuffle, a)
1 loops, best of 3: 4.64 s per loop
6

если перестановки столбцов перечислимы, то вы можете сделать следующее:

import itertools as IT
import numpy as np

def using_perms(array):
    nrows, ncols = array.shape
    perms = np.array(list(IT.permutations(range(ncols))))
    choices = np.random.randint(len(perms), size=nrows)
    i = np.arange(nrows).reshape(-1, 1)
    return array[i, perms[choices]]

N = 10**7
array = np.tile(np.arange(1,4), (N,1))
print(using_perms(array))

урожайность (что-то вроде)

[[3 2 1]
 [3 1 2]
 [2 3 1]
 [1 2 3]
 [3 1 2]
 ...
 [1 3 2]
 [3 1 2]
 [3 2 1]
 [2 1 3]
 [1 3 2]]

вот эталон, сравнивающий его с 

def using_shuffle(array):
    map(numpy.random.shuffle, array)
    return array

In [151]: %timeit using_shuffle(array)
1 loops, best of 3: 7.17 s per loop

In [152]: %timeit using_perms(array)
1 loops, best of 3: 2.78 s per loop

Edit: метод CT Zhu быстрее, чем мой:

def using_Zhu(array):
    nrows, ncols = array.shape    
    all_perm = np.array((list(itertools.permutations(range(ncols)))))
    b = all_perm[np.random.randint(0, all_perm.shape[0], size=nrows)]
    return (array.flatten()[(b+3*np.arange(nrows)[...,np.newaxis]).flatten()]
            ).reshape(array.shape)

In [177]: %timeit using_Zhu(array)
1 loops, best of 3: 1.7 s per loop

вот небольшая вариация метода Чжу, которая может быть даже немного быстрее:

def using_Zhu2(array):
    nrows, ncols = array.shape    
    all_perm = np.array((list(itertools.permutations(range(ncols)))))
    b = all_perm[np.random.randint(0, all_perm.shape[0], size=nrows)]
    return array.take((b+3*np.arange(nrows)[...,np.newaxis]).ravel()).reshape(array.shape)

In [201]: %timeit using_Zhu2(array)
1 loops, best of 3: 1.46 s per loop
7

вы также можете попробовать применить

0

Я считаю, что у меня есть альтернативная, эквивалентная стратегия, основанная на предыдущих ответах:

# original sequence
a0 = np.arange(3) + 1

# length of original sequence
L = a0.shape[0]

# number of random samples/shuffles
N_samp = 1e4

# from above
all_perm = np.array( (list(itertools.permutations(np.arange(L)))) )
b = all_perm[np.random.randint(0, len(all_perm), size=N_samp)]

# index a with b for each row of b and collapse down to expected dimension
a_samp = a0[np.newaxis, b][0]

Я не уверен, как это сравнивает производительность, но мне нравится его читаемость.

0