3搭建神经网络的套路：用Tensorflow API--tf.keras搭建网络（六步法）

搭建神经网络的套路

 

3.1六步法搭建神经网络

3.1.1 tf.keras搭建网络（六步法）来快速搭建神经网络于Sequential

可以搭建出上层输出就是下层输入的的顺序网络结构，但无法写出一些带有跳连的非顺序网络结构

提纲		举例
import	import相关模块	import tensorflow as tf
train, test	告知要喂入网络的训练集和测试集是什么	指定训练集的输入特征x_train和训练集的标签y_train；测试集的输入特征x_test和训练集的标签y_test
model = tf.keras.models.Sequential	在Sequential中搭建网络结构，逐层描述每层网络	相当于走了一遍前向传播
model.compile	在compile中配置训练方法	告知选择那个优化器、哪个损失函数、哪个评测指标
model.fit	在fit中执行训练过程	告知训练集和测试集的输入特征和标签，告知每个batch是多少，告知要迭代多少次数据集
model.summary	用summary打印出网络的结构和参数统计

 

---

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.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’ 或 tf.keras.losses.MeanSquaredError()

‘sparse_categorical_crossentropy’ 或 tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)

关于rom_logits=Ture还是Falsed的注：有些神经网络的输出是经过softmax等函数的概率分布，有些不经过概率分布直接输出，参数from_logits=是在询问这个输出是否是原始输出，false表示没有经过概率分布的输出。若神经网络预测结果输出前经过概率分布,用False；若神经网络预测结果输出前没有经过概率分布，直接输出了，用Ture。

---

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]（常用）

---

model.fit (训练集的输入特征, 训练集的标签,
           batch_size=每次喂入NN网络的样本数 , epochs=迭代数据集的次数 ,
           validation_data=(测试集的输入特征，测试集的标签),
           validation_split=从训练集划分多少比例给测试集，
           validation_freq = 每多少次epoch迭代使用测试集验证一次结果)

#  validation_data和validation_split二选一，前者是数据集和测试集已经分开，后者是从总数据集中分出测试集

---

model.summary（）#打印网络的结构和参数统计

---

例子：六步法实现鸢尾花分类

# --1-- import相关模块
import tensorflow as tf
from sklearn import datasets
import numpy as np

# --2-- train,test 交代训练集输入特征x_train和标签y_train
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-- 在Sequential中搭建网络结构
model = tf.keras.models.Sequential(
            [tf.keras.layers.Dense(3, 
                                   activation='softmax',                                                  
                                   kernel_regularizer=tf.keras.regularizers.l2())
            ])# 设置神经元个数、激活函数、正则化方法

# --4-- 在model.compilez中配置训练方法
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])
             # SGD优化器、学习率0.1、选损失函数SparseCategoricalCrossentropy，
             # 由于NN网络末端用了softmax，使输出为概率分布非原始输出，故from_logits设为False
             # 由于花的分类是标签，而网络输出的是概率，使用评测指标用sparse_categorical_accuracy

# --5-- 在fit中执行训练过程
#  告知训练集特征和标签、一次喂入数据量、数据集迭代循环次数、
#   选训练集20%作测试集、每迭代20次验证一次准确率
model.fit(x_train, y_train, batch_size=32, epochs=500, 
          validation_split=0.2, validation_freq=20) 

# --6-- summary打印网络结构和参数统计
model.summary()

打印出的结构如下

3.1.2 tf.keras搭建网络（六步法）来快速搭建神经网络于class类

用类class封装神经网络结构，可写出一些带有跳连的非顺序网络结构

提纲		举例
import	import相关模块	import tensorflow as tf
train, test	告知要喂入网络的训练集和测试集是什么	指定训练集的输入特征x_train和训练集的标签y_train；测试集的输入特征x_test和训练集的标签y_test
class MyModel(Model) model=MyModel	在class类中搭建网络结构，逐层描述每层网络	相当于走了一遍前向传播
model.compile	在compile中配置训练方法	告知选择那个优化器、哪个损失函数、哪个评测指标
model.fit	在fit中执行训练过程	告知训练集和测试集的输入特征和标签，告知每个batch是多少，告知要迭代多少次数据集
model.summary	用summary打印出网络的结构和参数统计

 

class MyModel(Model) model = MyModel

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

__init__( ) 定义所需网络结构块

call( ) 写出前向传播

程序开头记得调用from tensorflow.keras import Model

例子

class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = Dense(3)

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

对比

3.2 iris代码复现

---

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

3.3 MNIST数据集

---

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

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

导入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 0]

绘制灰度图

plt.imshow(x_train[0], cmap='gray')#绘制灰度图
plt.show()

打印：

print("x_train[0]:\n" , x_train[0])

x_train[0]:

print("y_train[0]:", y_train[0])

print("x_test.shape:", x_test.shape

y_train[0]：5

x_test.shape： (10000, 28, 28)

import tensorflow as tf
from matplotlib import pyplot as plt

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

# 可视化训练集输入特征的第一个元素
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)

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

3.5 Fashion数据集

---

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

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

标签如下

导入FASHION数据集：

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

1.基于sequential构建的神经网络

#  fashion_sequential.py 
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=50, epochs=200,
          validation_data=(x_test, y_test),
          validation_freq=1)
model.summary()

- loss: 0.0236

- sparse_categorical_accuracy: 0.9914

- val_loss: 1.2061

- val_sparse_categorical_accuracy: 0.8881

Model: "sequential"

2.基于 class类构建的神经网络

#  fashion_class.py 
import tensorflow as tf
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 FashionModel(Model):
    def __init__(self):
        super(FashionModel, self).__init__()
        self.flatten = tf.keras.layers.Flatten()
        self.d1 = tf.keras.layers.Dense(128, activation='relu')
        self.d2 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, x):
        x = self.flatten(x)
        x = self.d1(x)
        y = self.d2(x)
        return y

model = FashionModel()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train,
          batch_size=50, epochs=20,
          validation_data=(x_test, y_test),
          validation_freq=1)
model.summary()

 - loss: 0.1825

- sparse_categorical_accuracy: 0.9326

- val_loss: 0.3410

- val_sparse_categorical_accuracy: 0.8912

Model: "fashion_model"