Tensorflow学习笔记——搭建神经网络

Tensorflow学习笔记——搭建神经网络
目录

1.搭建神经网络6步法

2.函数用法和介绍

（1）tf.keras.models.Sequential()

（2）Model.compile(）

（3）model.fit(）

（4）model.summary()

（5）model.predict()

3.鸢尾花数据集

4. Fasion_Mnist数据集

1.搭建神经网络6步法

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

（1）tf.keras.models.Sequential()

Sequential函数是一个容器，描述了神经网络的网络结构，在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(filter=卷积核个数，

kernel_size=卷积核尺寸，

strides=卷积步长，

padding='valid' or 'same')

LSTM层：tf.keras.layers.LSTM()。

（2）Model.compile( optimizer=优化器，

loss=损失函数，

metrics=['准确率']）

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

        其中：

                optimizer可以是字符串给出的优化器名字，也可以是函数形式，使用函数形式可以自己设置学习率、动量和超参数。

        可选项包括：

‘sgd’ or tf.keras.optimizers.SGD(        learning_rate=0.01（初始学习率）,
                                                            momentum=0.0（动量参数）,
                                                            nesterov=False（是否应用涅斯捷罗夫动量）,
                                                            name='SGD')

‘adagrad’ or tf.keras.optimizers.Adagrad( learning_rate=0.001（初始学习率）,
                                                                         initial_accumulator_value=0.1（累加器的起始值）,
                                                                         epsilon=1e-07（用于保持数值稳定性的小浮点值）,
                                                                         name='Adagrad')

‘adadelta’ or tf.keras.optimizers.Adadelta(          learning_rate=0.001（初始学习率）,
                                                                        rho=0.95（学习率衰减率）,
                                                                        epsilon=1e-07（保持数值稳定性的小浮点数）,
                                                                         name='Adadelta',)

‘adam’ or tf.keras.optimizers.Adam(                   learning_rate=0.001（初始学习率）,
                                                                            beta_1=0.9（指数衰减率，控制权重分配）,
                                               beta_2=0.999（指数衰减率，控制之前的梯度平方的影响情况）,
                                                                            epsilon=1e-07,
                                                                     amsgrad=False（是否应用该算法的AMSGrad变体）,
                                                                            name='Adam',)

         Loss可以是字符串形式给出的损失函数的名字，也可以是函数形式。

        可选项包括：

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

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

        损失函数常需要经过softmax等函数将输出转化为概率分布的形式。from_logits则用来标注该损失函数是否需要转换为概率的形式，取False时表示转化为概率分布，取True时表示没有转化为概率分布，直接输出。

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）model.fit(训练集的输入特征，训练集的标签，

                batch_size=每次喂入神经网络的样本数，

                epochs=数据集迭代次数，

validataion_data=（测试集的输入特征，测试集的标签），

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

validataion_freq=测试的epoch间隔次数)）

        fit函数用于执行训练过程，validataion_data与validataion_split两者任选其一即可。

（4）model.summary()

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

        下图是鸢尾花数据集的网络结构，采用了三个神经元，对于一个四输入三输出的全连接网络，共有15个参数

（5）model.predict(
x（输入样本）,
batch_size=None（批量大小）,
verbose=0（是否显示进度条）
)

        predict用于对数据进行预测。

3.鸢尾花数据集

     用六步法搭建鸢尾花数据集分类神经网络：
```
# -*- coding: utf-8 -*-
# @Time : 2022/8/24 16:48
# @Author : 中意灬
# @FileName: iris分类.py
# @Software: PyCharm
""""第一步：导入相关模块"""
import numpy as np
import tensorflow as tf
from sklearn import datasets
from sklearn.model_selection import train_test_split
"""第二步：指定输入网络的训练集和测试集"""
x,y=datasets.load_iris(return_X_y=True)
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3,random_state=520)
"""第三步：逐层搭建神经网络结构"""
model=tf.keras.models.Sequential([
    tf.keras.layers.Dense(3,activation='softmax',kernel_regularizer=tf.keras.regularizers.l2())
])
"""第四步：在model.compile()中配置训练方法"""
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])
"""第五步：在model.fit()中训练模型"""
model.fit(x_train,y_train,batch_size=64,epochs=500,validation_data=(x_test,y_test),validation_freq=20)
"""第六步：使用model.summary()打印网络结构，统计网络参数"""
model.summary()
"""预测一下吧"""
x_new=np.array([[2,3,4,1]])
y_pred=model.predict(x_new)
print(np.argmax(y_pred,axis=1))#输出类别
print(y_pred)#输出概率
```
使用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__()函数为类的构造函数用于初始化类的参数，super(MyModel,self).__init__()这行表示初始化父类的参数。之后便可初始化网络结构，搭建出神经网络所需的各种网络结构块。call()函数中调用__init__()函数中完成初始化的网络块，实现向前传播并返回推理值。使用class方式搭建鸢尾花网络结构代码如下：
```
# -*- coding: utf-8 -*-
# @Time : 2022/8/24 22:14
# @Author : 中意灬
# @FileName: 使用class类搭建.py
# @Software: PyCharm
"""第一步：导入相关库"""
import tensorflow as tf
from sklearn import datasets
from tensorflow.keras.layers import Dense,Flatten
from sklearn.model_selection import train_test_split
from tensorflow.keras import Model
"""第二步：准备x_train，y_train,x_test,y_test数据集"""
x,y=datasets.load_iris(return_X_y=True)
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3,random_state=520)
"""第三步：逐层搭建网络结构"""
class IrisModel(Model):
    def __init__(self):
        super(IrisModel,self).__init__()
        self.d1=Dense(3,activation='sigmoid')
    def call(self,x):
        y=self.d1(x)
        return y
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'])
"""第五步：在model.fit()中执行训练过程"""
model.fit(x_train,y_train,batch_size=32,epochs=500,validation_data=(x_test,y_test),validation_freq=20)
"""第六步：使用model.summary()打印网络结构，统计参数数目"""
model.summary()
```
4. Fasion_Mnist数据集

平常大家可能用的都是Mnist数据集，这次我们换一个换成Fasion_Mnist数据集。

介绍：这是一个包含 10 个时尚类别的 60000 张 28x28 灰度图像的数据集，以及一组包含 10000 张图像的测试集，此数据集可用作 MNIST 的直接替代项。

数据集图像如下所示：

这些标签是：

标签描述
0 T恤/上衣
1 裤子
2 套衫
3 连衣裙
4 外套
5 凉鞋
6 衬衫
7 运动鞋
8 袋
9 踝靴

API：tf.keras.datasets.fashion_mnist.load_data()

返回：NumPy 数组的元组：.(x_train, y_train), (x_test, y_test)

x_train：NumPy数组的灰度图像数据与形状，包含训练数据。(60000, 28, 28)

y_train：NumPy 标签数组（范围为 0-9 的整数），带有训练数据的形状。(60000,)

x_test：NumPy数组的灰度图像数据与形状（10000，28，28），包含测试数据。

y_test：NumPy标签数组（范围为0-9的整数），带有测试数据的形状。(10000,)

打印出数据集中的图片观察一下

以二维数组的形式打印出来如下所示

然后运用六部法搭建神经网络：
```
# -*- coding: utf-8 -*-
# @Time : 2022/8/25 12:01
# @Author : 中意灬
# @FileName: fashion神经网络.py
# @Software: PyCharm
"""第一步：导入相关库"""
import tensorflow as tf
"""第二部：准备所用数据集"""
(x_train,y_train),(x_test,y_test)=tf.keras.datasets.fashion_mnist.load_data()
x_train,x_test=x_train/250,x_test/250#处理一下特征，便于收敛
"""第三步：逐层搭建网络结构"""
model=tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28,28)),
    tf.keras.layers.Dense(128,activation='sigmoid'),
    tf.keras.layers.Dense(10,activation='softmax')
])
"""第四步：在model.compile()中配置训练参数"""
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['sparse_categorical_accuracy'])
"""第五步：在model.fit()中训练网络"""
model.fit(x_train,y_train,batch_size=64,epochs=50,validation_data=(x_test,y_test),validation_freq=2)
"""第六步：使用model.summary()打印网络结构"""
model.summary()
```
运用class类搭建网络结构：
```
# -*- coding: utf-8 -*-
# @Time : 2022/8/25 12:32
# @Author : 中意灬
# @FileName: class_fashion搭建.py
# @Software: PyCharm
"""第一步：导入相关库"""
import tensorflow as tf
from tensorflow.keras.layers import Flatten,Dense
from tensorflow.keras import Model
"""第二步：准备数据集"""
(x_train,y_train),(x_test,y_test)=tf.keras.datasets.fashion_mnist.load_data()
x_train,x_test=x_train/300,x_test/300#将特征处理一下，使其位于[0,1],有助于收敛
"""第三步：使用class类搭建网络结构"""
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()配置网络训练参数"""
model.compile(optimizer='sgd',#优化器
              loss='sparse_categorical_crossentropy',#损失函数
              metrics=['sparse_categorical_accuracy'])#准确率评级标准
"""第五步：使用model.fit()训练网络"""
model.fit(x_train,y_train,batch_size=88,epochs=30,validation_data=(x_test,y_test),validation_freq=4)
"""第六步：使用model.summary打印网络结构"""
model.summary()
```
激活函数大家可以自己多次选择，从而选择出最优的，初学者建议选择relu作为激活函数，选择adma或者sgd作为优化器。优化器，迭代次数等参数大家都可以自己去设置和调整。因为这是个分类问题，所以在最后一层神经网络选择了softmax作为激活函数。
相关阅读:
某赛驱动器调节工具DM-Series使用笔记
 seata环境的安装
 链表OJ练习（2）
DNS、ICMP和NAT
分享几个关于Camera的坑
 MongoDB入门与实战-第六章-MongoDB分片
 vcontact2：病毒聚类（失败）
【操作系统】同步、通信与死锁2
JS 拖拽事件
 SpringCloud 09 Hystrix 服务熔断
原文地址：https://blog.csdn.net/qq_55977554/article/details/126505913

标签	描述
0	T恤/上衣
1	裤子
2	套衫
3	连衣裙
4	外套
5	凉鞋
6	衬衫
7	运动鞋
8	袋
9	踝靴

1.搭建神经网络6步法

2.函数用法和介绍

3.鸢尾花数据集

4. Fasion_Mnist数据集