NNDL作业XO识别

最新推荐文章于 2025-03-31 07:53:46 发布
最新推荐文章于 2025-03-31 07:53:46 发布
阅读量87 收藏
点赞数 1
文章标签： python 深度学习 numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30807319/article/details/127508101
版权

一、实现卷积-池化-激活

1. Numpy版本：手工实现 卷积-池化-激活
import numpy as np

# 初始化一张X图片矩阵
x = np.array([[-1, -1, -1, -1, -1, -1, -1, -1, -1],
              [-1, 1, -1, -1, -1, -1, -1, 1, -1],
              [-1, -1, 1, -1, -1, -1, 1, -1, -1],
              [-1, -1, -1, 1, -1, 1, -1, -1, -1],
              [-1, -1, -1, -1, 1, -1, -1, -1, -1],
              [-1, -1, -1, 1, -1, 1, -1, -1, -1],
              [-1, -1, 1, -1, -1, -1, 1, -1, -1],
              [-1, 1, -1, -1, -1, -1, -1, 1, -1],
              [-1, -1, -1, -1, -1, -1, -1, -1, -1]])
# 输出原矩阵
print("x=\n", x)
# 初始化 三个 卷积核
Kernel = [[0 for i in range(0, 3)] for j in range(0, 3)]
# 参考图卷积核1
Kernel[0] = np.array([[1, -1, -1],
                      [-1, 1, -1],
                      [-1, -1, 1]])
# 参考图卷积核2
Kernel[1] = np.array([[1, -1, 1],
                      [-1, 1, -1],
                      [1, -1, 1]])
# 参考图卷积核3
Kernel[2] = np.array([[-1, -1, 1],
                      [-1, 1, -1],
                      [1, -1, -1]])

# --------------- 卷积  ---------------
stride = 1  # 步长
feature_map_h = 7  # 特征图的高
feature_map_w = 7  # 特征图的宽
feature_map = [0 for i in range(0, 3)]  # 初始化3个特征图
for i in range(0, 3):
    feature_map[i] = np.zeros((feature_map_h, feature_map_w))  # 初始化特征图
for h in range(feature_map_h):  # 向下滑动，得到卷积后的固定行
    for w in range(feature_map_w):  # 向右滑动，得到卷积后的固定行的列
        v_start = h * stride  # 滑动窗口的起始行（高）
        v_end = v_start + 3  # 滑动窗口的结束行（高）
        h_start = w * stride  # 滑动窗口的起始列（宽）
        h_end = h_start + 3  # 滑动窗口的结束列（宽）
        window = x[v_start:v_end, h_start:h_end]  # 从图切出一个滑动窗口
        for i in range(0, 3):
            feature_map[i][h, w] = np.divide(np.sum(np.multiply(window, Kernel[i][:, :])), 9)
print("feature_map:\n", np.around(feature_map, decimals=2))

# --------------- 池化  ---------------
pooling_stride = 2  # 步长
pooling_h = 4  # 特征图的高
pooling_w = 4  # 特征图的宽
feature_map_pad_0 = [[0 for i in range(0, 8)] for j in range(0, 8)]
for i in range(0, 3):  # 特征图 补 0 ，行 列 都要加 1 (因为上一层是奇数，池化窗口用的偶数)
    feature_map_pad_0[i] = np.pad(feature_map[i], ((0, 1), (0, 1)), 'constant', constant_values=(0, 0))
# print("feature_map_pad_0 0:\n", np.around(feature_map_pad_0[0], decimals=2))

pooling = [0 for i in range(0, 3)]
for i in range(0, 3):
    pooling[i] = np.zeros((pooling_h, pooling_w))  # 初始化特征图
for h in range(pooling_h):  # 向下滑动，得到卷积后的固定行
    for w in range(pooling_w):  # 向右滑动，得到卷积后的固定行的列
        v_start = h * pooling_stride  # 滑动窗口的起始行（高）
        v_end = v_start + 2  # 滑动窗口的结束行（高）
        h_start = w * pooling_stride  # 滑动窗口的起始列（宽）
        h_end = h_start + 2  # 滑动窗口的结束列（宽）
        for i in range(0, 3):
            pooling[i][h, w] = np.max(feature_map_pad_0[i][v_start:v_end, h_start:h_end])
print("pooling:\n", np.around(pooling[0], decimals=2))
print("pooling:\n", np.around(pooling[1], decimals=2))
print("pooling:\n", np.around(pooling[2], decimals=2))


# --------------- 激活  ---------------
def relu(x):
    return (abs(x) + x) / 2


relu_map_h = 7  # 特征图的高
relu_map_w = 7  # 特征图的宽
relu_map = [0 for i in range(0, 3)]  # 初始化3个特征图
for i in range(0, 3):
    relu_map[i] = np.zeros((relu_map_h, relu_map_w))  # 初始化特征图

for i in range(0, 3):
    relu_map[i] = relu(feature_map[i])

