NNDL 作业6：基于CNN的XO识别

最新推荐文章于 2023-03-21 21:15:42 发布
最新推荐文章于 2023-03-21 21:15:42 发布
阅读量59 收藏
点赞数 1
文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73486730/article/details/127487618
版权

目录

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

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

2. Pytorch版本：调用函数实现 卷积-池化-激活

3. 可视化：了解数字与图像之间的关系

二、 基于CNN的XO识别

1. 数据集

 2. 构建模型

3. 训练模型

4. 测试训练好的模型

 5. 计算模型的准确率 

 6. 查看训练好的模型的特征图

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

 8. 训练模型源代码

9. 测试模型源代码

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

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))

运行结果：

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]]

Process finished with exit code -1073741749 (0xC000004B)

2. Pytorch版本：调用函数实现 卷积-池化-激活

调用框架自带算子实现，对比自定义算子

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)

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)


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.7787, -0.1102,  0.1120,  0.3343,  0.5565, -0.1102,  0.3343],
          [-0.1102,  1.0009, -0.1102,  0.3343, -0.1102,  0.1120, -0.1102],
          [ 0.1120, -0.1102,  1.0009, -0.3324,  0.1120, -0.1102,  0.5565],
          [ 0.3343,  0.3343, -0.3324,  0.5565, -0.3324,  0.3343,  0.3343],
          [ 0.5565, -0.1102,  0.1120, -0.3324,  1.0009, -0.1102,  0.1120],
          [-0.1102,  0.1120, -0.1102,  0.3343, -0.1102,  1.0009, -0.1102],
          [ 0.3343, -0.1102,  0.5565,  0.3343,  0.1120, -0.1102,  0.7787]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3359, -0.5530,  0.1137, -0.1085,  0.1137, -0.5530,  0.3359],
          [-0.5530,  0.5581, -0.5530,  0.3359, -0.5530,  0.5581, -0.5530],
          [ 0.1137, -0.5530,  0.5581, -0.7752,  0.5581, -0.5530,  0.1137],
          [-0.1085,  0.3359, -0.7752,  1.0026, -0.7752,  0.3359, -0.1085],
          [ 0.1137, -0.5530,  0.5581, -0.7752,  0.5581, -0.5530,  0.1137],
          [-0.5530,  0.5581, -0.5530,  0.3359, -0.5530,  0.5581, -0.5530],
          [ 0.3359, -0.5530,  0.1137, -0.1085,  0.1137, -0.5530,  0.3359]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.2992, -0.1452,  0.5214,  0.2992,  0.0770, -0.1452,  0.7436],
          [-0.1452,  0.0770, -0.1452,  0.2992, -0.1452,  0.9659, -0.1452],
          [ 0.5214, -0.1452,  0.0770, -0.3675,  0.9659, -0.1452,  0.0770],
          [ 0.2992,  0.2992, -0.3675,  0.5214, -0.3675,  0.2992,  0.2992],
          [ 0.0770, -0.1452,  0.9659, -0.3675,  0.0770, -0.1452,  0.5214],
          [-0.1452,  0.9659, -0.1452,  0.2992, -0.1452,  0.0770, -0.1452],
          [ 0.7436, -0.1452,  0.0770,  0.2992,  0.5214, -0.1452,  0.2992]]]],
       grad_fn=<DivBackward0>)
池化
torch.Size([1, 1, 4, 4])
tensor([[[[1.0009, 0.3343, 0.5565, 0.3343],
          [0.3343, 1.0009, 0.3343, 0.5565],
          [0.5565, 0.3343, 1.0009, 0.1120],
          [0.3343, 0.5565, 0.1120, 0.7787]]]], grad_fn=<DivBackward0>)
tensor([[[[0.5581, 0.3359, 0.5581, 0.3359],
          [0.3359, 1.0026, 0.5581, 0.1137],
          [0.5581, 0.5581, 0.5581, 0.1137],
          [0.3359, 0.1137, 0.1137, 0.3359]]]], grad_fn=<DivBackward0>)
tensor([[[[0.2992, 0.5214, 0.9659, 0.7436],
          [0.5214, 0.5214, 0.9659, 0.2992],
          [0.9659, 0.9659, 0.0770, 0.5214],
          [0.7436, 0.2992, 0.5214, 0.2992]]]], grad_fn=<DivBackward0>)
