TensorFlow神经网络学习笔记

张量（tensor）

就是多维数组 阶代表张量的维数

维数 阶 名字
0-D 0 标量scalar
1-D 1 向量vector
2-D 2 矩阵 matrix
n-D n 张量 tensor

张量可以表示0阶到n阶的数组（列表）

数据类型

tf.int, tf.float…
tf.int 32,tf.float 32,tf.float 64
tf.bool
tf.constant([True, False])
tf.string
tf.constant(“Hello, world!”)

创建张量

tf.constant(张量内容,dtype=数据类型(可选))

numpy转tensor

将numpy的数据类型转换为Tensor数据类型
tf.convert to tensor(数据名,dtype=数据类型(可选))

创建全为0的张量tf.zeros(维度)
创建全为1的张量tf.ones(维度)
创建全为指定值的张量tf.fiII(维度,指定值)

生成正态分布的随机数，默认均值为0，标准差为1
tf. random.normal(维度,mean=均值,stddev=标准差)
生成截断式正态分布的随机数(随机数更集中，保证取值在μ±2σ)
tf.random.truncated normal(维度,mean=均值,stddev=标准差)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7x8Zak8T-1632728451439)(neural network.assets/image-20210909180355459.png)]

生成均匀分布随机数[ minval,maxval )
tf. random. uniform(维度，minval=最小值，maxval=最大值)

常用函数

tf.cast转换类型

强制tensor转换为该数据类型tf.cast(张量名,dtype=数据类型)

tf.reduce_min最小值

计算张量维度上元素的最小值tf.reduce_min(张量名)

tf.reduce_max最大值

计算张量维度上元素的最大值tf.reduce_max(张量名)

axis

在一个二维张量或数组中，可以通过调整axis等于0或1控制执行维度。
axis=0代表列(经度，down)，而axis=1代表行(纬度,across)
如果不指定axis，则所有元素参与计算。

tf.Variable变量

tf. Variable()将变量标记为“可训练”，被标记的变量会在反向传播中记录梯度信息。神经网络训练中，常用该函数标记待训练参数。

tf.Variable(初始值)

w = tf.Variable(tf.random.normal([2, 2], mean=0, stddev=1))

数学运算

只有维度相同的张量才可以做四则运算

对应元素的四则运算:tf.add,tf.subtract,tf.multiply,tf.divide

平方、次方与开方:tf.square,tf.pow(张量名，n次方数),tf.sqrt

矩阵乘:tf.matmul

tf.data.Dataset.from tensor slices特征对应标签

切分传入张量的第一维度，生成输入特征标签对，构建数据集
data = tf.data.Dataset.from_tensor_slices((输入特征,标签))

(Numpy和lTensor格式都可用该语句读入数据)

tf.GradientTape求导

with结构记录计算过程，gradient求出张量的梯度
with tf.GradientTape( ) as tape:
若干个计算过程
grad=tape.gradient(函数，对谁求导)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9WJ3UGEH-1632728451441)(neural network.assets/image-20210910153126291.png)]

enumerate枚举

enumerate是python的内建函数，它可遍历每个元素(如列表、元组或字符串)，组合为:索引元素，常在for循环中使用。
enumerate(列表名)

tf.one_hot独热码

tf.one hot(待转换数据,depth=几分类)

独热编码（one-hot encoding）:在分类问题中，常用独热码做标签,标记类别:1表示是，0表示非。

(0狗尾草鸢尾,1杂色鸢尾,2弗吉尼亚鸢尾)
标签:1
独热码: （0.1.0.)

tf.nn.softmax 使输出符合概率分布

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pkyJ3Iy1-1632728451443)(neural network.assets/image-20210910153814824.png)]

输出概率分布与独热码做比较

当n分类的n个输出（V。，V. …y1）通过softmax(）函数,便符合概率分布了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i8VQvd4u-1632728451444)(neural network.assets/image-20210910154344465.png)]

assign_sub 自更新

赋值操作，更新参数的值并返回。
调用assian sub前，先用tf.Variable定义变量w为可训练
可自更新）。
w.assign_sub(w要自减的内容)

tf.argmax指定维度最大值索引

返回张量沿指定维度最大值的索引tf.argmax(张量名,axis=操作轴)

预备知识

tf.where

tf.where(条件语句，真返回A，假返回B)

a=tf.constant([1,2,3,1,1))

b=tf.constant([0,1,3,4,5])
c=tf.where(tf.greater(a,b), a,b)#若a>b，返回a对应位置的元素，否则返回b对应位置的元素
print(“c:”,c)
运行结果:
c: tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)

np.random.RandomState.rand()

