繁依Fanyi0

这个屌丝很懒，什么也没留下！

热门标签

神经网络笔记_输入层隐藏层输出层

作者：繁依Fanyi0 | 2024-03-26 02:15:33

踩

输入层隐藏层输出层

神经网络笔记

https://keras-cn.readthedocs.io/en/latest/getting_started/sequential_model/#sequential

该笔记，作为人工智能汇报的蓝本，亦作为作者的学习笔记

欢迎指点

简单神经网络

神经单元

在神经网络中，当输入为x1、x2、x3时，神经单元将它们如下整合为加权输入z，通过激活函数a(z)来处理。z1=w1x1+w2x2+w3x3+b（w1、w2、w3为权重，b为偏置）

a1=a(z1)

此时，权重w1、w2、w3与偏置b为参数，输入x1、x2、x3、加权输入z1、神经单元的输出a1为变量，变量的值根据学习数据的学习实例而变化。

？？？

参数介绍x，w，b，z，a

激活函数的概念

偏置是什么？阈值的负数

单个神经元的参数表达式–>一个完整神经网络

在这里插入图片描述

神经网络的参数和变量

建立一个神经网络，用来识别通过4×3像素的图像读取的手写数字0和1，其中像素是单色二值。

例题图像

简单的分为三层

输入层、隐藏层、输出层

对于此类问题，输入层和输出层的神经单元个数往往是很好确定的

4*3的像素输入12个单元

mnist数据集28*28所以输入为784unit

0-1分类输出2个单元

mnist手写数字识别范围0-9因此输出10unit

重点

对于隐藏层而言

层数，每层的神经单元个数是影响神经网络的重要因素

关于隐藏层的神经单元的个数，这点往往凭借经验，基本介于输入层和输出层个数之间

对于每层的神经单元又可以套用上述公式依次建立层与层之间的参数关系

z1=w1x1+w2x2+w3x3+b（w1、w2、w3为权重，b为偏置）

a1=a(z1)

所有问题，从实际生活中抽象出，数学解释，数学模型，参数解释，

很喜欢姚老师的一句话：神经网络是对现实生活的模拟

参数含义

注意右上角的参数表示处于第几层，不是 l次方

不同于之前的单个神经单元的参数，由于涉及到了分层所以在右上角加上了层数上标

在这里插入图片描述

神经网络变量的关系式

以上述例题为例

输入层的关系

在这里插入图片描述

隐藏层的关系

在这里插入图片描述

输出层的关系

在这里插入图片描述

学习数据和正解

预测解和正解的关系

预测解是神经网络算出的解

正解是实际的值

在这里插入图片描述

误差函数

又称代价函数、损失函数

均方误差

在线性回归中，最常用的是均方误差(Mean squared error)，具体形式为：

MSE

m：训练样本的个数；

hθ(x)：用参数θ和x预测出来的y值；

y：原训练样本中的y值，也就是标准答案

上角标(i)：第i个样本

交叉熵

在逻辑回归中，最常用的是代价函数是交叉熵(Cross Entropy)，交叉熵是一个常见的代价函数，在神经网络中也会用到。下面是《神经网络与深度学习》一书对交叉熵的解释：

交叉熵是对「出乎意料」（译者注：原文使用suprise）的度量。神经元的目标是去计算函数y, 且y=y(x)。但是我们让它取而代之计算函数a, 且a=a(x)。假设我们把a当作y等于1的概率，1−a是y等于0的概率。那么，交叉熵衡量的是我们在知道y的真实值时的平均「出乎意料」程度。当输出是我们期望的值，我们的「出乎意料」程度比较低；当输出不是我们期望的，我们的「出乎意料」程度就比较高。

交叉熵

你暂时不需要理解这是什么，只要明白在某些条件下这是更有效的误差函数

最优化的基础：误差函数的最小化

对于每个样本我们都可以得到一个误差

所有样本的误差之和求最小值，实现最优化

代价函数

对于一般的误差函数

比如一个简单线性回归问题

三个样本（点）求解线性回归函数

y=px+q

得到误差函数之后我们可以求导求解

实际上就是解参数p、q

介绍参数规模

参数规模

对于我们的神经网络，即使是简单的结构也依然难以求解

参数很多

对于损失函数最优解的求解很困难

一般方法求导数，将面临导数地狱的困境

对于每个参数都要求偏导数，上题就要联立47个方程

应声而来的

梯度下降法

梯度、学习率

