【北京大学】Tensorflow2.0第三讲

1 本讲摘要

（1）本讲目标：使用八股搭建神经网络
（2）摘要
• 神经网络搭建八股
• Iris代码复现
• MNIST数据集
• 训练 MNIST 数据集
• Fashion数据集

3 六步法搭建网络

用Tensorflow的API：tf.keras搭建网络八股
（1）六步法

imort
train,test
# 搭建网络结构
```python
model = tf.keras.models.Sequential
# 配置训练方法，优化器、参数、评测指标
model.compile
#执行训练过程，告知训练集和测试集的输入特征和标签
model.fit
#打印网络的结构和参数统计
model.summary

（2）网络结构

model = tf.keras.models.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(filters = 卷积和个数，kernel_size = 卷积核尺寸，
strides = 卷积步长，padding  = "valid" or "same")

LSTM 层

tf.keras.layers.LSTM()
model.compile(optimizer = 优化器，
loss = 损失函数
metrics = ["准确率"])

Optimizer可选

"sgd" or tf.keras.optimizer.SGD(lr = 学习率，momentum = 动量参数)
"adagrad" of or tf.keras.optimizer.Adagrad(lr = 学习率)
"adadelta" or or tf.keras.optimizer.Adadelta(lr = 学习率)
"adam" or or tf.keras.optimizer.Adam(lr = 学习率,beta_1 = 0.9,beta_2 = 0.999)

loss可选

"mse" or or tf.keras.losses.MeanSquaredError()
#from_logics，询问是否是原始输出，没有经过概率分布的输出。如果神经网络预测结果输出前有经过概率分布则是false,反之
"sparse_categorical_crossentropy " or or tf.keras.losses.SparseCategoricalCrossentropy(from_logics=False)

Metrics可选

# metrics告知网络评测指标
"accuracy": y_和y都是数值，如y_=[1] y = [1]
"categorical_accuracy" :y_和y都是独热码（概率分布），如y_=[1] y = [0.256,0.695,0.048]
"sparse_categocial_accuracy":y_是数值，y是独热码（概率分布），如y_=[1] 输出结果是概率分布y = [0.256,0.695，0.048]

model.fit

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

model.summary()
打印网络结构参数的统计

（3）Demo

import tensorflow as tf
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)
#搭建网络模型
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])
# 选择训练参数
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),# 因为神经网络最后一层用了softmax
              metrics=['sparse_categorical_accuracy'])#因为输出是概率分布
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
model.summary()

4 搭建网络八股class

六步法

import
train,test
class MyModel(Model) model = MyModel
model.compile
model.fit
model.summary
class封装神经网络的结构
class MyModel(Model)
    def __init__(self):# 定义所需网络结构块
        super(MyModel,self).__init__()
        定义网络结构块
     def call(self,x)# 写出前向传播
        调用网络结构块，实现前向传播
        return y
   model = MyModel()
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='sigmoid', 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'])
modelfit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
model.summary()

5 MINIST数据集

（1）MINIST数据集：
提供6万张图片用于训练，提供1万张用于测试
（2）导入数据集

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

（3）作为输入特征，输入神经网络时，将数据拉伸为一维数据：

tf.keras.layers.Flatten()

（4）绘制灰度图，可视化

plt.imshow(x_train[0],cmap ='gary')
plt.show()
print("x_train[0]:\n",x_train[0])#打印第一个输入特征
print("y_train[0]:",y_train[0])#打印第一个输入label
print("x_test.shape:",x_test,shape)

（5）Demo

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

6 FASHION数据集

（1）提供6万28*28张图片衣服裤子等的图片和标签.用于训练，提供1万张用于测试。十个分类
• 0 T恤T-shirt/top
• 1 裤子Trouser
• 2 套头衫Pullover
• 3 连衣裙Dress
• 4 外套coat
• 5 凉鞋Scandal
• 6 衬衫Shirt
• 7 运动鞋Sneaker
• 8 包Bag
• 9 靴子Ankle boot
（2）导入数据集

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

（3）Demo

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