Python: Matrixprodukt mit Tensorkomponenten, wie?

[Schmidt (Gast)]

Hallo liebe Gemeinschaft,


ich bin relativ neu im Bereich Python unterwegs und habe eine Frage an 
euch.

Ausgangssituation
Python 3.5
NumPy 1.16


Meine Problem ist folgendes:

Ich habe einen Tensor, welcher Bildinformationen enthält. Nehmen wir an, 
er habe die Dimensionen T^30x300x300. Jeder der 300x300 "Pixel"-Vektoren 
beinhaltet somit 30 Elemente.

Ich möchte nun eine Matrizenmultiplikation auf diese 30 Elemente eines 
jeden Pixelvektors durchführen, und das möglichst zeiteffektiv.

Somit wäre in Pseudo-Python-Code:

V[:] = T[:][j][i] der Vektor, welcher die Elemente des Pixels i, j 
beinhaltet. Leider funktioniert bereits dieser Übertrag nicht.

Nun soll eine Matrix M^30x30 auf V mit MV = V' angewendet werden und 
anschließend der neue Vektor V' als V'= T'[:][j][i] als neuer Tensor T' 
abgelegt werden.

---

1. Dieses Problem kann als for-Schleife und der Einsteinsumme gelöst 
werden, was jedoch ewig dauert.

2. Es gibt die Funktion np.matmul (Matrix, Vektor), welche bei mir 
jedoch stets Dimensionsfehler ausgibt.

---

Gibt es da einen offiziellen und effektiven Weg? Vielleicht habt ihr ein 
Schlagwort für mich, dass ich nachlesen kann?


Ich freue mich auf gute Ideen von euch

Schmidt

[Christopher J. (christopher_j23)]

Die Syntax

a = T[i][j][k]

funktioniert als Verkettung des [] operators, d.h. intern läuft so etwas 
ab wie

a1 = T[i]
a2 = a1[j]
a = a2[k]

Da T[:]==T kommst du nicht zum gewünschten Ergebnis

T[:][j][k]

schreibst du das einfach als

T[:,j,k]

kurzes Beispiel:

>>> T = np.arange(2*4*4).reshape(2,4,4)
>>> T
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23],
        [24, 25, 26, 27],
        [28, 29, 30, 31]]])
# das wäre ein Beispiel mit 4x4 Pixeln mit jeweils zwei Werten, d.h. zwei 4x4 Matrizen als Stapel

>>> T[:,1,1]
array([ 5, 21])
# so funktioniert es aber immer daran denken, dass Python 0-based indexing hat ;)

>>> M = np.array([[2,0],[0,2]])
>>> M
array([[2, 0],
       [0, 2]])
# als Beispiel verdoppeln wir einfach die Werte

>>> np.matmul(T[:,0,0],M)
array([ 0, 32])
# das wären die Werte für den ersten Pixel. Das könnte man jetzt in eine Schleife packen und drüber iterieren aber einfacher ist es das Array zu transformieren

>>> T.reshape(2,16)
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]])
# jetzt haben wir eine 2x16 Matrix, so dass matmul() damit arbeiten kann
# d.h. (2x2)*(2x16)->(2x16)

>>> np.matmul(M,T.reshape(2,16))
array([[ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30],
       [32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62]])
# das ganze dann wieder zurücktransformieren:

>>> T1 = np.matmul(M,T.reshape(2,16)).reshape(2,4,4)
>>> T1
array([[[ 0,  2,  4,  6],
        [ 8, 10, 12, 14],
        [16, 18, 20, 22],
        [24, 26, 28, 30]],

       [[32, 34, 36, 38],
        [40, 42, 44, 46],
        [48, 50, 52, 54],
        [56, 58, 60, 62]]])

# wie man sehen kann wurden alle Werte verdoppelt

Die reshape-Operationen dürften sehr günstig sein, da meines Wissens 
nach nur die äußere Repräsentation der Daten geändert wird aber sie nach 
wie vor linear im Speicher liegen und damit keine Rechenzeit in 
irgendwelchen Schleifen verbummelt wird.

[Sven B. (scummos)]

Um mir genau zu überlegen wie ist es zu warm, aber das lässt sich doch 
bestimmt mit "np.einsum" in einem Aufruf lösen.

[Programmierer (Gast)]

Schmidt schrieb:
> Ich habe einen Tensor, welcher Bildinformationen enthält. Nehmen wir an,
> er habe die Dimensionen T^30x300x300.

Hmm, warum hast Du den Tensor?

Doch bestimmt weil du mit Machine Learning rum machst, oder?

Warum dann nicht einfach eines der bekannten Frameworks dafür nehmen?