返回一个[0,1)之间的随机数
np.random.RandomState.rand(维度)#维度为空,返回标量

np.vstack()

将两个数组按垂直方向叠加np.vstack(数组1，数组2)

np.mgrid[ ] .ravel() np.c_[]

一般一起使用生成网格坐标点

np.mgrid[ ] [起始值，结束值)

np.mgrid[起始值:结束值:步长, 起始值:结束值:步长，… ]

行数由第一个参数1:4:0.5决定，为6行，列数由第二个参数2:4:0.5决定，为4列。

x.ravel(）将x变为一维数组，“把.前变量拉直”

np.c_[]使返回的间隔数值点配对
np.c_[数组1，数组2，…]

神经网络（NN）复杂度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JEbkkJKX-1632728451446)(neural network.assets/image-20210906084736474-16309812243145.png)]

NN复杂度:多用NN层数和NN参数的个数表示

空间复杂度:

层数=隐藏层的层数+1个输出层

图为2层NN
总参数=总w+总b
图3x4+4 + 4x2+2=26
第1层 第2层

时间复杂度:

乘加运算次数
图3x4 + 4x2 = 20
第1层 第2层

学习率Ir

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sVacWnW7-1632728451449)(neural network.assets/image-20210906085549555-16309812206664.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VPMiLmuk-1632728451451)(neural network.assets/image-20210906085913765-16309812178803.png)]

参数w初始化为5，学习率为0.2则
1次参数 w : 5 5-0.2*(2*5＋2)=2.6

2次参数 w : 2.6 2.6-0.2*(2*2.6＋2)=1.16

3次参数 w : 1.16 1.16-0.2*(2*1.16+2)=0.296

4次参数w:0.296

…

指数衰减学习率

可以先用较大的学习率，快速得到较优解，然后逐步减小学习率，使模型在训练后期稳定。
指数衰减学习率=初始学习率*当习率衰减率（当前轮数/多少轮衰减一次）

激活函数

对于线性函数，即使有多层神经元收尾相接构成深层神经网络，依旧是线性组合，模型的表达力不够，所以需要激活函数，提高模型的表达力，神经网络可以随层数的增加提高其表达力

优秀的激活函数

非线性:激活函数非线性时，多层神经网络可逼近所有函数

（只有激活函数是非线性的才不会被单层网络替代，使其自身有了意义）

可微性:优化器大多用梯度下降更新参数

单调性:当激活函数是单调的，能保证单层网络的损失函数是凸函数

近似恒等性:f(x)约等于x 当参数初始化为随机小值时，神经网络更稳定

激活函数输出值的范围:

激活函数输出为有限值时，基于梯度的优化方法更稳定

激活函数输出为无限值时，建议调小学习率

常用的激活函数

sigmoid

tf.nn.sigmoid(x)

相当于对输出归一化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bvV5Dn8N-1632728451451)(neural network.assets/image-20210906155917016-16309811816132.png)]

特点：

1.易造成梯度消失

（深层神经网络更新参数时，需要从输出层到输入层逐层进行链式求导，而sigmoid函数的导数输出是0_{0.25的小数，链式求导需要多层导数连续相乘，会出现多个0}0.25的连续相乘，使结果趋于0，造成梯度消失）

2.输出非0均值，收敛慢

3.幂运算复杂，训练时间长

Tanh函数

tf.math.tanh(x)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iJUXESBY-1632728451453)(neural network.assets/image-20210906161434796-16309811558541.png)]

特点：

(1)输出是0均值

(2)易造成梯度消失

(3)幂运算复杂,训练时间长

Relu函数

tf.nn.relu(x)

满足近似恒等性，计算速度快

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OQW6SfKa-1632728451454)(neural network.assets/image-20210906161647654.png)]

优点: 缺点:
(1)解决了梯度消失问题(在正区间) (1)输出非O均值,收敛慢

(2)只需判断输入是否大于0，计算速度快 (2)Dead Relu问题:某些神经元可能永远不

(3)收敛速度远快于sigmoid和Itanh 被激活，导致相应的参数永远不能被更新

解决dead relu

原因：经过relu函数的负数特征过多

解决：改进随机初始化，避免过多的负数特征被送入relu函数；通过设置更小的学习率

，减少参数分布的巨大变化，避免训练过程产生过多负数被送入relu函数

Leaky Relu函数

tf.nn.leaky_relu(x)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sx8t99fA-1632728451457)(neural network.assets/image-20210906162350460.png)]

理论上来讲，Leaky Relu有Relu的所有优点，外加不会有Dead Relu问题，但是在实际操作当中，并没有完全证明Leaky Relu总是好于Relu。

