b站的up主刘二大人的《PyTorch深度学习实践》P10 笔记+代码，视频链接。

目录

一、Conv2d、MaxPool2d、Linear

1. torch.nn.Conv2d

2. torch.nn.MaxPool2d

3. torch.nn.Linear

二、PPT上4个简单代码：维度、padding、stride、maxpooling

1、维度

2、padding

3、步长stride=2

4、maxpooling

三、MNIST 卷积神经网络

1、网络结构图：

2、MNIST代码：（CPU上）

3、使用GPU

四、作业：更改网络结构

1、网络设计图

2、 代码：

一、Conv2d、MaxPool2d 和 Linear

1. torch.nn.Conv2d

介绍：用于对二维输入（如图像）执行卷积操作。

主要参数：

  • in_channels: 输入特征图的通道数（如 RGB 图像为 3，灰度图像为 1）。
  • out_channels: 卷积层输出特征图的通道数，通常由卷积核的数量决定。
  • kernel_size: 卷积核的大小，可以是单个整数（表示正方形）或元组（表示长方形），如 (3, 3)。
  • stride: 卷积核移动的步幅，默认值为 1。
  • padding: 输入特征图的边缘填充，默认值为 0。可以是单个整数或元组，影响输出尺寸。
  • dilation: 卷积核元素之间的间距，默认值为 1。
  • groups: 控制输入通道与输出通道之间的连接，默认值为 1。

使用示例：

conv_layer = torch.nn.Conv2d(in_channels=1,
                             out_channels=16,
                             kernel_size=3, 
                             stride=1, 
                             padding=1)

2. torch.nn.MaxPool2d

介绍：用于在二维输入上执行最大池化操作。

主要参数：

  • kernel_size: 池化窗口的大小，可以是单个整数或元组。
  • stride: 池化窗口的步幅，默认值为 kernel_size。
  • padding: 输入特征图的边缘填充，默认值为 0。

使用示例：

max_pooling = torch.nn.MaxPool2d(kernel_size=2, stride=2)

3. torch.nn.Linear

介绍：用于执行全连接层（线性变换），将输入张量映射到输出张量。

主要参数：

  • in_features: 输入特征的数量。
  • out_features: 输出特征的数量。
  • bias: 是否添加偏置项，默认值为 True。

使用示例：

linear_layer = torch.nn.Linear(in_features=128, out_features=64)

二、PPT上4个简单代码：维度、padding、stride、maxpooling

1、维度

import torch
in_channels, out_channels = 5, 10
width, height = 100, 100
kernel_size = 3
batch_size = 1

input = torch.randn(batch_size,
                     in_channels,
                     width,
                     height)
conv_layer = torch.nn.Conv2d(in_channels,
                             out_channels,
                             kernel_size=kernel_size)
# 未自定义，卷积核的权重会随机初始化
out_put = conv_layer(input)

print(input.shape)                  # torch.Size([1, 5, 100, 100])
print(out_put.shape)                # torch.Size([1, 10, 98, 98])
print(conv_layer.weight.shape)      # torch.Size([10, 5, 3, 3])

2、padding

import torch

input = [3,4,6,5,7,
         2,4,6,8,2,
         1,6,7,8,4,
         9,7,4,6,2,
         3,7,5,4,1]

input = torch.tensor(input, dtype=torch.float32).view(1, 1, 5, 5)

conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, padding=1, bias=False)
# 自定义卷积核权重
kernel = torch.tensor([1,2,3,4,5,6,7,8,9], dtype=torch.float32).view(1, 1, 3, 3)
conv_layer.weight.data = kernel.data

output = conv_layer(input)
print(output)

输出

tensor([[[[ 91., 168., 224., 215., 127.],
          [114., 211., 295., 262., 149.],
          [192., 259., 282., 214., 122.],
          [194., 251., 253., 169.,  86.],
          [ 96., 112., 110.,  68.,  31.]]]], grad_fn=<ConvolutionBackward0>)

3、步长stride=2

可以视为特殊的下采样

import torch
input = [3,4,6,5,7,
         2,4,6,8,2,
         1,6,7,8,4,
         9,7,4,6,2,
         3,7,5,4,1]

input = torch.tensor(input, dtype=torch.float32).view(1, 1, 5, 5)

conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, stride=2, bias=False)
# 自定义卷积核权重
kernel = torch.tensor([1,2,3,4,5,6,7,8,9], dtype=torch.float32).view(1, 1, 3, 3)
conv_layer.weight.data = kernel.data

output = conv_layer(input)
print(output)import torch
input = [3,4,6,5,7,
         2,4,6,8,2,
         1,6,7,8,4,
         9,7,4,6,2,
         3,7,5,4,1]

input = torch.tensor(input, dtype=torch.float32).view(1, 1, 5, 5)

conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, stride=2, bias=False)
# 自定义卷积核权重
kernel = torch.tensor([1,2,3,4,5,6,7,8,9], dtype=torch.float32).view(1, 1, 3, 3)
conv_layer.weight.data = kernel.data

output = conv_layer(input)
print(output)

输出

tensor([[[[211., 262.],
          [251., 169.]]]], grad_fn=<ConvolutionBackward0>)

