reiner numpy Ausdruck für dieselbe Länge Subarrays mit unterschiedlichen Startindizes der Auswahl von 3-D-Array

Question

Ich habe einen 3-D numpy array (nennen wir es a) mit Form (74, 74, 4563), und ich mag einen längs- n sub- extrahieren Array von jedem Ort in den ersten beiden Dimensionen. Jedes dieser Teilarrays beginnt jedoch an einer anderen Stelle, abhängig von den Indizes in den ersten zwei Dimensionen, i & j.

Zum Beispiel, wenn n=1000 kann ich a[0, 0, 0:1000], aber auch a[0, 1, 2:1002], etc will ... Ich habe eine 2-D-Array (genannt ix0), die ein 2-D-Array ist, das mir sagt, wo jeden beginnt Sub-Array für jede i/j Position. Schließlich bin ich garantiert, dass es keinen "Überlauf" geben wird - das heißt, alle Werte in ix0 + n sind kleiner als die Dimension-2-Länge von a (so müssen wir uns keine Sorgen darüber machen, nach einem Index jenseits der Bereich, der vorhanden ist).

Zum Beispiel ...

a = np.arange(74*74*4563).reshape(74, 74, 4563) 
ix0 = np.arange(74*74).reshape(74,74)/2 + 50 
a[:, :, ix0:ix0+n] 

, die eine Möglichkeit, dies zu tun, ist es

IndexError: failed to coerce slice entry of type numpy.ndarray to integer 

produzieren die alle ohne Schleife durch i/j Indexkombinationen oder eine große Maskenanordnung zu schaffen?

Answer 1

Etwas in dieser Zeile wurde zuvor gefragt, aber für 2d. Ich werde versuchen, das herauszufinden.

Aber hier ist schnelles Beispiel von dem, was in dem 2. Fall geht

In [1463]: x=np.arange(12).reshape(3,4) 
In [1464]: ix0=np.array([0,2,1]) 
In [1465]: N=2 

Wir über jede Reihe von x laufen könnten, die N Länge Scheibe gewünschten sammeln, und dann kommen sie in eine Liste oder ein Array. Ein allgemeineres Problem variiert die Länge der Schichten, in welchem ​​Fall sie nicht wieder zu einem Array zusammengesetzt werden können.

In [1466]: [x[i,ix0[i]:ix0[i]+N] for i in range(3)] 
Out[1466]: [array([0, 1]), array([6, 7]), array([ 9, 10])] 

und dann diese Liste in np.array umbrechen.

Eine Alternative ist, die Indizes verketten zuerst:

In [1467]: x[np.arange(3)[:,None], np.array([np.r_[ix0[i]:ix0[i]+N] for i in range(3)])] 
Out[1467]: 
array([[ 0, 1], 
     [ 6, 7], 
     [ 9, 10]]) 

Der letzte Index Array ist:

In [1468]: np.array([np.r_[ix0[i]:ix0[i]+N] for i in range(3)]) 
Out[1468]: 
array([[0, 1], 
     [2, 3], 
     [1, 2]]) 

zum 3D Fall, dass wir zwei Möglichkeiten anwenden zu können. Man wird es zu 2d umformen, eine dieser Strategien anwenden und zurückverformen. Die andere ist die Verallgemeinerung der Aktion, die ich unternommen habe, um diese zu erstellen - das sollte nicht zu schwer sein, aber ein wenig experimentieren.

Das letzte Array sollte nicht schwer mit Rundfunk zu erstellen sein.

In [1469]: ix0[:,None]+np.arange(N) 
Out[1469]: 
array([[0, 1], 
     [2, 3], 
     [1, 2]]) 

In [1470]: x[np.arange(3)[:,None], ix0[:,None]+np.arange(N)] 
Out[1470]: 
array([[ 0, 1], 
     [ 6, 7], 
     [ 9, 10]]) 

Nun sollte es noch einfacher sein, zu verallgemeinern

In [1487]: X=np.arange(2*3*10).reshape(2,3,10) 

In [1488]: ix0=np.arange(2*3).reshape(2,3) 

In [1489]: ix0[...,None]+np.arange(N) 
Out[1489]: 
array([[[0, 1], 
     [1, 2], 
     [2, 3]], 

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

In [1490]: I,J,_=np.ix_(range(2),range(3),range(N)) 

In [1491]: I.shape 
Out[1491]: (2, 1, 1) 

In [1492]: J.shape 
Out[1492]: (1, 3, 1) 

In [1493]: X[I, J, ix0[...,None]+np.arange(N)] 
Out[1493]: 
array([[[ 0, 1], 
     [11, 12], 
     [22, 23]], 

     [[33, 34], 
     [44, 45], 
     [55, 56]]]) 

bis 3d I sollte die Werte sind recht sicher, aber die Formen übereinstimmen, die in dieser Art der Sache ist 80% der Arbeit.