课程地址：【北京大学】Tensorflow2.0_哔哩哔哩_bilibili

Python3.7和TensorFlow2.1

六讲：

神经网络计算：神经网络的计算过程，搭建第一个神经网络模型

神经网络优化：神经网络的优化方法，掌握学习率、激活函数、损失函数和正则化的使用，用Python语言写出SGD、Momentum、Adagrad、RMSProp、Adam五种反向传播优化器

神经网络八股：神经网络搭建八股，六步法写出手写数字识别训练模型

网络八股扩展：神经网络八股扩展，增加自制数据集、数据增强、断点续训、参数提取和acc/loss可视化，实现给图识物的应用程序

卷积神经网络：用基础CNN、LeNet、AlexNet、VGGNet、InceptionNet和ResNet实现图像识别

循环神经网络：用基础RNN、LSTM、GRU实现股票预测

前两讲：使用TensorFlow2的原生代码搭建神经网络

本讲：使用Keras搭建神经网络（八股：六步法，有Sequential和class两种）

神经网络搭建八股

用TensorFlow API：tf.keras搭建网络八股

keras介绍

tf.keras是TensorFlow2引入的高封装度框架，可以用于快速搭建神经网络模型

官方文档： https://tensorflow.google.cn/api_docs/python/tf

两种学习API的方法：

在PyCharm集成开发环境中查看框架源码：将鼠标放置在函数上按住Ctrl键会显示函数的基本信息，包括封装函数的类、函数入口参数、函数功能等

在TensorFlow官网中查询函数文档：通过左边的检索寻找目标函数。以查询 model.fit() 函数为例，打开tf.keras中的Model类，右方目录列出了Model类所包含的函数，点击fit()函数可以看到对于函数的介绍，包括输入参数具体介绍、函数功能等

六步法

import 相关模块

指定输入网络的训练集和测试集train test，如指定训练集的输入 x_train 和标签 y_train，以及测试集的输入x_test 和标签 y_test

逐层搭建网络结构，相当于走了一遍前向传播 models.Sequential

model = tf.keras.models.Sequential()

这里还有另一种方法：class MyModel

class MyModel(Model):   
    def __init__(self):   
        super(MyModel, self).__init__()   
        初始化网络结构，搭建出神经网络所需的各种网络结构块
    def call(self, x):   
        调用网络结构块，实现前向传播
        return y
model = MyModel()

配置训练方法，选择训练时使用的优化器、损失函数和评价指标 model.compile

model.compile()

执行训练过程，告知训练集和测试集的输入值和标签、每个batch的大小batch_size、数据集的迭代次数epoch model.fit

model.fit()

打印网络结构，统计参数数目 model.summary

model.summary()

函数用法

Sequential()

Sequential函数是一个容器，描述了神经网络的网络结构，在Sequential函数的输入参数中描述从输入层到输出层的网络结构

model = tf.keras.models.Sequential([网络结构])    # 描述各层网络

网络结构举例：

拉直层：可以变换张量的尺寸，把输入特征拉直为一维数组，只是形状转换，不含计算参数

tf.keras.layers.Flatten()

全连接层：又叫Dense层

tf.keras.layers.Dense(神经元个数,
                      activation="激活函数",   # 字符串给出，可选relu、softmax、sigmoid、tanh等
                      kernel_regularizer="正则化方式")   # 可选tf.keras.regularizers.l1()、tf.keras.regularizers.l2()

卷积层：卷积神经网络

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

LSTM层：循环神经网络

tf.keras.layers.LSTM()

compile()

用于配置神经网络的训练方法，告知训练时使用的优化器、损失函数和准确率评测标准

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

（1）optimizer可以是字符串形式给出的优化器名字，也可以是函数形式（可以设置学习率、动量等超参数）。建议入门时，先使用左边字符串形式的优化器名字，等掌握了整个框架后，可通过TensorFlow官网查询这些函数的具体用法，调节超参数

https://tensorflow.google.cn/api_docs/python/tf/keras/optimizers/experimental/SGD

‘sgd’ or tf.keras.optimizers.SGD(lr=学习率,
                                 decay=学习率衰减率,
                                 momentum=动量参数)

‘adagrad’ or tf.keras.optimizers.Adagrad(lr=学习率,
                                         decay=学习率衰减率)

‘adadelta’ or tf.keras.optimizers.Adadelta(lr=学习率,
                                           decay=学习率衰减率)

‘adam’ or tf.keras.optimizers.Adam (lr=学习率,
                                    beta_1=0.9,
                                    beta_2=0.999)

（2）loss可以是字符串形式给出的损失函数的名字，也可以是函数形式

‘mse’ or tf.keras.losses.MeanSquaredError()
‘sparse_categorical_crossentropy' or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)   # from_logits 是否是原始输出，即未经过概率分布的输出

损失函数常需要经过softmax函数将输出转化为概率分布的形式。from_logits用来标注该损失函数是否需要转换为概率的形式，取False表示转化为概率分布，取True表示没有转化为概率分布，直接输出

（3）metrics标注网络评测指标

