NNDL 实验六 卷积神经网络(2)基础算子

最新推荐文章于 2024-06-04 10:45:52 发布
最新推荐文章于 2024-06-04 10:45:52 发布
阅读量912 收藏
点赞数 2
文章标签： cnn 人工智能 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52551768/article/details/127472840
版权

目录

卷积神经网络的基础算子

卷积层算子

多通道卷积

多通道卷积层算子

卷积算子的参数量和计算量

汇聚层算子

选做题

使用pytorch实现Convolution Demo

总结

参考

卷积神经网络的基础算子

卷积神经网络是目前计算机视觉中使用最普遍的模型结构，如下图所示，由M个卷积层和b个汇聚层组合作用在输入图片上，在网络的最后通常会加入K个全连接层。

从上图可以看出，卷积网络是由多个基础的算子组合而成。下面我们先实现卷积网络的两个基础算子：卷积层算子和汇聚层算子。

首先我们实现卷积网络的两个基础算子：卷积层算子和汇聚层算子

卷积层算子

卷积层是指用卷积操作来实现神经网络中一层。

为了提取不同种类的特征，通常会使用多个卷积核一起进行特征提取。

多通道卷积

多通道卷积层算子

1. 多通道卷积卷积层的代码实现

2. Pytorch：torch.nn.Conv2d()代码实现

3. 比较自定义算子和框架中的算子

代码实现：

import torch
import torch.nn as nn

class Conv2D(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0,weight_attr=[],bias_attr=[]):
        super(Conv2D, self).__init__()
        # 创建卷积核
        weight_attr = torch.randn([out_channels, in_channels, kernel_size, kernel_size])
        weight_attr = torch.nn.init.constant(torch.tensor(weight_attr, dtype=torch.float32), val=1.0)
        self.weight = torch.nn.Parameter(weight_attr)
        # 创建偏置
        bias_attr = torch.zeros([out_channels, 1])
        bias_attr = torch.tensor(bias_attr, dtype=torch.float32)
        self.bias = torch.nn.Parameter(bias_attr)
        self.stride = stride
        self.padding = padding
        # 输入通道数
        self.in_channels = in_channels
        # 输出通道数
        self.out_channels = out_channels

    # 基础卷积运算
    def single_forward(self, X, weight):
        # 零填充
        new_X = torch.zeros([X.shape[0], X.shape[1]+2*self.padding, X.shape[2]+2*self.padding])
        new_X[:, self.padding:X.shape[1]+self.padding, self.padding:X.shape[2]+self.padding] = X
        u, v = weight.shape
        output_w = (new_X.shape[1] - u) // self.stride + 1
        output_h = (new_X.shape[2] - v) // self.stride + 1
        output = torch.zeros([X.shape[0], output_w, output_h])
        for i in range(0, output.shape[1]):
            for j in range(0, output.shape[2]):
                output[:, i, j] = torch.sum(new_X[:, self.stride*i:self.stride*i+u, self.stride*j:self.stride*j+v]*weight, [1, 2])
        return output

    def forward(self, inputs):
        """
        输入：
            - inputs：输入矩阵，shape=[B, D, M, N]
            - weights：P组二维卷积核，shape=[P, D, U, V]
            - bias：P个偏置，shape=[P, 1]
        """
        feature_maps = []
        # 进行多次多输入通道卷积运算
        p=0
        for w, b in zip(self.weight, self.bias): # P个(w,b),每次计算一个特征图Zp
            multi_outs = []
            # 循环计算每个输入特征图对应的卷积结果
            for i in range(self.in_channels):
                single = self.single_forward(inputs[:, i, :, :], w[i])
                multi_outs.append(single)
                # print("Conv2D in_channels:",self.in_channels,"i:",i,"single:",single.shape)
            # 将所有卷积结果相加
            feature_map = torch.sum(torch.stack(multi_outs), 0) + b  # Zp
            feature_maps.append(feature_map)
            # print("Conv2D out_channels:",self.out_channels, "p:",p,"feature_map:",feature_map.shape)
            p+=1
        # 将所有Zp进行堆叠
        out = torch.stack(feature_maps, 1)
        return out

