定义一个简单点的神经网络

1. import torch.nn as nn
3. class Net(nn.Module):
4.     """
5.     定义一个简单点的神经网络，卷积，池化，激活，全连接  嗯.....够简单了！
6.     输入的话就64*64的图片吧，通道数为3，卷积核为2，padding为1吧，这样的话就是
7.     : (3, 64, 64)
8.     卷积核为2，padding为1，输出通道数为64，这样的话就是
9.     : (64, 64, 64)
10.     池化核为2，输出通道数为64，这样的话就是
11.     : (64, 32, 32)
12.     全连接层的话就32*32*64=65536个神经元，输出10个类别的概率
13.     """
14.     def __init__(self):
15.         super(Net, self).__init__()
16.         self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=2, padding=1)
17.         self.pool = nn.MaxPool2d(kernel_size=2)
18.         self.relu = nn.ReLU()
19.         self.fc = nn.Linear(in_features=64*32*32, out_features=10)
20.         self.dropout = nn.Dropout(0.5)      # 随机失活，防止过拟合
22.     # 接下来的话就是定义前向传播了！
23.     def forward(self, x):
24.         x = self.conv1(x)
25.         x = self.pool(x)
26.         x = self.relu(x)
27.         x = x.view(-1, 64*32*32)    # 这里的-1就是让Pytorch自动计算这个维度的值
28.         x = self.fc(x)
29.         x = self.dropout(x)
30.         return x
31.     """
32.     这里就是定义了前向传播，这里就是将输入的图片进行卷积，然后进行池化，然后进行激活，然后进行全连接，然后返回结果
33.     """
35. # 实例化模型，看看效果吧
36. net = Net()
37. print(net)
39. import torch
41. # 创建一个简单的64*64的图片张量
42. array = torch.rand(64, 3, 64, 64)
44. # 创建目标标签（假设是10分类问题）
45. target = torch.randint(0, 10, (64,))
47. # 超参数定义
48. echo = 100
49. lr = 0.001
51. optimizer = torch.optim.SGD(net.parameters(), lr=lr)  # 优化器
53. """
54. 简单的训练过程实现
55. :
56. """
57. for i in range(echo):
58.     # 设置模型为训练模式
59.     net.train()
61.     output = net(array)
63.     # 定义损失函数
64.     criterion = nn.CrossEntropyLoss()   # 损失函数
65.     loss = criterion(output, target)    # 计算损失
66.     optimizer.zero_grad()               # 梯度清零
67.     loss.backward()                     # 反向传播
68.     optimizer.step()                    # 更新参数
70.     # 反向传播
71.     print(f"第{i+1}轮训练，损失值: {loss.item():.4f}")
72.     print("反向传播完成，梯度已计算")
74. # 保存模型
75. torch.save(net.state_dict(), 'model.pth')
77. # 测试
78. net.eval()
79. # 加载模型
80. model = Net()
81. model.load_state_dict(torch.load('model.pth'))
82. model.eval()
84. # 测试数据
85. test_array = torch.rand(1, 3, 64, 64)
86. with torch.no_grad():
87.     output = model(test_array)
88.     print(output)
89.     print(f"当前模型预测的类别是: {torch.argmax(output, dim=1).item()}")
91. # import torchvision.transforms as transforms
92. # import torchvision.datasets as datasets
94. # train_dataset = datasets.ImageFolder(root='./data/train', transform=transforms.ToTensor())
95. # train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
96. # test_dataset = datasets.ImageFolder(root='./data/test', transform=transforms.ToTensor())
97. # test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
99. # print(len(train_dataset))
100. # print(len(test_dataset))
101. # print(train_dataset.class_to_idx)
103. # import matplotlib.pyplot as plt
105. # plt.imshow(train_dataset[0][0].numpy().transpose(1, 2, 0))
106. # plt.title(train_dataset.classes[train_dataset[0][1]])
107. # plt.show()​

复制代码

核心组件详解

1. 卷积层 (nn.Conv2d)

• 作用: 提取图像特征
  
• 参数:
  
  
  
  • in_channels=3: 输入通道数(RGB)
    
  • out_channels=64: 输出特征图数量
    
  • kernel_size=2: 卷积核大小
    
  • padding=1: 边缘填充，保持尺寸
    
  
  

2. 池化层 (nn.MaxPool2d)

• 作用: 降维、防止过拟合
  
• 参数: kernel_size=2: 2×2最大池化
  

3. 激活函数 (nn.ReLU)