# y_是标签，y是网络输出结果
‘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_data=(测试集的输入特征，测试集的标签),
           validation_split=从训练集划分多少比例给测试集，
           validation_freq = 多少次epoch测试一次)

summary()

用于打印网络结构和参数统计

model.summary()

对于一个输入为4输出为3的全连接网络，共有15个参数（12个w+3个b）

iris分类代码复现

（一）Sequential搭建

# 1-import
import tensorflow as tf
from sklearn import datasets
import numpy as np

# 2-train test
'''
测试集的输入特征x_test 和 标签y_test 可以像x_train和y_train一样直接从数据集获取
也可以在fit中按比例从训练集中划分（本代码采用这种方式，所以只需加载x_train和y_train即可）
'''
x_train = datasets.load_iris().data
y_train = datasets.load_iris().target
# 以下代码实现了数据集的乱序
np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

# 3-models.Sequential   逐层搭建网络结构
'''
单层全连接神经网络，三个参数分别为：
神经元个数；网络所使用的激活函数；正则化方法
'''
model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])

# 4-model.compile   配置训练方法
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),   # SGD优化器，学习率设置为0.1
              # 由于神经网络输出使用了softmax激活函数，使得输出是概率分布，而不是原始输出，故from_logits=False
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              # iris数据集的标签是0/1/2这样的数值，而网络前向传播输出为概率分布
              metrics=['sparse_categorical_accuracy'])

# model.fit   执行训练过程
model.fit(x_train,   # 训练集输入特征
          y_train,   # 训练集标签
          batch_size=32,    # 训练时一次喂入神经网络多少组数据
          epochs=500,    # 数据集迭代循环多少次
          validation_split=0.2,    # 从训练集中选择20%的数据作为测试集
          validation_freq=20)   # 每迭代20次训练集要在测试集中验证一次准确率

# model.summary  打印网络结构，统计参数数目
model.summary()

iris数据集输入是4个特征，是三分类问题

这里test是用 validation_split=0.2 划分的（法1：在model.fit中按比例从训练集中划分，就不用写x_test和y_test了）

法2：也可以像x_train和y_train一样直接给定

以上是测试集test的两种划分方式

（二）类class搭建

使用Sequential可以快速搭建出上层输出就是下层输入的顺序网络结构，但如果网络包含跳连（Skip Connection）等复杂非顺序网络结构，Sequential就无法表示了，需要使用class类封装网络结构

class模板

class MyModel(Model):   # MyModel为声明的神经网络的名字，括号中的Model表示创建的类需要继承TensorFlow库中的Model类
# 类中需要定义两个函数
    def __init__(self):   #类的构造函数，用于初始化类的参数
        super(MyModel, self).__init__()   # 初始化父类的参数
        初始化网络结构，搭建出神经网络所需的各种网络结构块
    def call(self, x):   #调用__init__()函数完成初始化的网络块，实现前向传播并返回推理值
        调用网络结构块，实现前向传播
        return y

model = MyModel()

可以认为 __init__() 定义所需网络结构块，准备出搭建网络所需的各种积木，call()函数调用 __init__() 中搭建好的积木，实现前向传播

使用class方式搭建iris网络结构

class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        # 在__init__函数中定义了要在call函数中调用的具有三个神经元的全连接网络Dense
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())   # d1是给这一层起的名字，每一层都用self.引导

    def call(self, x):
        y = self.d1(x)    # 在call函数中调用self.d1实现了从输入x输出y的前向传播
        return y

搭建好网络结构后，只需要使用 Model = MyModel() 构建类的对象，就可以使用该模型了

model = IrisModel()   # 实例化

完整代码

这里我遇到了两个报错：

cannot import name ‘dtensor‘ from ‘tensorflow.compat.v2.experimental‘

原因：keras版本太高，需要降低到和TensorFlow版本一致，我这里TensorFlow是2.8.0，keras降到2.8.0即可

报错：cannot import name ‘dtensor‘ from ‘tensorflow.compat.v2.experimental‘ (/Users/pxs/anaconda3/lib - CSDN博客

cannot find reference ‘keras’ in ‘__init__.py‘

这两行代码下一直有红波浪线，但代码可以运行

原因：PyCharm找不到引用，改为下面代码即可

from keras.layers import Dense   # Dense层
from keras import Model   # Model模块

cannot find reference ‘keras’ in ‘__init__.py‘ - CSDN博客

解决上面两个问题后，完整代码如下：

# 和Sequential方法相比，改动的地方用##数字##标注出
import tensorflow as tf
from keras.layers import Dense  ##1##
from keras import Model  ##2##
from sklearn import datasets
import numpy as np

x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

##3##
class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())   # 在__init__函数中定义了要在call函数中调用的具有三个神经元的全连接网络Dense

    def call(self, x):
        y = self.d1(x)    # 在call函数中调用self.d1实现了从输入x输出y的前向传播
        return y
##4##
model = IrisModel()   # 实例化

model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

model.summary()

MNIST手写数字识别数据集

数据集介绍