print("relu map :\n", np.around(relu_map[0], decimals=2))
print("relu map :\n", np.around(relu_map[1], decimals=2))
print("relu map :\n", np.around(relu_map[2], decimals=2))

import matplotlib.pyplot as plt
# 可视化特征图
plt.subplot(3, 1, 1)
plt.imshow(feature_map[0], cmap='gray')
plt.title('feature_map0')

plt.subplot(3, 1, 2)
plt.imshow(feature_map[1], cmap='gray')
plt.title('feature_map1')

plt.subplot(3, 1, 3)
plt.imshow(feature_map[2], cmap='gray')
plt.title('feature_map2')

plt.show()
# 可视化池化后的结果
plt.subplot(3, 1, 1)
plt.imshow(pooling[0], cmap='gray')
plt.title('pooling0')

plt.subplot(3, 1, 2)
plt.imshow(pooling[1], cmap='gray')
plt.title('pooling1')

plt.subplot(3, 1, 3)
plt.imshow(pooling[2], cmap='gray')
plt.title('pooling2')

plt.show()
# 可视化relu激活后的结果
plt.subplot(3, 1, 1)
plt.imshow(relu_map[0], cmap='gray')
plt.title('relu_map0')

plt.subplot(3, 1, 2)
plt.imshow(relu_map[1], cmap='gray')
plt.title('relu_map1')

plt.subplot(3, 1, 3)
plt.imshow(relu_map[2], cmap='gray')
plt.title('relu_map2')

plt.show()
2. Pytorch版本：调用函数实现 卷积-池化-激活
# https://blog.youkuaiyun.com/qq_26369907/article/details/88366147
# https://zhuanlan.zhihu.com/p/405242579
import numpy as np
import torch
import torch.nn as nn

x = torch.tensor([[[[-1, -1, -1, -1, -1, -1, -1, -1, -1],
                    [-1, 1, -1, -1, -1, -1, -1, 1, -1],
                    [-1, -1, 1, -1, -1, -1, 1, -1, -1],
                    [-1, -1, -1, 1, -1, 1, -1, -1, -1],
                    [-1, -1, -1, -1, 1, -1, -1, -1, -1],
                    [-1, -1, -1, 1, -1, 1, -1, -1, -1],
                    [-1, -1, 1, -1, -1, -1, 1, -1, -1],
                    [-1, 1, -1, -1, -1, -1, -1, 1, -1],
                    [-1, -1, -1, -1, -1, -1, -1, -1, -1]]]], dtype=torch.float)
print(x.shape)
print(x)

print("--------------- 卷积  ---------------")
conv1 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv1.weight.data = torch.Tensor([[[[1, -1, -1],
                                    [-1, 1, -1],
                                    [-1, -1, 1]]
                                   ]])
conv2 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv2.weight.data = torch.Tensor([[[[1, -1, 1],
                                    [-1, 1, -1],
                                    [1, -1, 1]]
                                   ]])
conv3 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv3.weight.data = torch.Tensor([[[[-1, -1, 1],
                                    [-1, 1, -1],
                                    [1, -1, -1]]
                                   ]])

feature_map1 = conv1(x)
feature_map2 = conv2(x)
feature_map3 = conv3(x)

print(feature_map1 / 9)
print(feature_map2 / 9)
print(feature_map3 / 9)
# img = torch.tensor(feature_map3).data.squeeze().numpy()  # 将输出转换为图片的格式
# plt.imshow(img, cmap='gray')
print("--------------- 池化  ---------------")
max_pool = nn.MaxPool2d(2, padding=0, stride=2)  # Pooling
zeroPad = nn.ZeroPad2d(padding=(0, 1, 0, 1))  # pad 0 , Left Right Up Down

feature_map_pad_0_1 = zeroPad(feature_map1)
feature_pool_1 = max_pool(feature_map_pad_0_1)
feature_map_pad_0_2 = zeroPad(feature_map2)
feature_pool_2 = max_pool(feature_map_pad_0_2)
feature_map_pad_0_3 = zeroPad(feature_map3)
feature_pool_3 = max_pool(feature_map_pad_0_3)

print(feature_pool_1.size())
print(feature_pool_1 / 9)
print(feature_pool_2 / 9)
print(feature_pool_3 / 9)

print("--------------- 激活  ---------------")
activation_function = nn.ReLU()

feature_relu1 = activation_function(feature_map1)
feature_relu2 = activation_function(feature_map2)
feature_relu3 = activation_function(feature_map3)
print(feature_relu1 / 9)
print(feature_relu2 / 9)
print(feature_relu3 / 9)
3. 可视化：了解数字与图像之间的关系

结果

