Python 如何为两个矩阵创建卷积函数？

我想创建一个卷积函数，而不使用NumPy的卷积函数，该函数可以获得4个元素：

convolver_1(j, matrices_list, filter_matrix, stride_size)

---

函数应在使用

过滤器矩阵

执行卷积运算后以步长返回输出​<代码>跨步大小，在矩阵列表中索引j中的矩阵上，

过滤器矩阵

的维数低于

​矩阵列表

让我们看一下

np.convolve

的一个简单实现，可以找到它的文档

将numpy导入为np
def卷积_1d（a，过滤器）：
N、 M=len（a），len（过滤器）
断言N>=M#问题中的假设
#在全模式下（默认为np.卷积），结果长度为N+M-1
#因此，pad每侧应为M-1
#N-M+2p+1==N+M-1=>p=M-1
结果_长度=N+M-1
结果=np.0（结果长度）#为结果分配内存
p=M-1
加垫的a=np.pad（a，p）
翻转的过滤器=np.翻转（过滤器）
对于范围内的i（结果长度）：
结果[i]=np.sum（np.multiply（翻转的_过滤器，填充的_a[i:i+M]））
返回结果
a=np.数组（[1,2,3,4]）
filter=np.array（[1，-1,3]）
卷积（a，滤波器）

导致

array([ 1.,  1.,  4.,  7.,  5., 12.])

这与

np.convolve（a，filter）

的结果相同。 因此，它基本上用零填充输入数组，翻转过滤器并对两个数组的元素相乘求和

我不确定你提到的索引；结果是一个1d数组，您可以对其元素进行索引

要将步幅添加到此函数中，我们需要修改

结果长度

，并将步幅乘以迭代器：

def卷积1d_步幅（a，过滤器，步幅）：
N、 M=len（a），len（过滤器）
断言N>=M#问题中的假设
#在全模式下（默认为np.卷积），结果长度为N+M-1
#因此，pad每侧应为M-1
#N-M+2p+1==N+M-1=>p=M-1
结果_长度=（N+M-1）//步幅
结果=np.0（结果长度）#为结果分配内存
p=M-1
加垫的a=np.pad（a，p）
翻转的过滤器=np.翻转（过滤器）
对于范围内的i（结果长度）：
结果[i]=np.sum（np.multiply（翻转的_过滤器，填充的_a[i*步幅：i*步幅+M]））
返回结果
a=np.数组（[1,2,3,4]）
filter=np.array（[1，-1,3]）
卷积1d_跨步（a，过滤器，2）

---

希望它有帮助，如果这是您喜欢看到的，我很高兴将其扩展到二维。

让我们看一下

np.convalve的一个简单实现，可以找到它的文档

将numpy导入为np
def卷积_1d（a，过滤器）：
N、 M=len（a），len（过滤器）
断言N>=M#问题中的假设
#在全模式下（默认为np.卷积），结果长度为N+M-1
#因此，pad每侧应为M-1
#N-M+2p+1==N+M-1=>p=M-1
结果_长度=N+M-1
结果=np.0（结果长度）#为结果分配内存
p=M-1
加垫的a=np.pad（a，p）
翻转的过滤器=np.翻转（过滤器）
对于范围内的i（结果长度）：
结果[i]=np.sum（np.multiply（翻转的_过滤器，填充的_a[i:i+M]））
返回结果
a=np.数组（[1,2,3,4]）
filter=np.array（[1，-1,3]）
卷积（a，滤波器）

导致

array([ 1.,  1.,  4.,  7.,  5., 12.])

这与
np.convolve（a，filter）
的结果相同。
因此，它基本上用零填充输入数组，翻转过滤器并对两个数组的元素相乘求和

我不确定你提到的索引；结果是一个1d数组，您可以对其元素进行索引

要将步幅添加到此函数中，我们需要修改
结果长度
，并将步幅乘以迭代器：

def卷积1d_步幅（a，过滤器，步幅）：
N、 M=len（a），len（过滤器）
断言N>=M#问题中的假设
#在全模式下（默认为np.卷积），结果长度为N+M-1
#因此，pad每侧应为M-1
#N-M+2p+1==N+M-1=>p=M-1
结果_长度=（N+M-1）//步幅
结果=np.0（结果长度）#为结果分配内存
p=M-1
加垫的a=np.pad（a，p）
翻转的过滤器=np.翻转（过滤器）
对于范围内的i（结果长度）：
结果[i]=np.sum（np.multiply（翻转的_过滤器，填充的_a[i*步幅：i*步幅+M]））
返回结果
a=np.数组（[1,2,3,4]）
filter=np.array（[1，-1,3]）
卷积1d_跨步（a，过滤器，2）

希望能有所帮助，如果这是您喜欢的，我很乐意将其扩展到二维。
对于一维阵列：

import numpy as np
from numpy.lib.stride_tricks import as_strided


def conv1d(A, kernel, stride, reverse_kernel=True, mode='full'):
    if reverse_kernel:
        kernel = kernel[::-1]

    if mode == 'full':    
        A = np.pad(A, kernel.shape[0] - 1)
    #else: convolution in 'valid' mode

    # Sliding-window view of A
    output_size = (A.shape[0] - kernel.shape[0])//stride + 1
    A_w = as_strided(A, shape=(output_size, kernel.shape[0]), 
                        strides=(stride*A.strides[0], A.strides[0]))

    # Return convolution of A with kernel
    return np.sum(A_w * kernel, axis=1)

这里
A=矩阵\u列表[j]
。请注意，在深入学习中，卷积中的滤波器不会反转。
对于1D阵列：

import numpy as np
from numpy.lib.stride_tricks import as_strided


def conv1d(A, kernel, stride, reverse_kernel=True, mode='full'):
    if reverse_kernel:
        kernel = kernel[::-1]

    if mode == 'full':    
        A = np.pad(A, kernel.shape[0] - 1)
    #else: convolution in 'valid' mode

    # Sliding-window view of A
    output_size = (A.shape[0] - kernel.shape[0])//stride + 1
    A_w = as_strided(A, shape=(output_size, kernel.shape[0]), 
                        strides=(stride*A.strides[0], A.strides[0]))

    # Return convolution of A with kernel
    return np.sum(A_w * kernel, axis=1)

这里
A=矩阵\u列表[j]
。请注意，在深入学习时，卷积中的滤波器不会反转。
确切地说，为什么不使用numpy的卷积函数呢？您被困在哪里了？你能发布你当前尝试的代码吗？确切地说，你为什么不想使用numpy的卷积函数？你被困在哪里了？你能发布你当前尝试的代码吗？