课程来源：人工智能实践:Tensorflow笔记2

文章目录

• 前言
• 一、搭建网络八股sequential
• • 1.函数介绍
  • 2.6步法实现鸢尾花分类
• 二、搭建网络八股class
• • 1.创建自己的神经网络模板：
  • 2.调用自己创建的model对象
• 三、MNIST数据集
• • 1.用sequential搭建网络实现手写数字识别
  • 2.用类搭建网络实现手写数字识别
• 四、FASHION数据集
• • 用sequential搭建网络实现衣裤识别
• 总结

---

前言

本讲目标:使用八股搭建神经网络 神经网络搭建八股 iris代码复现 MNIST数据集 训练MNIST数据集 Fashion数据集

---

一、搭建网络八股sequential

使用六步法，使用TensorFlow的API: tf.keras搭建网络八股
1、import 导入相关模块
2、train、test 告知要喂入网络的训练集、测试集是什么，也就是要指定训练集、测试集的输入特征和训练集的标签
3、model = tf.keras.models.Sequential 在sequential()中搭建网络结构，逐层描述每层网络，相当于走了一遍前向传播
4、model.compile 在compile中配置训练方法，告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标
5、model.fit 在fit中执行训练过程，告知训练集和测试集的输入特征和标签，告知每个batch是多少，告知要迭代多少次数据集
6、model.summary 用summary打印出网络的结构和参数统计

1.函数介绍

sequential()用法：
model = tf.keras.models.Sequential([网络结构]) #描述各层网络
网络结构举例：
拉直层：tf.keras.layers.Flatter()
全连接层：tf.keras.layers.Dense(神经元个数,activation=“激活函数”,kernel_regularizer=哪种正则化)
activation(字符串给出) 可选：relu、softmax、signoid、tanh
kernel_regularizer可选:kernel_regularizer.l1()、kernel_regularizer.l2()
卷积层：tf.keras.layers.Conv2D(filters=卷积核个数,kernel_size=卷积核尺寸,strides=卷积步长,padding=“vaild” or “same”)
LSTM层：tf.kreas.layers.LSTM()

compile() 用法：
model.compile(optimizer =优化器,loss =损失函数,metrics=[“准确率”])
optimizer 可选：
‘sgd’ or tf.keras.optimizers.SGD(lr=学习率,momentum=动量参数)
‘adagrad’ or tf.keras.optimizers.Adagrad(lr=学习率)
‘adadelta’ or tf.keras.optimizers.Adadelta(lr=学习率)
‘adam’ or tf.keras.optimizers.Adam(lr=学习率,beta_1=0.9,beta_2=0.999)
loss 可选：
‘mse’ or tf.keras.losses.MeanSquaredError()
‘sparse_categorical_crossentropy’ or tf.keras.losses.SparseCategoricalCrossentropy(from_logits =False)
(有的神经网络的输出是经过了softmax等函数的概率分布，有些则不经概率分布直接输出，from_logits 是在询问是否是原始输出)
Metrics 可选：
‘accuracy’:y_pred和y都是数值，如y_pred=[1] y=[1]
‘categorical_accuracy’:y_pred 和 y 都是独热码(概率分布),如y_pred=[0,1,0], y=[0.5,0.5,0.5]
‘sparse_categorical_accuracy’:y_pred是数值，y是独热编码,y_pred=[1],y=[0.5,0.5,0.5]

fit()用法：
model.fit(训练集的输入特征,训练集的标签,
​ batch_size = ,epochs = ,
​ validation_data =(测试集的输入特征,测试集的标签),
​ validation_split =从训练集划分多少比例给测试集,
​ validation_freq =多少次epoch测试一次)

model()用法：
model.summary()

2.6步法实现鸢尾花分类

代码如下：

import tensorflow as tf
from sklearn import datasets
import numpy as np

#由于这里是选择从训练集划分出测试集，所以不需要单独导入test
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个神经元，softmax激活，L2正则化
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])
#SGD优化器、学习率0.1，使用SparseCategoricalCrossentropy作为损失函数，由于神经网络末端使用softmax函数，输出为概率分布，所以from_logits为false
#鸢尾花数据集给的标签为0,1,2，神经网络前向传播的输出是概率分布，使用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'])
#输入训练数据，一次喂入32组数据，迭代500次，从训练集中划分出20%作为测试集，每迭代20次训练集就要在测试集中验证一次准确率
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
#打印网络结构和参数统计
model.summary()

