【2021-2022 春学期】人工智能-作业5：卷积-池化-激活

最新推荐文章于 2024-11-01 17:13:19 发布
最新推荐文章于 2024-11-01 17:13:19 发布
阅读量137 收藏
点赞数 1
分类专栏： 人工智能作业 文章标签： 人工智能 深度学习 cnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Saturn_/article/details/125026840
版权

for循环版本：

import numpy as np
 
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)]
Kernel[0] = np.array([[1, -1, -1],
                      [-1, 1, -1],
                      [-1, -1, 1]])
Kernel[1] = np.array([[1, -1, 1],
                      [-1, 1, -1],
                      [1, -1, 1]])
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]]

Pytorch版本

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)
 
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.7503, -0.1385,  0.0837,  0.3059,  0.5281, -0.1385,  0.3059],
          [-0.1385,  0.9726, -0.1385,  0.3059, -0.1385,  0.0837, -0.1385],
          [ 0.0837, -0.1385,  0.9726, -0.3608,  0.0837, -0.1385,  0.5281],
          [ 0.3059,  0.3059, -0.3608,  0.5281, -0.3608,  0.3059,  0.3059],
          [ 0.5281, -0.1385,  0.0837, -0.3608,  0.9726, -0.1385,  0.0837],
          [-0.1385,  0.0837, -0.1385,  0.3059, -0.1385,  0.9726, -0.1385],
          [ 0.3059, -0.1385,  0.5281,  0.3059,  0.0837, -0.1385,  0.7503]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3379, -0.5510,  0.1157, -0.1066,  0.1157, -0.5510,  0.3379],
          [-0.5510,  0.5601, -0.5510,  0.3379, -0.5510,  0.5601, -0.5510],
          [ 0.1157, -0.5510,  0.5601, -0.7732,  0.5601, -0.5510,  0.1157],
          [-0.1066,  0.3379, -0.7732,  1.0045, -0.7732,  0.3379, -0.1066],
          [ 0.1157, -0.5510,  0.5601, -0.7732,  0.5601, -0.5510,  0.1157],
          [-0.5510,  0.5601, -0.5510,  0.3379, -0.5510,  0.5601, -0.5510],
          [ 0.3379, -0.5510,  0.1157, -0.1066,  0.1157, -0.5510,  0.3379]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3643, -0.0802,  0.5865,  0.3643,  0.1421, -0.0802,  0.8087],
          [-0.0802,  0.1421, -0.0802,  0.3643, -0.0802,  1.0309, -0.0802],
          [ 0.5865, -0.0802,  0.1421, -0.3024,  1.0309, -0.0802,  0.1421],
          [ 0.3643,  0.3643, -0.3024,  0.5865, -0.3024,  0.3643,  0.3643],
          [ 0.1421, -0.0802,  1.0309, -0.3024,  0.1421, -0.0802,  0.5865],
          [-0.0802,  1.0309, -0.0802,  0.3643, -0.0802,  0.1421, -0.0802],
          [ 0.8087, -0.0802,  0.1421,  0.3643,  0.5865, -0.0802,  0.3643]]]],
       grad_fn=<DivBackward0>)
--------------- 池化  ---------------
torch.Size([1, 1, 4, 4])
tensor([[[[0.9726, 0.3059, 0.5281, 0.3059],
          [0.3059, 0.9726, 0.3059, 0.5281],
          [0.5281, 0.3059, 0.9726, 0.0837],
          [0.3059, 0.5281, 0.0837, 0.7503]]]], grad_fn=<DivBackward0>)
tensor([[[[0.5601, 0.3379, 0.5601, 0.3379],
          [0.3379, 1.0045, 0.5601, 0.1157],
          [0.5601, 0.5601, 0.5601, 0.1157],
          [0.3379, 0.1157, 0.1157, 0.3379]]]], grad_fn=<DivBackward0>)
tensor([[[[0.3643, 0.5865, 1.0309, 0.8087],
          [0.5865, 0.5865, 1.0309, 0.3643],
          [1.0309, 1.0309, 0.1421, 0.5865],
          [0.8087, 0.3643, 0.5865, 0.3643]]]], grad_fn=<DivBackward0>)