激活
tensor([[[[0.7787, 0.0000, 0.1120, 0.3343, 0.5565, 0.0000, 0.3343],
          [0.0000, 1.0009, 0.0000, 0.3343, 0.0000, 0.1120, 0.0000],
          [0.1120, 0.0000, 1.0009, 0.0000, 0.1120, 0.0000, 0.5565],
          [0.3343, 0.3343, 0.0000, 0.5565, 0.0000, 0.3343, 0.3343],
          [0.5565, 0.0000, 0.1120, 0.0000, 1.0009, 0.0000, 0.1120],
          [0.0000, 0.1120, 0.0000, 0.3343, 0.0000, 1.0009, 0.0000],
          [0.3343, 0.0000, 0.5565, 0.3343, 0.1120, 0.0000, 0.7787]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3359, 0.0000, 0.1137, 0.0000, 0.1137, 0.0000, 0.3359],
          [0.0000, 0.5581, 0.0000, 0.3359, 0.0000, 0.5581, 0.0000],
          [0.1137, 0.0000, 0.5581, 0.0000, 0.5581, 0.0000, 0.1137],
          [0.0000, 0.3359, 0.0000, 1.0026, 0.0000, 0.3359, 0.0000],
          [0.1137, 0.0000, 0.5581, 0.0000, 0.5581, 0.0000, 0.1137],
          [0.0000, 0.5581, 0.0000, 0.3359, 0.0000, 0.5581, 0.0000],
          [0.3359, 0.0000, 0.1137, 0.0000, 0.1137, 0.0000, 0.3359]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.2992, 0.0000, 0.5214, 0.2992, 0.0770, 0.0000, 0.7436],
          [0.0000, 0.0770, 0.0000, 0.2992, 0.0000, 0.9659, 0.0000],
          [0.5214, 0.0000, 0.0770, 0.0000, 0.9659, 0.0000, 0.0770],
          [0.2992, 0.2992, 0.0000, 0.5214, 0.0000, 0.2992, 0.2992],
          [0.0770, 0.0000, 0.9659, 0.0000, 0.0770, 0.0000, 0.5214],
          [0.0000, 0.9659, 0.0000, 0.2992, 0.0000, 0.0770, 0.0000],
          [0.7436, 0.0000, 0.0770, 0.2992, 0.5214, 0.0000, 0.2992]]]],
       grad_fn=<DivBackward0>)

Process finished with exit code -1073741749 (0xC000004B)

3. 可视化：了解数字与图像之间的关系

可视化卷积核和特征图

import torch
import torch.nn as nn
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号 #有中文出现的情况，需要u'内容
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)
img = x.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('原图')
plt.show()

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]]
                                   ]])
img = conv1.weight.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 1)
plt.imshow(img, cmap='gray')
plt.title('Kernel 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]]
                                   ]])
img = conv2.weight.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 5)
plt.imshow(img, cmap='gray')
plt.title('Kernel 2')
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]]
                                   ]])