一共7万张图片，是28×28=784个像素的0-9手写数字数据集，其中6万张用于训练，1万张用于测试

import tensorflow as tf
from matplotlib import pyplot as plt

# 导入数据集
mnist = tf.keras.datasets.mnist   # keras函数库提供了使用mnist数据集的接口
(x_train, y_train), (x_test, y_test) = mnist.load_data()   # load_data()直接从mnist中读取测试集和训练集

# 可视化训练集输入特征的第一个元素
plt.imshow(x_train[0], cmap='gray')  # 绘制灰度图
plt.show()

# 打印出训练集输入特征的第一个元素
print("x_train[0]:\n", x_train[0])    # 28行28列个像素值的二维数组（0表示纯黑色，255表示纯白色）
# 打印出训练集标签的第一个元素
print("y_train[0]:\n", y_train[0])    # 数值5

# 打印出整个训练集输入特征形状
print("x_train.shape:\n", x_train.shape)   # 6万个28行28列的数据
# 打印出整个训练集标签的形状
print("y_train.shape:\n", y_train.shape)   # 6万个标签
# 打印出整个测试集输入特征的形状
print("x_test.shape:\n", x_test.shape)   # 1万个28行28列的三维数据
# 打印出整个测试集标签的形状
print("y_test.shape:\n", y_test.shape)   # 1万个标签

训练MNIST数据集

使用全连接网络，将784个像素点（灰度值）组成的长度为784的一维数组作为输入特征

输入全连接网络时需要先将数据拉直为一维数组 tf.keras.layers.Flatten()

训练时需要将输入特征的灰度值归一化到 [0,1] 区间，这可以使网络更快收敛

（一）Sequential搭建

# 用Sequential实现手写数字识别训练

# 1-import
import tensorflow as tf

# 2-train test
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0    # 对输入网络的输入特征进行归一化，使原本0-255之间的灰度值变成0-1之间的数值
# 把输入特征的数值变小更适合神经网络吸收

# 用Sequential搭建网络   3-models.Sequential
model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(),   # 先把输入特征拉直为一维数组，即748个数值
        tf.keras.layers.Dense(128, activation='relu'),    # 定义第一层网络有128个神经元
        tf.keras.layers.Dense(10, activation='softmax')    # 定义第二层网络有10个神经元，使输出符合概率分布
])

# 用compile配置训练方法   4-model.compile
model.compile(optimizer='adam',   # 优化器
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),   # 损失函数
              # 由于第二层网络用了softmax让输出符合概率分布了，不是直接输出的，所以from_logits=False
              # 如果输出不满足概率分布，要=True
              metrics=['sparse_categorical_accuracy'])  # 数据集中的标签是数值，神经网络输出y是概率分布

# 在fit中执行训练过程   5-model.fit
model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)   # validation_freq=1 每迭代一次训练集，执行一次测试集的评测

# 打印出网络结构和参数统计   6-model.summary
model.summary()

MNIST数据集有60000张图片用来训练，batch_size=32，所以每轮要迭代60000/32=1875次，共迭代5轮，即5 epochs

训练时每个step给出的是训练集accuracy，不具有参考价值。有实际评判价值的是validation_freq中设置的、隔若干轮输出的测试集accuracy

（二）类class搭建

# 用类实现手写数字识别训练
# 和Sequential方法相比，只是实例化model的方法不同
import tensorflow as tf
from keras.layers import Dense, Flatten
from keras import Model

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

class MnistModel(Model):
    def __init__(self):   # 定义call函数中所用到的层
        super(MnistModel, self).__init__()
        self.flatten = Flatten()
        self.d1 = Dense(128, activation='relu')
        self.d2 = Dense(10, activation='softmax')

    def call(self, x):   # 从输入x到输出y，走过一次前向传播返回输出y
        x = self.flatten(x)
        x = self.d1(x)
        y = self.d2(x)
        return y

model = MnistModel()   # 实例化model

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)

model.summary()

FASHION衣裤识别数据集及训练

Fashion_mnist数据集与MNIST数据集几乎一样，包括6w张训练图片和1w张测试图片，图片被分为十类（如T恤、裤子、套头衫等等），每张图片为28×28的分辨率（像素点的灰度值数据）

训练衣服、裤子等图片的识别模型：与训练MNIST数据集的不同之处就是加载数据集的代码不同，在此不再赘述

fashion = tf.keras.datasets.fashion_mnist
(x_train, y_train),(x_test, y_test) = fashion.load_data()   # 可以使用.load_data()直接从fashion数据集中读取训练集和测试集

最后准确率为86.85%

【3-神经网络八股】北京大学TensorFlow2.0

神经网络搭建八股

keras介绍

六步法

函数用法

Sequential()

compile()

fit()

summary()

iris分类代码复现

（一）Sequential搭建

（二）类class搭建

class模板

使用class方式搭建iris网络结构

完整代码

MNIST手写数字识别数据集

数据集介绍

训练MNIST数据集

（一）Sequential搭建

（二）类class搭建

FASHION衣裤识别数据集及训练

相关文章