devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

机器学习——python训练CNN模型实战（傻瓜式教学，小学生都可以学会）代码开源_python如何训练cnn网络

作者：weixin_40725706 | 2024-04-19 01:10:56

赞

踩

python如何训练cnn网络

​

机器学习实战目录

第一章 python训练线性模型实战

第二章 python训练决策树模型实战

第三章 python训练神经网络模型实战

第四章 python训练支持向量机模型实战

第五章 python训练贝叶斯分类器模型实战

第六章 python训练集成学习模型实战

第七章 python训练聚类模型实战

第八章 python训练KNN模型实战

第九章 python训练CNN模型实战

第十章 python训练RNN模型实战

......(会一直更新)

第九章 python训练CNN模型实战

目录

机器学习实战目录

第九章 python训练CNN模型实战

1. 下载数据集

2. 定义 CNN 模型

3. 训练模型

4. 测试模型

完整代码如下：

参考资料：

训练CNN模型的步骤如下：

1. 下载数据集

可以在各种网站上下载图像数据集，例如 CIFAR10 和 ImageNet。以使用的 CIFAR10 数据集为例，具体步骤如下：

- 安装 torchvision 库：使用以下命令安装 torchvision 库。

  1. ``` python
  3. !pip install torchvision
  5. ```

如果你使用的是 conda，可以使用以下命令来安装 torchvision 库。

  1. ``` python
  3. !conda install torchvision -c pytorch
  5. ```

- 加载数据集：使用以下代码来加载 CIFAR10 数据集。

  1. ``` python
  2.  
  3. import torch
  4.  
  5. import torchvision.datasets as datasets
  6.  
  7.  
  8.  
  9. # 加载数据集
  10.  
  11. train_data = datasets.CIFAR10(root='./data', train=True, download=True)
  12.  
  13. test_data = datasets.CIFAR10(root='./data', train=False, download=True)
  14.  
  15.  
  16.  
  17. # 将数据转换为 PyTorch 的张量格式
  18.  
  19. train_data = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)
  20.  
  21. test_data = torch.utils.data.DataLoader(test_data, batch_size=64, shuffle=True)
  22.  
  23. ```

2. 定义 CNN 模型

在本例中，我们定义了一个包含三个卷积层和两个全连接层的 CNN 模型，以处理 3 通道的 32x32 图像。

  1.  
  2. ``` python
  3.  
  4. import torch.nn as nn
  5.  
  6.  
  7.  
  8. class Net(nn.Module):
  9.  
  10.     def __init__(self):
  11.  
  12.         super(Net, self).__init__()
  13.  
  14.         
  15.  
  16.         # 定义卷积层
  17.  
  18.         self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)
  19.  
  20.         self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
  21.  
  22.         self.conv3 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
  23.  
  24.         
  25.  
  26.         # 定义全连接层
  27.  
  28.         self.fc1 = nn.Linear(64 * 4 * 4, 500)
  29.  
  30.         self.fc2 = nn.Linear(500, 10)
  31.  
  32.         
  33.  
  34.     def forward(self, x):
  35.  
  36.         
  37.  
  38.         # 卷积层
  39.  
  40.         x = self.conv1(x)
  41.  
  42.         x = nn.functional.relu(x)
  43.  
  44.         x = nn.functional.max_pool2d(x, 2)
  45.  
  46.         
  47.  
  48.         x = self.conv2(x)
  49.  
  50.         x = nn.functional.relu(x)
  51.  
  52.         x = nn.functional.max_pool2d(x, 2)
  53.  
  54.         
  55.  
  56.         x = self.conv3(x)
  57.  
  58.         x = nn.functional.relu(x)
  59.  
  60.         x = nn.functional.max_pool2d(x, 2)
  61.  
  62.         
  63.  
  64.         # 全连接层
  65.  
  66.         x = x.view(-1, 64 * 4 * 4)
  67.  
  68.         x = self.fc1(x)
  69.  
  70.         x = nn.functional.relu(x)
  71.  
  72.         x = self.fc2(x)
  73.  
  74.         
  75.  
  76.         return x
  77.  
  78.  
  79.  
  80. # 创建模型实例
  81.  
  82. model = Net()
  83.  
  84. ```

3. 训练模型

训练 CNN 模型的代码如下所示：

  1.  
  2. ``` python
  3.  
  4. import torch.optim as optim
  5.  
  6.  
  7.  
  8. # 定义优化器和损失函数
  9.  
  10. criterion = nn.CrossEntropyLoss()
  11.  
  12. optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
  13.  
  14.  
  15.  
  16. # 训练模型
  17.  
  18. for epoch in range(10):  # 训练 10 次
  19.  
  20.     running_loss = 0.0
  21.  
  22.     for i, data in enumerate(train_data, 0):
  23.  
  24.         # 获取输入
  25.  
  26.         inputs, labels = data
  27.  
  28.         
  29.  
  30.         # 梯度清零
  31.  
  32.         optimizer.zero_grad()
  33.  
  34.         
  35.  
  36.         # 前向传播，反向传播，优化器更新参数
  37.  
  38.         outputs = model(inputs)
  39.  
  40.         loss = criterion(outputs, labels)
  41.  
  42.         loss.backward()
  43.  
  44.         optimizer.step()
  45.  
  46.         
  47.  
  48.         # 输出统计信息
  49.  
  50.         running_loss += loss.item()
  51.  
  52.         if i % 100 == 99:
  53.  
  54.             print('[%d, %5d] loss: %.3f' %
  55.  
  56.                   (epoch + 1, i + 1, running_loss / 100))
  57.  
  58.             running_loss = 0.0
  59.  
  60. print('Finished Training')
  61.  
  62. ```