img = conv3.weight.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 9)
plt.imshow(img, cmap='gray')
plt.title('Kernel 3')

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 = feature_map1.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 2)
plt.imshow(img, cmap='gray')
plt.title('卷积后的特征图1')
img2 = feature_map2.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 6)
plt.imshow(img, cmap='gray')
plt.title('卷积后的特征图2')
img3 = feature_map3.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 10)
plt.imshow(img, cmap='gray')
plt.title('卷积后的特征图3')

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)
img = feature_pool_1.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 3)
plt.imshow(img, cmap='gray')
plt.title('卷积池化后的特征图1')
img2 = feature_pool_2.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 7)
plt.imshow(img, cmap='gray')
plt.title('卷积池化后的特征图2')
img3 = feature_pool_3.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 11)
plt.imshow(img, cmap='gray')
plt.title('卷积池化后的特征图3')

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)
img = feature_relu1.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 4)
plt.imshow(img, cmap='gray')
plt.title('卷积 + relu 后的特征图1')
img2 = feature_relu2.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 8)
plt.imshow(img, cmap='gray')
plt.title('卷积 + relu 后的特征图2')
img3 = feature_relu3.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.subplot(3, 4, 12)
plt.imshow(img, cmap='gray')
plt.title('卷积 + relu 后的特征图3')
plt.show()

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.7974, -0.0915,  0.1308,  0.3530,  0.5752, -0.0915,  0.3530],
          [-0.0915,  1.0197, -0.0915,  0.3530, -0.0915,  0.1308, -0.0915],
          [ 0.1308, -0.0915,  1.0197, -0.3137,  0.1308, -0.0915,  0.5752],
          [ 0.3530,  0.3530, -0.3137,  0.5752, -0.3137,  0.3530,  0.3530],
          [ 0.5752, -0.0915,  0.1308, -0.3137,  1.0197, -0.0915,  0.1308],
          [-0.0915,  0.1308, -0.0915,  0.3530, -0.0915,  1.0197, -0.0915],
          [ 0.3530, -0.0915,  0.5752,  0.3530,  0.1308, -0.0915,  0.7974]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3236, -0.5652,  0.1014, -0.1208,  0.1014, -0.5652,  0.3236],
          [-0.5652,  0.5459, -0.5652,  0.3236, -0.5652,  0.5459, -0.5652],
          [ 0.1014, -0.5652,  0.5459, -0.7875,  0.5459, -0.5652,  0.1014],
          [-0.1208,  0.3236, -0.7875,  0.9903, -0.7875,  0.3236, -0.1208],
          [ 0.1014, -0.5652,  0.5459, -0.7875,  0.5459, -0.5652,  0.1014],
          [-0.5652,  0.5459, -0.5652,  0.3236, -0.5652,  0.5459, -0.5652],
          [ 0.3236, -0.5652,  0.1014, -0.1208,  0.1014, -0.5652,  0.3236]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3383, -0.1062,  0.5605,  0.3383,  0.1160, -0.1062,  0.7827],
          [-0.1062,  0.1160, -0.1062,  0.3383, -0.1062,  1.0049, -0.1062],
          [ 0.5605, -0.1062,  0.1160, -0.3284,  1.0049, -0.1062,  0.1160],
          [ 0.3383,  0.3383, -0.3284,  0.5605, -0.3284,  0.3383,  0.3383],
          [ 0.1160, -0.1062,  1.0049, -0.3284,  0.1160, -0.1062,  0.5605],
          [-0.1062,  1.0049, -0.1062,  0.3383, -0.1062,  0.1160, -0.1062],
          [ 0.7827, -0.1062,  0.1160,  0.3383,  0.5605, -0.1062,  0.3383]]]],
       grad_fn=<DivBackward0>)
池化
torch.Size([1, 1, 4, 4])
tensor([[[[1.0197, 0.3530, 0.5752, 0.3530],
          [0.3530, 1.0197, 0.3530, 0.5752],
          [0.5752, 0.3530, 1.0197, 0.1308],
          [0.3530, 0.5752, 0.1308, 0.7974]]]], grad_fn=<DivBackward0>)
tensor([[[[0.5459, 0.3236, 0.5459, 0.3236],
          [0.3236, 0.9903, 0.5459, 0.1014],
          [0.5459, 0.5459, 0.5459, 0.1014],
          [0.3236, 0.1014, 0.1014, 0.3236]]]], grad_fn=<DivBackward0>)
tensor([[[[0.3383, 0.5605, 1.0049, 0.7827],
          [0.5605, 0.5605, 1.0049, 0.3383],
          [1.0049, 1.0049, 0.1160, 0.5605],
          [0.7827, 0.3383, 0.5605, 0.3383]]]], grad_fn=<DivBackward0>)