numpy+++++++++++++++++++++
x=
 [[-1 -1 -1 -1 -1 -1 -1 -1 -1]
 [-1  1 -1 -1 -1 -1 -1  1 -1]
 [-1 -1  1 -1 -1 -1  1 -1 -1]
 [-1 -1 -1  1 -1  1 -1 -1 -1]
 [-1 -1 -1 -1  1 -1 -1 -1 -1]
 [-1 -1 -1  1 -1  1 -1 -1 -1]
 [-1 -1  1 -1 -1 -1  1 -1 -1]
 [-1  1 -1 -1 -1 -1 -1  1 -1]
 [-1 -1 -1 -1 -1 -1 -1 -1 -1]]
feature_map:
 [[[ 0.78 -0.11  0.11  0.33  0.56 -0.11  0.33]
  [-0.11  1.   -0.11  0.33 -0.11  0.11 -0.11]
  [ 0.11 -0.11  1.   -0.33  0.11 -0.11  0.56]
  [ 0.33  0.33 -0.33  0.56 -0.33  0.33  0.33]
  [ 0.56 -0.11  0.11 -0.33  1.   -0.11  0.11]
  [-0.11  0.11 -0.11  0.33 -0.11  1.   -0.11]
  [ 0.33 -0.11  0.56  0.33  0.11 -0.11  0.78]]

 [[ 0.33 -0.56  0.11 -0.11  0.11 -0.56  0.33]
  [-0.56  0.56 -0.56  0.33 -0.56  0.56 -0.56]
  [ 0.11 -0.56  0.56 -0.78  0.56 -0.56  0.11]
  [-0.11  0.33 -0.78  1.   -0.78  0.33 -0.11]
  [ 0.11 -0.56  0.56 -0.78  0.56 -0.56  0.11]
  [-0.56  0.56 -0.56  0.33 -0.56  0.56 -0.56]
  [ 0.33 -0.56  0.11 -0.11  0.11 -0.56  0.33]]

 [[ 0.33 -0.11  0.56  0.33  0.11 -0.11  0.78]
  [-0.11  0.11 -0.11  0.33 -0.11  1.   -0.11]
  [ 0.56 -0.11  0.11 -0.33  1.   -0.11  0.11]
  [ 0.33  0.33 -0.33  0.56 -0.33  0.33  0.33]
  [ 0.11 -0.11  1.   -0.33  0.11 -0.11  0.56]
  [-0.11  1.   -0.11  0.33 -0.11  0.11 -0.11]
  [ 0.78 -0.11  0.11  0.33  0.56 -0.11  0.33]]]
pooling:
 [[1.   0.33 0.56 0.33]
 [0.33 1.   0.33 0.56]
 [0.56 0.33 1.   0.11]
 [0.33 0.56 0.11 0.78]]
pooling:
 [[0.56 0.33 0.56 0.33]
 [0.33 1.   0.56 0.11]
 [0.56 0.56 0.56 0.11]
 [0.33 0.11 0.11 0.33]]
pooling:
 [[0.33 0.56 1.   0.78]
 [0.56 0.56 1.   0.33]
 [1.   1.   0.11 0.56]
 [0.78 0.33 0.56 0.33]]
relu map :
 [[0.78 0.   0.11 0.33 0.56 0.   0.33]
 [0.   1.   0.   0.33 0.   0.11 0.  ]
 [0.11 0.   1.   0.   0.11 0.   0.56]
 [0.33 0.33 0.   0.56 0.   0.33 0.33]
 [0.56 0.   0.11 0.   1.   0.   0.11]
 [0.   0.11 0.   0.33 0.   1.   0.  ]
 [0.33 0.   0.56 0.33 0.11 0.   0.78]]
relu map :
 [[0.33 0.   0.11 0.   0.11 0.   0.33]
 [0.   0.56 0.   0.33 0.   0.56 0.  ]
 [0.11 0.   0.56 0.   0.56 0.   0.11]
 [0.   0.33 0.   1.   0.   0.33 0.  ]
 [0.11 0.   0.56 0.   0.56 0.   0.11]
 [0.   0.56 0.   0.33 0.   0.56 0.  ]
 [0.33 0.   0.11 0.   0.11 0.   0.33]]
relu map :
 [[0.33 0.   0.56 0.33 0.11 0.   0.78]
 [0.   0.11 0.   0.33 0.   1.   0.  ]
 [0.56 0.   0.11 0.   1.   0.   0.11]
 [0.33 0.33 0.   0.56 0.   0.33 0.33]
 [0.11 0.   1.   0.   0.11 0.   0.56]
 [0.   1.   0.   0.33 0.   0.11 0.  ]
 [0.78 0.   0.11 0.33 0.56 0.   0.33]]
torch++++++++++++++++++++++
torch.Size([1, 1, 9, 9])
tensor([[[[-1., -1., -1., -1., -1., -1., -1., -1., -1.],
          [-1.,  1., -1., -1., -1., -1., -1.,  1., -1.],
          [-1., -1.,  1., -1., -1., -1.,  1., -1., -1.],
          [-1., -1., -1.,  1., -1.,  1., -1., -1., -1.],
          [-1., -1., -1., -1.,  1., -1., -1., -1., -1.],
          [-1., -1., -1.,  1., -1.,  1., -1., -1., -1.],
          [-1., -1.,  1., -1., -1., -1.,  1., -1., -1.],
          [-1.,  1., -1., -1., -1., -1., -1.,  1., -1.],
          [-1., -1., -1., -1., -1., -1., -1., -1., -1.]]]])