对于初学者的建议:

首选relu激活函数;

学习率设置较小值;

输入特征标准化，即让输入特征满足以0为均值，1为标准差的正态分布;

初始参数中心化，即让随机生成的参数满足以0为均值,为标准差的正态分布。

损失函数

loss：y和y_的差距

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XSZz6Xx2-1632728451459)(neural network.assets/image-20210906164655978.png)]

均方误差(mse)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MrGkzSd3-1632728451462)(neural network.assets/image-20210906164740240.png)]

loss_mse=tf.reduce_mean(tf.square(y_-y))

用均方误差，默认预测多少损失一样

在实际中，预测销量多了，损失成本，预测少了，损失利润，而利润不等于成本，则mse产生的loss无法利益最大化

自定义损失函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KMpmEOa6-1632728451465)(neural network.assets\image-20210907101404461.png)]

loss_zdy=tf.reduce_sum(tf.where(tf.greater(y,y\_),(y-y\_)*cost,(y-y\_)\*profit))

交叉熵CE(Cross Entropy)

tf.losses.categorical_crossentropy(y_,y)

**表征两个概率分布之间的距离

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cLYMau5O-1632728451468)(neural network.assets/image-20210907103543325.png)]

with tf.GradientTape() as tape:

	hl = tf.matmul(x_train, wl)+ b1hl = tf.nn.relu(h1)
	y = tf.matmul (hl,w2)+b2
	loss_mse = tf.reduce_mean(tf.square(y_train - y))
	loss_regularization = []
	loss_regularization. append (tf.nn.l2_loss (w1))
	loss regularization. append(tf.nn.12_loss (w2))
	loss_regularization = tf.reduce_sum (loss regularization)
	loss = loss_mse + 0.03 * loss_regularization

variables = [w1,b1,w2,b2]
grads = tape.gradient (loss,variables)

缓解过拟合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KfNImoqr-1632728451470)(neural network.assets/image-20210908080756000.png)]

​ 欠拟合 正确拟合 过拟合

欠拟合

对现有模型的学习不够彻底

解决：增加更多维度的输入特征项，增加网络参数（提高网络深度），减少正则化参数

过拟合

模型对当前数据拟合太好，无法对从未见过的新数据进行正确的判断，模型缺乏泛化力

解决：数据清洗（降噪），增大数据集，采用正则化，增大正则化参数

正则化缓解过拟合

正则化在损失函数中引入模型复杂度指标，利用给W加权值，弱化了训练数据的噪声(一般不正则化b)

loss = loss( y 与 y_ ) + REGULARIZER * loss( w )

超参数REGULARIZER给出参数w在总loss中的比例，即正则化的权重；w为需要正则化的参数

正则化的选择

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o8ZqvmJZ-1632728451472)(neural network.assets/image-20210908082025399.png)]

L1正则化大概率会使很多参数变为零，因此该方法可通过稀疏参数，即减少参数的数量，降低复杂度。
L2正则化会使参数很接近零但不为零，因此该方法可通过减小参数值的大小降低复杂度。

with tf.GradientTape() as tape: hl = tf.matmul(x train, wl) +blh1 = tf.nn.relu (hl) y = tf.matmul(h1,w2)+ b2 loss_mse = tf.reduce_mean(tf.square(y_train - y)) loss_regularization =[] loss_regularization.append(tf.nn.l2_loss(w1))

loss regularization. append (tf.nn.l2_loss(w2)) loss regularization = tf.reduce sum (loss regularization)

loss = loss mse + 0.03 * loss regularization variables = [wl,b1,w2，b2] grads = tape.gradient (loss, variables)

优化器

待优化参数w，损失函数loss，学习率lr，每次迭代一个batch,t表示当前batch迭代的总次数:

1.计算t时刻损失函数关于当前参数的梯度[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-322IZuVG-1632728451474)(neural network.assets/image-20210912000352891.png)]
2.计算t时刻一阶动量mt和二阶动量Vt
3.计算t时刻下降梯度[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1XNTpJrT-1632728451476)(neural network.assets/image-20210912000325885.png)]
4.计算t+1时刻参数[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CeelOMVh-1632728451478)(neural network.assets/image-20210912000336638.png)]

不同的优化器实际上是对于一阶动量和二阶动量定义的不同

一阶动量:与梯度相关的函数

二阶动量:与梯度平方相关的函数

五种常用的神经网络优化器

SGD 随机梯度下降

公式：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cbi9Gqsy-1632728451481)(neural network.assets/image-20210912175400838.png)]

费时：9.994226455688477