激活
tensor([[[[0.7974, 0.0000, 0.1308, 0.3530, 0.5752, 0.0000, 0.3530],
          [0.0000, 1.0197, 0.0000, 0.3530, 0.0000, 0.1308, 0.0000],
          [0.1308, 0.0000, 1.0197, 0.0000, 0.1308, 0.0000, 0.5752],
          [0.3530, 0.3530, 0.0000, 0.5752, 0.0000, 0.3530, 0.3530],
          [0.5752, 0.0000, 0.1308, 0.0000, 1.0197, 0.0000, 0.1308],
          [0.0000, 0.1308, 0.0000, 0.3530, 0.0000, 1.0197, 0.0000],
          [0.3530, 0.0000, 0.5752, 0.3530, 0.1308, 0.0000, 0.7974]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3236, 0.0000, 0.1014, 0.0000, 0.1014, 0.0000, 0.3236],
          [0.0000, 0.5459, 0.0000, 0.3236, 0.0000, 0.5459, 0.0000],
          [0.1014, 0.0000, 0.5459, 0.0000, 0.5459, 0.0000, 0.1014],
          [0.0000, 0.3236, 0.0000, 0.9903, 0.0000, 0.3236, 0.0000],
          [0.1014, 0.0000, 0.5459, 0.0000, 0.5459, 0.0000, 0.1014],
          [0.0000, 0.5459, 0.0000, 0.3236, 0.0000, 0.5459, 0.0000],
          [0.3236, 0.0000, 0.1014, 0.0000, 0.1014, 0.0000, 0.3236]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3383, 0.0000, 0.5605, 0.3383, 0.1160, 0.0000, 0.7827],
          [0.0000, 0.1160, 0.0000, 0.3383, 0.0000, 1.0049, 0.0000],
          [0.5605, 0.0000, 0.1160, 0.0000, 1.0049, 0.0000, 0.1160],
          [0.3383, 0.3383, 0.0000, 0.5605, 0.0000, 0.3383, 0.3383],
          [0.1160, 0.0000, 1.0049, 0.0000, 0.1160, 0.0000, 0.5605],
          [0.0000, 1.0049, 0.0000, 0.3383, 0.0000, 0.1160, 0.0000],
          [0.7827, 0.0000, 0.1160, 0.3383, 0.5605, 0.0000, 0.3383]]]],
       grad_fn=<DivBackward0>)

Process finished with exit code -1073741749 (0xC000004B)

二、 基于CNN的XO识别

1. 数据集

 QQ群内下载的数据集没有分测试集和训练集。

共2000张图片，X、O各1000张。

从X、O文件夹，分别取出150张作为测试集。

文件夹train_data：放置训练集 1700张图片

文件夹test_data： 放置测试集 300张图片

 2. 构建模型

 

import torch
import torch.nn as nn
 
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 9, 3)
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(9, 5, 3)
 
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(27 * 27 * 5, 1200)
        self.fc2 = nn.Linear(1200, 64)
        self.fc3 = nn.Linear(64, 2)
 
    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

3. 训练模型

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from torchvision import transforms, datasets
from torch.utils.data import DataLoader
import torch.optim as optim



transforms = transforms.Compose([
    transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    transforms.Grayscale(1)  # 把图片 转为灰度图
])

path = r'C:\Users\栖\Desktop\data_sm\test_data'
path_test = r'C:\Users\栖\Desktop\data_sm\train_data'

data_train = datasets.ImageFolder(path, transform=transforms)
data_test = datasets.ImageFolder(path_test, transform=transforms)

print("size of train_data:", len(data_train))
print("size of test_data:", len(data_test))

data_loader = DataLoader(data_train, batch_size=64, shuffle=True)
data_loader_test = DataLoader(data_test, batch_size=64, shuffle=True)
model = Net()

criterion = torch.nn.CrossEntropyLoss()  # 损失函数 交叉熵损失函数
optimizer = optim.SGD(model.parameters(), lr=0.1)  # 优化函数：随机梯度下降

epochs = 10
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, 'model_name.pth')  # 保存的是模型， 不止是w和b权重值

 

4. 测试训练好的模型

# 读取模型
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()

 

 
 

 5. 计算模型的准确率 
 

# 读取模型
model_load = Net()
model_load.load_state_dict(torch.load('model_name1.pth'))
correct = 0
total = 0
with torch.no_grad():  # 进行评测的时候网络不更新梯度
    for data in data_loader_test:  # 读取测试集
        images, labels = data
        outputs = model_load(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))
 

 

 
 

 6. 查看训练好的模型的特征图
 

import torch
import matplotlib.pyplot as plt
import numpy as np
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'C:\Users\栖\Desktop\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 = "model_name1.pth"
model1.load_state_dict(torch.load(model_weight_path))