--------------- 激活  ---------------
tensor([[[[0.7503, 0.0000, 0.0837, 0.3059, 0.5281, 0.0000, 0.3059],
          [0.0000, 0.9726, 0.0000, 0.3059, 0.0000, 0.0837, 0.0000],
          [0.0837, 0.0000, 0.9726, 0.0000, 0.0837, 0.0000, 0.5281],
          [0.3059, 0.3059, 0.0000, 0.5281, 0.0000, 0.3059, 0.3059],
          [0.5281, 0.0000, 0.0837, 0.0000, 0.9726, 0.0000, 0.0837],
          [0.0000, 0.0837, 0.0000, 0.3059, 0.0000, 0.9726, 0.0000],
          [0.3059, 0.0000, 0.5281, 0.3059, 0.0837, 0.0000, 0.7503]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3379, 0.0000, 0.1157, 0.0000, 0.1157, 0.0000, 0.3379],
          [0.0000, 0.5601, 0.0000, 0.3379, 0.0000, 0.5601, 0.0000],
          [0.1157, 0.0000, 0.5601, 0.0000, 0.5601, 0.0000, 0.1157],
          [0.0000, 0.3379, 0.0000, 1.0045, 0.0000, 0.3379, 0.0000],
          [0.1157, 0.0000, 0.5601, 0.0000, 0.5601, 0.0000, 0.1157],
          [0.0000, 0.5601, 0.0000, 0.3379, 0.0000, 0.5601, 0.0000],
          [0.3379, 0.0000, 0.1157, 0.0000, 0.1157, 0.0000, 0.3379]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3643, 0.0000, 0.5865, 0.3643, 0.1421, 0.0000, 0.8087],
          [0.0000, 0.1421, 0.0000, 0.3643, 0.0000, 1.0309, 0.0000],
          [0.5865, 0.0000, 0.1421, 0.0000, 1.0309, 0.0000, 0.1421],
          [0.3643, 0.3643, 0.0000, 0.5865, 0.0000, 0.3643, 0.3643],
          [0.1421, 0.0000, 1.0309, 0.0000, 0.1421, 0.0000, 0.5865],
          [0.0000, 1.0309, 0.0000, 0.3643, 0.0000, 0.1421, 0.0000],
          [0.8087, 0.0000, 0.1421, 0.3643, 0.5865, 0.0000, 0.3643]]]],
       grad_fn=<DivBackward0>)

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

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.imshow(img, cmap='gray')
plt.title('Kernel 1')
plt.show()
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.imshow(img, cmap='gray')
plt.title('Kernel 2')
plt.show()
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.imshow(img, cmap='gray')
plt.title('Kernel 3')
plt.show()
 
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.imshow(img, cmap='gray')
plt.title('卷积后的特征图1')
plt.show()
 
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.imshow(img, cmap='gray')
plt.title('卷积池化后的特征图1')
plt.show()
 
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.imshow(img, cmap='gray')
plt.title('卷积 + relu 后的特征图1')
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.7500, -0.1389,  0.0833,  0.3055,  0.5278, -0.1389,  0.3055],
          [-0.1389,  0.9722, -0.1389,  0.3055, -0.1389,  0.0833, -0.1389],
          [ 0.0833, -0.1389,  0.9722, -0.3611,  0.0833, -0.1389,  0.5278],
          [ 0.3055,  0.3055, -0.3611,  0.5278, -0.3611,  0.3055,  0.3055],
          [ 0.5278, -0.1389,  0.0833, -0.3611,  0.9722, -0.1389,  0.0833],
          [-0.1389,  0.0833, -0.1389,  0.3055, -0.1389,  0.9722, -0.1389],
          [ 0.3055, -0.1389,  0.5278,  0.3055,  0.0833, -0.1389,  0.7500]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3406, -0.5483,  0.1184, -0.1038,  0.1184, -0.5483,  0.3406],
          [-0.5483,  0.5629, -0.5483,  0.3406, -0.5483,  0.5629, -0.5483],
          [ 0.1184, -0.5483,  0.5629, -0.7705,  0.5629, -0.5483,  0.1184],
          [-0.1038,  0.3406, -0.7705,  1.0073, -0.7705,  0.3406, -0.1038],
          [ 0.1184, -0.5483,  0.5629, -0.7705,  0.5629, -0.5483,  0.1184],
          [-0.5483,  0.5629, -0.5483,  0.3406, -0.5483,  0.5629, -0.5483],
          [ 0.3406, -0.5483,  0.1184, -0.1038,  0.1184, -0.5483,  0.3406]]]],
       grad_fn=<DivBackward0>)
