深度学习之卷积神经网络

import torch
from torch import nn
from d2l import torch as d2l

# 卷积核
def corr2d(X, K):
    # X: 输入图像，K: 卷积核
    h, w = K.shape # 卷积核的高和宽
    Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1)) # 输出图像的高和宽
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i:i+h, j:j+w] * K).sum() # 卷积操作：对应元素相乘后求和
    return Y

X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
print(corr2d(X, K))

class Conv2D(nn.Module):
    def __init__(self, kernel_size):
        super().__init__()
        self.weight = nn.Parameter(torch.rand(kernel_size)) # 卷积核权重
        self.bias = nn.Parameter(torch.zeros(1)) # 卷积核偏置

    def forward(self, x):
        return corr2d(x, self.weight) + self.bias # 卷积操作加上偏置

X = torch.ones((6, 8)) # 输入图像
X[:, 2:6] = 0 # 中间部分为0，形成一个白色矩形
K = torch.tensor([[1.0, -1.0]]) # 卷积核，检测水平边缘
Y = corr2d(X, K) # 卷积操作
print("原始图像X:")
print(X)
print("卷积结果Y:") 
print(Y)

X = torch.ones((6, 8)) # 输入图像
X[:, 2:6] = 0 # 中间部分为0，形成一个白色矩形
Y = corr2d(X, K) # 卷积操作
print("原始图像X:")
print(X)
print("卷积结果Y:") 
print(Y)

conv2d = nn.Conv2d(1, 1, kernel_size=(1,2), bias = False) # 卷积层，输入通道数为1，输出通道数为1，卷积核大小为1x2

X = X.reshape((1, 1, 6, 8)) # 将输入图像调整为4D张量，形状为(批量大小, 输入通道数, 高度, 宽度)
Y = Y.reshape((1, 1, 6, 7)) # 将卷积结果调整为4D张量，形状为(批量大小, 输出通道数, 高度, 宽度)

lr = 3e-2 # 学习率

for i in range(10):
    Y_hat = conv2d(X) # 卷积层的前向传播，得到预测结果Y_hat
    l = (Y_hat - Y) ** 2 # 计算损失，使用均方误差损失函数
    conv2d.zero_grad() # 清除卷积层的梯度，以便进行反向传播
    l.sum().backward() # 反向传播，计算卷积层权重的梯度
    # 迭代卷积核
    conv2d.weight.data[:] -= lr * conv2d.weight.grad
    if (i + 1) % 2 == 0:
        print(f'epoch {i+1}, loss {l.sum():.3f}')

J = conv2d.weight.data.reshape((1, 2)) # 将卷积核权重调整为2D张量，形状为(1, 2)
print('学习到的卷积核权重:')
print(J)

import torch

from torch import nn

def comp_conv2d(conv2d, X):
    # 计算卷积层conv2d的输出
    X = X.reshape((1, 1) + X.shape) # 将输入图像调整为4D张量，形状为(批量大小, 输入通道数, 高度, 宽度)
    Y = conv2d(X) # 卷积层的前向传播，得到输出Y
    return Y.reshape(Y.shape[2:]) # 将输出调整为2D张量，形状为(高度, 宽度)

# 卷积层，输入通道数为1，输出通道数为1，卷积核大小为3x3，使用padding保持输入输出尺寸相同
# 注意：在实际使用中，卷积层的权重是随机初始化的，因此每次运行代码时，卷积核权重和输出结果都会不同。
# 这里我们只是为了演示卷积操作，所以不需要对卷积核权重进行训练或调整。
# 如果需要固定卷积核权重，可以手动设置conv2d.weight.data的值，例如：
# conv2d.weight.data = torch.tensor([[[[0.0, 1.0, 0.0], [1.0, 1.0, 1.0], [0.0, 1.0, 0.0]]]]) # 设置卷积核权重为一个简单的边缘检测器
# 但在这里我们使用随机初始化的卷积核权重来演示卷积操作的效果。
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
print("卷积核权重:")
print(conv2d.weight.data.reshape((3, 3))) # 打印卷积核权重，调整为3x3的形状
X = torch.rand((8, 8)) # 输入图像，随机生成一个8x8的图像

print("输入图像X:")
print(X)
Y = comp_conv2d(conv2d, X) # 计算卷积层的输出
print("卷积层输出Y:")
print(Y)

conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
print("卷积核权重:")
print(conv2d.weight.data.reshape((3, 3))) # 打印卷积核权重，调整为3x3的形状
X = torch.rand((8, 8)) # 输入图像，随机生成一个8x8的图像

print("输入图像X:")
print(X)
Y = comp_conv2d(conv2d, X) # 计算卷积层的输出
print("卷积层输出Y:")
print(Y)

卷积层输出Y:
tensor([[0.2706, 0.0957, 0.1677, 0.1079],
        [0.6081, 0.3156, 0.3279, 0.2736],
        [0.6496, 0.6177, 0.7421, 0.9332],
        [0.4267, 0.2278, 0.3566, 0.6257]], grad_fn=<ViewBackward0>)

import torch
from d2l import torch as d2l

def corr2d_multi_in(X, K):
    # 多输入通道的卷积操作
    # 对每个输入通道和对应的卷积核进行卷积操作，并将结果相加
    return sum(d2l.corr2d(x, k) for x, k in zip(X, K)) 

# 输入图像，包含两个通道
X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]], 
                  [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
# 卷积核，包含两个通道，每个通道的卷积核相同
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])

 # 输出卷积结果，形状为(2, 2)，每个元素是两个通道卷积结果的和
print(corr2d_multi_in(X, K))

def corr2d_multi_in_out(X, K):
    # 多输入通道和多输出通道的卷积操作
    # 对每个输出通道，计算所有输入通道与对应卷积核的卷积结果，并将结果相加
    # K的形状为(输出通道数, 输入通道数, 卷积核高, 卷积核宽)
    # 输出的形状为(输出通道数, 卷积结果高, 卷积结果宽)
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)

print("多输入通道：")
print(X)
K = torch.stack([K, K + 1, K + 2], 0) # 创建三个输出通道的卷积核，每个通道的卷积核相同但数值不同
print("卷积核K的形状:")
print(K.shape) # 输出卷积核的形状，应该是(3, 2, 2, 2)，表示3个输出通道，每个通道有2个输入通道，每个卷积核大小为2x2
print("卷积核K的数值:")
print(K) # 输出卷积核的数值
print("多输入通道和多输出通道的卷积结果:")
print(corr2d_multi_in_out(X, K))

def corr2d_multi_in_out_1x1(X, K):
    c_i, h, w = X.shape # 输入图像的通道数、高度和宽度
    c_o = K.shape[0] # 输出通道数
    X = X.reshape((c_i, h * w)) # 将输入图像调整为(c_i, h*w)，每列是一个像素点的所有通道值
    K = K.reshape((c_o, c_i)) # 将卷积核调整为(c_o, c_i)，每行是一个输出通道的卷积核权重
    Y = torch.matmul(K, X) # 进行矩阵乘法，得到形状为(c_o, h*w)的输出
    return Y.reshape((c_o, h, w)) # 将输出调整为(c_o, h, w)，每个输出通道对应一个卷积结果

X = torch.normal(0, 1, (3, 3, 3)) # 输入图像，包含3个通道，每个通道的大小为3x3
K = torch.normal(0, 1, (2, 3, 1, 1)) # 卷积核，包含2个输出通道，每个输出通道有3个输入通道，每个卷积核大小为1x1
print("输入图像X的形状:")
print(X.shape) # 输出输入图像的形状，应该是(3, 3, 3)，表示3个通道，每个通道的大小为3x3\
print("输入图像X的数值:")
print(X) # 输出输入图像的数值
print("卷积核K的形状:")
print(K.shape) # 输出卷积核的形状，应该是(2, 3, 1, 1)，表示2个输出通道，每个输出通道有3个输入通道，每个卷积核大小为1x1
print("卷积核K的数值:")
print(K) # 输出卷积核的数值
print("卷积结果:")
Y1 = corr2d_multi_in_out_1x1(X, K) # 计算卷积结果
print(Y1) # 输出卷积结果，形状为(2, 3, 3)，表示2个输出通道，每个通道的大小为3x3
Y2 = corr2d_multi_in_out(X, K) # 计算卷积结果，使用多输入通道和多输出通道的卷积函数
print("使用多输入通道和多输出通道的卷积结果:")
print(Y2) # 输出卷积结果，形状为(2, 3, 3)，表示2个输出通道，每个通道的大小为3x3