SGDM 在SDG的基础上增加了一阶动量

和SDG的mt相比，多了上一时刻的一阶动量，β这个超参数，数值一般接近1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UlC0bvSW-1632728451484)(neural network.assets/image-20210913190133052.png)]

费时：9.894362926483154

Adagrad 在SDG的基础上增加二阶动量

可以给模型的每个参数增加自适应学习率

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YUfuESeq-1632728451486)(neural network.assets/image-20210913191334257.png)]

费时：9.202043533325195

RMSProp 在SDG的基础上增加二阶动量(与Adagrad不同)

二阶动量V用的是指数滑动平均值计算，表征过去一段时间的平均值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-au7xkHde-1632728451487)(neural network.assets/image-20210913191754243.png)]

费时：9.348316192626953

出现震荡，可以调小学习率(当前为0.1)来解决

Adam 同时结合SGDM一阶动量和RMSProp二阶动量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G9uRduis-1632728451489)(neural network.assets/image-20210913192446591.png)]

费时：11.04874324798584

使用Sequential搭建神经网络八股

六步法搭建神经网络

1. import 导入相关包
2. train,test 指定训练集输入特征x_train，标签y_train；测试集输入特征x_test，标签y_test
3. model = tf.keras.models.Sequential 在Sequential中搭建网络，逐层描述每层网络
4. model.compile 在complie中配置驯良方法，告知训练用优化器，损失函数，评测指标等
5. model.fit 在fit执行训练过程告知训练集和测试集的输入特征和标签，告知batch的大小和迭代次数
6. model.summary 打印出网络的结构和参数统计

sequential

tf.keras.models.sequential([网络结构])

描述各层网络结构，例：

拉直层： tf.keras.layers.Flatten()

全连接层：tf.keras.layers.Dense(神经元个数,activition=“激活函数”,kernel_regularizer=正则化选择)

activation（字符串给出）可选: relu、softmax、sigmoid 、tanh
kernel_regularizer可选: tf.keras.regularizers.l1()、tf.keras.regularizers.12()

卷积层：tf.keras.layers.Conv2D(filters=卷积核个数,kernel_size=卷积核尺寸,strides=卷积步长，padding = " valid" or “same”)

LSTM层:tf.keras.layers.LSTM()

compile

model.compile(optimizer = 优化器,loss=损失函数,metrics = [‘准确率’])

ptimizer可选:
‘sgd’ or tf.keras.optimizers.SGD (Ir=学习率,momentum=动量参数)
‘adagrad’ or tf.keras.optimizers.Adagrad (Ir=学习率)
‘adadelta’ or tf.keras.optimizers.Adadelta (Ilr=学习率)
‘adam’ or tf.keras.optimizers.Adam (Ir=学习率, beta_1=0.9, beta_2=0.999)

loss可选:
‘mse’ or tf.keras.losses.MeanSquaredError()
‘sparse_categorical_crossentropy’ or tf.keras.losses.sparse_categorical_crossentropy(from_logits=False)
（常用于损失函数，有些神经网络的输出经过softmax等函数的概率分布，from_logits为询问是否是原始输出）

Metrics可选：
‘accuracy’: y_和y都是数值，如y_=[1] y=[1]
‘categorical_accuracy’:y_和y都是独热码（概率分布），如y_=[0,1,0] y=[0.256,0.695,0.048]
‘sparse_categorical_accuracy’:y_是数值，y是独热码（概率分布），如y_=[1] y=[0.256,0.695,0.048]

fit

model.fit(训练集的输入特征,训练集的标签,batch_size=,epochs=,validation_data=(测试集的输入特征，测试集标签),validation_split=从训练集划分多少比例给测试集,validation_freq=多少次epoch测试一次)
validation_data和validation_split选其一

summary

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2o4L9O4N-1632728451490)(neural network.assets/image-20210913200955610.png)]

sequential可以搭建出上层输出就是下层输入的顺序网络结构，但是无法写出一些带有跳连的非顺序网络结构

使用class搭建神经网络八股

用自定义class来封装一个神经网络结构

class MyModel(Model):
    def __init__(self):
        super(MyModel,self).__init__()
        定义网络结构块
    def call(self,x):
        调用网络结构块，实现前向传播
        return y
    
model=MyModel()

神经网络八股功能

1. 自制数据集，解决本领域应用
2. 数据增强，扩充数据集
3. 断点续训，存取模型
4. 参数提取，把参数存入文本
5. acc/loss可视化，查看训练效果
6. 应用程序，给图识物

自制数据集

数据集生成函数