tensor([[[[ 0.3218, -0.1227,  0.5440,  0.3218,  0.0995, -0.1227,  0.7662],
          [-0.1227,  0.0995, -0.1227,  0.3218, -0.1227,  0.9884, -0.1227],
          [ 0.5440, -0.1227,  0.0995, -0.3449,  0.9884, -0.1227,  0.0995],
          [ 0.3218,  0.3218, -0.3449,  0.5440, -0.3449,  0.3218,  0.3218],
          [ 0.0995, -0.1227,  0.9884, -0.3449,  0.0995, -0.1227,  0.5440],
          [-0.1227,  0.9884, -0.1227,  0.3218, -0.1227,  0.0995, -0.1227],
          [ 0.7662, -0.1227,  0.0995,  0.3218,  0.5440, -0.1227,  0.3218]]]],
       grad_fn=<DivBackward0>)
--------------- 池化  ---------------
torch.Size([1, 1, 4, 4])
tensor([[[[0.9722, 0.3055, 0.5278, 0.3055],
          [0.3055, 0.9722, 0.3055, 0.5278],
          [0.5278, 0.3055, 0.9722, 0.0833],
          [0.3055, 0.5278, 0.0833, 0.7500]]]], grad_fn=<DivBackward0>)
tensor([[[[0.5629, 0.3406, 0.5629, 0.3406],
          [0.3406, 1.0073, 0.5629, 0.1184],
          [0.5629, 0.5629, 0.5629, 0.1184],
          [0.3406, 0.1184, 0.1184, 0.3406]]]], grad_fn=<DivBackward0>)
tensor([[[[0.3218, 0.5440, 0.9884, 0.7662],
          [0.5440, 0.5440, 0.9884, 0.3218],
          [0.9884, 0.9884, 0.0995, 0.5440],
          [0.7662, 0.3218, 0.5440, 0.3218]]]], grad_fn=<DivBackward0>)
--------------- 激活  ---------------
tensor([[[[0.7500, 0.0000, 0.0833, 0.3055, 0.5278, 0.0000, 0.3055],
          [0.0000, 0.9722, 0.0000, 0.3055, 0.0000, 0.0833, 0.0000],
          [0.0833, 0.0000, 0.9722, 0.0000, 0.0833, 0.0000, 0.5278],
          [0.3055, 0.3055, 0.0000, 0.5278, 0.0000, 0.3055, 0.3055],
          [0.5278, 0.0000, 0.0833, 0.0000, 0.9722, 0.0000, 0.0833],
          [0.0000, 0.0833, 0.0000, 0.3055, 0.0000, 0.9722, 0.0000],
          [0.3055, 0.0000, 0.5278, 0.3055, 0.0833, 0.0000, 0.7500]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3406, 0.0000, 0.1184, 0.0000, 0.1184, 0.0000, 0.3406],
          [0.0000, 0.5629, 0.0000, 0.3406, 0.0000, 0.5629, 0.0000],
          [0.1184, 0.0000, 0.5629, 0.0000, 0.5629, 0.0000, 0.1184],
          [0.0000, 0.3406, 0.0000, 1.0073, 0.0000, 0.3406, 0.0000],
          [0.1184, 0.0000, 0.5629, 0.0000, 0.5629, 0.0000, 0.1184],
          [0.0000, 0.5629, 0.0000, 0.3406, 0.0000, 0.5629, 0.0000],
          [0.3406, 0.0000, 0.1184, 0.0000, 0.1184, 0.0000, 0.3406]]]],
       grad_fn=<DivBackward0>)
tensor([[[[0.3218, 0.0000, 0.5440, 0.3218, 0.0995, 0.0000, 0.7662],
          [0.0000, 0.0995, 0.0000, 0.3218, 0.0000, 0.9884, 0.0000],
          [0.5440, 0.0000, 0.0995, 0.0000, 0.9884, 0.0000, 0.0995],
          [0.3218, 0.3218, 0.0000, 0.5440, 0.0000, 0.3218, 0.3218],
          [0.0995, 0.0000, 0.9884, 0.0000, 0.0995, 0.0000, 0.5440],
          [0.0000, 0.9884, 0.0000, 0.3218, 0.0000, 0.0995, 0.0000],
          [0.7662, 0.0000, 0.0995, 0.3218, 0.5440, 0.0000, 0.3218]]]],
       grad_fn=<DivBackward0>)
