[TensorFlow2.0]搭建神经网络

机智的小陈今天学习了吗

已于 2022-02-23 14:40:07 修改

阅读量1.1k

点赞数 3

分类专栏： tensorflow 文章标签：神经网络深度学习 tensorflow

于 2022-02-22 22:51:07 首次发布

本文链接：https://blog.csdn.net/weixin_43890415/article/details/123079054

版权

tensorflow 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

tf.keras 搭建神经网络

1.1搭建神经网络六步法

1.import 相关模块，如 import tensorflow as tf。
2.指定输入网络的训练集和测试集，如指定训练集的输入 x_train 和标签y_train，测试集的输入 x_test 和标签 y_test。
3.逐层搭建网络结构，model = tf.keras.models.Sequential()。
4.在 model.compile()中配置训练方法，选择训练时使用的优化器、损失函数和最终评价指标。
5.在 model.fit()中执行训练过程，告知训练集和测试集的输入值和标签、每个 batch 的大小（batchsize）和数据集的迭代次数（epoch）。
6.使用 model.summary()打印网络结构，统计参数数目。

1.2基本函数

tf.keras.models.Sequential()
Sequential 函数是一个容器，描述了神经网络的网络结构，在 Sequential函数的输入参数中描述从输入层到输出层的网络结构。
如：
1）拉直层：tf.keras.layers.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( filter = 卷积核个数,
 kernel_size = 卷积核尺寸,
 strides = 卷积步长,
 padding = “valid” or “same”)

4）LSTM 层：tf.keras.layers.LSTM()。
本章只使用拉直层和全连接层，卷积层和循环神经网络层将在之后的章节介绍。

Compile函数用于配置神经网络的训练方法，告知训练时使用的优化器、损失函数和准确率评测标准。

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

其中：
1.optimizer 可以是字符串形式给出的优化器名字，也可以是函数形式，使用函数形式可以设置学习率、动量和超参数。
可选项包括：

‘sgd’or tf.optimizers.SGD( lr=学习率,decay=学习率衰减率,momentum=动量参数)
‘adagrad’or tf.keras.optimizers.Adagrad(lr=学习率,decay=学习率衰减率)
‘adadelta’or tf.keras.optimizers.Adadelta(lr=学习率, decay=学习率衰减率)
‘adam’or tf.keras.optimizers.Adam (lr=学习率,decay=学习率衰减率)

2.Loss 可以是字符串形式给出的损失函数的名字，也可以是函数形式。
可选项包括：

‘mse’or tf.keras.losses.MeanSquaredError()
‘sparse_categorical_crossentropy
or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)

3.损失函数常需要经过 softmax 等函数将输出转化为概率分布的形式。
from_logits 则用来标注该损失函数是否需要转换为概率的形式，取 False 时表示转化为概率分布，取 True 时表示没有转化为概率分布，直接输出。
4.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]。

fit 函数用于执行训练过程

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

summary 函数用于打印网络结构和参数统计

2.1使用鸢尾花数据集实现代码

使用sequencial搭建上层输出就是下层输入的顺序网络结构


    # -*- coding=utf-8 -*-
    # name: nan chen
    # date: 2022/2/22 20:36
    
    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)
    
    # 使用sequential搭建网络结构
    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),
                  # softmax函数使得输出为概率分布
                  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)
    # 数据 标签 一次喂入神经网络多少组数据 迭代循环次数 20%作为测试集 每迭代20次计算一次测试集的评测指标
    
    # 打印网络结构
    model.summary()

使用类class搭建带有跳连（skip connection 上层输出可能是下几层部分输入）的非顺序神经网络结构

    # -*- coding=utf-8 -*-
    # name: nan chen
    # date: 2022/2/22 20:36
    
    import tensorflow as tf
    from keras import Model
    from keras.layers import Dense
    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搭建网络结构
    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),
                  # softmax函数使得输出为概率分布
                  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)
    # 数据 标签 一次喂入神经网络多少组数据 迭代循环次数 20%作为测试集 每迭代20次计算一次测试集的评测指标
    
    # 打印网络结构
    model.summary()

3.1 使用minist数据集实现模型保存断点续训提取可训练参数参数可视化

# -*- coding=utf-8 -*-
# name: nan chen
# date: 2022/2/22 20:36
import os

import tensorflow as tf
from keras import Model
from keras.layers import Dense
from sklearn import datasets
import numpy as np
from matplotlib import pyplot as plt

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

# 使用sequential搭建网络结构
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',
              # softmax函数使得输出为概率分布
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

checkpoint_save_path = "minist.ckpt"
if os.path.exists(checkpoint_save_path + ".index"):
    print('---load the model---')
    model.load_weights(checkpoint_save_path)

cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True,
                                                 save_best_only=True)

# 执行训练过程
history = model.fit(x_train, y_train, batch_size=32, epochs=500, validation_data=(x_test, y_test), validation_freq=1,
                    callbacks=[cp_callback])
# 数据 标签 一次喂入神经网络多少组数据 迭代循环次数 20%作为测试集 每迭代20次计算一次测试集的评测指标

# 打印网络结构
model.summary()

# 参数提取
# 打印所有内容
np.set_printoptions(threshold=np.inf)
# 打印所有可训练参数
print(model.trainable_variables)
file = open('weights.txt', 'w')
for v in model.trainable_variables:
    file.write(str(v.name) + '\n')
    file.write(str(v.shape) + '\n')
    file.write(str(v.numpy()) + '\n')
file.close()

# 显示acc曲线与loss曲线
acc = history.history['sparse_categorical_accuracy']
val_acc = history.history['val_sparse_categorical_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

plt.subplot(1, 2, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()