def generateds(path,txt):
	f=open(txt,'r')
	contents = f.readlines()
	f.close()
	x,y_=[],[]
	for content in contents:
		value = content.split()
		img_path = path + value[0]
		img = Image.open(img_path)
		img = np.array(img.convert('L'))
		img = img / 255.0
		x.append(img)
		y_.append(value[1])
		print('loaded:',content)
	x=np.array(x)
	y_=np.array(y_)
	y_ = y_.astype(np.int64)
	return x,y_

判断数据集是否存在，存在直接读取

if os.path.exists(x_train_savepath) and os.path.exists(y_train_savepath) and os.path.exists(x_test_savepath) and os.path.exixts(y_test_savepath):

保存数据集

x_train_save = np.reshape(x_train,(len(x_train),-1))
x_test_save = np.reshape(x_test,(len(x_test),-1))
np.save(x_train_savepath,x_train_save)
np.save(y_train_savepath,y_train)
np.save(x_test_savepath,x_test_save)
np.save(y_test_savepath,y_test)

数据增强

ImageDataGenerator

image_gen_train=tf.keras.preprocessing.image.ImageDataGenerator(
rescale=所有数据将乘以该数值
rotation_range=随机旋转角度数范围
width_shift_range=随机宽度偏移量
height_shift_range=随机高度偏移量
水平翻转：horizontal_flip=是否随机水平翻转
随机缩放：zoom_range=随机缩放的范围[1-n,1+n])
image_gen_train.fit(x_train)
......
model.fit(image_gen_train.flow(x_train,y_train,batch_size=32),......)

预处理

归一化 MinMaxScaler

# 定义归一化：归一化到(0,1之间)
sc = sklearn.preprocessing.MinMaxScaler(feature_range=(0,1)) 
# 求得训练集最大值；最小值这些参数，训练集进行归一化
training_set_scaled = sc.fit_transform(训练集)
# 利用训练集的属性对测试集进行归一化
test_set = sc.transform(训练集)

断点续训

断点续训的意思是因为某些原因模型还没有训练完成就被中断，下一次训练可以在上一次训练的基础上继续训练而不用从头开始；这种方式对于你那些训练时间很长的模型来说非常友好。
如果要进行断点续训，那么得满足两个条件：
（1）本地保存了模型训练中的快照；（即断点数据保存）
（2）可以通过读取快照恢复模型训练的现场环境。（断点数据恢复）

load_weights(路径文件名) 读取模型

checkpoint_savepath = './checkpoint/mnist.ckpt'
# 通过是否存在索引表来判断是否已经保存过模型参数
if os.path.exist(checkpoint_savepath + '.index'):
	print('——————————————load model——————————————')
	model.load_weights(checkpoint_savepath)

ModelCheckpoint() 保存模型

cp_callback=tf.keras.callbacks.ModelCheckpoint(
	filepath=路径文件名
	save_weight_only=True/False 只保留模型参数
	save_bast_only=True/False 只保存最优结果)
history = model.fit(......,callbacks=[cp_callback])

参数提取

model.trainable_variables 返回模型中可训练的参数

设置print输出格式