打印结果如下：

二、搭建网络八股class

用sequential可以搭建出上层输出就是下层输入的顺序网络结构，但是无法写出一些带有跳连的非顺序网络结构。这时我们可以选择用类class搭建神经网络结构
使用六步法，使用TensorFlow的API: tf.keras搭建网络八股
1、import
2、train、test
3、class MyMode(Model) model=MyModel
4、model.compile
5、model.fit
6、model.summary

1.创建自己的神经网络模板：

伪代码如下：

class MyModel(Model):
	def _init_(self):
		super(MyModel,self).init_()
	    定义网络结构块
	def call(self,x):
		调用网络结构块，实现前向传播
		return y

model=MyModel()

代码如下：

class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        #鸢尾花分类的单层网络是含有3个神经元的全连接
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x):
        y = self.d1(x)
        return y
#实例化名为model的对象
model = IrisModel()

2.调用自己创建的model对象

代码如下：

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

打印结果如下：

三、MNIST数据集

MNIST数据集

提供6万张28x28像素点的0~9手写数字图片和标签，用于训练。
提供1万张28x28像素点的0~9手写数字图片和标签，用于测试。

导入数据集

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

作为输入特征，输入神经网络时，将数据拉伸为一维数组

tf.keras.layers.Flatter()

1.用sequential搭建网络实现手写数字识别

code:

import tensorflow as tf

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#对输入网络的特征进行归一化，使原本0~255的灰度值转化为0~1的小数。
#把输入特征的值变小更有利于神经网络吸收
x_train, x_test = x_train / 255.0, x_test / 255.0
#用Sequential搭建网络
model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),                          #把输入特征拉直为1维数组，即784（28*28）个数值
    tf.keras.layers.Dense(128, activation='relu'),      #定义第一层网络有128个神经元，relu为激活函数
    tf.keras.layers.Dense(10, activation='softmax')     #定义第二层网络有10个神经元，softmax使输出符合概率分布
])
#用compile配置训练方法
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()

print result:

Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [] - 4s 62us/sample - loss: 0.2589 - sparse_categorical_accuracy: 0.9262 - val_loss: 0.1373 - val_sparse_categorical_accuracy: 0.9607
Epoch 2/5
60000/60000 [] - 2s 40us/sample - loss: 0.1114 - sparse_categorical_accuracy: 0.9676 - val_loss: 0.1027 - val_sparse_categorical_accuracy: 0.9699
Epoch 3/5
60000/60000 [] - 3s 43us/sample - loss: 0.0762 - sparse_categorical_accuracy: 0.9775 - val_loss: 0.0898 - val_sparse_categorical_accuracy: 0.9722
Epoch 4/5
60000/60000 [] - 2s 41us/sample - loss: 0.0573 - sparse_categorical_accuracy: 0.9822 - val_loss: 0.0851 - val_sparse_categorical_accuracy: 0.9752
Epoch 5/5
60000/60000 [] - 2s 41us/sample - loss: 0.0450 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0846 - val_sparse_categorical_accuracy: 0.9738
Model: “sequential”
Layer (type) Output Shape Param #
=================================================================
flatten (Flatten) multiple 0
dense (Dense) multiple 100480
Total params: 101,770
Trainable params: 101,770
Non-trainable params: 0

---

可以观察到，随着迭代轮数增加，准确率也不断提升。训练的参数也是极其多的，达到10万多个。

2.用类搭建网络实现手写数字识别

只是实例化model的方法不同，其他与用sequential搭建网络实现手写数字识别一致。
init函数中定义了call函数中所用到的层，call函数中从输入x到输出y走过一次前向传播，返回输出y

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

四、FASHION数据集

FASHION数据集

提供6万张 28x28像素点的衣裤等图片和标签，用于训练.
提供1万张28x28像素点的衣裤等图片和标签，用于测试。

导入数据集

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

用sequential搭建网络实现衣裤识别

加载数据需要较长时间，需耐心等待

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

用类的方法也可以实现，这里不做重复展开，套用八股模板即可。

---

总结

这个单元将整个训练的构架走了一遍，并且以八股的形式做了总结，收获很大。

课程链接:MOOC人工智能实践：TensorFlow笔记2