--------------- 卷积  ---------------
tensor([[[[ 0.8099, -0.0790,  0.1432,  0.3655,  0.5877, -0.0790,  0.3655],
          [-0.0790,  1.0321, -0.0790,  0.3655, -0.0790,  0.1432, -0.0790],
          [ 0.1432, -0.0790,  1.0321, -0.3012,  0.1432, -0.0790,  0.5877],
          [ 0.3655,  0.3655, -0.3012,  0.5877, -0.3012,  0.3655,  0.3655],
          [ 0.5877, -0.0790,  0.1432, -0.3012,  1.0321, -0.0790,  0.1432],
          [-0.0790,  0.1432, -0.0790,  0.3655, -0.0790,  1.0321, -0.0790],
          [ 0.3655, -0.0790,  0.5877,  0.3655,  0.1432, -0.0790,  0.8099]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3480, -0.5408,  0.1258, -0.0964,  0.1258, -0.5408,  0.3480],
          [-0.5408,  0.5703, -0.5408,  0.3480, -0.5408,  0.5703, -0.5408],
          [ 0.1258, -0.5408,  0.5703, -0.7631,  0.5703, -0.5408,  0.1258],
          [-0.0964,  0.3480, -0.7631,  1.0147, -0.7631,  0.3480, -0.0964],
          [ 0.1258, -0.5408,  0.5703, -0.7631,  0.5703, -0.5408,  0.1258],
          [-0.5408,  0.5703, -0.5408,  0.3480, -0.5408,  0.5703, -0.5408],
          [ 0.3480, -0.5408,  0.1258, -0.0964,  0.1258, -0.5408,  0.3480]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.2964, -0.1480,  0.5186,  0.2964,  0.0742, -0.1480,  0.7409],
          [-0.1480,  0.0742, -0.1480,  0.2964, -0.1480,  0.9631, -0.1480],
          [ 0.5186, -0.1480,  0.0742, -0.3702,  0.9631, -0.1480,  0.0742],
          [ 0.2964,  0.2964, -0.3702,  0.5186, -0.3702,  0.2964,  0.2964],
          [ 0.0742, -0.1480,  0.9631, -0.3702,  0.0742, -0.1480,  0.5186],
          [-0.1480,  0.9631, -0.1480,  0.2964, -0.1480,  0.0742, -0.1480],
          [ 0.7409, -0.1480,  0.0742,  0.2964,  0.5186, -0.1480,  0.2964]]]],
       grad_fn=<DivBackward0>)
--------------- 池化  ---------------
torch.Size([1, 1, 4, 4])
tensor([[[[1.0321, 0.3655, 0.5877, 0.3655],
          [0.3655, 1.0321, 0.3655, 0.5877],
          [0.5877, 0.3655, 1.0321, 0.1432],
          [0.3655, 0.5877, 0.1432, 0.8099]]]], grad_fn=<DivBackward0>)
tensor([[[[0.5703, 0.3480, 0.5703, 0.3480],
          [0.3480, 1.0147, 0.5703, 0.1258],
          [0.5703, 0.5703, 0.5703, 0.1258],
          [0.3480, 0.1258, 0.1258, 0.3480]]]], grad_fn=<DivBackward0>)
tensor([[[[0.2964, 0.5186, 0.9631, 0.7409],
          [0.5186, 0.5186, 0.9631, 0.2964],
          [0.9631, 0.9631, 0.0742, 0.5186],
          [0.7409, 0.2964, 0.5186, 0.2964]]]], grad_fn=<DivBackward0>)