# 打印出模型的结构
print(model1)
x = images[0]
x = x.reshape([1, x.shape[0], x.shape[1], x.shape[2]])
# forward正向传播过程
out_put = model1(x)
for feature_map in out_put:
    im = np.squeeze(feature_map.detach().numpy())
    im = np.transpose(im, [1, 2, 0])
    print(im.shape)

    plt.figure()
    for i in range(9):
        ax = plt.subplot(3, 3, i + 1)
        plt.imshow(im[:, :, i], cmap='gray')
    plt.show()
 

 

 
 

 
 

 
 

 
 

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

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'
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_name1.pth"
model1.load_state_dict(torch.load(model_weight_path))
 
x = images[0]
 
# 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()
 

 
 

 
 

 
 

 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 8. 训练模型源代码
 

import torch
from torchvision import transforms, datasets
import torch.nn as nn
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import torch.optim as optim
 
transforms = transforms.Compose([
    transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    transforms.Grayscale(1)  # 把图片 转为灰度图
])
 
path = r'train_data'
path_test = r'test_data'
 
data_train = datasets.ImageFolder(path, transform=transforms)
data_test = datasets.ImageFolder(path_test, transform=transforms)
 
print("size of train_data:",len(data_train))
print("size of test_data:",len(data_test))
 
data_loader = DataLoader(data_train, batch_size=64, shuffle=True)
data_loader_test = DataLoader(data_test, batch_size=64, shuffle=True)
 
for i, data in enumerate(data_loader):
    images, labels = data
    print(images.shape)
    print(labels.shape)
    break
 
for i, data in enumerate(data_loader_test):
    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):
        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 = 10
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权重值
 
# 读取模型
model = torch.load('model_name1.pth')
 

9. 测试模型源代码
 

# https://blog.csdn.net/qq_53345829/article/details/124308515
import torch
from torchvision import transforms, datasets
import torch.nn as nn
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import torch.optim as optim
 
transforms = transforms.Compose([
    transforms.ToTensor(),  # 把图片进行归一化，并把数据转换成Tensor类型
    transforms.Grayscale(1)  # 把图片 转为灰度图
])
 
path = r'train_data'
path_test = r'test_data'
 
data_train = datasets.ImageFolder(path, transform=transforms)
data_test = datasets.ImageFolder(path_test, transform=transforms)
 
print("size of train_data:", len(data_train))
print("size of test_data:", len(data_test))
 
data_loader = DataLoader(data_train, batch_size=64, shuffle=True)
data_loader_test = DataLoader(data_test, batch_size=64, shuffle=True)
print(len(data_loader))
print(len(data_loader_test))
 
 
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()
model.load_state_dict(torch.load('model_name1.pth', map_location='cpu')) # 导入网络的参数
 
# model_load = torch.load('model_name1.pth')
# https://blog.csdn.net/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))
 
#  "_," 的解释 https://blog.csdn.net/weixin_48249563/article/details/111387501
 

总结：本次作业学会不同版本实现卷积-池化-激活和实现图片数据集的识别 基于CNN的XO识别 中间提取并可视化了一些训练过程 更好地理解了图片卷积后的尺寸变化 在CNN中神经网络的层次和结构都是不固定的可以调整的 可根据训练数据集的不同，去修改全连接层或者参数。
 

 ref: 
 

https://blog.csdn.net/qq_38975453/article/details/127181162
 

卷积-池化-激活_HBU_David的博客-CSDN博客
 

CNN实现XO识别_HBU_David的博客-CSDN博客

                

        

        

    




    

      

        

            

              
                
                  _Gypsophila___
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
NNDL-solutions:迈克尔·尼尔森（Michael Nielsen）的《神经网络与深度学习》一书中的练习和问题的解决方案

				
			

			

				

					05-03
				

			

		

		

			
				
NNDL解决方案 迈克尔·尼尔森（Michael Nielsen）的书《 （以及对Python 3和Theano 1.0.3的代码的改编）中的练习和问题的解决方案（数学和代码）。  在这里找到练习和问题的解决方案：  涉及数学： notebooks  涉及...

			
		

	



                

              
                



	

		

			

				
					