直接print会省略掉中间的很多数据，用以下函数解决
np.set_printoptions(threshold=np.inf) np.inf表示无限大
......
print(model.trainable_variables)
file=open('./weights.txt','w')
for v in model.trainable_variables:
    file.write(str(v.name)+'\n'
    file.write(str(v.shape)+'\n')    
    file.write(str(v.numpy())+'\n') 
file.close()

acc&loss可视化

acc&loss曲线

history = model.fit(训练集数据，训练集标签，batch_size=，epochs=，validation_split=用作测试数据的比例，validation_data=测试集，validation_freq=测试频率)

history:
训练集loss：loss
测试集loss：val_loss
训练集准确率：sparse_categorical_accuracy
测试集准确率：val_sparse_categorical_accuracy
画图：

acc=history.history['sparse_categorical_accuracy']
val_acc=history.history['val_sparse_categorical_accuracy']
loss=history.history['loss']
val_loss = history.history['val_loss']

plt.subplot(1,2,1)
plt.plot(acc,label='Training Accuracy')
plt.plot(val_acc,label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

plt.subplot(1,2,2)
plt.plot(loss,label='Training Loss')
plt.plot(val_loss,label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()

八股实现给图识物(预测)

predict(输入特征，batch_size=)

返回前向传播计算结果

model = tf.keras.models.Sequential([
	tf.keras.layers.Flatten()
	tf.keras.layers.Dense(128,activation='relu')
	tf.keras.layers.Dense(10,activation='softmax')
])
model.load_weights(model_save_path)
......
result=model.predict(x_predict)

预处理

将预测数据变成神经网络从未见过的数据，靠拉高对比度等，但是要保证数据的有用信息，用滤波等操作使图片更干净。
常用的有：二值化

预测代码

from PIL import Image
import numpy as np
import tensorflow as tf
model_save_path = '. / checkpoint/mnist.ckpt'
model = tf . keras.models.sequential( [
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers. Dense (10, activation='softmax')])

model.load_weights (model_save path)
preNum = int (input ("input the number of test pictures : "))

for i in range (preNum):
    image_path = input ("the path of test picture:")
    img = Image. open (image _path)
    img = img.resize ((28,28),Image.ANTIALIAS)
    img_arr = np.array (img.convert ('L'))

	for i in range (28) :
		for j in range (28):
			if img_arr[i][j]<200:
				img_arr[i][j] - 255
             else:
				img_arr[i][j] = 0
img arr = img_arr / 255.0
# 由于神经网络每次喂入都是以batch为单位的，所以要在x_predict里前面添加一个维度
# （28,28） -> （1,28,28）
x_predict = img_arr[tf.newaxis, ...] 
result = model.predict(x _predict)
pred = tf.argmax (result, axis=l)
print ('\n')
tf.print(pred)

全连接网络的问题

用八股可以基本实现所有全连接网络，但其参数过多；在实际引用中，输入图片的数据量大，通道数多，导致送入全连接网络的输入特征过多；随着隐藏层层数增加，模型规模过大，待优化参数过多，容易使模型过拟合

在实际引用中，会先对原始图片进行特征提取，把提取来的特征送入全连接神经网络；一张彩色图片会先进行若干层的特征提取，然后再将提取的特征送入全连接网络

卷积计算（特征提取）

卷积计算可认为是一种有效提取图像特征的方法
一般用正方形的卷积核，按指定步长，在输入特征图上滑动，遍历输入特征图中的每一个像素点。每一个步长，卷积核会与输入特征图出现重合区域，对应元素相乘、求和加上偏置得到输出特征的一个像素点

在应用中，卷积核的通道必须与输入特征图的通道大小一样，每个卷积核在输入特征图中计算后都会得到一张输出特征图，所以当前卷积核的个数决定了当前层输出特征图的深度，增加卷积核可以提高该层的特征提取能力，

感受野

卷积神经网络各输出特征图中的每个像素点，在原始输入图片上映射区域的大小

当不同卷积核输出特征图和特征提取能力一样时，应该考虑它们所承载的待训练参数量和计算量
例：两个3x3卷积核和一个5x5卷积核相比，3x3卷积核的参数量为9+9=18，计算量为18x*x-108x+180，而5x5卷积核参数量为25，计算量为25x*x-200x+400，x为输入特征图的宽高；当x>10时，两层3x3由于一层5x5
两层3x3卷积核计算量公式：(x-2)^2 * 9 + (x-4)^2 * 9
5x5卷积核计算量公式：(x-4)^2 * 25

全零填充 padding

有时希望卷积计算后保持输入特征图的尺寸不变，此时就需要全零填充在输入特征图周围一圈。

参数padding=‘SAME’(全零填充) 入长/步长 (向上取整)
参数padding=‘VALID’(不全零填充) (入长 - 核长 + 1)/步长 (向上取整)

tf描述卷积层 Conv2D

tf.keras.layers.Conv2D(
	filters = 卷积核个数,
	kernel_size = 卷积核尺寸,#非正方形写(核高h,核宽w)
	strides = 滑动步长, #横纵不相同写(纵向步长h,横向步长w),默认1
	padding = 'Same' or 'valid', #全零填充
	activation = 'relu'、'sigmoid'、'tanh'、'softmax'等 #如果后面还有池标准化操作，则不在卷积里激活
	input_shape = (高,宽,通道数) #输入特征图维度，可略
)

批标准化 BN

神经网络对0附近的数值比较敏感，但是随着网络层数的增加，特征数据会出现偏离0均值的情况，标准化可以使数据符合以0为均值1为标准差的正态分布，可以把偏移的特征数据重新拉回0附近

常用在卷积操作和激活操作之间

批标准化后，第k个卷积核的输出特征图(feature map)中第i个像素点:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jwscj3Cm-1632728451492)(neural network.assets/image-20210915091517741.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KpPniSMG-1632728451493)(neural network.assets/image-20210915091351388.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-44ArEQWP-1632728451495)(neural network.assets/image-20210915091405866.png)]

每批数据一组做标准化，每个像素的均值和方差计算自这组输出特征图中相同位置的像素点

批标准化可以把原本偏离0的数据重新拉回到零均值，使输入数据的微小变化更明显的体现到激活函数的输出，提升对输入数据的区分；但是简单的批标准化，使特征数据完全满足标准正态分布，集中在激活函数中心的线性区域，使激活函数丧失了非线性特性。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2xrqBdX-1632728451496)(neural network.assets/image-20210916155930684.png)]