--------------- 激活  ---------------
tensor([[[[0.8099, 0.0000, 0.1432, 0.3655, 0.5877, 0.0000, 0.3655],
          [0.0000, 1.0321, 0.0000, 0.3655, 0.0000, 0.1432, 0.0000],
          [0.1432, 0.0000, 1.0321, 0.0000, 0.1432, 0.0000, 0.5877],
          [0.3655, 0.3655, 0.0000, 0.5877, 0.0000, 0.3655, 0.3655],
          [0.5877, 0.0000, 0.1432, 0.0000, 1.0321, 0.0000, 0.1432],
          [0.0000, 0.1432, 0.0000, 0.3655, 0.0000, 1.0321, 0.0000],
          [0.3655, 0.0000, 0.5877, 0.3655, 0.1432, 0.0000, 0.8099]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3480, 0.0000, 0.1258, 0.0000, 0.1258, 0.0000, 0.3480],
          [0.0000, 0.5703, 0.0000, 0.3480, 0.0000, 0.5703, 0.0000],
          [0.1258, 0.0000, 0.5703, 0.0000, 0.5703, 0.0000, 0.1258],
          [0.0000, 0.3480, 0.0000, 1.0147, 0.0000, 0.3480, 0.0000],
          [0.1258, 0.0000, 0.5703, 0.0000, 0.5703, 0.0000, 0.1258],
          [0.0000, 0.5703, 0.0000, 0.3480, 0.0000, 0.5703, 0.0000],
          [0.3480, 0.0000, 0.1258, 0.0000, 0.1258, 0.0000, 0.3480]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.2964, 0.0000, 0.5186, 0.2964, 0.0742, 0.0000, 0.7409],
          [0.0000, 0.0742, 0.0000, 0.2964, 0.0000, 0.9631, 0.0000],
          [0.5186, 0.0000, 0.0742, 0.0000, 0.9631, 0.0000, 0.0742],
          [0.2964, 0.2964, 0.0000, 0.5186, 0.0000, 0.2964, 0.2964],
          [0.0742, 0.0000, 0.9631, 0.0000, 0.0742, 0.0000, 0.5186],
          [0.0000, 0.9631, 0.0000, 0.2964, 0.0000, 0.0742, 0.0000],
          [0.7409, 0.0000, 0.0742, 0.2964, 0.5186, 0.0000, 0.2964]]]],
       grad_fn=<DivBackward0>)

在这里插入图片描述在这里插入图片描述在这里插入图片描述

二、 基于CNN的XO识别

数据集

在这里插入图片描述