NNDL:神经网络和深度学习课程回购

				
			

			

				

					04-12
				

			

		

		

			
				
作业6： 在房屋价格数据集上实现小批量梯度下降。作业7： 它由批量梯度下降优化器的实现组成，该优化器用于对点样本进行采样，这些点取自线y = 2 * x + 3的方程式。作业8： 在压力和重量数据集上实现微型批次梯度...

			
		

	



                


  
              

                


	

		

			

				
					
深度学习实用代码块集锦

				
			

			

				

					MJy65535的博客
				

				

					03-21
					
					889
					
				

			

		

		

			
				
本文为学习深度学习过程中实用代码总结、小经验小技巧总结，持续更新~

			
		

	





	

		

			

				
					
神经网络与深度学习 作业6：基于CNN的XO识别

				
			

			

				

					weixin_53651790的博客
				

				

					10-22
					
					380
					
				

			

		

		

			
				
基于CNN的XO识别

			
		

	



		

			
		



	

		

			

				
					
深度学习作业-图像识别

				
			

			

				

					qq_34112576的博客
				

				

					03-16
					
					3011
					
				

			

		

		

			
				
深度学习作业-图像识别
一、AlexNet进行中文字体的识别
	1 、数据准备
	2 、构造数据生成器
	3 、输出图像
	4 、AlexNet代码实现
		1 .模型结构搭建
		2 .模型编译
		3 .模型运行与拟合
二、自搭建网络进行中文字体的识别
	1 、数据准备
	2 、构造数据生成器
	3 、自搭建模型代码实现
		1 .模型结构搭建
		2 .模型运行与拟合
		3 .对新预测集进行模型预测
			1 .使用带泄露的ReLU函数
			2 .模型中不使用dropout
结论

数据背景
本次

			
		

	





	

		

			

				
					
halcon 深度学习（一）：分类

				
			

			

				

					长春小佛爷的博客
				

				

					01-23
					
					4009
					
				

			

		

		

			
				
*设置窗体
*关闭窗体
dev_update_off ()
dev_close_window ()
*新建窗体
WindowWidth := 800
WindowHeight := 600
dev_open_window_fit_size (0, 0, WindowWidth, WindowHeight, -1, -1, WindowHandle)
*字体
set_display_font (WindowHandle, 16, 'mono', 'true', 'false')

*打上标签
*选...

			
		

	





	

		

			

				
					
Halcon 深度学习（三）：缺陷检测

					
热门推荐

				
			

			

				

					qq_41373415的博客
				

				

					04-21
					
					1万+
					
				

			

		

		

			
				
目录前言一、准备1、准备缺陷检测所需图片1.1、images文件夹：3种类型图片1.2、divisionImages文件夹：3种类型图片（用于分割背景）二、编写代码1、设置输入输出路径2、设置参数3、处理图片、拆分4、预处理数据集5、测试

前言
最近学习深度学习时的一些总结和看法，参照深度学习的自带案例（segment_pill_deep_learning_1_preprocess.hdev）

一、准备
1、准备缺陷检测所需图片
1.1、images文件夹：3种类型图片

每个类型中分为3种：conta

			
		

	





	

		

			

				
					
NNDL:使用python的梯度下降算法

				
			

			

				

					03-25
				

			

		

		

			
				
在神经网络领域，梯度下降算法是训练模型时最常用的一种优化方法，特别是在深度学习中。本主题将深入探讨如何在Python环境中，结合Jupyter Notebook工具实现梯度下降算法，以便于理解和应用到实际的神经网络模型中。...

			
		

	





	

		

			

				
					
NNDL:神经网络与深度学习

				
			

			

				

					03-07
				

			

		

		

			
				
3. 卷积神经网络：详解CNN的结构、卷积层、池化层和全连接层，以及它们在图像识别中的应用。 4. 循环神经网络：RNNs的基本概念、LSTMs的工作原理以及在序列数据处理中的应用。 5. 深度学习框架：如TensorFlow和...

			
		

	





	

		

			

				
					
锻炼：锻炼nndl

				
			

			

				

					02-26
				

			

		

		

			
				
