TensorFlow支持递归神经网络：搭建与训练

1.tf.keras 搭建神经网络六步法

第一步：import 相关模块，如 import tensorflow as tf。

第二步：指定输入网络的训练集和测试集，如指定训练集的输入 x_train 和标签
y_train，测试集的输入 x_test 和标签 y_test。

第三步：逐层搭建网络结构，model = tf.keras.models.Sequential()。

第四步：在 model.compile()中配置训练方法，选择训练时使用的优化器、损失
函数和最终评价指标。

第五步：在 model.fit()中执行训练过程，告知训练集和测试集的输入值和标签、
每个 batch 的大小（batchsize）和数据集的迭代次数（epoch）。

第六步：使用 model.summary()打印网络结构，统计参数数目。

2.函数用法介绍

1.tf.keras.models.Sequential()
Sequential 函数是一个容器，描述了神经网络的网络结构，在 Sequential
函数的输入参数中描述从输入层到输出层的网络结构。

2.拉直层：tf.keras.layers.Flatten()
拉直层可以变换张量的尺寸，把输入特征拉直为一维数组，是不含计算参数的层。

3.全连接层：tf.keras.layers.Dense( 神经元个数,activation=”激活函数”,kernel_regularizer=”正则化方式”)
其中：
activation（字符串给出）可选 relu、softmax、sigmoid、tanh 等
kernel_regularizer 可选 tf.keras.regularizers.l1()、
tf.keras.regularizers.l2()

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

5.LSTM 层：tf.keras.layers.LSTM()

6.Model.compile( optimizer = 优化器, loss = 损失函数, metrics = [“准确率”]) Compile 用于配置神经网络的训练方法，告知训练时使用的优化器、损失函数和准确率评测标准。
其中： optimizer 可以是字符串形式给出的优化器名字，也可以是函数形式，使用函数
形式可以设置学习率、动量和超参数。

7.model.fit(训练集的输入特征， 训练集的标签， batch_size, epochs, validation_data = (测试集的输入特征，测试集的标签)， validataion_split = 从测试集划分多少比例给训练集， validation_freq = 测试的 epoch 间隔次数)
fit 函数用于执行训练过程

8.model.summary()
summary 函数用于打印网络结构和参数统计

3.iris 数据集代码复现

1.使用 Sequential 快速搭建鸢尾花分类神经网络

网络结构

登录后复制

#第一步：import 相关模块：
import tensorflow as tf
from sklearn import datasets
import numpy as np

#第二步：指定输入网络的训练集和测试集：
x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

# 其中测试集的输入特征 x_test 和标签 y_test 可以像 x_train 和 y_train 一
# 样直接从数据集获取，也可以如上述在 fit 中按比例从训练集中划分，本例选择
# 从训练集中划分，所以只需加载 x_train，y_train 即可。

# 实现数据集的乱序
np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

# 第三步：逐层搭建网络结构：
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])
# 如上所示，本例使用了单层全连接网络，第一个参数表示神经元个数，第二
# 个参数表示网络所使用的激活函数，第三个参数表示选用的正则化方法。


# 第四步：在 model.compile()中配置训练方法：
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])
# 如上所示，本例使用 SGD 优化器，并将学习率设置为 0.1 ，选择
# SparseCategoricalCrossentrop 作为损失函数。由于神经网络输出使用了
# softmax 激活函数，使得输出是概率分布，而不是原始输出，所以需要将
# from_logits 参数设置为 False。鸢尾花数据集给的标签是 0，1，2 这样的数值，
# 而网络前向传播的输出为 概率分布，所以 metrics 需要设置为
# sparse_categorical_accuracy。


# 第五步：在 model.fit()中执行训练过程:
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
# 在 fit 中执行训练过程,x_train,y_train 分别表示网络的输入特征和标签，
# batch_size 表示一次喂入神经网络的数据量，epochs 表示数据集的迭代次数
# validation_split 表示数据集中测试集的划分比例，validation_freq 表示每迭
# 代 20 次在测试集上测试一次准确率。

