scipy.sparse.coo_matrix.

tensordot#

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

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

Das tensordot unterscheidet sich von dot und matmul dadurch, dass für jedes der ersten und zweiten Arrays beliebige Achsen ausgewählt werden können und die Summe der Produkte genauso wie bei der Matrixmultiplikation berechnet wird, nur eben nicht nur für die Zeilen des ersten mit den Spalten des zweiten. Es nimmt das Skalarprodukt der Sammlung von Vektoren entlang der angegebenen Achsen. Hier können wir sogar die Summe der Produkte über zwei oder mehr Achsen nehmen, wenn 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, die als 2-Tupel/Liste/Array mit zwei Sequenzen von Achsennummern angegeben sind, (a_axes, b_axes). Summiere die Produkte der Elemente (Komponenten) von a und b über die durch a_axes und b_axes angegebenen Achsen. Die Eingabe axes kann eine einzelne nicht-negative ganze Zahl, N, sein; 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 eine Ganzzahl N, summiere über die letzten N Achsen von a und die ersten N Achsen von b in Ordnung. 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-Dot-Produkt 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 von Tupeln 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]])