• 人工智能基础 作业6

    本次来实现XO图形的识别

    数据集

    数据集要按照一定比例自行划分好训练集training_set和测试集test_set

    代码

    1. import torch
    2. from torch import nn, optim
    3. from torch.utils.data import DataLoader, Dataset
    4. from torchvision import datasets, transforms
    5.  
    6. # 模型构建
    7. class Net(nn.Module):
    8.     def __init__(self):
    9.         super(Net, self).__init__()
    10.         self.conv1 = nn.Conv2d(1, 9, 3)
    11.         self.maxpool = nn.MaxPool2d(2, 2)
    12.         self.conv2 = nn.Conv2d(9, 5, 3)
    13.         self.relu = nn.ReLU()
    14.         self.fc1 = nn.Linear(27 * 27 * 5, 1200)
    15.         self.fc2 = nn.Linear(1200, 64)
    16.         self.fc3 = nn.Linear(64, 2)
    17.  
    18.     def forward(self, x):
    19.         x = self.maxpool(self.relu(self.conv1(x)))
    20.         x = self.maxpool(self.relu(self.conv2(x)))
    21.         x = x.view(-1, 27 * 27 * 5)
    22.         x = self.relu(self.fc1(x))
    23.         x = self.relu(self.fc2(x))
    24.         x = self.fc3(x)
    25.         return x
    26.  
    27. # 数据集加载
    28. data_loader = DataLoader(
    29.     dataset=datasets.ImageFolder(
    30.         root='training_data_sm',
    31.         transform=transforms.Compose([
    32.             transforms.Grayscale(),
    33.             transforms.ToTensor()
    34.         ])
    35.     ),
    36.     batch_size=64,
    37.     shuffle=True
    38. )
    39.  
    40. # 实例化模型
    41. model = Net()
    42. # 损失函数
    43. criterion = torch.nn.CrossEntropyLoss()
    44. # 参数优化器
    45. optimizer = optim.SGD(model.parameters(), lr=0.1)
    46.  
    47. # 开始训练
    48. epochs = 10
    49. for epoch in range(epochs):
    50.     running_loss = 0.0
    51.     for i, data in enumerate(data_loader):
    52.         # 获取数据
    53.         images, label = data  # images.shape = (batch, 1, w, h)
    54.         # 推理
    55.         out = model(images)
    56.         # 计算损失
    57.         loss = criterion(out, label)
    58.         # 清空梯度
    59.         optimizer.zero_grad()
    60.         # 反向传播
    61.         loss.backward()
    62.         # 更新参数
    63.         optimizer.step()
    64.         # 计算平均损失
    65.         running_loss += loss.item()
    66.         if (i + 1) % 10 == 0:
    67.             print('[%d  %5d]   loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
    68.             running_loss = 0.0
    69. print('finished train')
    70. # 保存模型
    71. torch.save(model, 'model_name.pth')  # 保存的是模型， 不止是w和b权重值

     训练

    [1     10]   loss: 0.069
    [1     20]   loss: 0.068
    [1     30]   loss: 0.065
    [2     10]   loss: 0.057
    [2     20]   loss: 0.038
    [2     30]   loss: 0.016
    [3     10]   loss: 0.009
    [3     20]   loss: 0.007
    [3     30]   loss: 0.005
    [4     10]   loss: 0.037
    [4     20]   loss: 0.021
    [4     30]   loss: 0.007
    [5     10]   loss: 0.003
    [5     20]   loss: 0.003
    [5     30]   loss: 0.002
    [6     10]   loss: 0.002
    [6     20]   loss: 0.001
    [6     30]   loss: 0.002
    [7     10]   loss: 0.001
    [7     20]   loss: 0.001
    [7     30]   loss: 0.001
    [8     10]   loss: 0.000
    [8     20]   loss: 0.002
    [8     30]   loss: 0.000
    [9     10]   loss: 0.000
    [9     20]   loss: 0.001
    [9     30]   loss: 0.000
    [10     10]   loss: 0.000
    [10     20]   loss: 0.000
    [10     30]   loss: 0.001
    finished train

     测试

    1. images, labels = data_loader.__iter__().__next__()
    2. # 读取一张图片 images[0]，测试
    3. print("labels[0] truth:\t", labels[0])
    4. x = images[0]
    5. # 读取模型
    6. model_load = torch.load('model_name.pth')
    7. predicted = torch.max(model_load(x), 1)
    8. print("labels[0] predict:\t", predicted.indices)
    9. img = images[0].data.squeeze().numpy()  # 将输出转换为图片的格式
    10. plt.imshow(img, cmap='gray')
    11. plt.show()

     计算模型的准确率

    1. data_loader_test = DataLoader(
    2.     dataset=datasets.ImageFolder(
    3.         root='test_data_sm',
    4.         transform=transforms.Compose([
    5.             transforms.Grayscale(),
    6.             transforms.ToTensor()
    7.         ])
    8.     ),
    9.     batch_size=64,
    10.     shuffle=True
    11. )
    12. # 读取模型
    13. model_load = torch.load('model_name.pth')
    14. correct = 0
    15. total = 0
    16. with torch.no_grad():  # 进行评测的时候网络不更新梯度
    17.     for data in data_loader_test:  # 读取测试集
    18.         images, labels = data
    19.         outputs = model_load(images)
    20.         _, predicted = torch.max(outputs.data, 1)  # 取出 最大值的索引 作为 分类结果
    21.         total += labels.size(0)  # labels 的长度
    22.         correct += (predicted == labels).sum().item()  # 预测正确的数目
    23. print('Accuracy of the network on the  test images: %f %%' % (100. * correct / total))

    Accuracy of the network on the  test images: 99.550000 %

    查看训练好的模型特征图 

    1. # 看看每层的 卷积核 长相，特征图 长相
    2. # 获取网络结构的特征矩阵并可视化
    3. import torch
    4. import matplotlib.pyplot as plt
    5. import numpy as np
    6. from PIL import Image
    7. from torchvision import transforms, datasets
    8. import torch.nn as nn
    9. from torch.utils.data import DataLoader
    10.  
    11. #  定义图像预处理过程(要与网络模型训练过程中的预处理过程一致)
    12.  
    13. transforms = transforms.Compose([
    14.     transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    15.     transforms.Grayscale(1)  # 把图片 转为灰度图
    16. ])
    17. path = r'training_data_sm'
    18. data_train = datasets.ImageFolder(path, transform=transforms)
    19. data_loader = DataLoader(data_train, batch_size=64, shuffle=True)
    20. for i, data in enumerate(data_loader):
    21.     images, labels = data
    22.     print(images.shape)
    23.     print(labels.shape)
    24.     break
    25.  
    26.  
    27. class Net(nn.Module):
    28.     def __init__(self):
    29.         super(Net, self).__init__()
    30.         self.conv1 = nn.Conv2d(1, 9, 3)  # in_channel , out_channel , kennel_size , stride
    31.         self.maxpool = nn.MaxPool2d(2, 2)
    32.         self.conv2 = nn.Conv2d(9, 5, 3)  # in_channel , out_channel , kennel_size , stride
    33.  
    34.         self.relu = nn.ReLU()
    35.         self.fc1 = nn.Linear(27 * 27 * 5, 1200)  # full connect 1
    36.         self.fc2 = nn.Linear(1200, 64)  # full connect 2
    37.         self.fc3 = nn.Linear(64, 2)  # full connect 3
    38.  
    39.     def forward(self, x):
    40.         outputs = []
    41.         x = self.conv1(x)
    42.         outputs.append(x)
    43.         x = self.relu(x)
    44.         outputs.append(x)
    45.         x = self.maxpool(x)
    46.         outputs.append(x)
    47.         x = self.conv2(x)
    48.  
    49.         x = self.relu(x)
    50.  
    51.         x = self.maxpool(x)
    52.  
    53.         x = x.view(-1, 27 * 27 * 5)
    54.         x = self.relu(self.fc1(x))
    55.         x = self.relu(self.fc2(x))
    56.         x = self.fc3(x)
    57.         return outputs
    58.  
    59.  
    60. model1 = torch.load('model_name.pth')
    61.  
    62. # 打印出模型的结构
    63. print(model1)
    64.  
    65. x = images[0]
    66.  
    67. # forward正向传播过程
    68. out_put = model1(x)
    69.  
    70. for feature_map in out_put:
    71.     # [N, C, H, W] -> [C, H, W]    维度变换
    72.     im = np.squeeze(feature_map.detach().numpy())
    73.     # [C, H, W] -> [H, W, C]
    74.     im = np.transpose(im, [1, 2, 0])
    75.     print(im.shape)
    76.  
    77.     # show 9 feature maps
    78.     plt.figure()
    79.     for i in range(9):
    80.         ax = plt.subplot(3, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
    81.         # [H, W, C]
    82.         # 特征矩阵每一个channel对应的是一个二维的特征矩阵，就像灰度图像一样，channel=1
    83.         # plt.imshow(im[:, :, i])
    84.         plt.imshow(im[:, :, i], cmap='gray')
    85.     plt.show()

    卷积后的特征图

    激活后的特征图

    池化后的特征图

     查看训练好的模型的卷积核

    1. # 看看每层的 卷积核 长相，特征图 长相
    2. # 获取网络结构的特征矩阵并可视化
    3. import torch
    4. import matplotlib.pyplot as plt
    5. import numpy as np
    6. from PIL import Image
    7. from torchvision import transforms, datasets
    8. import torch.nn as nn
    9. from torch.utils.data import DataLoader
    10.  
    11. plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    12. plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号 #有中文出现的情况，需要u'内容
    13. #  定义图像预处理过程(要与网络模型训练过程中的预处理过程一致)
    14. transforms = transforms.Compose([
    15.     transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    16.     transforms.Grayscale(1)  # 把图片 转为灰度图
    17. ])
    18. path = r'training_data_sm'
    19. data_train = datasets.ImageFolder(path, transform=transforms)
    20. data_loader = DataLoader(data_train, batch_size=64, shuffle=True)
    21. for i, data in enumerate(data_loader):
    22.     images, labels = data
    23.     # print(images.shape)
    24.     # print(labels.shape)
    25.     break
    26.  
    27.  
    28. class Net(nn.Module):
    29.     def __init__(self):
    30.         super(Net, self).__init__()
    31.         self.conv1 = nn.Conv2d(1, 9, 3)  # in_channel , out_channel , kennel_size , stride
    32.         self.maxpool = nn.MaxPool2d(2, 2)
    33.         self.conv2 = nn.Conv2d(9, 5, 3)  # in_channel , out_channel , kennel_size , stride
    34.  
    35.         self.relu = nn.ReLU()
    36.         self.fc1 = nn.Linear(27 * 27 * 5, 1200)  # full connect 1
    37.         self.fc2 = nn.Linear(1200, 64)  # full connect 2
    38.         self.fc3 = nn.Linear(64, 2)  # full connect 3
    39.  
    40.     def forward(self, x):
    41.         outputs = []
    42.         x = self.maxpool(self.relu(self.conv1(x)))
    43.         # outputs.append(x)
    44.         x = self.maxpool(self.relu(self.conv2(x)))
    45.         outputs.append(x)
    46.         x = x.view(-1, 27 * 27 * 5)
    47.         x = self.relu(self.fc1(x))
    48.         x = self.relu(self.fc2(x))
    49.         x = self.fc3(x)
    50.         return outputs
    51.  
    52.  
    53. model1 = torch.load('model_name.pth')
    54.  
    55. x = images[0]
    56.  
    57. # forward正向传播过程
    58. out_put = model1(x)
    59.  
    60. weights_keys = model1.state_dict().keys()
    61. for key in weights_keys:
    62.     print("key :", key)
    63.     # 卷积核通道排列顺序 [kernel_number, kernel_channel, kernel_height, kernel_width]
    64.     if key == "conv1.weight":
    65.         weight_t = model1.state_dict()[key].numpy()
    66.         print("weight_t.shape", weight_t.shape)
    67.         k = weight_t[:, 0, :, :]  # 获取第一个卷积核的信息参数
    68.         # show 9 kernel ,1 channel
    69.         plt.figure()
    70.  
    71.         for i in range(9):
    72.             ax = plt.subplot(3, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
    73.             plt.imshow(k[i, :, :], cmap='gray')
    74.             title_name = 'kernel' + str(i) + ',channel1'
    75.             plt.title(title_name)
    76.         plt.show()
    77.  
    78.     if key == "conv2.weight":
    79.         weight_t = model1.state_dict()[key].numpy()
    80.         print("weight_t.shape", weight_t.shape)
    81.         k = weight_t[:, :, :, :]  # 获取第一个卷积核的信息参数
    82.         print(k.shape)
    83.         print(k)
    84.  
    85.         plt.figure()
    86.         for c in range(9):
    87.             channel = k[:, c, :, :]
    88.             for i in range(5):
    89.                 ax = plt.subplot(2, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
    90.                 plt.imshow(channel[i, :, :], cmap='gray')
    91.                 title_name = 'kernel' + str(i) + ',channel' + str(c)
    92.                 plt.title(title_name)
    93.             plt.show()

  • 相关阅读:
    【机器学习可解释性】4.SHAP 值
    软件设计模式系列之六——单例模式
    【2023】Git版本控制-远程仓库详解
    在springboot中实现WebSocket协议通信
    QT实战项目1——无边框窗口拖拽和阴影
    leetcode 63. 不同路径 II
    NIFI集群_队列Queue中数据无法清空_清除队列数据报错_无法删除queue_解决_集群中机器交替重启删除---大数据之Nifi工作笔记0061
    微信小程序商城搭建步骤_我们来说说微信小程序商城开发的作用
    好物周刊#19：开源指北
    centos使用Iptables控制防火墙——使用
  • 原文地址：https://blog.csdn.net/Rabbit_Gray/article/details/124937776