inputs = torch.tensor([[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
               [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]])
conv2d = Conv2D(in_channels=2, out_channels=3, kernel_size=2)
print("inputs shape:", inputs.shape)
outputs = conv2d(inputs)
print("Conv2D outputs shape:", outputs.shape)

# 比较与torch API运算结果
weight_attr = torch.ones([3, 2, 2, 2])
bias_attr = torch.zeros([3, 1])
bias_attr = torch.tensor(bias_attr,dtype=torch.float32)
conv2d_torch = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=2, bias=True)
conv2d_torch.weight = torch.nn.Parameter(weight_attr)
outputs_torch = conv2d_torch(inputs)
# 自定义算子运算结果
print('Conv2D outputs:', outputs)
# torch API运算结果
print('nn.Conv2D outputs:', outputs_torch)

实现效果：

inputs shape: torch.Size([1, 2, 3, 3])
Conv2D outputs shape: torch.Size([1, 3, 2, 2])
Conv2D outputs: tensor([[[[20., 28.],
          [44., 52.]],

         [[20., 28.],
          [44., 52.]],

         [[20., 28.],
          [44., 52.]]]], grad_fn=<StackBackward0>)
nn.Conv2D outputs: tensor([[[[20.0537, 28.0537],
          [44.0537, 52.0537]],

         [[20.1784, 28.1784],
          [44.1784, 52.1784]],

         [[20.1576, 28.1576],
          [44.1576, 52.1576]]]], grad_fn=<ConvolutionBackward0>)

卷积算子的参数量和计算量

卷积层的参数量计算

卷积核（kernel）的参数量：H_k\times W_k

滤波器（filter）的参数量：C_{out}\times H_k\times W_k\times C_{in}

bias参数量：C_{out}

总的参数量：C_{out}\times H_k\times W_k\times C_{in}+C_{out}

卷积操作的计算量

乘法计算量：为了得到输出feature map的一个像素点，需要进行H_k\times W_k\times C_{in}​次乘法操作。因此为了得到整个输出feature map，需要进行H_k\times W_k\times C_{in}\times W_{out}\times C_{out} \times H_{out}

加法计算量：为了得到输出feature map的一个像素点，需要进行C_{in}\times (H_k\times W_k-1)+(C_{in}-1)+1=C_{in}\times H_k\times W_k次加法操作。注意最后一个1是bias。因此为了得到整个输出feature map，需要进行H_k\times W_k\times C_{in}\times W_{out}\times C_{out} \times H_{out}次加法。

可以发现，加法与乘法计算量是一样的。

参考：卷积中参数量和计算量

汇聚层算子

汇聚层的作用是进行特征选择，降低特征数量，从而减少参数数量。由于汇聚之后特征图会变得更小，如果后面连接的是全连接层，可以有效地减小神经元的个数，节省存储空间并提高计算效率。

常用的汇聚方法有两种，分别是：平均汇聚和最大汇聚。

  • 平均汇聚：将输入特征图划分为2×22×2大小的区域，对每个区域内的神经元活性值取平均值作为这个区域的表示；
  • 最大汇聚：使用输入特征图的每个子区域内所有神经元的最大活性值作为这个区域的表示。

如图给出了两种汇聚层的示例：

 

汇聚层的参数量和计算量

由于汇聚层中没有参数，所以参数量为0；最大汇聚中，没有乘加运算，所以计算量为0，而平均汇聚中，输出特征图上每个点都对应了一次求平均运算。

1. 代码实现一个简单的汇聚层。 

2. torch.nn.MaxPool2d()；torch.nn.avg_pool2d()代码实现

3. 比较自定义算子和框架中的算子

代码实现：

import torch
import torch.nn as nn