5.卷积神经网络卷积神经网络（CNN） 利用卷积神经网络，处理MNIST数据集分类问题。 6.循环神经网络 基于循环神经网络的唐诗生成问题 7.注意力机制 使用序列对模型进行建模。 使用注意序列对模型进行排序。 11.高斯...

			
		

	





	

		

			

				
					
nndl：神经网络和深度学习的另一种中文翻译

				
			

			

				

					02-21
				

			

		

		

			
				
神经网络和深度学习的另一种中文翻译 这是迈克尔·尼尔森（Michael Nielsen）的《另一本（正在进行中的）中文译本，最初是我对这本免费在线书的学习笔记。 它是用LaTeX编写的，以使数学方程式和曲线图具有...$ cd nndl

			
		

	





	

		

			

				
					
NNDL

				
			

			

				

					03-22
				

			

		

		

			
				
标题 "NNDL" 暗示我们正在探讨神经网络领域的知识，而描述中的内容却提到了一个数学问题，寻找函数 \( f(x) = x^4 + 3x^2 + 10 \) 的全局最小点和值。这个问题虽然不是直接与神经网络相关的，但它涉及到优化，这是...

			
		

	





	

		

			

				
					
NNDL-18K41A0505:18K41A0505（CSE III SRU）-神经网络和深度学习作业

				
			

			

				

					04-10
				

			

		

		

			
				
NNDL-18K41A0505 18K41A0505（CSE III SRU）-神经网络和深度学习作业作业01-梯度下降算法（Python实现和手动计算） 作业02-梯度下降算法-多变量（Python实现和手动计算） 作业03-随机梯度下降（SGD）算法（Python...

			
		

	





	

		

			

				
					
实验环境5-1所需要的nndl包

					
最新发布

				
			

			

				

					10-28
				

			

		

		

			
				
《神经网络基础与nndl库解析》  神经网络，作为人工智能领域的核心组成部分，已经在机器学习、深度学习等众多领域展现出强大的潜力。nndl（Neural Network and Deep Learning Library）是针对这一主题的一个重要...

			
		

	





	

		

			

				
					
神经⽹络与深度学习nndl-ebook.zip

				
			

			

				

					05-14
				

			

		

		

			
				
深度神经网络（DNN）能够自动学习数据的抽象表示，适用于图像识别、语音识别、自然语言处理等多种任务。书中会深入讨论卷积神经网络（CNN）和循环神经网络（RNN），这两种网络结构在图像和序列数据处理中有着广泛的...

			
		

	





	

		

			

				
					
Halcon 深度学习--手写数字分类（亲测）

				
			

			

				

					panda HAHA的博客
				

				

					03-02
					
					1485
					
				

			

		

		

			
				
Halcon 版的深度学习，操作简单。

			
		

	





	

		

			

				
					
神经网络与深度学习 作业11：优化算法比较

				
			

			

				

					weixin_53651790的博客
				

				

					12-04
					
					389
					
				

			

		

		

			
				
作业11：优化算法比较

			
		

	





	

		

			

				
					
【深度学习-吴恩达】L1-4 深层神经网络 作业

				
			

			

				

					u011315681的博客
				

				

					07-28
					
					647
					
				

			

		

		

			
				
【深度学习-吴恩达】L1-4 深层神经网络 作业笔记

			
		

	





	

		

			

				
					
halcon深度学习4：深度学习在 OCR的用法-deep_ocr_workflow解析

				
			

			

				

					mlxg99999的博客
				

				

					08-10
					
					8291
					
				

			

		

		

			
				
1. 什么是OCR技术
OCR，全称是Optical Character Recognition, 即光学字符识别，面向扫描文件。但是由于现在数字图像的普及，这里泛指文字检测和识别，包括扫描文档和自然场景的文字识别。



			
		

	





	

		

			

				
					
2、编程练习：基于循环神经网络的唐诗生成问题 https://github.com/nndl/exercise/

				
			

			

				

					05-04
				

			

		

		

			
				
这个项目是基于 Tensorflow 实现的，目标是使用循环神经网络生成唐诗。  在这个项目中，你将学习如何使用 Tensorflow 实现循环神经网络，并且了解到如何在自然语言处理任务中使用它们。你将使用唐诗数据集进行模型...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值