4. 测试模型

对测试集进行推理并计算准确率。

  1.  
  2. ``` python
  3.  
  4. correct = 0
  5.  
  6. total = 0
  7.  
  8. with torch.no_grad():
  9.  
  10.     for data in test_data:
  11.  
  12.         images, labels = data
  13.  
  14.         outputs = model(images)
  15.  
  16.         _, predicted = torch.max(outputs.data, 1)
  17.  
  18.         total += labels.size(0)
  19.  
  20.         correct += (predicted == labels).sum().item()
  21.  
  22.  
  23.  
  24. print('Accuracy of the network on the 10000 test images: %d %%' % (
  25.  
  26.     100 * correct / total))
  27.  
  28. ```

完整代码如下：

  1.  
  2. ``` python
  3.  
  4. import torch
  5.  
  6. import torch.nn as nn
  7.  
  8. import torch.optim as optim
  9.  
  10. import torchvision.datasets as datasets
  11.  
  12.  
  13.  
  14. # 加载数据集
  15.  
  16. train_data = datasets.CIFAR10(root='./data', train=True, download=True)
  17.  
  18. test_data = datasets.CIFAR10(root='./data', train=False, download=True)
  19.  
  20.  
  21.  
  22. # 将数据转换为 PyTorch 的张量格式
  23.  
  24. train_data = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)
  25.  
  26. test_data = torch.utils.data.DataLoader(test_data, batch_size=64, shuffle=True)
  27.  
  28.  
  29.  
  30. # 定义 CNN 模型
  31.  
  32. class Net(nn.Module):
  33.  
  34.     def __init__(self):
  35.  
  36.         super(Net, self).__init__()
  37.  
  38.         
  39.  
  40.         # 定义卷积层
  41.  
  42.         self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)
  43.  
  44.         self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
  45.  
  46.         self.conv3 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
  47.  
  48.         
  49.  
  50.         # 定义全连接层
  51.  
  52.         self.fc1 = nn.Linear(64 * 4 * 4, 500)
  53.  
  54.         self.fc2 = nn.Linear(500, 10)
  55.  
  56.         
  57.  
  58.     def forward(self, x):
  59.  
  60.         
  61.  
  62.         # 卷积层
  63.  
  64.         x = self.conv1(x)
  65.  
  66.         x = nn.functional.relu(x)
  67.  
  68.         x = nn.functional.max_pool2d(x, 2)
  69.  
  70.         
  71.  
  72.         x = self.conv2(x)
  73.  
  74.         x = nn.functional.relu(x)
  75.  
  76.         x = nn.functional.max_pool2d(x, 2)
  77.  
  78.         
  79.  
  80.         x = self.conv3(x)
  81.  
  82.         x = nn.functional.relu(x)
  83.  
  84.         x = nn.functional.max_pool2d(x, 2)
  85.  
  86.         
  87.  
  88.         # 全连接层
  89.  
  90.         x = x.view(-1, 64 * 4 * 4)
  91.  
  92.         x = self.fc1(x)
  93.  
  94.         x = nn.functional.relu(x)
  95.  
  96.         x = self.fc2(x)
  97.  
  98.         
  99.  
  100.         return x
  101.  
  102.  
  103.  
  104. # 创建模型实例
  105.  
  106. model = Net()
  107.  
  108.  
  109.  
  110. # 定义优化器和损失函数
  111.  
  112. criterion = nn.CrossEntropyLoss()
  113.  
  114. optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
  115.  
  116.  
  117.  
  118. # 训练模型
  119.  
  120. for epoch in range(10):  # 训练 10 次
  121.  
  122.     running_loss = 0.0
  123.  
  124.     for i, data in enumerate(train_data, 0):
  125.  
  126.         # 获取输入
  127.  
  128.         inputs, labels = data
  129.  
  130.         
  131.  
  132.         # 梯度清零
  133.  
  134.         optimizer.zero_grad()
  135.  
  136.         
  137.  
  138.         # 前向传播，反向传播，优化器更新参数
  139.  
  140.         outputs = model(inputs)
  141.  
  142.         loss = criterion(outputs, labels)
  143.  
  144.         loss.backward()
  145.  
  146.         optimizer.step()
  147.  
  148.         
  149.  
  150.         # 输出统计信息
  151.  
  152.         running_loss += loss.item()
  153.  
  154.         if i % 100 == 99:
  155.  
  156.             print('[%d, %5d] loss: %.3f' %
  157.  
  158.                   (epoch + 1, i + 1, running_loss / 100))
  159.  
  160.             running_loss = 0.0
  161.  
  162. print('Finished Training')
  163.  
  164.  
  165.  
  166. # 测试模型
  167.  
  168. correct = 0
  169.  
  170. total = 0
  171.  
  172. with torch.no_grad():
  173.  
  174.     for data in test_data:
  175.  
  176.         images, labels = data
  177.  
  178.         outputs = model(images)
  179.  
  180.         _, predicted = torch.max(outputs.data, 1)
  181.  
  182.         total += labels.size(0)
  183.  
  184.         correct += (predicted == labels).sum().item()
  185.  
  186.  
  187.  
  188. print('Accuracy of the network on the 10000 test images: %d %%' % (
  189.  
  190.     100 * correct / total))
  191.  
  192. ```

参考资料：

[[1](https://www.python.org/)]

[[2](https://zhuanlan.zhihu.com/p/344562609)]

大家觉得有帮助的话还请大家给个收藏关注鼓励一下，有什么问题评论区留言，看到会恢复哒~

​

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/449185
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号