tf.keras搭建神经网络八股：六步法，实践鸢尾花分类、MNIST手写数字识别、Fashion
keras简介
Keras官方文档
tensorflow2引入的高封装度的框架用于快速搭建神经网络模型，为支持快速实验而生深度学习框架之中最终易上手的一个，提供了一致而简洁的API，能够极大地减少一般应用下的工作量，提高代码地封装程度和复用性学习API：阅读源码和注释
1. 在pycharm集成开发环境中查看框架源码 将鼠标放置在函数上按住Ctrl键，会显示函数的基本信息，包括封装函数的类，函数入口参数，函数功能等；按住Ctrl键点击函数会跳转到函数的源代码部分，使用者可以根据源码和注释进一步了解函数的实现方法。 2. 在tensorflow官网中查询函数文档TensorFlow API
tf.keras搭建神经网络“六步法”
第一步：import相关模块比如import tensorflow as tf。
第二步：指定输入网络的训练集和测试集告知要喂入的训练集、测试集是什么，如指定训练集的输入x_train和标签y_train，测试集的输入x_test和标签y_test。
第三步：逐层搭建网络结构注：tensorflow2.* 以后的版本可以直接使用tf.keras.Sequential()和tf.keras.Model()两个类。不用再使用keras.models的API。
1. tf.keras.models.Sequential()（顺序结构） 在sequential()中搭建网络结构，逐层描述每层网络，相当于走了一遍前向传播。Sequential函数是一个容器，描述了神经网络的网络结构，在Sequential函数的输入参数中描述从输入层到输出层的网络结构。拉直层：拉直层可以变换张量的尺寸，把输入特征拉直为一维数组，是不含计算参数的层。
tf.keras.layers.Flatten() 1
全连接层：
tf.keras.layers.Dense( 神经元个数,activation=”激活函数”,kernel_regularizer=”正则化方式”) 123 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”) 1234
LSTM层：
tf.keras.layers.LSTM() 1
示例：
import tensorflow as tf from tensorflow.keras import layers, models model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(10, activation='softmax')) 12345678910111213
也可以不使用.add方法。直接在Sequntial里放入层列表：
import tensorflow as tf from tensorflow.keras import layers, models model = models.Sequential([ layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu'), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu'), layers.Flatten(), layers.Dense(64, activation='relu'), layers.Dense(10, activation='softmax') ]) 12345678910111213 2. 使用类/class（非顺序结构）
使用Sequential()可以快速搭建网络结构，但是如果网络包含跳连等其他复杂网络结构，Sequential()就无法表示了。这就需要使用class来声明网络结构。如下是使用class类封装网络结构的模板：
class MyModel(Model):def __init__(self):super(MyModel, self).__init__()初始化网络结构def call(self, x):y = self.d1(x)return y 1234567 MyModel表示声明的神经网络的名字，括号中的Model表示创建的类需要继承tensorflow库中的Model类。__init__()函数为类的构造函数用于初始化类的参数，spuer(MyModel,self).__init__()这行表示初始化父类的参数。之后便可初始化网络结构,搭建出神经网络所需的各种网络结构块。call()函数中调用__init__()函数中完成初始化的网络块，实现前向传播并返回推理值。
搭建好网络结构后只需要使用Model=MyModel()构建类的对象，就可以使用该模型了。
3. tf.keras.models.Model() 搭建多输入多输出的网络。流程使用keras.Input定义输入张量shape； 创建网络层，定义每层的输入和输出张量；keras.models.Model确定输入张量和输出层，keras可以根据每一层的输入输出关系完成整个网络图的创建。import tensorflow as tf from tensorflow.keras import layers, models, Input input_tensor = Input(shape=(32, 32, 3)) x = layers.Conv2D(32, (3, 3), activation='relu')(input_tensor) x = layers.MaxPooling2D((2, 2))(x) x = layers.Conv2D(64, (3, 3), activation='relu')(x) x = layers.MaxPooling2D((2, 2))(x) x = layers.Conv2D(64, (3, 3), activation='relu')(x) output_tensor1=layers.Flatten()(x) x = layers.Dense(64, activation='relu')(output_tensor1) output_tensor2 = layers.Dense(10, activation='softmax')(x) model = models.Model(inputs=input_tensor, outputs=[output_tensor1, output_tensor2]) model.summary() 123456789101112131415
TensorFlow2网络结构的搭建方法及共享权重问题
第四步：配置训练方法 在model.compile()中配置训练方法，选择训练时使用的优化器、损失函数和最终评价指标。Model.compile( optimizer = 优化器,loss = 损失函数,metrics = [“准确率”]) 123
optimizer 可以是字符串形式给出的优化器名字，也可以是函数形式，使用函数形式可以设置学习率、动量和超参数。
字符串形式函数形式‘sgd’tf.optimizers.SGD( lr=学习率,decay=学习率衰减率,momentum=动量参数)‘adagrad’tf.keras.optimizers.Adagrad(lr=学习率,decay=学习率衰减率)‘adadelta’tf.keras.optimizers.Adadelta(lr=学习率,decay=学习率衰减率)‘adam’tf.keras.optimizers.Adam (lr=学习率,decay=学习率衰减率)Loss可以是字符串形式给出的损失函数的名字，也可以是函数形式。
字符串形式函数形式‘mse’tf.keras.losses.MeanSquaredError()‘sparse_categorical_crossentropy’tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)‘categorical_crossentropy’‘binary_crossentropy’‘hinge’‘squared_hinge’损失函数常需要经过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]。*‘accuracy’：准确率Tensorflow2.0 model.compile详细介绍
第五步：执行训练过程 在model.fit()中执行训练过程，告知训练集和测试集的输入值和标签、每个batch的大小（batchsize）和数据集的迭代次数（epoch）。model.fit(训练集的输入特征， 训练集的标签， batch_size, epochs,validation_data = (测试集的输入特征，测试集的标签)，validataion_split = 从测试集划分多少比例给训练集，validation_freq = 测试的epoch间隔次数) 1234 x_train,y_train分别表示网络的输入特征和标签，batch_size表示一次喂入神经网络的数据量，epochs表示数据集的迭代次数validation_split表示数据集中测试集的划分比例，validation_freq表示每迭代多少次在测试集上测试一次准确率。 第六步：打印网络结构，统计参数数目 使用model.summary()打印网络结构，统计参数数目。
实例
1.iris数据集 tf.keras.models.Sequential()#-------第一步：import相关模块------ import tensorflow as tf from sklearn import datasets import numpy as np #-------第二步：指定输入网络的训练集和测试集------ #1.测试集的输入特征x_test和标签y_test可以像x_train和y_train一样直接从数据集获取； #2.在model.fit()中按比例从训练集中划分。 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(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2()) ]) #-------第四步：配置训练方法------- #由于神经网络输出使用了softmax激活函数，使得输出是概率分布，而不是原始输出，所以需要将from_logits参数设置为False； #鸢尾花数据集给的标签是0，1，2这样的数值，而网络前向传播的输出为概率分布，所以metrics需要设置为sparse_categorical_accuracy。 model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) #-------第五步：在model.fit()中执行训练过程------- model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20) #-------第六步：打印网络结构，统计参数数目------- model.summary()
1234567891011121314151617181920212223242526272829303132333435 使用类/class#-------第一步：import相关模块------ 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()中执行训练过程------- model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20) #-------第六步：打印网络结构，统计参数数目------- model.summary()
123456789101112131415161718192021222324252627282930313233343536373839 使用Sequential()方法和class方法的区别：(1). import中添加了Model模块和Dense层、Flatten层。
(2). 使用class声明网络结构，model = IrisModel()初始化模型对象。
MNIST数据集一共有7万张图片，是28×28像素的0到9手写数字数据集，其中6万张用于训练，1万张用于测试。每张图片包括 784 （ 28 × 28 ） 784（28times28） 784（28×28）个像素点，使用全连接网络时可将784个像素点组成长度为784的一维数组，作为输入特征。数据集图片如下所示。
导入数据集
import tensorflow as tf from matplotlib import pyplot as plt #keras函数库中提供了使用mnist数据集的接口 mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() 12345
使用plt库中的两个函数可视化训练集中的图片
# 可视化训练集输入特征的第一个元素 plt.imshow(x_train[0], cmap='gray') # 绘制灰度图 plt.show() 123
使用print打印出训练集中第一个样本以二位数组的形式打印出来
# 打印出训练集输入特征的第一个元素 print("x_train[0]:n", x_train[0]) # 打印出训练集标签的第一个元素 print("y_train[0]:n", y_train[0]) 1234
打印出测试集样本的形状，共有10000个28行28列的三维数据
# 打印出整个训练集输入特征形状 print("x_train.shape:n", x_train.shape) # 打印出整个训练集标签的形状 print("y_train.shape:n", y_train.shape) # 打印出整个测试集输入特征的形状 print("x_test.shape:n", x_test.shape) # 打印出整个测试集标签的形状 print("y_test.shape:n", y_test.shape) 12345678 训练MNIST数据集
使用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()
123456789101112131415161718使用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()
123456789101112131415161718192021222324252627282930值得注意的是训练时需要将输入特征的灰度值归一化到[0,1]区间，这可以使网络更快收敛。
训练时每个step给出的是训练集accuracy不具有参考价值，有实际评判价值的是validation_freq中设置的隔若干轮输出的测试集accuracy。
Fashion_mnist数据集具有mnist近乎所有的特征，包括60000张训练图片和10000张测试图片，图片被分为十类，每张图像为28×28的分辨率。
import tensorflow as tf fashion = tf.keras.datasets.fashion_mnist (x_train, y_train),(x_test, y_test) = fashion.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()
123456789101112131415161718import tensorflow as tf from tensorflow.keras.layers import Dense, Flatten from tensorflow.keras import Model fashion = tf.keras.datasets.fashion_mnist (x_train, y_train),(x_test, y_test) = fashion.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()
12345678910111213141516171819202122232425262728293031北大人工智能实践：Tensorflow笔记
相关知识
TensorFlow学习记录（八）
神经网络与深度学习
神经网络与深度学习（五）前馈神经网络（3）鸢尾花分类
深度学习应用开发
Tensorflow学习笔记——搭建神经网络
pytorch实现简单卷积神经网络（CNN）网络完成手写数字识别
34 花卉识别
基于神经网络——鸢尾花识别（Iris）
“花朵分类“ 手把手搭建【卷积神经网络】
手写数字识别
网址: tf.keras搭建神经网络八股：六步法，实践鸢尾花分类、MNIST手写数字识别、Fashion https://m.huajiangbk.com/newsview764605.html
| 上一篇: 【深度学习】详解CNN实现手写数 |
下一篇: 毕业设计项目 深度学习手写数字识 |