因此，在BN操作中为每个卷积核引入了两个可训练参数，缩放因子γ和偏移因子β

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NxY9X7Qi-1632728451498)(neural network.assets/image-20210916160609872.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xErdQlHf-1632728451500)(neural network.assets/image-20210916160541506.png)]

在反向传播时，缩放因子和偏移因子会与其他待训练参数一同被训练优化，使标准正态分布后的特征数据通过它们优化了特征数据的宽窄和偏移量，保证了网络的非线性表达力

BatchNormalization BN层

tf.keras.layers.BatchNormalization()

BN层位于卷积层之后，激活层之前

池化 （滤波）

池化的主要方法有最大池化和均值池化，最大池化可以提取图片纹理；均值池化可以保留背景特征
如果用2x2的池化核对输入图片以2为步长进行池化，输出图片将变为输入图片的1/4大小

最大池化 MaxPool2D

tf.keras.layers.MaxPool2D(
pool_size = 池化核尺寸，# 正方形写核长整数，或（核高h，核宽w）
strides = 池化步长， # 步长整数，或(纵向步长h，横向步长w)，默认为pool_size
padding = 'valid’or’same ’ # 使用全零填充是"same"，不使用是"valid”（默认）
)

均值池化 AveragePooling2D

tf.keras.layers.AveragePooling2D(
pool_size=池化核尺寸，# 正方形写核长整数，或（核高h，核宽w）
strides=池化步长，#步长整数，或(纵向步长h，横向步长w)，默认为pool_size
padding=valid’or’same’ #使用全零填充是"same"，不使用是"valid"（默认）
)

池化层位于激活层后，舍弃层前

舍弃

为了缓解神经网络过拟合，在训练中常把隐藏层的部分神经元按照一定比例从神经网络中临时舍弃，在使用时，再将其恢复到神经网络中

Dropout

tf.keras.layers.dropout(舍弃的概率)

卷积神经网络

主要模块

卷积、批标准化、激活、池化、全连接

卷积：特征提取器， 就是CBAPD：卷积、批标准化、激活、池化、舍弃

cifar0数据集

公有6w数据，5w训练，1w测试，32x32的彩色三通道图片和标签

导入数据集：tf.datasets.cifar10

cifar10=tf.kera.sdatasets.cifar10
(x_train,y_train),(x_test,y_test)=cifar10.load_data()

10个分类[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N9A9foxg-1632728451502)(neural network.assets/image-20210919215858344.png)]

卷积神经网络八股

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k55nAcm9-1632728451503)(neural network.assets/image-20210920000330753.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7ofCQL1E-1632728451504)(neural network.assets/image-20210920000339678.png)]

经典卷积神经网络

LeNet

通过共享卷积核减少了网络的参数

在统计卷积神经网络参数时，一般只统计卷积计算层和全连接计算层

LeNet一共有5层网络：两层卷积加上三层全连接

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0VWGYQYH-1632728451505)(neural network.assets/image-20210920170305996.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WkIu6Y4C-1632728451507)(neural network.assets/image-20210922215119994.png)]

AlexNet

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g8HtsPH7-1632728451508)(neural network.assets/image-20210922220800487.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6au8ms5x-1632728451509)(neural network.assets/image-20210922222149398.png)]

VggNet

使用小尺寸卷积核，在减少参数的同时，提高了识别准确率，网络结果规整，非常适合硬件加速

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a9MoLaLO-1632728451510)(neural network.assets/image-20210922231118905.png)]

InceptionNet

在同一层网络内使用不同尺寸的卷积核，可以提取不同尺寸的特征，作用到输入特征图的每个像素点，通过设定少于输入特征图深度的1*1卷积核个数，减少了输出特征图深度，起到了降维的作用，减少计算，提升了模型的感知力，使用的批标准化，缓解了梯度消失

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OehglZIQ-1632728451511)(neural network.assets/image-20210922232746875.png)]

Inception结构块包含4个分支，分别输出到卷积连接器，送到卷积连接器的特征数据尺寸相同，卷积连接器会把收到的特征数据按深度方向拼接，形成Inception结构块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ifvOd53h-1632728451512)(neural network.assets/image-20210922233442516.png)]

ResNet

提出了层间残差跳连

