scipy.sparse.coo_array.

tensordot#

coo_array.tensordot(other, axes=2)[Quelle]#

Gibt das Tensordot-Produkt mit einem anderen Array entlang der angegebenen Achsen zurück.

Der tensordot unterscheidet sich von dot und matmul dadurch, dass für jedes der ersten und zweiten Arrays eine beliebige Achse gewählt werden kann und die Summe der Produkte wie bei der Matrixmultiplikation berechnet wird, nur nicht nur für die Zeilen des ersten mal die Spalten des zweiten. Er nimmt das Skalarprodukt der Vektoren entlang der angegebenen Achsen. Hier können wir sogar die Summe der Produkte entlang von zwei oder mehr Achsen nehmen, falls gewünscht. Tensordot ist also eine Skalarproduktberechnung, die auf Arrays beliebiger Dimension >= 1 angewendet wird. Es ist wie matmul, aber über beliebige Achsen für jede Matrix.

Gegeben seien zwei Tensoren, a und b, und die gewünschten Achsen, angegeben als ein 2-Tupel/Liste/Array, das zwei Sequenzen von Achsennummern enthält, (a_axes, b_axes), summiere die Produkte der Elemente (Komponenten) von a und b über die durch a_axes und b_axes spezifizierten Achsen. Die Eingabe axes kann eine einzelne nicht-negative Ganzzahl sein, N; wenn dies der Fall ist, werden die letzten N Dimensionen von a und die ersten N Dimensionen von b summiert.

Parameter:

a, barray_like

Tensoren zum „Dot-Produkt“.

axesint oder (2,) array_like

integer_like Wenn ein Int N, summiere nacheinander über die letzten N Achsen von a und die ersten N Achsen von b. Die Größen der entsprechenden Achsen müssen übereinstimmen.
(2,) array_like Ein 2-Tupel von Sequenzen von Achsen, über die summiert werden soll, wobei die erste auf a und die zweite auf b angewendet wird. Die Sequenzen müssen die gleiche Länge haben. Die Form der entsprechenden Achsen muss zwischen a und b übereinstimmen.

Rückgabe:

outputcoo_array: Das Tensor-Skalarprodukt dieses Arrays mit other. Es wird dicht/dünn sein, wenn other dicht/dünn ist.

Siehe auch

dot

Beispiele

>>> import numpy as np
>>> import scipy.sparse
>>> A = scipy.sparse.coo_array([[[2, 3], [0, 0]], [[0, 1], [0, 5]]])
>>> A.shape
(2, 2, 2)

Ganzzahlige Achsen N sind eine Kurzform für (range(-N, 0), range(0, N))

>>> A.tensordot(A, axes=1).toarray()
array([[[[ 4,  9],
         [ 0, 15]],

        [[ 0,  0],
         [ 0,  0]]],


       [[[ 0,  1],
         [ 0,  5]],

        [[ 0,  5],
         [ 0, 25]]]])
>>> A.tensordot(A, axes=2).toarray()
array([[ 4,  6],
       [ 0, 25]])
>>> A.tensordot(A, axes=3)
array(39)

Verwendung eines Tupels für Achsen

>>> a = scipy.sparse.coo_array(np.arange(60).reshape(3,4,5))
>>> b = np.arange(24).reshape(4,3,2)
>>> c = a.tensordot(b, axes=([1,0],[0,1]))
>>> c.shape
(5, 2)
>>> c
array([[4400, 4730],
       [4532, 4874],
       [4664, 5018],
       [4796, 5162],
       [4928, 5306]])