tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集

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

全连接层

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

示例:

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

也可以不使用.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')
])

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

TensorFlow2网络结构的搭建方法及共享权重问题

第四步:配置训练方法

  • model.compile()中配置训练方法,选择训练时使用的优化器、损失函数和最终评价指标
Model.compile( optimizer = 优化器,
				loss = 损失函数,
				metrics = [“准确率”])

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间隔次数)
  • x_train,y_train分别表示网络的输入特征和标签,
  • batch_size表示一次喂入神经网络的数据量,
  • epochs表示数据集的迭代次数
  • validation_split表示数据集中测试集的划分比例,
  • validation_freq表示每迭代多少次在测试集上测试一次准确率。

第六步:打印网络结构,统计参数数目

  • 使用model.summary()打印网络结构,统计参数数目。
tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第1张图片

实例

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

使用类/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()

使用Sequential()方法和class方法的区别:

(1). import中添加了Model模块和Dense层、Flatten层。
(2). 使用class声明网络结构,model = IrisModel()初始化模型对象。

2.MNIST数据集

数据集介绍

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

tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第2张图片

导入、查看数据集

导入数据集

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

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

# 可视化训练集输入特征的第一个元素
plt.imshow(x_train[0], cmap='gray')  # 绘制灰度图
plt.show()
tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第3张图片

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

# 打印出训练集输入特征的第一个元素
print("x_train[0]:\n", x_train[0])
# 打印出训练集标签的第一个元素
print("y_train[0]:\n", y_train[0])
tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第4张图片

打印出测试集样本的形状,共有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)

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

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

值得注意的是训练时需要将输入特征的灰度值归一化到[0,1]区间,这可以使网络更快收敛。
tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第5张图片
训练时每个step给出的是训练集accuracy不具有参考价值,有实际评判价值的是validation_freq中设置的隔若干轮输出的测试集accuracy。
tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第6张图片

3.Fashion-mnist数据集

  Fashion_mnist数据集具有mnist近乎所有的特征,包括60000张训练图片和10000张测试图片,图片被分为十类,每张图像为28×28的分辨率。
tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第7张图片 tf.keras搭建神经网络八股:六步法,实践鸢尾花分类、MNIST手写数字识别、Fashion-mnist数据集_第8张图片

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

北大人工智能实践:Tensorflow笔记

你可能感兴趣的:(深度学习框架)