误差反向传播法

以梯度下降法为基础

卷积神经网络

卷积

模式、过滤器、卷积、特征映射

对于2这个图像

我们设定一种模式S作为过滤器

过滤器

用过滤器S扫描图像2

2的特征映射

这就是根据过滤器S得到的卷积（convolution）的结果，称为特征映射（feature map）

这样的过滤器的计算称为卷积

2的卷积

加权输入

激活函数

卷积层的各个神经单元通过激活函数来处理加权输入，并将处理结果作为神经单元的输出。这样卷积层的处理就完成了。
在这里插入图片描述

池化

通过池化进行信息压缩

压缩的方法十分简单，只需要将卷积层神经单元划分为不重叠的2×2的区域，然后在各个区域中计算出代表值即可。本书中我们使用最有名的信息压缩方法最大池化（max pooling），具体来说就是将划分好的各区域的最大值提取出来。

整个卷积网络的过程

通过指定的过滤器S得到图像的特征映射

映射结果加上偏置b，得到加权输入

加权输入Z通过激活函数得到卷积层输出

通过池化方法得到池化层结果（池化层往往是筛选，max、avg）

2的卷积池化过程

卷积神经网络的变量关系式

卷积层上标F

池化层上标P

输出层上标O

建立一个神经网络，用来识别通过6×6像素的图像读取的手写数字1、2、3。图像像素为单色二值。学习数据为96张图像。

2的过程

参数规定

参数规定

与神经网络不同的是，卷积神经网络中考虑的参数增加了过滤器这个新的成分

输入层

a上标l为Input

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-caYbuhHb-1621473923408)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210515232939540.png)]$

过滤器和卷积层

F为Filter的首字母

过滤器也称为核（kernel）

在这里插入图片描述

我们利用这些过滤器进行卷积处理，将输入层从左上角开始的3×3区域与过滤器1的对应分量相乘，得到下面的卷积值（c为convolution的首字母）。

在这里插入图片描述

一般地，使用过滤器k的卷积的结果可以如下表示。这里的i、j为输入层中与过滤器对应的区域的起始行列编号（i、j为4以下的自然数）

在这里插入图片描述

这样得到的数值集合就形成特征映射。

给上偏置b

在这里插入图片描述

激活函数

在这里插入图片描述

即

在这里插入图片描述

####池化层

以最大池化为例

在2*2内max

池化层这里只做筛选，a=z

在这里插入图片描述

输出层

与之前的神经网络一样，它们接收来自上一层（池化层）的所有神经单元的箭头（即全连接）。

这样就可以综合地考察池化层的神经单元的信息。

在这里插入图片描述

激活函数

在这里插入图片描述

代价函数

在这里插入图片描述

实战 mnist手写数字识别

基于Keras的手写体识别

认识数据集

http://yann.lecun.com/exdb/mnist/

简单介绍

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
1

训练集

train_images(60000,28,28)

在该数据集中每张图片由28x28个像素点构成，每个像素点用一个灰度值（0-255）表示。

在这里插入图片描述

train_labels(60000,)

标签值代表对应数值

例如 train_labels[0]=5，train_images[0]对应的图片内容为5

测试集

test_images(10000,28,28)

test_labels(10000,)

数据集的修改

#reshape-train_images本来是60000x28x28的数组，把它转换成60000x784的二维数组
#astype-将它的元素类型转换为float
train_images = train_images.reshape((60000, 28*28)).astype('float')
test_images = test_images.reshape((10000, 28*28)).astype('float')
#把train_labels转换成了60000x10的数组
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
1
2
3
4
5
6
7

简单的全连接网络

Keras的核心数据结构是“模型”，模型是一种组织网络层的方式。Keras中主要的模型是Sequential模型，Sequential是一系列网络层按顺序构成的栈。

from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils import to_categorical
# from keras import models, layers, regularizers
from keras.optimizers import RMSprop, SGD, Adam
from keras.datasets import mnist
import matplotlib.pyplot as plt

# 加载数据集
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# print(train_images.shape, test_images.shape)
# print(train_images[0])
# print(train_labels[0])-
# plt.imshow(train_images[0])
# plt.show()

train_images = train_images.reshape(60000, 28 * 28).astype('float')
test_images = test_images.reshape(10000, 28 * 28).astype('float')
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# print(train_images.shape)
# print(train_labels[0])

#将一些网络层通过.add()堆叠起来，就构成了一个模型：
model = Sequential()

