卷积层里的填充和步幅

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

# # 卷积核与图像进行卷积操作
# def corr2d(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))
# # # tensor([[19., 25.],
# # #         [37., 43.]])

# # 定义二维卷积层
# class Conv2D(nn.Module):
#     def __init__(self, kernel_size):    #kernel_size为指定的卷积核尺寸
#         super().__init__()
#         # 随机初始化卷积核权重参数
#         self.weight = nn.Parameter(torch.rand(kernel_size))
#         # 将偏执初始化为0
#         self.bias = nn.Parameter(torch.zeros(1))
#     # 前向传播函数:将图像与卷积核进行卷积操作
#     def forward(self, x):
#         return corr2d(x, self.weight) + self.bias

# # 学习卷积层的权重(卷积核)
# # 学习卷积核之前需要构建出来数据集(X,Y)
# # 构造X(X为6行8列,其中2~5列为0,其余列为1)
# X = torch.ones((6, 8))
# X[:, 2:6] = 0
# # 待学习的卷积核为K
# K = torch.tensor([[1.0, -1.0]])
# # X和K进行卷积操作得到输出为Y(Y为6行7列,其中第1列为1,第5列为-1,其余列为0)
# Y = corr2d(X, K)

# # 下面开始学习卷积核
# # 用PyTorch的API来构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
# # in_channels:输入图像的通道数,out_channels:输出图像的通道数,kernel_size:卷积核的尺寸,bias:是否需要学习偏执量
# conv2d = nn.Conv2d(1,1, kernel_size=(1, 2), bias=False)
# X = X.reshape((1, 1, 6, 8)) #二维卷积层使用的四维输入格式:（批量大小、通道、高度、宽度）
# Y = Y.reshape((1, 1, 6, 7)) #二维卷积层使用的四维输出格式:（批量大小、通道、高度、宽度）
# lr = 3e-2  # 学习率

# # 训练过程
# for i in range(10):
#     # 预测输出Y_hat
#     Y_hat = conv2d(X)
#     # 预测损失l
#     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}')
# print("学习到的卷积核为:")
# print(conv2d.weight.data.reshape((1, 2)))

# # epoch 2, loss 11.735
# # epoch 4, loss 3.833
# # epoch 6, loss 1.407
# # epoch 8, loss 0.549
# # epoch 10, loss 0.220
# # 学习到的卷积核为:
# # tensor([[ 1.0377, -0.9415]])










import torch
from torch import nn

# 所有侧边都填充1
# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
# 定义一个计算图像经过卷积操作后的输出Y的函数
def comp_conv2d(conv2d, X):
    X = X.reshape((1, 1) + X.shape) #二维卷积层使用的四维输入格式:（批量大小、通道、高度、宽度）
    Y = conv2d(X)   # 通过卷积运算得到输出Y， 二维卷积层使用的四维输出格式:（批量大小、通道、高度、宽度）
    return Y.reshape(Y.shape[2:])   #省略Y的前两个维度：（批量大小和通道）

# 用PyTorch的API来构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
# in_channels:输入图像的通道数,out_channels:输出图像的通道数,kernel_size:卷积核的尺寸,padding:图像的上下左右各填充1行或1列
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
# 构造一个大小为8×8的随机图像X
X = torch.rand(size=(8, 8))
Y = comp_conv2d(conv2d, X)
print(Y.shape)

# 输出：
# torch.Size([8, 8])



# 填充不同的高度和宽度
# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
# 定义一个计算图像经过卷积操作后的输出Y的函数
def comp_conv2d(conv2d, X):
    X = X.reshape((1, 1) + X.shape) #二维卷积层使用的四维输入格式:（批量大小、通道、高度、宽度）
    Y = conv2d(X)   # 通过卷积运算得到输出Y， 二维卷积层使用的四维输出格式:（批量大小、通道、高度、宽度）
    return Y.reshape(Y.shape[2:])   #省略Y的前两个维度：（批量大小和通道）

# 用PyTorch的API来构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
# in_channels:输入图像的通道数,out_channels:输出图像的通道数,kernel_size:卷积核的尺寸,padding:图像的上下左右各填充1行或1列
conv2d = nn.Conv2d(1, 1, kernel_size=(5,3), padding=(2,1))
# 构造一个大小为8×8的随机图像X
X = torch.rand(size=(8, 8))
Y = comp_conv2d(conv2d, X)
print(Y.shape)

# 输出：
# torch.Size([8, 8])


# 将高度和宽度的步幅都设置为2
# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
# 定义一个计算图像经过卷积操作后的输出Y的函数
def comp_conv2d(conv2d, X):
    X = X.reshape((1, 1) + X.shape) #二维卷积层使用的四维输入格式:（批量大小、通道、高度、宽度）
    Y = conv2d(X)   # 通过卷积运算得到输出Y， 二维卷积层使用的四维输出格式:（批量大小、通道、高度、宽度）
    return Y.reshape(Y.shape[2:])   #省略Y的前两个维度：（批量大小和通道）

# 用PyTorch的API来构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
# in_channels:输入图像的通道数,out_channels:输出图像的通道数,kernel_size:卷积核的尺寸,padding:图像的上下左右各填充1行或1列
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride = 2)
# 构造一个大小为8×8的随机图像X
X = torch.rand(size=(8, 8))
Y = comp_conv2d(conv2d, X)
print(Y.shape)

# 输出：
# torch.Size([4, 4])