Numpy свернуть с действительным

Я предполагаю, что (1) читатель имеет базовое представление о том, что такое свертка, и (2) используется ядро ​​с нечетным числом элементов > 1.

Короткий ответ:

• Используйте np.convolve(…, mode = "valid").

• Прежде чем сворачивать, дополните куски

  • … в начале с (len(kernel) - 1) / 2 последними элементами предыдущего фрагмента,
  • … в конце первые элементы (len(kernel) - 1) / 2 из следующего фрагмента,

  где kernel относится к вашему скользящему ядру ([1]*3 в вашем вопросе).

Длинный ответ:

Поскольку свертку можно рассматривать как операцию со скользящим ядром, вопрос, как вы поняли, в том, что происходит на границах.

Функция numpy.convolve() имеет 3 режима обработки границ, как описано здесь:

• mode = "valid" гарантирует, что скользящее ядро ​​никогда не покинет сигнал. Однако это означает, что результат будет содержать меньше элементов, чем сигнал; а именно len(kernel) - 1 меньше элементов. Итак, если у вас есть сигнал из 100 элементов и ядро ​​из 5 элементов, ваш результат будет содержать 100-(5-1)=96 элементов. Вопрос о том, где операция «удаляет» недостающие элементы, может немного ввести в заблуждение; однако один из способов представить результат - записать его значения в центры скользящего ядра (что имеет смысл для симметричного ядра с нечетным числом элементов, как в случае с вашим вопросом), поэтому с этой интерпретацией можно было бы симметрично удалить элементы: (len(kernel) - 1) / 2 элементы в начале, (len(kernel) - 1) / 2 элементы в конце сигнала. Мы увидим, что это содержательная интерпретация в примере кода ниже.
• mode = "same" гарантирует, что результирующий сигнал будет иметь то же количество значений, что и входной сигнал. Однако это подразумевает, что нам придется «придумать» значения, чтобы компенсировать эффект меньшего количества элементов, который мы видели с помощью mode = "valid". Как следствие, в этом режиме сигнал дополняется нулями – (len(kernel) - 1) / 2 как в начале, так и в конце – перед операцией свертки.
• mode = "full", наконец, гарантирует, что будут созданы все потенциальные комбинации перекрытия между сигналом и скользящим ядром. Это означает, что (а) нам придется «составить» еще больше значений и (б) что результат будет больше, чем входной сигнал. «Придуманные» значения здесь снова равны нулям, а результат будет содержать элементы len(signal) + len(kernel) - 1, то есть 100+5-1=104 элемента для предыдущего примера.

Если вы обрабатываете свой сигнал частями, лучше всего использовать mode = "valid": вы можете гарантировать, что полученные свернутые фрагменты будут иметь ту же длину, что и входные фрагменты, без необходимости «составлять» значения (т. е. без необходимости заполнения нулями) , путем заполнения конечными значениями из предыдущего фрагмента и ведущими значениями из следующего фрагмента. Это справедливо для всех фрагментов, кроме первого и последнего, и в этих случаях вам придется самостоятельно решать, как следует обрабатывать граничную ситуацию. Во всех остальных случаях дополняйте значениями предыдущего и последующего фрагментов на половину единицы меньше, чем длина ядра.

Код ниже демонстрирует, что описанное заполнение фрагментов дает точно такие же результаты, как если бы сигнал вообще не дробился на фрагменты. Обратите внимание, что я сместил полученные свернутые сигналы на графиках на значения (len(kernel) - 1) / 2, чтобы учесть описанные недостающие значения с mode = "valid" в самом начале сигнала.

import matplotlib.pyplot as plt
import numpy as np

len_signal, len_kernel = 100, 5
num_chunks = 10

rand = np.random.default_rng(seed=42)
signal = np.cumsum(rand.normal(size=len_signal))
kernel = np.ones(len_kernel) / len_kernel

# Produce convolution result without chunking for reference
signal_convolved = np.convolve(signal, kernel, mode = "valid")

# Split into chunks, then pad them: (1) start with `(len_kernel - 1) / 2`
# last values from preceding chunk (except first chunk), (2) end with
# `(len_kernel - 1) / 2` first values from following chunk (except last chunk)
len_arm = (len_kernel - 1) // 2  # Length of a "kernel arm"
chunks_convolved = []
for i, chunk in enumerate(chunks := np.split(signal, num_chunks)):
    p1 = [] if i == 0 else chunks[i - 1][-len_arm:]  # Start padding
    p2 = [] if i == len(chunks) - 1 else chunks[i + 1][:len_arm]  # End padding
    chunk_conv = np.convolve(np.r_[p1, chunk, p2], kernel, mode = "valid")
    chunks_convolved = np.r_[chunks_convolved, chunk_conv]  # Append

assert np.allclose(signal_convolved, chunks_convolved)  # Check: same result?
# Show: convolved w/o chunking (left) vs chunked, padded, and convolved (right)
x_c = np.arange(len(signal_convolved)) + len_arm   # Right-shift conv. result
plt.subplot(121)
plt.plot(signal, "--"); plt.plot(x_c, signal_convolved); plt.title("no chunks")
plt.subplot(122)
plt.plot(signal, "--"); plt.plot(x_c, chunks_convolved); plt.title("chunks")
plt.show()

Как вы можете видеть (и как мы проверили с помощью assert), оба результата одинаковы:

И последнее примечание: convolve1d() scipy предоставляет больше возможностей, кроме заполнения нулями, для обработки оставшейся граничной ситуации в начале и конце вашего общего сигнала и, таким образом, может быть альтернативой, в зависимости от варианта использования.