model.add(Dense(input_dim=28 * 28, units=20, activation='sigmoid'))

model.add(Dense(units=10, activation='softmax'))

#输出模型各层的参数状况
model.summary()

#完成模型的搭建后，我们需要使用.compile()方法来编译模型：
model.compile(loss='mse', optimizer=SGD(lr=0.1), metrics=['accuracy'])

#完成模型编译后，我们在训练数据上按batch进行一定次数的迭代来训练网络
model.fit(train_images, train_labels, batch_size=100, epochs=10)

#随后，我们可以使用一行代码对我们的模型进行评估，看看模型的指标是否满足我们的要求
result = model.evaluate(test_images, test_labels)

# print(result)
# result[0] loss
# result[1] acc
print('\nTest Loss:%.2f%%' % (result[0] * 100))
print('\nTest Acc:%.2f%%' % (result[1] * 100))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

在这里插入图片描述

Epoch 1/10
600/600 [==============================] - 0s 610us/step - loss: 0.0757 - accuracy: 0.4790
Epoch 2/10
600/600 [==============================] - 0s 673us/step - loss: 0.0581 - accuracy: 0.6789
Epoch 3/10
600/600 [==============================] - 0s 607us/step - loss: 0.0479 - accuracy: 0.7366
Epoch 4/10
600/600 [==============================] - 0s 595us/step - loss: 0.0409 - accuracy: 0.7749
Epoch 5/10
600/600 [==============================] - 0s 603us/step - loss: 0.0361 - accuracy: 0.8016
Epoch 6/10
600/600 [==============================] - 0s 723us/step - loss: 0.0324 - accuracy: 0.8269
Epoch 7/10
600/600 [==============================] - 0s 680us/step - loss: 0.0294 - accuracy: 0.8467
Epoch 8/10
600/600 [==============================] - 0s 598us/step - loss: 0.0271 - accuracy: 0.8590
Epoch 9/10
600/600 [==============================] - 0s 590us/step - loss: 0.0254 - accuracy: 0.8672
Epoch 10/10
600/600 [==============================] - 0s 691us/step - loss: 0.0238 - accuracy: 0.8731
313/313 [==============================] - 0s 440us/step - loss: 0.0233 - accuracy: 0.8757
Test Loss:2.33%
Test Acc:87.57%
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#查看神经网络结构 参数个数
model.summary()
1
2

影响因子

####1神经网络层数

#加入一层隐藏层，神经单元个数为20
model = Sequential()
model.add(Dense(input_dim=28 * 28, units=20, activation='sigmoid'))
model.add(Dense(units=20, activation='sigmoid'))
model.add(Dense(units=10, activation='softmax'))
1
2
3
4
5

test1:

Test Loss:6.76%
Test Acc:65.72%

test2:

Test Loss:7.03%
Test Acc:49.81%

test3:

Test Loss:7.05%
Test Acc:56.46%

#再次加入一层隐藏层
model = Sequential()
model.add(Dense(input_dim=28 * 28, units=20, activation='sigmoid'))
model.add(Dense(units=20, activation='sigmoid'))
model.add(Dense(units=20, activation='sigmoid'))
model.add(Dense(units=10, activation='softmax'))
1
2
3
4
5
6

test4:

Test Loss:8.89%
Test Acc:28.68%

当加到十层时

test5:

Test Loss:9.00%
Test Acc:11.35%

相当惨淡的准确率！

以Sigmoid为激活函数，发生梯度弥散

https://www.cnblogs.com/yangmang/p/7477802.html

发现的问题、

？

神经网络层数、复杂度影响准确率

同时测试过程中，准确率上下波动，不稳定，这样的模型显然不妥

那么一个好的模型势必兼具准确率高，稳定两个特征

2神经单元个数

将神经单元个数加到200个

model = Sequential()
model.add(Dense(input_dim=28 * 28, units=200, activation='sigmoid'))
model.add(Dense(units=10, activation='softmax'))
1
2
3

依次增加到200*n（n=1,2,3,4,5）

Acc	50	100	150	200	400	600	28*28	800	1000
test1	90.93%	92.35%	92.98%	93.00%	94.04%	94.23%	94.48%	94.62%	94.77%
test2	91.23%	92.53%	92.68%	93.30%	93.61%	94.29%	94.27%	94.48%	94.62%
test3	91.40%	92.21%	92.86%	93.10%	93.87%	94.43%	94.50%	94.61%	94.70%
avg	91.19%	92.36%	92.84%	93.13%	93.84%	94.32%	94.42%	94.57%	94.70%