4、maxpooling

不改变通道数，只改变特征图大小

import torch

input = [3,4,6,5,
         2,4,6,8,
         1,6,7,8,
         9,7,4,6]

input = torch.tensor(input, dtype=torch.float32).view(1, 1, 4, 4)

maxpooling_layer = torch.nn.MaxPool2d(kernel_size=2)

output = maxpooling_layer(input)
print(output, output.shape)

输出

tensor([[[[4., 8.],
          [9., 8.]]]]) torch.Size([1, 1, 2, 2])

三、MNIST 卷积神经网络

1、网络结构图：

2、MNIST代码：（CPU上）

import torch
from torchvision import transforms, datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import time

batch_size = 64
# 数据预处理：将图像转换为张量，并进行归一化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])

# 加载训练集和测试集
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True,
                               download=False,
                               transform=transform)
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=False,
                              transform=transform)
test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)

# 定义卷积神经网络CNN
class CNN(torch.nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        self.pooling = torch.nn.MaxPool2d(2)
        self.fc = torch.nn.Linear(320, 10)
    
    def forward(self, x):
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1) # flatten
        x = self.fc(x)
        return x
    
model = CNN()
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# 训练函数
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        # 每300个batch打印一次损失
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

# 测试函数
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    start_time = time.time()  # 记录开始时间
    for epoch in range(10):
        train(epoch)
        test()
    end_time = time.time()  # 记录结束时间
    print('Total time: %.2f seconds' % (end_time - start_time))

运行结果

[1,   300] loss: 0.597
[1,   600] loss: 0.174
[1,   900] loss: 0.131
Accuracy on test set: 97 %
[2,   300] loss: 0.112
[2,   600] loss: 0.094
[2,   900] loss: 0.086
Accuracy on test set: 97 %
[3,   300] loss: 0.082
[3,   600] loss: 0.074
[3,   900] loss: 0.068
Accuracy on test set: 98 %
[4,   300] loss: 0.061
[4,   600] loss: 0.069
[4,   900] loss: 0.061
Accuracy on test set: 98 %
[5,   300] loss: 0.054
[5,   600] loss: 0.057
[5,   900] loss: 0.057
Accuracy on test set: 98 %
[6,   300] loss: 0.051
[6,   600] loss: 0.050
[6,   900] loss: 0.047
Accuracy on test set: 98 %
[7,   300] loss: 0.042
[7,   600] loss: 0.047
[7,   900] loss: 0.050
Accuracy on test set: 98 %
[8,   300] loss: 0.040
[8,   600] loss: 0.046
[8,   900] loss: 0.040
Accuracy on test set: 98 %
[9,   300] loss: 0.038
[9,   600] loss: 0.040
[9,   900] loss: 0.038
Accuracy on test set: 98 %
[10,   300] loss: 0.036
[10,   600] loss: 0.037
[10,   900] loss: 0.036
Accuracy on test set: 98 %
Total time: 378.79 seconds

3、使用GPU

NVIDlA GeForce GTX 1660 Ti

import torch
from torchvision import transforms, datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import time

batch_size = 64
# 数据预处理：将图像转换为张量，并进行归一化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])

# 加载训练集和测试集
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True,
                               download=False,
                               transform=transform)
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=False,
                              transform=transform)
test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)

# 定义卷积神经网络CNN
class CNN(torch.nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        self.pooling = torch.nn.MaxPool2d(2)
        self.fc = torch.nn.Linear(320, 10)
    
    def forward(self, x):
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1) # flatten
        x = self.fc(x)
        return x
    
model = CNN()

# 使用cuda训练
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(torch.cuda.is_available())

model.to(device)
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# 训练函数
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        # 将数据传入GPU
        inputs, target = inputs.to(device), target.to(device)

        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        # 每300个batch打印一次损失
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

# 测试函数
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            # 将数据传入GPU
            images, labels = images.to(device), labels.to(device)

            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    start_time = time.time()  # 记录开始时间
    for epoch in range(10):
        train(epoch)
        test()
    end_time = time.time()  # 记录结束时间
    print('Total time: %.2f seconds' % (end_time - start_time))

运行结果

True
[1,   300] loss: 0.701
[1,   600] loss: 0.194
[1,   900] loss: 0.148
Accuracy on test set: 96 %
[2,   300] loss: 0.119
[2,   600] loss: 0.100
[2,   900] loss: 0.097
Accuracy on test set: 97 %
[3,   300] loss: 0.083
[3,   600] loss: 0.077
[3,   900] loss: 0.074
Accuracy on test set: 97 %
[4,   300] loss: 0.069
[4,   600] loss: 0.065
[4,   900] loss: 0.062
Accuracy on test set: 98 %
[5,   300] loss: 0.055
[5,   600] loss: 0.058
[5,   900] loss: 0.059
Accuracy on test set: 98 %
[6,   300] loss: 0.050
[6,   600] loss: 0.053
[6,   900] loss: 0.049
Accuracy on test set: 98 %
[7,   300] loss: 0.048
[7,   600] loss: 0.045
[7,   900] loss: 0.045
Accuracy on test set: 98 %
[8,   300] loss: 0.044
[8,   300] loss: 0.044
[8,   600] loss: 0.041
[8,   900] loss: 0.043
Accuracy on test set: 98 %
[9,   300] loss: 0.038
[9,   600] loss: 0.037
[9,   900] loss: 0.044
Accuracy on test set: 98 %
[10,   300] loss: 0.035
[10,   600] loss: 0.037
[10,   900] loss: 0.037
Accuracy on test set: 98 %
Total time: 266.13 seconds