Saturn_
关注
专栏目录
[Python人工智能] 十八.Keras搭建卷积神经网络及CNN原理详解
杨秀璋的专栏
02-19 1万+
从本专栏开始，作者正式研究Python深度学习、神经网络及人工智能相关知识。前一篇文章详细讲解了Keras实现分类学习，以MNIST数字图片为例进行讲解。本篇文章详细讲解了卷积神经网络CNN原理，并通过Keras编写CNN实现了MNIST分类学习案例。基础性文章，希望对您有所帮助！
人工智能-作业5：卷积-池化-激活
jiaotshidi的博客
05-22 312
文章目录实现【卷积-池化-激活】代码，并分析总结1. For循环版本：手工实现 卷积-池化-激活2. Pytorch版本：调用函数完成 卷积-池化-激活3. 可视化：了解数字与图像之间的关系运行效果如下：原图卷积核特征图参考资料 实现【卷积-池化-激活】代码，并分析总结 使用不同的卷积核进行卷积 再进行最大池化，池化采用的是2×2的窗口，间隔为2 再使用relu函数进行激活，就是把负数都变成0，正数不变 以上就是进行一次卷积-池化-激活的过程。如果图片有卷积核的特征的话，明显了一些。通过多次的卷积-池
人工智能基础作业5：卷积-池化-激活
qq_46127366的博客
05-22 255
目录 实现【卷积-池化-激活】代码，并分析总结 一、for循环版本：手工实现 卷积-池化-激活 二、pytorch版本：调用函数完成 卷积-池化-激活 三、可视化：了解数字与图像之间的关系 参考链接 实现【卷积-池化-激活】代码，并分析总结 一、for循环版本：手工实现 卷积-池化-激活 代码： import numpy as np x = np.array([[-1, -1, -1, -1, -1, -1, -1, -1, -1], ...
【2021-2022 春学期】人工智能-作业6：CNN实现XO识别
lhy3112632的博客
05-23 284
文章目录一、数据集二、构建模型三、训练模型四、测试训练好的模型五、计算模型准确率六、查看训练好模型的特征图七、查看卷积核八、源码1.训练模型源码2.测试模型源码总结 一、数据集 二、构建模型 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 9, 3) self.maxpool = nn.MaxPool2
卷积-池化-激活
qq_45898993的博客
05-21 1149
文章目录01 实现卷积-池化-激活1.1 python实现1.2 Torch 实现1.3 实验结果02 图像可视化2.1 原图像2.2 卷积核2.3 特征图2.4 卷积+relu后的特征图2.5 实验源码03 总结Reference 01 实现卷积-池化-激活 CNN 会比较图片里的各个局部信息。在相似的位置上进行特征特征比对，会更好地分辨两张图片是否相同。 卷积 CNN提取局部信息的方式是通过卷积来实现的。具体的操作流程为 对于位置做乘法，得到 9 个值 9 个值进行相加 得到的值在除以 9 e
【22-23 春学期】AI作业9-卷积3-XO识别
Notebook
05-08 307
2.CNN实现XO识别（选做。有能力的同学，建议做一下。1. 编程实现例题（必做）
人工智能-作业4：CNN - 卷积
qq_53585999的博客
05-10 323
目录 一、卷积、卷积核、多通道、特征图、特征选择概念。 二、编程实现： 1.经典卷积核，实现灰度图的边缘检测、锐化、模糊 2.调整经典卷积核参数，测试并总结 3.使用不同尺寸图片，测试并总结 4.探索更多类型卷积核 5.尝试彩色图片边缘检测 一、卷积、卷积核、多通道、特征图、特征选择概念。 卷积：是通过两个函数，f和g生成第三个函数的一种数学运算，其本质是一种特殊的积分变换，表征函数f与g经过翻转和平移的重叠部分函数值乘积对重叠长度的积分 数学表达...
【22-23 春学期】AI作业10-经典卷积网络
qq_39898476的博客
06-25 101
ResNet通过引入残差块（Residual Block）来处理神经网络中的梯度消失和网络深度增加时的性能下降问题，使得神经网络可以训练更深的层数，从而在图像分类、物体检测、语音识别等任务中取得了极好的结果。总之，AlexNet提出了较深的神经网络结构和有效的训练技巧，为后续卷积神经网络的发展奠定了基础，在图像分类领域的广泛应用中具有重要意义。总之，AlexNet提出了较深的神经网络结构和有效的训练技巧，为后续卷积神经网络的发展奠定了基础，在图像分类领域的广泛应用中具有重要意义。
人工智能-作业6：CNN实现XO识别
还是小说有意思
05-26 549
训练模型 ​ 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.Grayscale(1), # 把
探讨Facebook的AI研究：未来社交平台的技术前瞻
LokiSan的博客
10-29 1388
在数字时代，社交媒体已成为人们日常生活的重要组成部分。作为全球最大的社交网络之一，Facebook不断致力于人工智能（AI）的研究与应用，以提升用户体验、增强平台功能并推动技术创新。本文将探讨Facebook在AI领域的研究方向及其对未来社交平台的潜在影响。
UOS AI 1.6 版本升级，如何实现精准搜索，效率翻倍？
vickynesss的博客
11-01 479
通过直接接入互联网的实时数据流，搜索结果变得多样化，不仅限于文字总结，还包括思维导图、事件与人物的综合概述，以及图片、视频、音频等多种形式，显著提高了回答的准确性和全面性。全局搜索全新搭载端侧大模型：支持离线自然语言搜索，无论身在何处，即使没有网络，只需通过快捷键“Shift+space(空格键）”唤醒全局搜索，都能轻松找到所需文件。：对于日常积累的海量截图，只需借助全局搜索功能，简要描述图片内的文字信息，便能迅速锁定并检索到所需图片。：重要信息直接添加到知识库，方便日后查阅，让全局搜索成为你的第二大脑。
基于Keras的U-Net模型在图像分割与计数中的应用
10-31 2056
网络结构优化：项目基于经典的U-Net模型进行改进，采用了更深的网络层次结构，使模型能够在多尺度上捕捉到图像中的细节信息。特别是针对医学图像分割，项目通过增加卷积层数和引入Dropout层来增强模型的特征提取能力，并有效防止过拟合，从而提高模型在训练数据较少情况下的表现。项目中采用了he_normal初始化器和relu激活函数组合，使得网络在训练时能够更快地收敛，降低梯度消失的风险。自定义数据增强策略：在中实现了一个自定义的图像增强类。
如何在 AI 时代打造你的核心竞争力？
最新发布
玉树芝兰
11-01 357
（注：本文为小报童精选文章。已订阅小报童或加入知识星球「玉树芝兰」用户请勿重复付费）焦虑在《AI 研究已摘得诺奖桂冠，普通科研工作者将何去何从？》一文中我谈过自己对目前 AI 技术浪潮对大众影响的体会——未来已来，只是分布不均。很多人在还没有意识到 AI 带来的变革潜能时，觉得与自己无关，日子该怎么过怎么过，倒也轻松。而一旦突然意识到 AI 的重要性，就会变得焦虑万分。这种焦虑，就是挣扎与思考在外...
人工智能—机器学习-图像处理
中段丸家
10-31 1102
使用深度学习算法来分析医学影像（如X光、CT扫描、MRI），帮助医生更快、更准确地做出诊断。：图像处理技术在自动驾驶汽车中至关重要，用于识别路标、行人和其他车辆。：通过机器学习分析监控视频，实时检测异常行为或可疑活动，提高安全性。：在身份验证和安防领域广泛应用，尤其在金融服务和个人设备解锁中。：利用图像处理技术提升用户体验，实现更沉浸的互动环境。
大模型系列——AlphaZero/强化学习/MCTS
hang on it more longer
10-29 1270
AlphaGo Zero无需任何人类历史棋谱，仅使用深度强化学习，从零开始训练三天的成就已远远超过了人类数千年积累的。
YoloV9改进策略：Block改进|RFE模块，提高小物体的识别精度|即插即用|代码+修改过程
m0_47867638的博客
10-29 434
本文介绍了一种基于YOLOv5的人脸检测方法，命名为YOLO-FaceV2。该方法旨在解决人脸检测中的尺度变化、简单与困难样本不平衡以及人脸遮挡等问题。通过引入一系列创新模块和损失函数，YOLO-FaceV2在WiderFace数据集上取得了优异的表现，特别是在小物体、遮挡和困难样本的检测上。
AI产品经理实战手册：策略、开发与商业化指南
清图出版
10-31 614
通过《AI产品经理手册》，将可以了解不同类型的AI，如何将AI整合到产品或业务中，以及支持创建AI产品或将AI集成到现有产品所需的基础设施。熟悉实践管理AI产品开发流程、评估和优化AI模型，以及应对与AI产品相关的复杂伦理和法律问题等相关知识。通过案例研究和学习，在快速发展的AI和机器学习领域保持领先地位。通过阅读本书，读者将能够从产品角度全面了解AI领域。
AI代币是什么？AI与Web3结合的未来方向在哪里？
BlockOne11的博客
10-30 1227
近两年随着人工智能的崛起，AI已经渗透到制造业、电商、广告、医药等各个行业，加密货币领域也不例外，人工智能与区块链的融合，让我们看到了独特的数字资产 — AI加密代币。它的流行始于2022年底，随着OpenAI智能聊天机器人ChatGPT的火爆，许多人意识到，人工智能不再只是出现在电影里面，更多的应用已经照进现实，AI已经作为一种高效的生产力应用到实际的产业中。人工智能狂热也影响了机构巨头。例如，谷歌宣布将着手开发自己的人工智能聊天机器人 Bard。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值