文章目录

  • 一、六步法搭建顺序神经网络（Sequential）
  • 1、步骤
  • 2、相关介绍
  • （1）Sequential
  • （2）compile
  • （3）fit
  • （4）summary
  • 3、代码
  • 二、六步法搭建非顺序神经网络（class）
  • 1、步骤
  • 2、class MyModel(Model) model = MyModel定义方式
  • 3、代码
  • 三、MNIST例子
  • 1、mnist_datasets
  • 2、mnist_Sequential



tf.keras是Tensorflow的API（应用程序接口）,可以快速搭建神经网络模型。

一、六步法搭建顺序神经网络（Sequential）

1、步骤
  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()打印出网络的结构和参数统计
2、相关介绍
（1）Sequential

1）描述各层网络

model = tf.keras.models.Sequential([网络结构])

2）网络结构举例
拉直层

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()
（2）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=O.9,beta_2=0.999)

loss可选：

'mse' or tf.keras.losses.MeanSquaredError()
'sparse_categorical_crossentropy' or tf.keras,losses.SparseCategoricalCrossentropy(from_logits=False)

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]
（3）fit
model.fit(训练集的输入特征,训练集的标签,batch_size= ,epoch= ,validation_data=(测试集的输入特征,测试集的标签)，validation_split=从训练集划分多少比例给测试集,validation_freq=多少次epoch测试一次)
（4）summary
model.summary()

tensorflow自定义网络结构_深度学习

3、代码
# import相关模块
import tensorflow as tf
from sklearn import datasets
import numpy as np

# 交代训练集的输入特征x_train和标签y_train
x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

# 实现了数据集的乱序
# seed是随机种子，保证每次循环生成的随机数是一样的，输入特征和标签一一对应
np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

# Sequential搭建网络结构
# 参数分别为：神经元个数3，选用的激活函数softmax，选用的正则化方法l2
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])

# compile配置训练方法
# 参数分别为：
# SGD优化器，学习率0.1
# 损失函数 SparseCategoricalCrossentropy
# from_logits是False：因为神经网络末端选用了softmax函数，使得输出是概率分布而不是原始输出
# sparse_categorical_accuracy作为评测指标：因为鸢尾花数据集给的标签是0 1 2，神经网络前向传播的输出是概率分布
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# fit执行训练过程
# 参数分别为：
# x_train：训练集输入特征
# y_train：训练集标签
# batch_size：训练时一次喂入神经网络多少组数据
# epochs：训练集迭代循环多少次
# validation_split：告知从训练集中选择20%的数据作为测试集
# validation_freq：每迭代20次训练集，要在测试集中验证一次准确率
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

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

二、六步法搭建非顺序神经网络（class）

1、步骤
  1. import相关模块
  2. train，test：告知要喂入网络的训练集和测试集是什么，指定训练集的输入特征x_train和训练集的标签y_train，还可以指定测试集的输入特征x_test和测试集的标签y_test
  3. class MyModel(Model) model = MyModel
  4. model.compile：在compile()中配置训练方法，告知训练时选择哪种优化器、损失函数、评测指标
  5. model.fit：在fit()中执行训练过程，告知训练集和测试集的输入特征和标签，告知每个batch是多少，告知要迭代多少次训练集
  6. model.summary：用summary()打印出网络的结构和参数统计
2、class MyModel(Model) model = MyModel定义方式

可以理解为__init__函数准备出搭建网络需要的各种积木，call函数调用__init__中搭建好的积木

init() 定义所需网络结构块
call() 写出前向传播

class MyModel(Model):
   def__init__(self):
     super(MyModel,self).__init__()
     定义网络结构块
   def call(self,x):
     调用网络结构块，实现前向传播
    return y
model = MyModel()
3、代码
# import相关模块
import tensorflow as tf
# 添加了model模块
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
from sklearn import datasets
import numpy as np

# 交代训练集的输入特征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)

# 搭建网络结构
# 定义了IrisModel类
class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        # 定义了要在call函数中调用的，具有三个神经元的全连接网络Dense
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x):
        # 调用self.d1实现了从输入x到输出y的前向传播
        y = self.d1(x)
        return y
# 实例化model
model = IrisModel()

# compile配置训练方法
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# fit执行训练过程
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

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

三、MNIST例子

1、mnist_datasets
import tensorflow as tf
from matplotlib import pyplot as plt

# 导入mnist数据集
mnist = tf.keras.datasets.mnist
# 使用load_data从数据集中读取训练集和测试集
(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])

# 打印出整个训练集输入特征形状：60000张图片，每张图片是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)

结果

tensorflow自定义网络结构_人工智能_02


tensorflow自定义网络结构_神经网络_03

2、mnist_Sequential
import tensorflow as tf

# 导入mnist数据集
mnist = tf.keras.datasets.mnist
# 使用load_data从数据集中读取训练集和测试集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 输入特征归一化，使像素值集中在0到1之间
x_train, x_test = x_train / 255.0, x_test / 255.0

# 搭建网络结构
# 作为输入特征，输入神经网络时，将数据拉伸为一维数组
# 第一层网络128个神经元，激活函数relu
# 第二层网络10个神经元，激活函数softmax
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()