互相关运算和卷积运算是两种常用的图像处理方法。它们都是用于在图像处理中进行滤波操作的。
1. 互相关运算
互相关运算是一种基于滤波的图像处理方法，它用于对图像进行平滑和增强等操作。在互相关运算中，我们将一个滤波器（也称为卷积核或核函数）应用于图像的每个像素，以产生一个输出图像。
互相关运算的计算公式如下：
y i , j = ∑ k , l x i + k , j + l h k , l y_{i,j} = \sum_{k,l} x_{i+k,j+l}h_{k,l} yi,j=k,l∑xi+k,j+lhk,l
其中， x x x 表示输入图像， y y y 表示输出图像， h h h 表示滤波器。
下面是一个简单的例子，展示了如何使用 PyTorch 实现互相关运算：
import torch
import torch.nn.functional as F
# 创建一个 1x3x3 的输入张量和一个 1x2x2 的滤波器
x = torch.tensor([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]], dtype=torch.float32)
h = torch.tensor([[[1, 2], [3, 4]]], dtype=torch.float32)
# 使用 PyTorch 的函数进行互相关运算
y = F.conv2d(x, h)
# 输出结果
print(y)
输出结果为：
tensor([[[20., 26.],
[38., 44.]]])
假设有两个矩阵A和B，A的形状为(m,n)，B的形状为(p,q)，其中m>=p，n>=q。那么，它们的互相关运算C的形状为(m-p+1,n-q+1)。
互相关运算的公式如下：
C i , j = ∑ u = 0 p − 1 ∑ v = 0 q − 1 A i + u , j + v B u , v C_{i,j}=\sum_{u=0}^{p-1}\sum_{v=0}^{q-1}A_{i+u,j+v}B_{u,v} Ci,j=u=0∑p−1v=0∑q−1Ai+u,j+vBu,v
其中， C i , j C_{i,j} Ci,j表示输出矩阵C的第i行第j列的元素， A i + u , j + v A_{i+u,j+v} Ai+u,j+v表示矩阵A中的元素， B u , v B_{u,v} Bu,v表示矩阵B中的元素。
以你给出的例子为例，假设有两个矩阵A和B，它们的形状分别为(3,3)和(2,2)，如下所示：
A = [ 1 2 3 4 5 6 7 8 9 ] A=\begin{bmatrix} 1 & 2 & 3\\ 4 & 5 & 6\\ 7 & 8 & 9 \end{bmatrix} A= 147258369
B = [ 2 3 5 6 ] B=\begin{bmatrix} 2 & 3\\ 5 & 6 \end{bmatrix} B=[2536]
则它们的互相关运算C的形状为(2,2)，公式如下：
C i , j = ∑ u = 0 1 ∑ v = 0 1 A i + u , j + v B u , v C_{i,j}=\sum_{u=0}^{1}\sum_{v=0}^{1}A_{i+u,j+v}B_{u,v} Ci,j=u=0∑1v=0∑1Ai+u,j+vBu,v
其中， C i , j C_{i,j} Ci,j表示输出矩阵C的第i行第j列的元素， A i + u , j + v A_{i+u,j+v} Ai+u,j+v表示矩阵A中的元素， B u , v B_{u,v} Bu,v表示矩阵B中的元素。
以C的第0行第0列的元素为例，它的计算过程如下：
C 0 , 0 = A 0 , 0 B 0 , 0 + A 0 , 1 B 0 , 1 + A 1 , 0 B 1 , 0 + A 1 , 1 B 1 , 1 C_{0,0}=A_{0,0}B_{0,0}+A_{0,1}B_{0,1}+A_{1,0}B_{1,0}+A_{1,1}B_{1,1} C0,0=A0,0B0,0+A0,1B0,1+A1,0B1,0+A1,1B1,1
= 1 × 2 + 2 × 3 + 4 × 5 + 5 × 6 =1\times 2+2\times 3+4\times 5+5\times 6 =1×2+2×3+4×5+5×6
= 20 =20 =20
因此，输出矩阵C的值为：
C = [ 20 26 38 44 ] C=\begin{bmatrix} 20 & 26\\ 38 & 44 \end{bmatrix} C=[20382644]
在PyTorch中，可以使用torch.nn.functional.conv2d()函数来进行互相关运算。代码如下：
import torch
# 定义输入矩阵A和卷积核B
A = torch.tensor([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]])
B = torch.tensor([[2., 3.], [5., 6.]])
# 对输入矩阵A进行二维卷积
C = torch.nn.functional.conv2d(A.view(1, 1, 3, 3), B.view(1, 1, 2, 2))
print(C) # 输出tensor([[[[20., 26.], [38., 44.]]]])
其中，A.view(1, 1, 3, 3)和B.view(1, 1, 2, 2)将输入矩阵A和卷积核B转换为四维张量，分别表示输入通道数、输出通道数、输入高度、输入宽度。在本例中，输入通道数和输出通道数均为1，高度和宽度分别为3和3的矩阵A转换为了大小为(1,1,3,3)的四维张量；大小为(2,2)的卷积核B转换为了大小为(1,1,2,2)的四维张量。
2. 卷积运算
卷积运算也是一种基于滤波的图像处理方法，它与互相关运算非常相似，但是在卷积运算中，滤波器是经过翻转后再进行滤波的。
卷积运算的计算公式如下：
y i , j = ∑ k , l x i − k , j − l h k , l y_{i,j} = \sum_{k,l} x_{i-k,j-l}h_{k,l} yi,j=k,l∑xi−k,j−lhk,l
下面是一个简单的例子，展示了如何使用 PyTorch 实现卷积运算：
import torch
import torch.nn.functional as F
# 创建一个 1x3x3 的输入张量和一个 1x2x2 的滤波器
x = torch.tensor([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]], dtype=torch.float32)
h = torch.tensor([[[1, 2], [3, 4]]], dtype=torch.float32)
# 使用 PyTorch 的函数进行卷积运算
y = F.conv2d(x, h.flip(dims=[2, 3]))
# 输出结果
print(y)
输出结果为：
tensor([[[13., 20.],
[29., 36.]]])
假设有两个二维张量A和B，形状分别为 A m × n A_{m \times n} Am×n和 B p × q B_{p \times q} Bp×q，其中 m ≥ p m \geq p m≥p， n ≥ q n \geq q n≥q，则它们的互相关运算和卷积运算定义如下：
互相关运算（cross-correlation）：
C i , j = ∑ u = 1 p ∑ v = 1 q A i + u − 1 , j + v − 1 B u , v C_{i,j}=\sum_{u=1}^{p} \sum_{v=1}^{q} A_{i+u-1,j+v-1} B_{u,v} Ci,j=u=1∑pv=1∑qAi+u−1,j+v−1Bu,v
卷积运算（convolution）：
C i , j = ∑ u = 1 p ∑ v = 1 q A i + u − 1 , j + v − 1 B p − u + 1 , q − v + 1 C_{i,j}=\sum_{u=1}^{p} \sum_{v=1}^{q} A_{i+u-1,j+v-1} B_{p-u+1,q-v+1} Ci,j=u=1∑pv=1∑qAi+u−1,j+v−1Bp−u+1,q−v+1
其中， C i , j C_{i,j} Ci,j表示输出张量的第 i i i行第 j j j列的值。
对于题目中的例子，我们可以手动计算它们的互相关运算和卷积运算：
假设有两个二维张量 A A A和 B B B，它们分别为：
A = [ 1 2 3 4 5 6 7 8 9 ] A=\begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} A= 147258369
B = [ 1 2 3 4 ] B=\begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} B=[1324]
则它们的互相关运算和卷积运算分别为：
互相关运算：
C 1 , 1 = 1 × 1 + 2 × 3 + 3 × 2 + 4 × 4 = 25 C_{1,1}=1 \times 1 + 2 \times 3 + 3 \times 2 + 4 \times 4 = 25 C1,1=1×1+2×3+3×2+4×4=25
C 1 , 2 = 1 × 2 + 2 × 4 + 3 × 1 + 4 × 3 = 31 C_{1,2}=1 \times 2 + 2 \times 4 + 3 \times 1 + 4 \times 3 = 31 C1,2=1×2+2×4+3×1+4×3=31
C 2 , 1 = 4 × 1 + 5 × 3 + 6 × 2 + 7 × 4 = 73 C_{2,1}=4 \times 1 + 5 \times 3 + 6 \times 2 + 7 \times 4 = 73 C2,1=4×1+5×3+6×2+7×4=73
C 2 , 2 = 4 × 2 + 5 × 4 + 6 × 1 + 7 × 3 = 79 C_{2,2}=4 \times 2 + 5 \times 4 + 6 \times 1 + 7 \times 3 = 79 C2,2=4×2+5×4+6×1+7×3=79
因此，互相关运算的结果为：
C = [ 25 31 73 79 ] C=\begin{bmatrix} 25 & 31 \\ 73 & 79 \end{bmatrix} C=[25733179]
卷积运算：
C 1 , 1 = 1 × 4 + 2 × 3 + 3 × 2 + 4 × 1 = 20 C_{1,1}=1 \times 4 + 2 \times 3 + 3 \times 2 + 4 \times 1 = 20 C1,1=1×4+2×3+3×2+4×1=20
C 1 , 2 = 1 × 3 + 2 × 4 + 3 × 1 + 4 × 2 = 26 C_{1,2}=1 \times 3 + 2 \times 4 + 3 \times 1 + 4 \times 2 = 26 C1,2=1×3+2×4+3×1+4×2=26
C 2 , 1 = 4 × 4 + 5 × 3 + 6 × 2 + 7 × 1 = 38 C_{2,1}=4 \times 4 + 5 \times 3 + 6 \times 2 + 7 \times 1 = 38 C2,1=4×4+5×3+6×2+7×1=38
C 2 , 2 = 4 × 3 + 5 × 4 + 6 × 1 + 7 × 2 = 44 C_{2,2}=4 \times 3 + 5 \times 4 + 6 \times 1 + 7 \times 2 = 44 C2,2=4×3+5×4+6×1+7×2=44
因此，卷积运算的结果为：
C = [ 20 26 38 44 ] C=\begin{bmatrix} 20 & 26 \\ 38 & 44 \end{bmatrix} C=[20382644]
3. 结构图
下面是互相关运算和卷积运算的结构图，可以更直观地了解它们的区别：
重新生成
4. 附录
卷积运算是一种在信号处理和图像处理中广泛应用的线性运算，其主要思想是将两个函数重叠在一起，然后对它们进行积分。在离散情况下，卷积运算可以看作是两个序列的加权和，其中一个序列是翻转后的另一个序列在不同位置上的加权和。下面我们来推导一下离散情况下的卷积公式。
假设有两个长度为 M M M 和 N N N 的离散序列 x [ n ] x[n] x[n] 和 h [ n ] h[n] h[n]，它们的卷积为 y [ n ] y[n] y[n]，则卷积公式为：
y [ n ] = ∑ k = − ∞ ∞ x [ k ] h [ n − k ] y[n] = \sum_{k=-\infty}^{\infty} x[k]h[n-k] y[n]=k=−∞∑∞x[k]h[n−k]
但是，由于 x [ n ] x[n] x[n] 和 h [ n ] h[n] h[n] 在实际应用中是有限长度的，因此我们需要将上式改写为有限和的形式：
y [ n ] = ∑ k = 0 M − 1 x [ k ] h [ n − k ] , 0 ≤ n ≤ M + N − 2 y[n] = \sum_{k=0}^{M-1} x[k]h[n-k],\quad 0\leq n\leq M+N-2 y[n]=k=0∑M−1x[k]h[n−k],0≤n≤M+N−2
其中， M + N − 2 M+N-2 M+N−2 表示卷积结果的长度。
对于二维卷积运算，假设有两个大小分别为 M × N M\times N M×N 和 K × L K\times L K×L 的离散图像 f ( x , y ) f(x,y) f(x,y) 和 h ( x , y ) h(x,y) h(x,y)，则它们的卷积运算为：
g ( x , y ) = ∑ k = − ∞ ∞ ∑ l = − ∞ ∞ f ( k , l ) h ( x − k , y − l ) g(x,y) = \sum_{k=-\infty}^{\infty}\sum_{l=-\infty}^{\infty}f(k,l)h(x-k,y-l) g(x,y)=k=−∞∑∞l=−∞∑∞f(k,l)h(x−k,y−l)
同样地，由于 f ( x , y ) f(x,y) f(x,y) 和 h ( x , y ) h(x,y) h(x,y) 在实际应用中是有限大小的，因此我们需要将上式改写为有限和的形式：
g ( x , y ) = ∑ k = 0 M − 1 ∑ l = 0 N − 1 f ( k , l ) h ( x − k , y − l ) , 0 ≤ x < M + K − 1 , 0 ≤ y < N + L − 1 g(x,y) = \sum_{k=0}^{M-1}\sum_{l=0}^{N-1}f(k,l)h(x-k,y-l),\quad 0\leq x<M+K-1,\ 0\leq y<N+L-1 g(x,y)=k=0∑M−1l=0∑N−1f(k,l)h(x−k,y−l),0≤x<M+K−1, 0≤y<N+L−1
其中， M + K − 1 M+K-1 M+K−1 和 N + L − 1 N+L-1 N+L−1 分别表示卷积结果的行数和列数。
下面是一个在 PyTorch 中实现二维卷积运算的例子：
import torch
# 定义输入图像和卷积核
input = torch.tensor([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]], dtype=torch.float32)
kernel = torch.tensor([[[1, 0, -1], [2, 0, -2], [1, 0, -1]]], dtype=torch.float32)
# 使用 PyTorch 提供的卷积函数进行卷积运算
output = torch.nn.functional.conv2d(input, kernel)
# 输出卷积结果
print(output)
输出结果为：文章来源：https://www.toymoban.com/news/detail-840367.html
tensor([[[ 0., -3.],
[-12., -15.]]])
其中，输入图像的大小为 1 × 3 × 3 1\times 3\times 3 1×3×3，卷积核的大小为 1 × 3 × 3 1\times 3\times 3 1×3×3，卷积结果的大小为 1 × 2 × 2 1\times 2\times 2 1×2×2。文章来源地址https://www.toymoban.com/news/detail-840367.html
到了这里，关于互相关运算和卷积运算的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
![计算机视觉与深度学习-卷积神经网络-卷积&图像去噪&边缘提取-图像去噪 [北邮鲁鹏]](https://imgs.yssmx.com/Uploads/2024/02/732098-1.png)