在这里插入图片描述

通过这个例子可以看到在一定程度内，

神经单元的个数影响准确率

同时两者呈正相关，后期增长速率放缓

？

数据的稳定程度

隐藏层神经元个数

https://zhuanlan.zhihu.com/p/100419971

在隐藏层中使用太少的神经元将导致欠拟合(underfitting)。相反，使用过多的神经元同样会导致一些问题。首先，隐藏层中的神经元过多可能会导致过拟合(overfitting)。当神经网络具有过多的节点（过多的信息处理能力）时，训练集中包含的有限信息量不足以训练隐藏层中的所有神经元，因此就会导致过拟合。即使训练数据包含的信息量足够，隐藏层中过多的神经元会增加训练时间，从而难以达到预期的效果。显然，选择一个合适的隐藏层神经元数量是至关重要的。

图源：吴恩达-深度学习

通常，对所有隐藏层使用相同数量的神经元就足够了。对于某些数据集，拥有较大的第一层并在其后跟随较小的层将导致更好的性能，因为第一层可以学习很多低阶的特征，这些较低层的特征可以馈入后续层中，提取出较高阶特征。

需要注意的是，与在每一层中添加更多的神经元相比，添加层层数将获得更大的性能提升。因此，不要在一个隐藏层中加入过多的神经元。

对于如何确定神经元数量，有很多经验之谈。

stackoverflow上有大神给出了经验公式以供参考：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pIlgzc67-1621473923441)(https://www.zhihu.com/equation?tex=N_h+%3D+%5Cfrac%7BN_s%7D+%7B%28%5Calpha+%2A+%28N_i+%2B+N_o%29%29%7D)]

其中： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wCQ6o1qV-1621473923442)(https://www.zhihu.com/equation?tex=N_i)] 是输入层神经元个数；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1HRd2MIx-1621473923443)(https://www.zhihu.com/equation?tex=N_o)]是输出层神经元个数；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ciUmIzos-1621473923444)(https://www.zhihu.com/equation?tex=N_s)]是训练集的样本数；
α 是可以自取的任意值变量，通常范围可取 2-10。

还有另一种方法可供参考，神经元数量通常可以由一下几个原则大致确定：

隐藏神经元的数量应在输入层的大小和输出层的大小之间。
隐藏神经元的数量应为输入层大小的2/3加上输出层大小的2/3。
隐藏神经元的数量应小于输入层大小的两倍。

总而言之，隐藏层神经元是最佳数量需要自己通过不断试验获得，建议从一个较小数值比如1到5层和1到100个神经元开始，如果欠拟合然后慢慢添加更多的层和神经元，如果过拟合就减小层数和神经元。此外，在实际过程中还可以考虑引入Batch Normalization, Dropout, 正则化等降低过拟合的方法。

3激活函数

在神经网络层数加深，复杂之后，sigmoid准确率急速下降

sigmoid

tanh

relu

ReLU函数其实就是一个取最大值函数，注意这并不是全区间可导的，但是我们可以取sub-gradient，如上图所示。ReLU虽然简单，但却是近几年的重要成果，有以下几大优点：
1）解决了gradient vanishing问题 (在正区间)
2）计算速度非常快，只需要判断输入是否大于0
3）收敛速度远快于sigmoid和tanh

ReLU也有几个需要特别注意的问题：
1）ReLU的输出不是zero-centered
2）Dead ReLU Problem，指的是某些神经元可能永远不会被激活，导致相应的参数永远不能被更新。有两个主要原因可能导致这种情况产生: (1) 非常不幸的参数初始化，这种情况比较少见 (2) learning rate太高导致在训练过程中参数更新太大，不幸使网络进入这种状态。解决方法是可以采用Xavier初始化方法，以及避免将learning rate设置太大或使用adagrad等自动调节learning rate的算法。

尽管存在这两个问题，ReLU目前仍是最常用的activation function，在搭建人工神经网络的时候推荐优先尝试！

4损失函数

model.compile(loss='categorical_crossentropy',optimizer=SGD(lr=0.1),metrics=['accuracy'])
1

将Loss损失函数，更改成交叉熵

均方差损失函数
简单来说，均方误差（MSE）的含义是求一个batch中n个样本的n个输出与期望输出的差的平方的平均值。比如对于一个神经元（单输入单输出，sigmoid函数）,定义其代价函数为
（其中y是我们期望的输出，a为神经元的实际输出【 a=σ(z), where z=wx+b 】。）：

在训练神经网络过程中，我们通过梯度下降算法来更新w和b，因此需要计算损失函数对w和b的导数：

然后更新w、b：
w <—— w - η* ∂C/∂w = w - η * a σ′(z) b <—— b - η ∂C/∂b = b - η * a * σ′(z)
因为sigmoid函数的性质，导致σ′(z)在z取大部分值时会很小，这样会使得w和b更新非常慢（因为η * a * σ′(z)这一项接近于0）。

为了克服这个不足，引入了categorical_crossentropy（交叉熵损失函数）

categorical_crossentropy（交叉熵损失函数)