• 作用: 引入非线性，增强模型表达能力
  

4. 全连接层 (nn.Linear)

• 作用: 分类决策
  
• 参数:
  
  
  
  • in_features=65536: 展平后的特征数量
    
  • out_features=10: 输出类别数
    
  
  

训练流程

基本设置

1. # 模型实例化
2. net = Net()
4. # 优化器
5. optimizer = torch.optim.SGD(net.parameters(), lr=0.001)
7. # 损失函数
8. criterion = nn.CrossEntropyLoss()

复制代码

训练循环

1. for epoch in range(100):
2.     # 前向传播
3.     output = net(input_tensor)
4.    
5.     # 计算损失
6.     loss = criterion(output, target)
7.    
8.     # 反向传播三部曲
9.     optimizer.zero_grad()  # 梯度清零
10.     loss.backward()        # 反向传播
11.     optimizer.step()       # 参数更新
12.    
13.     print(f"第{epoch+1}轮训练，损失值: {loss.item():.4f}")

复制代码

关键要点

1. 反向传播原理

• 梯度清零: 防止梯度累积
  
• loss.backward(): 自动计算所有参数的梯度
  
• optimizer.step(): 根据梯度更新参数
  

2. 尺寸匹配规则

• 卷积输出尺寸: (输入尺寸 + 2×padding - kernel_size) / stride + 1
  
• 池化输出尺寸: 输入尺寸 / kernel_size
  
• 全连接层输入必须展平为一维
  

3. 常见问题解决

• RuntimeError: grad can be implicitly created only for scalar outputs
  
  
  
  • 原因: backward()只能对标量求导
    
  • 解决: 使用损失函数(loss)而不是原始输出
    
  
  

快速构建模板

基础模板

1. import torch
2. import torch.nn as nn
4. class SimpleCNN(nn.Module):
5.     def __init__(self, input_channels, num_classes):
6.         super(SimpleCNN, self).__init__()
7.         self.conv1 = nn.Conv2d(input_channels, 64, 3, padding=1)
8.         self.pool = nn.MaxPool2d(2)
9.         self.relu = nn.ReLU()
10.         self.fc = nn.Linear(64*32*32, num_classes)  # 根据实际尺寸调整
11.    
12.     def forward(self, x):
13.         x = self.conv1(x)
14.         x = self.pool(x)
15.         x = self.relu(x)
16.         x = x.view(x.size(0), -1)  # 自动展平
17.         x = self.fc(x)
18.         return x
20. # 使用示例
21. model = SimpleCNN(3, 10)
22. optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
23. criterion = nn.CrossEntropyLoss()

复制代码

数据加载模板

1. from torchvision import datasets, transforms
3. # 数据预处理
4. transform = transforms.Compose([
5.     transforms.Resize((64, 64)),
6.     transforms.ToTensor(),
7. ])
9. # 数据集加载
10. train_dataset = datasets.ImageFolder('./data/train', transform=transform)
11. train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

复制代码

进阶功能

1. 模型保存与加载

1. # 保存模型
2. torch.save(model.state_dict(), 'model.pth')
4. # 加载模型
5. model = SimpleCNN(3, 10)
6. model.load_state_dict(torch.load('model.pth'))

复制代码

2. 训练验证分离

1. def train(model, dataloader, criterion, optimizer):
2.     model.train()
3.     for batch_idx, (data, target) in enumerate(dataloader):
4.         optimizer.zero_grad()
5.         output = model(data)
6.         loss = criterion(output, target)
7.         loss.backward()
8.         optimizer.step()
10. def validate(model, dataloader, criterion):
11.     model.eval()
12.     total_loss = 0
13.     with torch.no_grad():
14.         for data, target in dataloader:
15.             output = model(data)
16.             total_loss += criterion(output, target).item()
17.     return total_loss / len(dataloader)

复制代码

实用技巧

• 学习率调整: 使用torch.optim.lr_scheduler
  
• 早停机制: 监控验证集损失
  
• 数据增强: 使用torchvision.transforms
  
• GPU加速: 使用.to('cuda')迁移到GPU
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

很好很强大  我过来先占个楼 待编辑

谢谢楼主提供！

不错，里面软件多更新就更好了

新版吗？好像是停更了吧。

不错，里面软件多更新就更好了

收藏一下   不知道什么时候能用到

谢谢分享，试用一下

感谢发布原创作品，程序园因你更精彩

不错，里面软件多更新就更好了

过来提前占个楼

谢谢楼主提供！