N-D-Version von iertools.combinations in numpy

Question

Ich möchte itertools.combinations für numpy implementieren. Basierend auf this discussion habe ich eine Funktion, die für 1D-Eingabe funktioniert:

def combs(a, r): 
    """ 
    Return successive r-length combinations of elements in the array a. 
    Should produce the same output as array(list(combinations(a, r))), but 
    faster. 
    """ 
    a = asarray(a) 
    dt = dtype([('', a.dtype)]*r) 
    b = fromiter(combinations(a, r), dt) 
    return b.view(a.dtype).reshape(-1, r) 

und der Ausgang macht Sinn:

In [1]: list(combinations([1,2,3], 2)) 
Out[1]: [(1, 2), (1, 3), (2, 3)] 

In [2]: array(list(combinations([1,2,3], 2))) 
Out[2]: 
array([[1, 2], 
     [1, 3], 
     [2, 3]]) 

In [3]: combs([1,2,3], 2) 
Out[3]: 
array([[1, 2], 
     [1, 3], 
     [2, 3]]) 

wäre es jedoch am besten, wenn ich es ND-Eingänge erweitern könnte, wo Zusätzliche Dimensionen ermöglichen es Ihnen, schnell mehrere Anrufe gleichzeitig zu tätigen. Wenn also combs([1, 2, 3], 2)[1, 2], [1, 3], [2, 3] und combs([4, 5, 6], 2)[4, 5], [4, 6], [5, 6] produziert, dann sollte combs((1,2,3) and (4,5,6), 2)[1, 2], [1, 3], [2, 3] and [4, 5], [4, 6], [5, 6] produzieren, wobei "und" nur parallele Zeilen oder Spalten darstellt (was auch immer sinnvoll ist). (Und ebenso für zusätzliche Dimensionen)

Ich bin nicht sicher:

1. Wie die Dimensionen in einer logischen Art und Weise arbeiten zu machen, die mit der Art und Weise andere Funktionen konsistent sind arbeiten (wie, wie einige numpy Funktionen ein axis= haben Parameter und ein Standard von Achse 0. Also sollte Achse 0 die sein, die ich kombiniere, und alle anderen Achsen nur Parallelrechnungen darstellen?)
2. Wie bekomme ich den obigen Code um mit ND zu arbeiten (gerade jetzt bekomme ich ValueError: setting an array element with a sequence.)
3. Gibt es eine bessere Möglichkeit, dt = dtype([('', a.dtype)]*r) zu tun?

Answer 1

nicht sicher, wie es funktionieren wird aus Performance-weise, aber Sie können die Kombinationen auf einem Index Array tun, dann extrahieren Sie die tatsächliche Array Scheiben mit np.take:

def combs_nd(a, r, axis=0): 
    a = np.asarray(a) 
    if axis < 0: 
     axis += a.ndim 
    indices = np.arange(a.shape[axis]) 
    dt = np.dtype([('', np.intp)]*r) 
    indices = np.fromiter(combinations(indices, r), dt) 
    indices = indices.view(np.intp).reshape(-1, r) 
    return np.take(a, indices, axis=axis) 

>>> combs_nd([1,2,3], 2) 
array([[1, 2], 
     [1, 3], 
     [2, 3]]) 
>>> combs_nd([[1,2,3],[4,5,6]], 2, axis=1) 
array([[[1, 2], 
     [1, 3], 
     [2, 3]], 

     [[4, 5], 
     [4, 6], 
     [5, 6]]]) 

Answer 2

Sie itertools.combinations() erstellen können der Index-Array und dann NumPy Phantasie Indexierungs verwenden:

import numpy as np 
from itertools import combinations, chain 
from scipy.misc import comb 

def comb_index(n, k): 
    count = comb(n, k, exact=True) 
    index = np.fromiter(chain.from_iterable(combinations(range(n), k)), 
         int, count=count*k) 
    return index.reshape(-1, k) 

data = np.array([[1,2,3,4,5],[10,11,12,13,14]]) 

idx = comb_index(5, 3) 
print data[:, idx] 

output:

[[[ 1 2 3] 
    [ 1 2 4] 
    [ 1 2 5] 
    [ 1 3 4] 
    [ 1 3 5] 
    [ 1 4 5] 
    [ 2 3 4] 
    [ 2 3 5] 
    [ 2 4 5] 
    [ 3 4 5]] 

[[10 11 12] 
    [10 11 13] 
    [10 11 14] 
    [10 12 13] 
    [10 12 14] 
    [10 13 14] 
    [11 12 13] 
    [11 12 14] 
    [11 13 14] 
    [12 13 14]]]