Tensorflow⑤——用keras搭建神经网络框架

tf.keras 是 tensorflow2 引入的高封装度的框架，可以用于快速搭建神经网络模型，keras 为支持快速实验而生，能够把想法迅速转换为结果，是深度学习框架之中最终易上手的一个，它提供了一致而简洁的 API，能够极大地减少一般应用下的工作量，提高代码地封装程度和复用性。

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

搭建神经网络六部法

tf.keras 搭建神经网络六部法

import
train, test
model = tf.keras.models.Sequential / class MyModel(Model) model=MyModel
model.compile
model.fit
model.summary

第一步：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()打印网络结构，统计参数数目。

函数用法介绍

tf.keras.models.Sequential()

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

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

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

---

全连接层：

tf.keras.layers.Dense( 神经元个数,
					   activation=”激活函数”,
                       kernel_regularizer=”正则化方式”)

其中：

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

卷积层：

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

LSTM 层：

tf.keras.layers.LSTM() 

常用如：

model = tf.keras.models.Sequential([
	# tf.keras.layers.Dense(神经元个数, activation='激活函数', kernel_regularizer=正则化方式)
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2)
])

model.compile

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

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

• optimizer 可以是字符串形式给出的优化器名字，也可以是函数形式，使用函数形式可以设置学习率、动量和超参数。
  可选项包括：

   ‘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=学习率,
									  decay=学习率衰减率)

• loss 可以是字符串形式给出的损失函数的名字，也可以是函数形式。
  可选项包括：

   ‘mse’or tf.keras.losses.MeanSquaredError()
   ‘sparse_categorical_crossentropy or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
   # 损失函数常需要经过 softmax 等函数将输出转化为概率分布的形式。
   # from_logits 则用来标注该损失函数是否需要转换为概率的形式，取 False 时表示已经转化为概率分布，取 True 时表示没有转化为概率分布，直接输出。

• 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]。

model.fit：用于执行训练过程

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

model.summary()

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

举例

• 以sklearn中的iris数据集为例，使用Sequential函数进行初始化，用6步法进行准确率识别

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
import numpy as np
from sklearn import datasets

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)

model = tf.keras.models.Sequential([
# tf.keras.layers.Dense( 神经元个数, activation='激活函数', kernel_regularizer=正则化方式 )
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])

# Model.compile( optimizer = 优化器, loss = 损失函数, metrics = ['准确率'])
model.compile(
    # optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),
    optimizer=tf.keras.optimizers.SGD(lr=0.1),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
    metrics=['sparse_categorical_accuracy']
)

# model.fit(训练集的输入特征， 训练集的标签， batch_size, epochs,
#  		    validation_data = (测试集的输入特征，测试集的标签)，
#  		    validataion_split = 从测试集划分多少比例给训练集，
#  		    validation_freq = 测试的 epoch 间隔次数)
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

model.summary()

• 以sklearn中的iris数据集为例，使用class函数进行初始化，用6步法进行准确率识别

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
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, training=None, mask=None):
    # 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()