class Pool2D(nn.Module):
    def __init__(self, size=(2, 2), mode='max', stride=1):
        super(Pool2D, self).__init__()
        # 汇聚方式
        self.mode = mode
        self.h, self.w = size
        self.stride = stride

    def forward(self, x):
        output_w = (x.shape[2] - self.w) // self.stride + 1
        output_h = (x.shape[3] - self.h) // self.stride + 1
        output = torch.zeros([x.shape[0], x.shape[1], output_w, output_h])
        # 汇聚
        for i in range(output.shape[2]):
            for j in range(output.shape[3]):
                # 最大汇聚
                if self.mode == 'max':
                    value_m = max(torch.max(x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h], 3).values[0][0])
                    output[:, :, i, j] = torch.tensor(value_m)
                # 平均汇聚
                elif self.mode == 'avg':
                    value_m = max(torch.mean(x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h],
                        3)[0][0])
                    output[:, :, i, j] = torch.tensor(value_m)

        return output

# 1.实现一个简单汇聚层
inputs = torch.tensor([[[[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [13., 14., 15., 16.]]]])
pool2d = Pool2D(stride=2)
outputs = pool2d(inputs)
print("input: {}, \noutput: {}".format(inputs.shape, outputs.shape))
# 比较Maxpool2D与torch API运算结果
maxpool2d_torch = nn.MaxPool2d(kernel_size=(2, 2), stride=2)
outputs_torch = maxpool2d_torch(inputs)
# 自定义算子运算结果
print('Maxpool2D outputs:', outputs)
# torch API运算结果
print('nn.Maxpool2D outputs:', outputs_torch)

avgpool2d_torch = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
outputs_torch = avgpool2d_torch(inputs)
pool2d = Pool2D(mode='avg', stride=2)
outputs = pool2d(inputs)
# 自定义算子运算结果
print('Avgpool2D outputs:', outputs)
# torch API运算结果
print('nn.Avgpool2D outputs:', outputs_torch)

实现结果：

input: torch.Size([1, 1, 4, 4]), 
output: torch.Size([1, 1, 2, 2])
Maxpool2D outputs: tensor([[[[ 6.,  8.],
          [14., 16.]]]])
nn.Maxpool2D outputs: tensor([[[[ 6.,  8.],
          [14., 16.]]]])
Avgpool2D outputs: tensor([[[[ 5.5000,  7.5000],
          [13.5000, 15.5000]]]])
nn.Avgpool2D outputs: tensor([[[[ 3.5000,  5.5000],
          [11.5000, 13.5000]]]])

Process finished with exit code 0

汇聚层的参数量和计算量

由于汇聚层中没有参数，所以参数量为0；

最大汇聚中，没有乘加运算，所以计算量为0，

平均汇聚中，输出特征图上每个点都对应了一次求平均运算。

选做题

使用pytorch实现Convolution Demo

翻译图片中的内容

 翻译：卷积演示。下面是conv层的运行演示。由于3D体积很难进行可视化，所有体积（输入体积（蓝色）、权重体积（红色）、输出体积（绿色））都会可视化，每个深度切片都会成行堆叠。输入体积的大小为W_1＝5，H_1＝5，D_1＝3，conv层参数为K＝2，F＝3，S＝2，P＝1。也就是说，我们有两个大小为3 X 3的过滤器，它们是应用的参数，它们是K＝2、F＝3、S＝2、P＝1的。也就是，我们有2个大小为3X 3的滤波器，它们被应用于输入体积的填充。P＝1应用于输入容积，使输入体积的外边界为零。P=1的填充应用于输入体积，使输入体积的外边界为零。将高亮显示的输入（蓝色）与过滤器（红色）按元素相乘，相加，然后将结果除以偏差。

代码实现下图

首先观察上面图片可以看出，输入的矩阵最外面一圈都是零，即可以看作是对蓝色矩阵数据进行了零填充操作，使得其尺寸变大，避免输出特征缩减，实现这个Demo即实现多通道卷积算子，只需要将对应矩阵，卷积核等参数输入即可。

实现代码：

import torch
import torch.nn as nn

class Conv2D(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, weight_attr=[], bias_attr=[]):
        super(Conv2D, self).__init__()
        self.weight = torch.nn.Parameter(weight_attr)
        self.bias = torch.nn.Parameter(bias_attr)
        self.stride = stride
        self.padding = padding
        # 输入通道数
        self.in_channels = in_channels
        # 输出通道数
        self.out_channels = out_channels

    # 基础卷积运算
    def single_forward(self, X, weight):
        # 零填充
        new_X = torch.zeros([X.shape[0], X.shape[1]+2*self.padding, X.shape[2]+2*self.padding])
        new_X[:, self.padding:X.shape[1]+self.padding, self.padding:X.shape[2]+self.padding] = X
        u, v = weight.shape
        output_w = (new_X.shape[1] - u) // self.stride + 1
        output_h = (new_X.shape[2] - v) // self.stride + 1
        output = torch.zeros([X.shape[0], output_w, output_h])
        for i in range(0, output.shape[1]):
            for j in range(0, output.shape[2]):
                output[:, i, j] = torch.sum(new_X[:, self.stride*i:self.stride*i+u, self.stride*j:self.stride*j+v]*weight, [1, 2])
        return output

    def forward(self, inputs):
        """
        输入：
            - inputs：输入矩阵，shape=[B, D, M, N]
            - weights：P组二维卷积核，shape=[P, D, U, V]
            - bias：P个偏置，shape=[P, 1]
        """
        feature_maps = []
        # 进行多次多输入通道卷积运算
        p=0
        for w, b in zip(self.weight, self.bias): # P个(w,b),每次计算一个特征图Zp
            multi_outs = []
            # 循环计算每个输入特征图对应的卷积结果
            for i in range(self.in_channels):
                single = self.single_forward(inputs[:, i, :, :], w[i])
                multi_outs.append(single)
                # print("Conv2D in_channels:",self.in_channels,"i:",i,"single:",single.shape)
            # 将所有卷积结果相加
            feature_map = torch.sum(torch.stack(multi_outs), 0) + b  # Zp
            feature_maps.append(feature_map)
            # print("Conv2D out_channels:",self.out_channels, "p:",p,"feature_map:",feature_map.shape)
            p += 1
        # 将所有Zp进行堆叠
        out = torch.stack(feature_maps, 1)
        return out

# 传入矩阵参数
Input_Volume = torch.tensor([[[0, 1, 1, 0, 2], [2, 2, 2, 2, 1], [1, 0, 0, 2, 0], [0, 1, 1, 0, 0], [1, 2, 0, 0, 2]],
                             [[1, 0, 2, 2, 0], [0, 0, 0, 2, 0], [1, 2, 1, 2, 1], [1, 0, 0, 0, 0], [1, 2, 1, 1, 1]],
                             [[2, 1, 2, 0, 0], [1, 0, 0, 1, 0], [0, 2, 1, 0, 1], [0, 1, 2, 2, 2], [2, 1, 0, 0, 1]]])
Input_Volume = Input_Volume.reshape([1, 3, 5, 5])

# 创建卷积核
# 第一层卷积核
weight_attr1 = torch.tensor([[[-1, 1, 0], [0, 1, 0], [0, 1, 1]], [[-1, -1, 0], [0, 0, 0], [0, -1, 0]],
                             [[0, 0, -1], [0, 1, 0], [1, -1, -1]]], dtype=torch.float32)
weight_attr1 = weight_attr1.reshape([1, 3, 3, 3])
# 第二层卷积核
weight_attr2 = torch.tensor([[[1, 1, -1], [-1, -1, 1], [0, -1, 1]], [[0, 1, 0], [-1, 0, -1], [-1, 1, 0]],
                             [[-1, 0, 0], [-1, 0, 1], [-1, 0, 0]]], dtype=torch.float32)
weight_attr2 = weight_attr2.reshape([1, 3, 3, 3])

# 创建偏置1，2
bias_attr1 = torch.tensor(torch.ones([3, 1]))
bias_attr2 = torch.tensor(torch.zeros([3, 1]))

# 第一层卷积的计算
conv2d_1 = Conv2D(in_channels=3, out_channels=3, kernel_size=3, stride=2, padding=1, weight_attr=weight_attr1, bias_attr=bias_attr1)
output1 = conv2d_1(Input_Volume)
print("第一层卷积,卷积核Filter　W0的输出结果为:\n", output1)
# 第二层卷积的计算
conv2d_2 = Conv2D(in_channels=3, out_channels=2, kernel_size=3, stride=2, padding=1, weight_attr=weight_attr2, bias_attr=bias_attr2)
output2 = conv2d_2(Input_Volume)
print("使用卷积核Filter　W1的输出结果为:\n", output2)

实现结果：

第一层卷积,卷积核Filter　W0的输出结果为:
 tensor([[[[ 6.,  7.,  5.],
          [ 3., -1., -1.],
          [ 2., -1.,  4.]]]], grad_fn=<StackBackward0>)
使用卷积核Filter　W1的输出结果为:
 tensor([[[[ 2., -5., -8.],
          [ 1., -4., -4.],
          [ 0., -5., -5.]]]], grad_fn=<StackBackward0>)

对照结果，代码实现结果与所计算的结果相同，说明实现成功。

总结

本次实验主要是对多通道卷积算子进行实现实验，以及学习汇聚层算子参数量和计算量如何计算，在对这些知识的框架进行学习后其实本次实验已经可以说是完成了，但是我个人认为最后的选做题目是十分有意义的，本次的选做相当于为前面实验学习知识的巩固所给出的一道例题，在做完选做题后，我才真正感觉掌握了这节实验的知识！

参考

魏老师，NNDL 实验六 卷积神经网络（2）基础算子

NNDL 实验5（上） - HBU_DAVID - 博客园 (cnblogs.com)

白小码i
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
相量的加减乘除计算
weixin_42550185的博客
04-18 1万+
相量的加减乘除计算。改变阻抗，即可改变功率因素。
数值计算 - 计算量
Garson的博客
05-20 437
我们把作一次浮点数的乘法运算连同一次加法运算的计算量作为计算量的计量单位。
PTA_02线性结构2 一元多项式的乘法与加法运算
sxycylq的博客
09-22 1530
PTA_02_线性结构2_ 一元多项式的乘法与加法运算 问题： 设计函数分别求两个一元多项式的乘积与和。 输入格式： 输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。 输出格式： 输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。 输入样例： 4 3 4 -5 2 6 1 -2 0 3 5 20 -7 4 3 1 /
PTA 习题3.6 一元多项式的乘法与加法运算
m0_62283830的博客
08-19 4688
PTA 习题3.6 一元多项式的乘法与加法运算
题02-线性结构2 一元多项式的乘法与加法运算（C语言）
denglongjiao的博客
09-07 1529
题02-线性结构2 一元多项式的乘法与加法运算（C语言）
NNDL 实验六 卷积神经网络（2）基础算子
staceey的博客
10-26 127
NNDL 实验六 卷积神经网络（2）基础算子
实验环境5-1所需要的nndl包
10-28
实验环境5-1所需要的nndl包
邱锡鹏著 《神经网络与深度学习》案例与实践实验1-5中所需的nndl包
11-10
如出现如下问题均可导入nndl包均...1、实验中出现from nndl.dataset import load_data报错的 2、No module named 'nndl' 3、运行是显示ModuleNotFoundError: No module named 'nndl' 去下载nndl这个模块的时候显示没有
NNDL:神经网络和深度学习课程回购
04-12
神经网络神经网络和深度学习课程库。 它包含以下问题：找到函数f（x）= x 4 + 3 * x 2 + 10的全局最小值。作业2： 它包含以下问题：找到函数f（x，y）= x 2 + y 2 + 10的x和y的全局最优点。作业3： 它包括对点采样的...
NNDL:神经网络与深度学习
03-07
NNDL:神经网络与深度学习
神经⽹络与深度学习nndl-ebook.zip
05-14
从浅层的神经网络，循序渐进过度到深层的深度神经网络
RNN, LSTM, GRU模型的作用, 构建, 优劣势比较,attention机制
热门推荐
码python的Vinsmoke
10-29 2万+
1. RNN架构解析 1.1 认识RNN模型 学习目标 了解什么是RNN模型. 了解RNN模型的作用. 了解RNN模型的分类. 什么是RNN模型 RNN(Recurrent Neural Network), 中文称作循环神经网络, 它一般以序列数据为输入, 通过网络内部的结构设计有效捕捉序列之间的关系特征, 一般也是以序列形式进行输出. 一般单层神经网络结构: RNN单层网络结构: 以时间步对RNN进行展开后的单层网络结构: RNN的循环机制使模型隐层上一时间步产..
强化学习——学习笔记3
qq_52302919的博客
05-29 1744
先上图：在上述流程图中所说的Q表即为下表：假设我们在玩一个小游戏，该游戏有上下左右不同的动作，同时也会有不同的状态，比如游戏结束等。Q表也可以称为状态-价值函数QsaQ(s,a)Qsa：这个表格的每一行代表每个 state上述例子中的游戏结束等，每一列代表每个 action上述例子中的上下左右，表格的数值就是在各个 state 下采取各个 action 时能够获得的最大的未来期望奖励。
pytorch学习笔记5
drarad的博客
06-02 1288
前向钩子（forward hook）在模块的前向传播开始时触发，前向后钩子（forward pre-hook）在前向传播之前触发，反向钩子（backward hook）在反向传播过程中触发。总结来说，钩子提供了一种在 PyTorch 模型的执行过程中插入自定义代码的方法，使得用户可以灵活地调试、监控和扩展模型的功能。作用: 这是一个内部的 C 语言指针，指向张量在底层库（通常是 C++ 实现的 PyTorch 核心）中的具体数据结构。这些钩子可以在张量的梯度计算之前或之后执行自定义的操作。
AI推文神器，绘唐ai，文刻创作出品，sdmj二合一虹猫
2401_84285498的博客
05-28 779
然而，值得注意的是，AI推文神器虽然能够生成高质量的推文内容，但仍然需要人类的审查和修改。因为它虽然能够模仿人类的写作风格，但仍然无法完全理解人类的情感和语境，因此在使用AI推文神器时，人类编辑和审阅的角色仍然十分重要，以确保推文的准确性和符合品牌形象。AI推文神器的工作原理是通过自然语言处理和机器学习算法，将用户输入的关键词、主题或简要描述转化为语义信息，然后结合相关数据和模型，生成相应的推文内容。它通过分析大量的文字和数据，学习并模仿人类的写作风格和推文技巧，从而能够生成独特、有吸引力的推文内容。
AI Agent：人类工作范式的颠覆者还是人机协作新范式？
Baihai_IDP的博客
05-29 950
生成式 AI 只是人工智能发展的开端，未来可能会出现更先进的 AI 智能体系统（AI Agent），我们应当重视 Andrew Ng（译者注：Andrew Ng 是斯坦福大学计算机科学系和电气工程系的客座教授，曾任斯坦福人工智能实验室主任。作者相信人工智能的未来必将呈现出更智能、更自主的 AI Agent 形态。但是 AI Agent 强调的是综合智能，包括但不限于决策制定、环境交互和跨领域的知识应用，这样的智能系统能够适应更复杂的任务需求，并在与人的交流合作中展现出更强的灵活性和实用性。
AI降痕工具使用指南：如何有效降低AIGC疑似度
最新发布
Lindapaper的博客
06-04 414
AI去痕技术正悄然改变学术写作的面貌。它通过消除AI代写论文中的明显特征，如强逻辑词汇和过于规整的句子结构，帮助作者创造出更加自然、流畅的学术作品。这项技术的应用，不仅提高了论文的原创性，还增强了学术诚信，使学术界的发展更加健康和可持续。AI去痕，作为学术界的隐形守护者，正在为学术写作的原创性和创新性保驾护航。
Python热重载调试新利器
weixin_53707653的博客
06-03 448
Reloading是一个Python工具库，它让我们可以在每次迭代之前从源代码中重新加载（或函数）而不丢失任何当前已执行过程。该工具对于在深度学习模型训练期间编辑源代码尤其好用，它让我们可以添加日志记录、打印统计数据或保存模型，而无需重新启动训练。
2、编程练习：利用卷积神经网络，处理MNIST 数据集分类问题。 https://github.com/nndl/exercise/
05-04
好的，以下是处理 MNIST 数据集分类问题的卷积神经网络的代码： ```python import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # 加载 MNIST 数据集 mnist = input_data.read_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值