Tensorflow API：从零开始用keras搭建深度神经网络

核心六大模块：

六步法

import：

相关模块

train, test：

指定训练集和测试集的输入特征feature与标签label

注意：使用shuffle随机打乱数据

将数据随机打乱后再训练，有助于模型的训练，否则模型应该更倾向于预测为后半部分的分类（二分类问题中）

import random


def shuffleData(X, y, seed=None):
    random.seed(seed)
    index = [i for i in range(len(X))]
    random.shuffle(index)
    print(index)
    X = X[index]
    y = y[index]
    return X, y


def shuffle_data_list_dict(data_list_dict: dict, seed=None):
    train_X, train_y = shuffleData(data_list_dict["train_X"], data_list_dict["train_y"], seed)
    test_X, test_y = shuffleData(data_list_dict["test_X"], data_list_dict["test_y"], seed)
    return {'train_X': train_X, 'train_y': train_y, 'test_X': test_X, 'test_y': test_y}


原文链接：https://blog.csdn.net/qq_37774098/article/details/121016694

model = tf.keras.models.Sequential：

在sequential中搭建网络，逐层描述每一层网络，也就是过一遍前向传播。

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

在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=0.9, beta_2=0.999)

loss可选:

‘mse’ or tf.keras.losses.MeanSquaredError()

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

注意事项： from_logits 是在询问是否使用原始输出，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]

注：‘sparse_categorical_accuracy’ 主要用在，以数值输入标签，概率分布表示输出

model.fit

在fit中告知训练集的输入特征与标签，batch大小，需要迭代多少数据集

model.fit (训练集的输入特征, 训练集的标签,

batch_size= , epochs= ,

validation_data=(测试集的输入特征，测试集的标签),

validation_split=从训练集划分多少比例给测试集，

validation_freq = 多少次epoch测试一次)

model.summary

打印网络结构与参数统计

第一步： import 相关模块：

import tensorflow as tf

from sklearn import datasets import numpy as np

第二步： 指定输入网络地训练集和测试集：

x_train = datasets.load_iris().data

y_train = datasets.load_iris().target

其中测试集的输入特征 x_test 和标签 y_test 可以像 x_train 和 y_train 一

样直接从数据集获取，也可以如上述在 fit 中按比例从训练集中划分，本例选择

从训练集中划分，所以只需加载 x_train ， y_train 即可。

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

])

如上所示，本例使用了单层全连接网络，第一个参数表示神经元个数，第二

个参数表示网络所使用的激活函数，第三个参数表示选用的正则化方法。

使用 Sequential 可以快速搭建网络结构，但是如果网络包含跳连等其他复

杂网络结构， Sequential 就无法表示了。这就需要使用 class 来声明网络结构。

class MyModel(Model):
def __init__(self):
super(MyModel, self).__init__()
//初始化网络结构def call(self, x):
y = self.d1(x)
return y

使用 class 类封装网络结构，如上所示是一个 class 模板， MyModel 表示声

明的神经网络的名字，括号中的 Model 表示创建的类需要继承 tensorflow 库中

的 Model 类。

类中需要定义两个函数， __init__() 函数为类的构造函数用于初

始化类的参数， spuer(MyModel,self).__init__() 这行表示初始化父类的参

数。之后便可初始化网络结构 , 搭建出神经网络所需的各种网络结构块。 call()

函数中调用 __init__() 函数中完成初始化的网络块，实现前向传播并返回推理

值。

使用 class 方式搭建鸢尾花网络结构的代码如下所示。

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=MyModel() 构建类的对象，就可以使用

该模型了。

对比使用 Sequential() 方法和 class 方法，有两点区别：

① import 中添加了 Model 模块和 Dense 层、 Flatten 层。

②使用 class 声明网络结构， model = IrisModel() 初始化模型对象。

第四步： 在 model.compile() 中配置训练方法：

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 ，选择

SparseCategoricalCrossentrop 作为损失函数。

由于神经网络输出使用了softmax 激活函数，使得输出是概率分布，而不是原始输出，所以需要将

from_logits 参数设置为 False 。

鸢尾花数据集给的标签是 0 ， 1 ， 2 这样的数值，而网络前向传播的输出为概率分布，所以 metrics 需要设置为 sparse_categorical_accuracy。

第五步： 在 model.fit() 中执行训练过程 :

model.fit(x_train,y_train,batch_size=32,epochs=500, validation_split
= 0.2,validation_freq=20)

在 fit 中执行训练过程,x_train,y_train 分别表示网络的输入特征和标签，

batch_size 表示一次喂入神经网络的数据量

epochs 表示数据集的迭代次数

validation_split 表示数据集中测试集的划分比例

validation_freq 表示每迭代 20 次在测试集上测试一次准确率

第六步： 使用 model.summary() 打印网络结构，统计参数数目：

model.summary()

Tensorflow API：从零开始用keras搭建深度神经网络

猜你喜欢