scipy.linalg.

convolution_matrix#

scipy.linalg.convolution_matrix(a, n, mode='full')[источник]#

Построить матрицу свертки.

Строит матрицу Тёплица, представляющую одномерную свёртку [1]. Подробности см. в примечаниях ниже.

Параметры:
a(…, m) array_like

Одномерный массив для свертки. N-мерные массивы обрабатываются как пакет: каждый срез по последней оси является одномерным массивом для свертки.

nint

Количество столбцов в результирующей матрице. Определяет длину входных данных для свертки с a. Это аналогично длине v в numpy.convolve(a, v).

modestr

Это аналогично mode в numpy.convolve(v, a, mode). Он должен быть одним из ('full', 'valid', 'same'). Смотрите ниже, как mode определяет форму результата.

Возвращает:
A(…, k, n) ndarray

Матрица свёртки, количество строк которой k зависит от mode:

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

Для пакетного ввода каждый срез формы (k, n) вдоль последних двух измерений выхода соответствует срезу формы (m,) вдоль последнего измерения входных данных.

Смотрите также

toeplitz

матрица Тёплица

Примечания

Код:

A = convolution_matrix(a, n, mode)

создает матрицу Тёплица A такой, что A @ v эквивалентно использованию convolve(a, v, mode). Возвращаемый массив всегда имеет n столбцов. Количество строк зависит от указанного mode, как объяснено выше.

В режиме по умолчанию 'full', элементы A задаются как:

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

где m = len(a). Предположим, например, входной массив [x, y, z]. Матрица свертки имеет вид:

[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]

В режиме 'valid' элементы A задаются как:

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

Это соответствует матрице, строки которой являются подмножеством строк из 'полного' случая, где все коэффициенты в a содержатся в строке. Для входных данных [x, y, z], этот массив выглядит как:

[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]

В режиме 'same' элементы A задаются как:

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

Типичное применение режима 'same' — когда имеется сигнал длиной n (с n больше чем len(a)), и желаемый результат представляет собой отфильтрованный сигнал, который всё ещё имеет длину n.

Для входных данных [x, y, z], этот массив выглядит как:

[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]

Добавлено в версии 1.5.0.

Ссылки

Примеры

>>> 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]])

Сравнение умножения на A с использованием numpy.convolve.

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

Проверить, что A @ x дал тот же результат, что и применение функции свёртки.

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

Для сравнения со случаем mode='same' показанные выше, вот матрицы, созданные mode='full' и mode='valid' для тех же коэффициентов и размера.

>>> 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]])
На этой странице