tensorflow.keras六步法搭建神经网络

深度学习之tensorflow六步法搭建神经网络

利用tensorflow.kears 搭建神经网络，实现iris，mnist数据集分类

---

---

前言

上一篇文章：https://blog.csdn.net/lixinyu990724/article/details/132833357?spm=1001.2014.3001.5501 提到如何手动搭建简单的鸢尾花数据分类的神经网络，这一节将对上一节进行简化，利用keras实现更高效、更便捷的神经网络搭建，并附上了实现iris以及mnist数据集的分类的简单神经网络搭建代码。

本文共分为三个部分，第一部分是通过Sequential搭建神经网络的具体步骤及详细讲解，第二部分是通过class搭建神经网络的具体步骤及详细讲解，通过class搭建的神经网络相比于Sequential搭建的神经网络，优势在于：可以实现神经网络的跳跃连接。最后一部分是通过Sequential 以及 class搭建的用于实现 iris 以及 mnist 数据集分类的简单神经网络。

---

一、Sequential六步法搭建神经网络

step1: import 导入相关库
step2: 构建数据集：train_x, train_y, test_x, test_y
step3: model = tf.keras.models.Sequential()
step4: model.compile()
step5: model.fit()
step6: model.summary()

接下来，详细介绍step4, step5以及step6

1.tf.keras.models.Sequential()

本部分用于指定神经网络的各个层，描述整体的网络结构

model = tf.keras.models.Sequential([网络结构])
'''
此处可填写的常见的网络结构如下：
拉直层Flatten：  tf.keras.layers.Flatten()   #常用于将二维的输入图片拉直为一维数组
全连接层Dense:   tf.keras.layers.Dense(神经元个数, activation = “激活函数”, kernel_regularizer = 正则化方式)
			activation可选择：relu, softmax, sigmoid, tanh等
			kernel_regularizer可选择：tf.keras.regularizer.l1(), tf.keras.regularizer.l2()等
卷积层Conv:      tf.keras.layers.Conv2D(filters = 卷积核个数, kernel_size = 卷积核大小, strides = 卷积步长, padding = "valid" or "same")
LSTM层：         tf.keras.layers.LSTM()	
'''

2.model.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' of tf.keras.losses.SparseCategoricalCrossentropy(from_logits = True/False)		#交叉熵损失函数（常用）
	此处的from_logits参数，若输出的y经过了概率分布处理，则为False，反之为True
metrics常用：
	'accuracy' : 适用于y 与 y_ 都是数值的情况
	'categorical_accuracy': 适用于y 和 y_ 都是one-hot/概率分布的情况
	'sparse_categorical_accurracy': 适用于y_是数值，y为one-hot/概率分布的情况
'''

3.model.fit()

本部分主要用于指定训练集、测试集、训练次数等

model.fit(训练集的输入特征，训练集的标签，batch_size =   , epoch =    ,
		  validation_data = (测试集的输入特征， 测试集的标签),
		  validation_split = 从训练集中分出多少比例作为测试集, 
		  validation_freq = 多少epoch测试一次
		  )
注意：validation_data 与 validation_split 二选一即可

3.model.summary()

用于打印网络的参数和结构

二、class六步法搭建神经网络

step1: import 导入相关库
step2: 构建数据集：train_x, train_y, test_x, test_y
step3: class MyModel()
step4: model.compile()
step5: model.fit()
step6: model.summary()
除了step3外，其余步骤都与Sequential相同，因此，此处只重点介绍class部分

1.class MyModel()

class MyModel(tf.keras.Model):
	def __ init __(self):
		super(MyModel, self).__init__()
		定义网络结构块
	
	def call(sekf, x):
		调用__init__中定义的网络结构块
		return y
model = MyModel()

#不同的神经网络，只有函数名MyModel, 定义网络结构块以及调用__init__中定义的网络结构块三个部分不同，其余部分完全相同

三、Sequential六步法实现iris数据集分类

import pandas as pd
from sklearn import datasets
import numpy as np
import tensorflow as tf
from matplotlib import pyplot as plt

train_x = datasets.load_iris().data
train_y = datasets.load_iris().target

#打乱数据结构
np.random.seed(116)
np.random.shuffle(train_x)
np.random.seed(116)
np.random.shuffle(train_y)
tf.random.set_seed(116)

model = tf.keras.models.Sequential([tf.keras.layers.Dense(3, activation = 'softmax', kernel_regularizer = tf.keras.regularizers.l2())])
#共三类图片，因此次数的神经元个数为3
model.compile(optimizer = tf.keras.optimizers.SGD(lr = 0.1), loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits = False), metrics = ['sparse_categorical_accuracy'])

model.fit(train_x, train_y, batch_size = 32, epochs = 500, validation_split = 0.2, validation_freq = 20)

model.summary()

模型训练结果如下：
model.summary()的输出结果如下：

四、class六步法实现iris数据集分类

import pandas as pd
from sklearn import datasets
import numpy as np
import tensorflow as tf
from matplotlib import pyplot as plt

train_x = datasets.load_iris().data
train_y = datasets.load_iris().target

#打乱数据结构
np.random.seed(116)
np.random.shuffle(train_x)
np.random.seed(116)
np.random.shuffle(train_y)
tf.random.set_seed(116)

class IrisModel(tf.keras.Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = tf.keras.layers.Dense(3, activation = 'softmax', kernel_regularizer = tf.keras.regularizers.l2())	#共三类图片，因此次数的神经元个数为3

    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(train_x, train_y, batch_size = 32, epochs = 500, validation_split = 0.2, validation_freq = 20)

model.summary()

模型训练结果如下：

五、Sequential六步法实现mnist数据集分类

import tensorflow as tf
import pandas as pd
import numpy as np
from sklearn import datasets


mnist = tf.keras.datasets.mnist
(train_x, train_y),(test_x, test_y) = mnist.load_data()
train_x, test_x = train_x/255.0, test_x/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=tf.keras.optimizers.SGD(learning_rate=0.1), loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy'])

model.fit(
    train_x, train_y, batch_size=32, epochs=10, validation_data=(test_x, test_y), validation_freq=1
)

model.summary()

训练结果如下：

六、class六步法实现mnist数据集分类

import tensorflow as tf
import pandas as pd
import numpy as np
from sklearn import datasets

mnist = tf.keras.datasets.mnist
(train_x, trian_y),(test_x, test_y) = mnist.load_data()
trian_x, test_x = train_x/255.0, test_x/255.0       #归一化处理

class MnistModel(tf.keras.Model):
    def __init__(self):     #定义各个层
        super(MnistModel, 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)
        y1 = self.d1(x)
        y = self.d2(y1)
        return y

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

model.fit(train_x, trian_y, batch_size=32, epochs=10, validation_data=(test_x, test_y), validation_freq=1)
model.summary()

训练结果如下：

总结

今天主要学习了利用六步法搭建简单的神经网络，后续会继续学习，继续更新，搭建更深层次、效果更优的神经网络。