四、作业：更改网络结构

1、网络设计图

2、 代码：

import torch
from torchvision import transforms, datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import time

batch_size = 64
# 数据预处理：将图像转换为张量，并进行归一化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])

# 加载训练集和测试集
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True,
                               download=False,
                               transform=transform)
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=False,
                              transform=transform)
test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)

# 定义卷积神经网络CNN
class CNN(torch.nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=3)
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=3, padding=1)
        self.conv3 = torch.nn.Conv2d(20, 30, kernel_size=3, padding=1)
        self.pooling = torch.nn.MaxPool2d(2)
        self.fc1 = torch.nn.Linear(270, 128)
        self.fc2 = torch.nn.Linear(128, 10)
    
    def forward(self, x):
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = F.relu(self.pooling(self.conv3(x)))
        x = x.view(batch_size, -1) # flatten
        x = self.fc2(self.fc1(x))
        return x
    
model = CNN()

# 使用cuda训练
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(torch.cuda.is_available())

model.to(device)
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# 训练函数
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        # 将数据传入GPU
        inputs, target = inputs.to(device), target.to(device)

        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        # 每300个batch打印一次损失
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

# 测试函数
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            # 将数据传入GPU
            images, labels = images.to(device), labels.to(device)

            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    start_time = time.time()  # 记录开始时间
    for epoch in range(10):
        train(epoch)
        test()
    end_time = time.time()  # 记录结束时间
    print('Total time: %.2f seconds' % (end_time - start_time))

 运行结果

True
[1,   300] loss: 1.558
[1,   600] loss: 0.308
[1,   900] loss: 0.188
Accuracy on test set: 94 %
[2,   300] loss: 0.140
[2,   600] loss: 0.131
[2,   900] loss: 0.113
Accuracy on test set: 97 %
[3,   300] loss: 0.093
[3,   600] loss: 0.100
[3,   900] loss: 0.089
Accuracy on test set: 97 %
[4,   300] loss: 0.079
[4,   600] loss: 0.077
[4,   900] loss: 0.070
Accuracy on test set: 97 %
[5,   300] loss: 0.065
[5,   600] loss: 0.064
[5,   900] loss: 0.068
Accuracy on test set: 98 %
[6,   300] loss: 0.059
[6,   600] loss: 0.057
[6,   900] loss: 0.059
Accuracy on test set: 98 %
[7,   300] loss: 0.056
[7,   600] loss: 0.051
[7,   900] loss: 0.052
Accuracy on test set: 98 %
[8,   300] loss: 0.047
[8,   600] loss: 0.049
[8,   900] loss: 0.047
Accuracy on test set: 98 %
[9,   300] loss: 0.045
[9,   600] loss: 0.044
[9,   900] loss: 0.043
Accuracy on test set: 98 %
[10,   300] loss: 0.045
[10,   600] loss: 0.039
[10,   900] loss: 0.041
Accuracy on test set: 98 %
Total time: 301.56 seconds

朋友们有什么建议或疑问可以在评论区给出，或者是私信我！

# python # 深度学习 # pytorch # cnn # 图像处理
Logo
乐奇 Rokid 开放社区

更多推荐

AI 智能眼镜的柔性神经，开启轻量化人机交互新世代

AI 智能眼镜的核心诉求，是在接近传统眼镜的轻薄体积内，塞进 AI 主控芯片、摄像头、麦克风阵列、骨传导 / 扬声器、光波导显示模组、触控传感器、电池、蓝牙 / Wi-Fi 射频模块等大量器件。随着 AI 眼镜出货量快速上行，鹏鼎、弘信、则成等国内 FPC 厂商纷纷布局 AI 眼镜软板、软硬结合板量产方案，单机 FPC 价值量显著高于 TWS 耳机，带动国内柔性线路板供应链升级，倒逼国内厂商突破超

avatar 乐奇 Rokid 开放社区
cover

一期一会 | 什么是抬头显示器（HUD）？

avatar 乐奇 Rokid 开放社区

听书阁：让你在 AR 眼镜上也可以读小说

戴上眼镜之后我才发现，"翻页"是个需要用手完成的动作。手机上有触屏，滑动、点按、长按选词，一整套肌肉记忆。到了 AR 眼镜上这些全没了：视野只有一小块，手上可能还拎着东西，能稳定输入的只剩嘴和眼镜腿上的几颗按键。把手机阅读器原样搬过来没有意义，得重新想一遍"读一本书"在眼镜上该拆成哪几个动作。听书阁就是这次重想的产物。它跑在 Rokid Craft 上，用 AIUI 的 Ink 写页面，四个页面加

avatar 乐奇 Rokid 开放社区