构建模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)  # in_channel , out_channel , kennel_size , stride
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(9, 5, 3)  # in_channel , out_channel , kennel_size , stride

        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(27 * 27 * 5, 1200)  # full connect 1
        self.fc2 = nn.Linear(1200, 64)  # full connect 2
        self.fc3 = nn.Linear(64, 2)  # full connect 3

    def forward(self, x):
        x = self.maxpool(self.relu(self.conv1(x)))
        x = self.maxpool(self.relu(self.conv2(x)))
        x = x.view(-1, 27 * 27 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x
训练模型
model = Net()
criterion = torch.nn.CrossEntropyLoss()  # 损失函数 交叉熵损失函数
optimizer = optim.SGD(model.parameters(), lr=0.1)  # 优化函数：随机梯度下降

epochs = 5
for epoch in range(epochs):
    running_loss = 0.0
    for i, data in enumerate(data_loader):
        images, label = data
        out = model(images)
        loss = criterion(out, label)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if (i + 1) % 10 == 0:
            print('[%d  %5d]   loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

print('finished train')

# 保存模型 torch.save(model.state_dict(), model_path)
torch.save(model.state_dict(), 'model_name1.pth')  # 保存的是模型， 不止是w和b权重值

size of train_data: 1600
size of test_data: 400
torch.Size([64, 1, 116, 116])
torch.Size([64])
torch.Size([64, 1, 116, 116])
torch.Size([64])
[1     10]   loss: 0.069
[1     20]   loss: 0.068
[2     10]   loss: 0.064
[2     20]   loss: 0.053
[3     10]   loss: 0.069
[3     20]   loss: 0.068
[4     10]   loss: 0.059
[4     20]   loss: 0.065
[5     10]   loss: 0.050
[5     20]   loss: 0.015

odel = Net()
model.load_state_dict(torch.load('model_name1.pth', map_location='cpu'))  # 导入网络的参数

# model_load = torch.load('model_name1.pth')
# https://blog.youkuaiyun.com/qq_41360787/article/details/104332706

correct = 0
total = 0
with torch.no_grad():  # 进行评测的时候网络不更新梯度
    for data in data_loader_test:  # 读取测试集
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)  # 取出 最大值的索引 作为 分类结果
        total += labels.size(0)  # labels 的长度
        correct += (predicted == labels).sum().item()  # 预测正确的数目
print('Accuracy of the network on the  test images: %f %%' % (100. * correct / total))
计算模型的准确率
finished train
Accuracy of the network on the  test images: 97.500000 %
查看训练好的模型的特征图
model_load = torch.load('model_name.pth')
# 读取一张图片 images[0]，测试
print("label[0] truth:\t", label[0])
x = images[0]
x = x.reshape([1, 1, 116, 116])
predicted = torch.max(model_load(x), 1)
print("label[0] predict:\t", predicted.indices)

img = images[0].data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.show()

# 看看每层的 卷积核 长相，特征图 长相
# 获取网络结构的特征矩阵并可视化
import torch
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
from torchvision import transforms, datasets
import torch.nn as nn
from torch.utils.data import DataLoader

#  定义图像预处理过程(要与网络模型训练过程中的预处理过程一致)

transforms = transforms.Compose([
    transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    transforms.Grayscale(1)  # 把图片 转为灰度图
])
path = r'training_data_sm\train_data'
data_train = datasets.ImageFolder(path, transform=transforms)
data_loader = DataLoader(data_train, batch_size=64, shuffle=True)
for i, data in enumerate(data_loader):
    images, labels = data
    print(images.shape)
    print(labels.shape)
    break


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)  # in_channel , out_channel , kennel_size , stride
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(9, 5, 3)  # in_channel , out_channel , kennel_size , stride

        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(27 * 27 * 5, 1200)  # full connect 1
        self.fc2 = nn.Linear(1200, 64)  # full connect 2
        self.fc3 = nn.Linear(64, 2)  # full connect 3

    def forward(self, x):
        outputs = []
        x = self.conv1(x)
        outputs.append(x)
        x = self.relu(x)
        outputs.append(x)
        x = self.maxpool(x)
        outputs.append(x)
        x = self.conv2(x)

        x = self.relu(x)

        x = self.maxpool(x)

        x = x.view(-1, 27 * 27 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return outputs


# create model
model1 = Net()

# load model weights加载预训练权重
# model_weight_path ="./AlexNet.pth"
model_weight_path = "model_name.pth"
model1 = torch.load(model_weight_path)

# 打印出模型的结构

print(model1)

x = images[0]
x = x.reshape([1, 1, 116, 116])
# forward正向传播过程
out_put = model1(x)
for feature_map in out_put:
    # [N, C, H, W] -> [C, H, W]    维度变换
    im = np.squeeze(feature_map.detach().numpy())
    # [C, H, W] -> [H, W, C]
    im = np.transpose(im, [1, 2, 0])
    print(im.shape)

    # show 9 feature maps
    plt.figure()
    for i in range(9):
        ax = plt.subplot(3, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
        # [H, W, C]
        # 特征矩阵每一个channel对应的是一个二维的特征矩阵，就像灰度图像一样，channel=1
        # plt.imshow(im[:, :, i])
        plt.imshow(im[:, :, i], cmap='gray')
    plt.show()

在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

查看训练好的模型的卷积核
# 看看每层的 卷积核 长相，特征图 长相
# 获取网络结构的特征矩阵并可视化
import torch
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
from torchvision import transforms, datasets
import torch.nn as nn
from torch.utils.data import DataLoader

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号 #有中文出现的情况，需要u'内容
#  定义图像预处理过程(要与网络模型训练过程中的预处理过程一致)
transforms = transforms.Compose([
    transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    transforms.Grayscale(1)  # 把图片 转为灰度图
])
path = r'training_data_sm\train_data'
data_train = datasets.ImageFolder(path, transform=transforms)
data_loader = DataLoader(data_train, batch_size=64, shuffle=True)
for i, data in enumerate(data_loader):
    images, labels = data
    # print(images.shape)
    # print(labels.shape)
    break


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)  # in_channel , out_channel , kennel_size , stride
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(9, 5, 3)  # in_channel , out_channel , kennel_size , stride

        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(27 * 27 * 5, 1200)  # full connect 1
        self.fc2 = nn.Linear(1200, 64)  # full connect 2
        self.fc3 = nn.Linear(64, 2)  # full connect 3

    def forward(self, x):
        outputs = []
        x = self.maxpool(self.relu(self.conv1(x)))
        # outputs.append(x)
        x = self.maxpool(self.relu(self.conv2(x)))
        outputs.append(x)
        x = x.view(-1, 27 * 27 * 5)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return outputs


# create model
model1 = Net()

# load model weights加载预训练权重
model_weight_path = "model_name.pth"
model1 = torch.load(model_weight_path)

x = images[0]
x = x.reshape([1, 1, 116, 116])
# forward正向传播过程
out_put = model1(x)

weights_keys = model1.state_dict().keys()
for key in weights_keys:
    print("key :", key)
    # 卷积核通道排列顺序 [kernel_number, kernel_channel, kernel_height, kernel_width]
    if key == "conv1.weight":
        weight_t = model1.state_dict()[key].numpy()
        print("weight_t.shape", weight_t.shape)
        k = weight_t[:, 0, :, :]  # 获取第一个卷积核的信息参数
        # show 9 kernel ,1 channel
        plt.figure()

        for i in range(9):
            ax = plt.subplot(3, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
            plt.imshow(k[i, :, :], cmap='gray')
            title_name = 'kernel' + str(i) + ',channel1'
            plt.title(title_name)
        plt.show()

    if key == "conv2.weight":
        weight_t = model1.state_dict()[key].numpy()
        print("weight_t.shape", weight_t.shape)
        k = weight_t[:, :, :, :]  # 获取第一个卷积核的信息参数
        print(k.shape)
        print(k)

        plt.figure()
        for c in range(9):
            channel = k[:, c, :, :]
            for i in range(5):
                ax = plt.subplot(2, 3, i + 1)  # 参数意义：3：图片绘制行数，5：绘制图片列数，i+1：图的索引
                plt.imshow(channel[i, :, :], cmap='gray')
                title_name = 'kernel' + str(i) + ',channel' + str(c)
                plt.title(title_name)
            plt.show()

第一层：
在这里插入图片描述
第二层：
在这里插入图片描述

【华为OD机试真题 java、python、c++】统计匹配的二元组个数（100%通过+复盘思路）
hjc的博客
01-06 1722
给定两个数组A和B，若数组A的某个元素A[i]与数组B中的某个元素B[j]满足 A[i]==A[j],则寻找到一个值匹配的二元组(j,i).请统计在这两个数组A和B中二元组。
【LeetCode】大厂面试算法真题回忆(59)--统计匹配的二元组个数
最新发布
zkw54334的博客
04-16 43
若下标从0开始，则匹配的二元组分别为(0, 3), (1, 2), (2, 1), (3, 0)共计4个。若下标从0开始，则匹配的二元组分别为(0, 0), (1, 1), (4, 1), (5, 0)共计4个。输入数组中允许出现重复数字，一个数字可以匹配多次。若不存在相等的值，则输出0。所采用的算法复杂度需小于。循环的方式，可以考虑用空间换取时间。中，一共存在多少个这样的二元组。，则寻找到一个值匹配的二元组。输出匹配的二元组个数。题目要求时间复杂度小于。
统计匹配的二元组个数
wzlcy0720的博客
05-14 237
其中，主版本和次版本都是必须的，主版本，次版本，增量版本由多位数字组成，可能包含前导零，里程碑版本由字符串组成。Maven 版本号定义，..-，举例3.1.4-beta。说明 里程碑版本号，基于字典序比较，a 大于 A。..：基于数字比较；输入2个版本号，换行分割，每个版本的最大长度小于50。说明 版本号相同，输出第一个版本号。输入2个版本号，输出最大版本号。版本号相同时输出第一个输入版本号。输出 1.5.0。
华为OD机试 - 统计匹配的二元组个数（Python） | 机试题+算法思路+考点+代码解析 【2023】
坚果的博客
02-22 634
给定两个数组 A 和 B，若数组 A 的某个元素 A[i] 与数组 B 中的某个元素 B[j] 满足 A[i]==B[j]，则寻找到一个匹配的二元组(i,j) ，请统计再这两个数组 A 和 B 中，一共存在多少个这样的二元组。
题目0168-统计匹配的二元组个数
amos_cloud的博客
12-11 1503
给定两个数组 AAA 和 BBB，若数组 AAA 的某个元素 A[i]A[i]A[i] 与数组 BBB 中的某个元素 B[j]B[j]B[j] 满足 A[i]==B[j]A[i]==B[j]A[i]==B[j]，则寻找到一个匹配的二元组 (i,j)(i,j)(i,j) ，请统计再这两个数组 AAA 和 BBB 中，一共存在多少个这样的二元组。第一行输入数组 AAA 的长度 MMM ； 第一行输入数组 BBB 的长度 NNN ； 第三行输入数组 AAA 的值； 第四行输入数组 BBB 的值。 1≤M,N≤10
NNDL 作业7 基于CNN的XO识别
gdx1314520的博客
11-13 185
通过多通道的设计，神经网络可以更加灵活地处理和表达复杂的数据，从而提高模型的性能和效果。每个通道对应于输入数据的一种特定特征，增加通道数意味着模型可以检测到更多的特征，从而提高模型的表达能力。这样做的好处是减少了网络的参数数量，降低了模型的复杂度，并且可以更好地处理平移不变性的特征。通过在通道维度上进行卷积操作，可以将不同通道的特征信息相互影响和融合，从而生成更加丰富和综合的特征表示。中级特征对应于更加抽象的图像描述，它们可能需要对低级特征进行一定程度的组合和解释，才能够描述图像中的相对复杂的结构信息。
NNDL 作业6：基于CNN的XO识别
qq_52551768的博客
10-22 487
NNDL 作业6：基于CNN进行XO识别
深度学习作业 - 作业七 - 基于CNN的XO识别
m0_74221395的博客
10-30 684
1.这一次作业主要是认识了在卷积神经网络过程中的一些新的专业词汇，经过这次作业的学习，我对卷积提取特征这一过程算是彻底明明白白了。首先，一般在卷积的过程中，会采用局部感知+权值共享的方式来在降低网络复杂度的同时保持网络性能或增加性能，局部感知让每个卷积核专注于特定的特征提取任务，权值共享让这些特征提取任务在整个图像上保持一致。池化同样是一种降低网络复杂度同时又保持网络性能的手段，通过使用某些值来代表一个区域中的所有像素点，来降低特征尺寸，同时还能很好的继承共有的特征。
神经网络与深度学习 作业6：基于CNN的XO识别
weixin_53651790的博客
10-22 719
基于CNN的XO识别
【华为OD机试】统计匹配的二元组个数
算法菌的博客
11-05 68
给定两个数组A和B，若数组A的某个元素A[i]与数组B中某个元素B[j]满足 A[i] == B[j]，则寻找到一个值匹配的二元组(i,j)。 请统计在这两个数组A和B中，一共存在多少个这样的二元组。
华为OD机试 - 统计匹配的二元组个数（C 语言解题）【独家】
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
03-08 5644
本期题目：统计匹配的二元组个数 题目 给定两个数组 A 和 B，若数组 A 的某个元素 A[i] 与数组 B 中的某个元素 B[j] 满足 A[i]==B[j]，则寻找到一个匹配的二元组(i,j) ，请统计再这两个数组 A 和 B 中，一共存在多少个这样的二元组。 输入 第一行输入数组 A 的长度 M ； 第一行输入数组 B 的长度 N ； 第三行输入数组 A 的值； 第四行输入数组 B 的值。 1≤M,N≤100000 A,B 数组中数值的取值均小于 100000
【相亲派对】
优快云
12-08 3976
已支持（Java & JS & Python & C & C++），实现：哈希表
华为OD机试 - 统计匹配的二元组个数（Python/JS/C/C++ 2025 A卷 100分）
学Java，找哪吒
03-18 730
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。给定两个数组A和B，若数组A的某个元素A[i]与数组B中的某个元素B[j]满足 A[i] == B[j], 则寻找到一个值匹配的二元组(i, j). 请统计在这两个数组A和B中，一共存在多少个这样的二元组。1 <= M, N <= 100000A
华为OD机试2025年A卷-统计匹配的二元组个数[100分]（ Java | Python3 | C++ | C语言 | JsNode | Go）实现100%通过率
算法算法算法！！！
03-30 190
给定两个数组A和B，若数组A的某个元素A[i]与数组B中的某个元素B[j]满足A[i]==B[j]，则寻找到一个值匹配的二元组（i,j).请统计在这两个数组A和B中，一共存在多少个这样的二元组。
统计匹配的二元组个数_20230411
jmzrj的博客
04-11 325
给定两个数组A和 B，若数组 A* 的某个元素Ai] 与数组 B 中的某个元素B[jAi]==Bj]，则寻找到一个匹配的二元组(ij) ，请统计再这两个数组A和 B中，一共存在多少个这样的二元组。
2024华为OD试题及答案-A015-二元组个数
2401_86417859的博客
08-05 800
给定两个数组a，b，若a[i] == b[j] 则称 [i, j] 为一个二元组，求在给定的两个数组中，二元组的个数。该程序能够根据输入的两个数组，正确计算并输出相等元素的二元组数量。该程序能够根据输入的两个数组，正确计算并输出相等元素的二元组数量。题目要求找到两个数组中相等元素的对数。具体来说，给定两个数组。第二行输入m个数，表示第一个数组。第四行输入n个数，表示第二个数组。
华为OD机试用Python实现 -【统计匹配的二元组个数】(2023-Q1 新题)
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
02-25 3259
给定两个数组 A 和 B，若数组 A 的某个元素 A[i]与数组 B 中的某个元素 B[j]满足 A[i] == B[j], 则寻找到一个值匹配的二元组(i, j). 请统计在这两个数组 A 和 B 中，一共存在多少个这样的二元组。若下标从 0 开始，则匹配的二元组分别为(0, 3), (1, 2), (2, 1), (3, 0), 共计 4 个。若下标从 0 开始，则匹配的二元组分别为(0, 0), (1, 1), (4, 1), (5, 0) 共计 4 个。的最后一个位置，并且这个位置的值等于。
题解 | # 华为OD - 统计匹配的二元组个数 #
weixin_51337282的博客
08-23 94
本人与2023年8月机考400通过，会持续更新本专栏。本专栏会包含JavaScript和Java两种实现方式，会以很简洁的代码去实现。相对于其他人的专栏，本专栏代码是浅显易懂的，可以在看懂代码的基础上去按自己的思路编写代码，通过率以及分数都会倍增。
华为OD刷题笔记-2025A卷-统计匹配的二元组个数
qq_40749873的博客
03-31 250
给定两个数组A和B，若数组A的某个元素A[i]与数组B中某个元素B[j]满足 A[i] == B[j]，则寻找到一个值匹配的二元组(i,j)。请统计在这两个数组A和B中，一共存在多少个这样的二元组。若不存在相等的值，则输出0。输入数组中允许出现重复数字，一个数字可以匹配多次。简单题，双层for循环遍历判断下标ij是否满足元素A[i]=B[j]，如果是，个数加1，输出总个数。第一行输入数组A的长度M，第二行输入数组B的长度N，第三行输入数组A的值，第四行输入数组B的值。输出匹配的二元组个数。
NNDL课程第二次作业解析与实践
- 深度学习是机器学习的一个分支，它使用具有许多处理层的神经网络来学习数据的高级特征，适用于图像识别、语音识别、自然语言处理等复杂任务。 3. **编程任务和实践** - "NNDL-Assignment2"很可能指代一个关于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值