交叉熵是用来评估当前训练得到的概率分布与真实分布的差异情况。它刻画的是实际输出（概率）与期望输出（概率）的距离，也就是交叉熵的值越小，两个概率分布就越接近。

公式如下:
（其中y为期望的输出，a为神经元实际输出）
【a=σ(z), where z=∑Wj * Xj+b】

同样进行求导：

从上图可以看到，导数中没有σ′(z)这一项，权重的更新是受σ(z)−y这一项影响，即受误差的影响，所以当误差大的时候，权重更新就快，当误差小的时候，权重的更新就慢。

5迭代次数

训练次数越多不能说明越精确，精度主要决定于几个重要参数，如隐含层节点数，传递函数的设置，还有目标值和学习率等等，可以看训练次数和误差的曲线分析。训练时也会出现过拟合现象，那么随着训练次数增多反而误差越大。

改进后的全连接

from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils import to_categorical
from keras import models, layers, regularizers
from keras.optimizers import RMSprop, SGD, Adam
from keras.datasets import mnist
import matplotlib.pyplot as plt

# 加载数据集
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# print(train_images.shape, test_images.shape)
# print(train_images[0])
# print(train_labels[0])-
# plt.imshow(train_images[0])
# plt.show()

train_images = train_images.reshape(60000, 28 * 28).astype('float')
test_images = test_images.reshape(10000, 28 * 28).astype('float')
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# print(train_images.shape)
# print(train_labels[0])

model = Sequential()
model.add(Dense(input_dim=28 * 28, units=200, activation='relu'
                , kernel_regularizer=regularizers.l1(0.0001)))
model.add(layers.Dropout(0.01))
model.add(Dense(units=32, activation='relu'
                , kernel_regularizer=regularizers.l1(0.0001)))
model.add(layers.Dropout(0.01))
# 将一些网络层通过.add()堆叠起来，就构成了一个模型：
model.add(Dense(units=10, activation='softmax'))

# 输出模型各层的参数状况
model.summary()

# 完成模型的搭建后，我们需要使用.compile()方法来编译模型：
model.compile(loss='categorical_crossentropy', optimizer=Adam(), metrics=['accuracy'])

# 完成模型编译后，我们在训练数据上按batch进行一定次数的迭代来训练网络
model.fit(train_images, train_labels, batch_size=100, epochs=20)

# 随后，我们可以使用一行代码对我们的模型进行评估，看看模型的指标是否满足我们的要求
result = model.evaluate(test_images, test_labels, batch_size=100,verbose=1)

# print(result)
# result[0] loss
# result[1] acc

print('\nTest Loss:%.2f%%' % (result[0] * 100))
print('\nTest Acc:%.2f%%' % (result[1] * 100))

# weights = model.get_weights()
# print(weights)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

结果

