第三讲神经网络八股

本讲目标：使用八股搭建神经网络

• 神经网络搭建八股
• iris 代码复现
• MNIST数据集
• Fashion数据集

1、搭建神经网络八股sequential

用TensorFlow API：tf.keras搭建网络八股

六步法：

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

以上六步是以后写代码的提纲。

Sequential()

model = tf.keras.models.Sequential([网络结构])  # 描述各层网络

Sequential() 可以认为是个容器，这个容器里封装了一个神经网络结构。

在Sequential()中要描述从输入层到输出层每一层的网络结构，每一层的网络结构可以是以下几种：

1. 拉直层：tf.keras.Flatten()，这一层不包含计算，只是形状转换，把输入特征拉直成一维数组。
2. 全连接层：tf.keras.layers.Dense(神经元个数, activation="激活函数", kernel_regularizer=哪种正则化)
   activation可选：relu，softmax，sigmoid，tanh等
   kernel_regularizer可选：tf.keras.regularizers.l1()，tf.keras.regularizers.l2()
3. 卷积层：tf.keras.layers.Conv2D(fliters = 卷积核个数, kernel_size = 卷积核尺寸, strides = 卷积步长, padding = "valid" or "same")
4. LSTM层（循环神经网络）：tf.keras.layers.LSTM()

compile()

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

optimizer可选：

• ‘sgd’ 或 tf.keras.optimizers.SGD(lr = 学习率, momentum = 动量参数)
• ‘adagrad’ 或 tf.keras.optimizers.Adagrad(lr = 学习率)
• ‘adadelta’ 或 tf.keras.optimizers.Adadelta(lr = 学习率)
• ‘adam’ 或 tf.keras.optimizers.Adam(lr = 学习率, beta_1 = 0.9, beta_2 = 0.999)

loss可选：

• ‘mse’ 或 tf.keras.losses.MeanSquaredError()
• ‘sparse_categorical_crossentropy’ 或 tf.keras.losses.SparseCategoricalCrossentropy(from_logits = False)
  有些神经网络的输出经过了softmax等函数的概率分布，有些则不经概率分布直接输出。可以认为from_logits在询问输出是否是原始数据。如果神经网络预测结果输出前经过概率分布，则为false，否则是true。

Metrics可选（告知网络评测指标）：

fit()

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

summary()

可以打印出网格的结构和参数统计

改写鸢尾花的代码

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

# train, test
# test可以选择在这里指定，也可以在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())
])

# compile配置训练方法
# 鸢尾花分类是数值，前向传播给出概率分布，选择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'])
# 执行网络，validation_split=0.2告知从训练集中选择20%作为测试集
# validation_freq=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搭建神经网络结构，此时的六步法：
1.import 2. train, test 3. class MyModel(Model) model = MyModel 4. model.compile 5. model.fit 6.model.summary

class MyModel(Model) model = MyModel

# class 类名（继承TensorFlow的Model类）
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__()
        # 定义网络结构块部分
        # 每一层用self引导，d1是这一层的名字
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x):
    	# 调用
        y = self.d1(x)
        return y
model = IrisModel()

以下是完整鸢尾花复刻代码

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数据集

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

# 导入MNIST数据集
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 作为输入特征输入神经网络时，将数据拉伸为一维数组
tf.keras.layers.Flatten()
# [	0	0	0	48	238	252	252	...	...	253	186	12	0	0	0	0]


# 可以使用这两句话可视化样本
plt.imshow(x_train[0], cmap='gray')  # 绘制灰度图
plt.show()

# 打印出训练集输入特征的第一个元素
print("x_train[0]:\n", x_train[0])

# 打印出训练集标签的第一个元素
print("y_train[0]:\n", y_train[0])

# 打印出整个训练集输入特征形状
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)

使用Sequential()实现mnist手写数字识别：

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

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类实现mnist手写数字识别

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数据集

提供七万张28*28像素点的衣裤等图片和标签，其中六万张用于训练，一万张用于测试。

# 导入fashion数据集
fashion = tf.keras.datasets.fashion_mnist
(x_train, y_train),(x_test,y_test) = fashion.load_data()