# 第六步：使用 model.summary()打印网络结构，统计参数数目
model.summary()

2.使用class快速搭建鸢尾花分类神经网络

使用 Sequential 可以快速搭建网络结构，但是如果网络包含跳连等其他复
杂网络结构，Sequential 就无法表示了。这就需要使用 class 来声明网络结构。

登录后复制

class MyModel(Model):
	def __init__(self):
		super(MyModel, self).__init__()
 		#初始化网络结构
	def call(self, x):
		y = self.d1(x)
		return y
		
		

使用 class 类封装网络结构，如上所示是一个 class 模板，MyModel 表示声明的神经网络的名字，括号中的 Model 表示创建的类需要继承 tensorflow 库中的 Model 类。类中需要定义两个函数，__ init__()函数为类的构造函数用于初始化类的参数，spuer(MyModel,self).__ init__()这行表示初始化父类的参数。之后便可初始化网络结构,搭建出神经网络所需的各种网络结构块。call()函数中调用__init__()函数中完成初始化的网络块，实现前向传播并返回推理值。使用 class 方式搭建鸢尾花网络结构的代码如下所示。

登录后复制

class IrisModel(Model):
	def __init__(self):
		super(IrisModel, self).__init__()
		self.d1 = Dense(3,activation='sigmoid',kernel_regularizer=tf.keras.regularizers.l2())
	def call(self, x):
		y = self.d1(x)
		return y
		
		

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

使用class的完整代码如下:

登录后复制

import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
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)

class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x):
        y = self.d1(x)
        return y

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()

对比使用 Sequential()方法和 class 方法，有两点区别：

①import 中添加了 Model 模块和 Dense 层、Flatten 层。

②使用 class 声明网络结构，model = IrisModel()初始化模型对象。

4.MNIST 数据集

1.介绍

MNIST 数据集一共有 7 万张图片，是 28×28 像素的 0 到 9 手写数字数据集，其中 6 万张用于训练，1 万张用于测试。每张图片包括 784（28×28）个像素点，使用全连接网络时可将 784 个像素点组成长度为 784 的一维数组，作为输入特征。

数据集图片如下所示:

2.导入数据集

1.keras 函数库中提供了使用 mnist 数据集的接口，代码如下所示，可以使用load_data()直接从 mnist 中读取测试集和训练集。

登录后复制

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

2.输入全连接网络时需要先将数据拉直为一维数组，把 784 个像素点的灰度值作为输入特征输入神经网络。

登录后复制

tf.keras.layers.Flatten()

3.使用 plt 库中的两个函数可视化训练集中的图片.

登录后复制

plt.imshow(x_train[0],cmap=’gray’)
plt.show()

4.使用 print 打印出训练集中第一个样本以二位数组的形式打印出来，如下

所示。

登录后复制

print(“x_train[0]:”,x_train[0])

5.打印出第一个样本的标签，为 5。

登录后复制

print("y_train[0]:\n", y_train[0])

6.打印出测试集样本的形状，共有 60000 个 28 行 28 列的三维数据。

登录后复制

print(“x_test.shape:”x_test.shape)

3. 训练 MNIST 数据集

1.使用 Sequential 实现手写数字识别

登录后复制

import tensorflow as tf

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

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

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()

2.使用 class 实现手写数字识别

登录后复制

import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.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):
        super(MnistModel, self).__init__()
        self.flatten = Flatten()
        self.d1 = Dense(128, activation='relu')
        self.d2 = Dense(10, activation='softmax')

    def call(self, x):
        x = self.flatten(x)
        x = self.d1(x)
        y = self.d2(x)
        return y


model = MnistModel()

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()

免责声明：本文系网络转载或改编，未找到原创作者，版权归原作者所有。如涉及版权，请联系删