Epoch 1/20
600/600 [==============================] - 1s 2ms/step - loss: 2.6997 - accuracy: 0.5442
Epoch 2/20
600/600 [==============================] - 1s 2ms/step - loss: 1.3144 - accuracy: 0.7247
Epoch 3/20
600/600 [==============================] - 1s 2ms/step - loss: 1.0508 - accuracy: 0.7986
Epoch 4/20
600/600 [==============================] - 1s 2ms/step - loss: 0.8115 - accuracy: 0.8743
Epoch 5/20
600/600 [==============================] - 1s 2ms/step - loss: 0.6775 - accuracy: 0.9110
Epoch 6/20
600/600 [==============================] - 1s 2ms/step - loss: 0.5910 - accuracy: 0.9333
Epoch 7/20
600/600 [==============================] - 1s 2ms/step - loss: 0.5122 - accuracy: 0.9451
Epoch 8/20
600/600 [==============================] - 1s 2ms/step - loss: 0.4536 - accuracy: 0.9541
Epoch 9/20
600/600 [==============================] - 1s 2ms/step - loss: 0.4099 - accuracy: 0.9592
Epoch 10/20
600/600 [==============================] - 1s 2ms/step - loss: 0.3652 - accuracy: 0.9638
Epoch 11/20
600/600 [==============================] - 1s 2ms/step - loss: 0.3409 - accuracy: 0.9661
Epoch 12/20
600/600 [==============================] - 1s 2ms/step - loss: 0.3150 - accuracy: 0.9679
Epoch 13/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2966 - accuracy: 0.9697
Epoch 14/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2894 - accuracy: 0.9689
Epoch 15/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2675 - accuracy: 0.9715
Epoch 16/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2557 - accuracy: 0.9720
Epoch 17/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2504 - accuracy: 0.9725
Epoch 18/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2408 - accuracy: 0.9736
Epoch 19/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2265 - accuracy: 0.9764
Epoch 20/20
600/600 [==============================] - 1s 2ms/step - loss: 0.2272 - accuracy: 0.9751
100/100 [==============================] - 0s 910us/step - loss: 0.2312 - accuracy: 0.9766



Test Acc:97.66%
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

卷积神经网络

https://keras-cn.readthedocs.io/en/latest/layers/convolutional_layer/#conv2d


from keras.utils import to_categorical
from keras import models, layers
from keras.optimizers import RMSprop
from keras.datasets import mnist
# 加载数据集
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 搭建LeNet网络
def LeNet():
    network = models.Sequential()
    network.add(layers.Conv2D(filters=6, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
    network.add(layers.AveragePooling2D((2, 2)))
    network.add(layers.Conv2D(filters=16, kernel_size=(3, 3), activation='relu'))
    network.add(layers.AveragePooling2D((2, 2)))
    network.add(layers.Conv2D(filters=120, kernel_size=(3, 3), activation='relu'))
    network.add(layers.Flatten())
    network.add(layers.Dense(84, activation='relu'))
    network.add(layers.Dense(10, activation='softmax'))
    return network
network = LeNet()
network.compile(optimizer=RMSprop(lr=0.001), loss='categorical_crossentropy', metrics=['accuracy'])

train_images = train_images.reshape((60000, 28, 28, 1)).astype('float') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float') / 255
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# 训练网络，用fit函数, epochs表示训练多少个回合， batch_size表示每次训练给多大的数据
network.fit(train_images, train_labels, epochs=10, batch_size=128, verbose=2)
test_loss, test_accuracy = network.evaluate(test_images, test_labels)
print("test_loss:", test_loss, "    test_accuracy:", test_accuracy)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

运行结果

Epoch 1/10
469/469 [==============================] - 7s 16ms/step - loss: 0.3787 - accuracy: 0.8834
Epoch 2/10
469/469 [==============================] - 8s 17ms/step - loss: 0.1068 - accuracy: 0.9668
Epoch 3/10
469/469 [==============================] - 7s 15ms/step - loss: 0.0681 - accuracy: 0.9791
Epoch 4/10
469/469 [==============================] - 6s 12ms/step - loss: 0.0518 - accuracy: 0.9838
Epoch 5/10
469/469 [==============================] - 8s 16ms/step - loss: 0.0411 - accuracy: 0.9869
Epoch 6/10
469/469 [==============================] - 5s 11ms/step - loss: 0.0350 - accuracy: 0.9891
Epoch 7/10
469/469 [==============================] - 6s 13ms/step - loss: 0.0281 - accuracy: 0.9915
Epoch 8/10
469/469 [==============================] - 7s 15ms/step - loss: 0.0250 - accuracy: 0.9919
Epoch 9/10
469/469 [==============================] - 6s 13ms/step - loss: 0.0209 - accuracy: 0.9937
Epoch 10/10
469/469 [==============================] - 8s 17ms/step - loss: 0.0182 - accuracy: 0.9941
313/313 [==============================] - 1s 2ms/step - loss: 0.0304 - accuracy: 0.9914
test_loss: 0.03039652481675148     test_accuracy: 0.9914000034332275

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

文献资料

《深度学习的数学》涌井良幸

https://blog.csdn.net/m0_37788308/article/details/80638359

https://www.jianshu.com/p/ae3932eda8f2

https://www.cnblogs.com/wj-1314/p/9579490.html

很详细

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/313999