scipy.linalg.

convolution_matrix#

scipy.linalg.convolution_matrix(a, n, mode='full')[Quelle]#

Konstruiert eine Konvolutionsmatrix.

Konstruiert die Toeplitz-Matrix, die eine eindimensionale Konvolution darstellt [1]. Details finden Sie unten in den Hinweisen.

Parameter:
a(…, m) array_like

Das 1D-Array, das gefaltet werden soll. N-dimensionale Arrays werden als Stapel behandelt: Jeder Schnitt entlang der letzten Achse ist ein 1D-Array, das gefaltet werden soll.

nint

Die Anzahl der Spalten in der resultierenden Matrix. Sie gibt die Länge des Inputs an, der mit a gefaltet wird. Dies ist analog zur Länge von v in numpy.convolve(a, v).

modestr

Dies ist analog zu mode in numpy.convolve(v, a, mode). Es muss einer der Werte (‘full’, ‘valid’, ‘same’) sein. Wie mode die Form des Ergebnisses bestimmt, siehe unten.

Rückgabe:
A(…, k, n) ndarray

Die Konvolutionsmatrix, deren Zeilenanzahl k von mode abhängt

=======  =========================
 mode    k
=======  =========================
'full'   m + n -1
'same'   max(m, n)
'valid'  max(m, n) - min(m, n) + 1
=======  =========================

Bei Stapel-Input entspricht jeder Schnitt der Form (k, n) entlang der letzten beiden Dimensionen des Outputs einem Schnitt der Form (m,) entlang der letzten Dimension des Inputs.

Siehe auch

toeplitz

Toeplitz-Matrix

Hinweise

Der Code

A = convolution_matrix(a, n, mode)

erzeugt eine Toeplitz-Matrix A, so dass A @ v äquivalent zur Verwendung von convolve(a, v, mode) ist. Das zurückgegebene Array hat immer n Spalten. Die Anzahl der Zeilen hängt vom angegebenen mode ab, wie oben erläutert.

Im Standardmodus ‘full’ sind die Einträge von A gegeben durch

A[i, j] == (a[i-j] if (0 <= (i-j) < m) else 0)

wobei m = len(a). Nehmen wir zum Beispiel an, das Eingabearray ist [x, y, z]. Die Konvolutionsmatrix hat die Form

[x, 0, 0, ..., 0, 0]
[y, x, 0, ..., 0, 0]
[z, y, x, ..., 0, 0]
...
[0, 0, 0, ..., x, 0]
[0, 0, 0, ..., y, x]
[0, 0, 0, ..., z, y]
[0, 0, 0, ..., 0, z]

Im Modus ‘valid’ sind die Einträge von A gegeben durch

A[i, j] == (a[i-j+m-1] if (0 <= (i-j+m-1) < m) else 0)

Dies entspricht einer Matrix, deren Zeilen die Teilmenge der Zeilen aus dem ‘full’-Fall sind, bei denen alle Koeffizienten in a in der Zeile enthalten sind. Für die Eingabe [x, y, z] sieht diese Matrix wie folgt aus

[z, y, x, 0, 0, ..., 0, 0, 0]
[0, z, y, x, 0, ..., 0, 0, 0]
[0, 0, z, y, x, ..., 0, 0, 0]
...
[0, 0, 0, 0, 0, ..., x, 0, 0]
[0, 0, 0, 0, 0, ..., y, x, 0]
[0, 0, 0, 0, 0, ..., z, y, x]

Im Modus ‘same’ sind die Einträge von A gegeben durch

d = (m - 1) // 2
A[i, j] == (a[i-j+d] if (0 <= (i-j+d) < m) else 0)

Die typische Anwendung des Modus ‘same’ ist, wenn man ein Signal der Länge n hat (wobei n größer als len(a) ist) und das gewünschte Ergebnis ein gefiltertes Signal ist, das immer noch die Länge n hat.

Für die Eingabe [x, y, z] sieht diese Matrix wie folgt aus

[y, x, 0, 0, ..., 0, 0, 0]
[z, y, x, 0, ..., 0, 0, 0]
[0, z, y, x, ..., 0, 0, 0]
[0, 0, z, y, ..., 0, 0, 0]
...
[0, 0, 0, 0, ..., y, x, 0]
[0, 0, 0, 0, ..., z, y, x]
[0, 0, 0, 0, ..., 0, z, y]

Hinzugefügt in Version 1.5.0.

Referenzen

Beispiele

>>> import numpy as np
>>> from scipy.linalg import convolution_matrix
>>> A = convolution_matrix([-1, 4, -2], 5, mode='same')
>>> A
array([[ 4, -1,  0,  0,  0],
       [-2,  4, -1,  0,  0],
       [ 0, -2,  4, -1,  0],
       [ 0,  0, -2,  4, -1],
       [ 0,  0,  0, -2,  4]])

Vergleichen Sie die Multiplikation mit A mit der Verwendung von numpy.convolve.

>>> x = np.array([1, 2, 0, -3, 0.5])
>>> A @ x
array([  2. ,   6. ,  -1. , -12.5,   8. ])

Überprüfen Sie, ob A @ x dasselbe Ergebnis liefert wie die Anwendung der Faltungsfunktion.

>>> np.convolve([-1, 4, -2], x, mode='same')
array([  2. ,   6. ,  -1. , -12.5,   8. ])

Zum Vergleich mit dem oben gezeigten Fall mode='same' sind hier die Matrizen aufgeführt, die von mode='full' und mode='valid' für dieselben Koeffizienten und dieselbe Größe erzeugt werden.

>>> convolution_matrix([-1, 4, -2], 5, mode='full')
array([[-1,  0,  0,  0,  0],
       [ 4, -1,  0,  0,  0],
       [-2,  4, -1,  0,  0],
       [ 0, -2,  4, -1,  0],
       [ 0,  0, -2,  4, -1],
       [ 0,  0,  0, -2,  4],
       [ 0,  0,  0,  0, -2]])

>>> convolution_matrix([-1, 4, -2], 5, mode='valid')
array([[-2,  4, -1,  0,  0],
       [ 0, -2,  4, -1,  0],
       [ 0,  0, -2,  4, -1]])
Auf dieser Seite