残差跳连(skip connect)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HYPCkGJ0-1632728451513)(neural network.assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2,size_16,color_FFFFFF,t_70.png)]

将输入引入到输出，将输出表述为输入和输入的一个非线性变换的线性叠加，解决了深层网络的训练问题；引出前方信息缓解梯度消失，使神经网络层数的增加成为可能，有效缓解了神经网络的模型堆叠导致的退化。

Inception网络层的相加是深度方向的相加，而ResNet网络层的相加是矩阵相加

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mTM6IMFY-1632728451514)(neural network.assets/image-20210922234812489.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qtmVxGA4-1632728451515)(neural network.assets/image-20210923000055048.png)]

循环神经网络

借助卷积核提取空间特征，送入全连接网络，实现连续数据的预测

循环核

参数时间共享，循环层提取时间信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ovB1GUfw-1632728451516)(neural network.assets/image-20210923212705049.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-34SbMm5e-1632728451517)(neural network.assets/image-20210923212714671.png)]
ht为记忆体内存储的特征信息，为实时更新

按时间展开

把循坏核按时候轴展开，记忆体周围的参数矩阵wxh、whh、why是固定不变的，训练优化这些参数矩阵，训练完成后使用效果最好的参数矩阵，使用前向传播输出预测，借助循坏核实现的时间特征提取。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0eu3yR88-1632728451518)(neural network.assets/image-20210923212915503.png)]

循坏计算层SimpleRNN

tf.keras.layers.SimpleRNN(记忆体个数，activation=‘激活函数’，return_sequences=是否每个时刻输出ht到下一层(默认False))
activation不写默认使用tanh

要求送入循环层的数据为三维的：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]

循环计算过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OuWeuXTi-1632728451520)(neural network.assets/image-20210926184918143.png)]

参数矩阵不变，对记忆体进行前向传播

传统RNN

通过记忆体实现短期记忆进行连续数据的预测，但是当连续数的序列变长时，会使展开时间步过长；在反向传播更新参数时，梯度要按照时间步连续相乘，会导致梯度消失

股票预测结果,训练速度一般

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AMIRaaDN-1632728451521)(neural network.assets/image-20210927150902867.png)]

长短记忆网络LSTM

LSTM计算过程[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZbWmpSOM-1632728451522)(neural network.assets/image-20210927144540117.png)]

长短记忆网络中引入了三个门限，输入门it，遗忘门ft，输出门ot，引入了表征长期记忆的细胞态ct，引入了等待存入长期记忆的候选态ct波

作用：

三个门限都是当前时刻的输入特征xt和上个时刻的短期记忆ht-1的函数，这三个公式中wi、wf、wo是待训练参数矩阵，bi、bf、bo是待训练偏执项，他们都经过sigmoid函数，使值处在0-1之间；
细胞态表示长期记忆，等于上个时刻的长期记忆乘以遗忘门加上当前时刻归纳出的新知识(候选态)乘以输入门；
记忆体表示短期记忆，是长期记忆的一部分，是细胞态过tanh激活函数乘以输出门的结果；
候选态表示归纳出的待存入细胞态的新知识，是当前时刻的输入特征xt和上个时刻ht-1的函数Wc是待训练参数矩阵，bc是待训练偏执项

LSTM()

tf.keras.layers.LSTM(记忆体个数，return_sequences=是否返回输出)
True 各时间步输出ht False 仅最后时间步输出ht(默认)

股票预测结果，训练速度较快

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FSLj7onp-1632728451523)(neural network.assets/image-20210927150932871.png)]

GRU 减化的LSTM

计算过程[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sn5y6vqL-1632728451524)(neural network.assets/image-20210927151059124.png)]

GRU使记忆体ht融合了长期记忆和短期记忆，ht包含了过去信息ht-1和现在信息ht波浪号，现在信息是过去信息ht-1过重置门与当前输入共同决定，两个门限的范围也是0-1

GRU()

tf.keras.layers.GRU(记忆体个数，return_sequences=是否返回输出)
True 各时间步输出ht False 仅最后时间步输出ht(默认)

预测结果，训练速度较慢

Embedding —— 一种编码方式

独热码:数据量大过于稀疏，映射之间是独立的，没有表现出关联性Embedding:是一种单词编码方法，用低维向量实现了编码，这种编码通过神经网络训练优化，能表达出单词间的相关性。

tf.keras.layers.Embedding(词汇表大小，编码维度)

编码维度就是用几个数字表达一个单词
例：对1-100进行编码，[4]编码为[0.25,0.1,0.11]
Embedding对x_train维度的要求：[送入样本数，循环核时间展开步数]