三天学会搭建神经网络做分类预测（tensorflow）

三天学会搭建神经网络做分类预测（tensorflow）

---

前言

这篇文章适合那些对深度学习感兴趣想入门，或者想在自己的项目应用中添加简单分类预测功能的小伙伴们阅读，也欢迎AI领域的大佬提出意见和建议。本文从准备工作（环境搭建）到基本计算过程再到网络的搭建和优化。最后再总结一套六步法让你能快速搭建自己的神经网络实现分类功能需求。
有的小伙伴就要问了，为什么是三天不是一天呢？学习编程，不写点代码能学得会吗，不敲代码学编程就像学车不摸方向盘，我要是告诉你不用摸方向盘用意念一天就学会开车，那不是瞎扯吗。

---

准备工作

anaconda安装

官网： https://www.anaconda.com/
下载安装对应自己系统的python3.8版本

tensorflow安装

1、在开始菜单这里选择anaconda powershell prompt进入命令行模式

2、输入命令 conda create -n tf2.1 python=3.8回车，新建一个名叫tf2.1的环境

3、新建好环境之后继续输入conda activate tf2.1回车 进入刚才新建的这个环境,可以看到最前面的括号里面环境名变了

4、之后继续输入conda install cudatoolkit=10.1回车，安装英伟达的SDK10.1版本，询问是否安装依赖包时输入y选择安装，回车继续安装，该过程可能由于网络原因会导致失败很多次，可以重新键入这条命令多次尝试，也可以更换安装源，更换安装源的方法问度娘很简单。

5、安装完成之后继续输入conda install cudnn=7.6回车，安装英伟达深度学习软件包7.6版本

6、前面两步安装英伟达的软件包要是确实安装不了也没关系，也可以不安装它，这两个包主要用于使用GPU提速，对于没有GPU或者网络情况不太理想的小伙伴可以选择直接跳过进入到下一步输入命令pip install tensorflow==2.1安装tensorflow2.1版本

pycharm安装

官网： https://www.jetbrains.com/pycharm/
选择版本我们选择免费版完全够用，能白嫖就白嫖，省一分是一分
安装好pycharm之后新建工程，将我们刚才装的anaconda的tf2.1环境导入到pycharm中，不会导环境的小伙伴可以在csdn上搜索pycharm环境配置，有很多文章都写的很详细。

---

一、神经网络的计算（第一天）

第一天咋们来点简单易懂的，咋们通过一个简单的鸢尾花分类的例子来感受下神经网络的魔力。

1.基本流程

准备数据：采集大量的‘特征/标签’数据
搭建网络：搭建神经网络的基本结构
优化参数：训练网络获取最佳的参数使得预测值与真实值更接近
应用网络：将训练好的网络保存为模型，传入新数据，给出预测结果

2.数据介绍（鸢尾花数据集）

选用最经典的鸢尾花数据集，经典永不过时嘛。
简单介绍一下鸢尾花数据集的结构：
鸢尾花一般被我们分为三类，分类的依据是花萼长、花萼宽、花瓣长，花瓣宽，我们把要用于分类的依据属性，比如这四个属性就是我们本次训练的特征。根据这四种属性我们所分出来的三类（狗尾草鸢尾、杂色鸢尾、弗吉尼亚鸢尾），这三种类别我们称之为标签。
鸢尾花数据集的结构是四个特征值对应一个标签值，特征值就是花萼长、花萼宽、花瓣长，花瓣宽的值，比如[5.8、4.0、1.2、0.2]，标签值就是对应的类别值，我们把三种类别分别对应为0、1、2，鸢尾花数据集就是许多组这样4+1结构构成的集合。

3.基本概念（理解不了可以暂时跳过）

w、b：训练参数，w被称之为权重，b被称之为偏置。预测值矩阵=特征值矩阵*w+b
损失函数loss：预测值与标准答案（标签）的差距，损失函数可以判断w、b的优劣，当损失函数输出最小时，也就是预测值与真实值的差距最小时，参数w、b就是最优值
梯度：函数对各参数求偏导后的向量。函数梯度下降方向是函数值减小的方向。
梯度下降法：沿损失函数梯度下降的方向，寻找损失函数的最小值，得到最优参数的方法。
梯度下降的目的：找到一组参数w和b，使得损失函数值最小
学习率lr：每次利用梯度进行参数更新时的程度，学习率过小参数更新会很缓慢，学习率过大可能会在最小值附近来回震荡无法收敛，什么样的学习率最合适这个只能自己去试，我喜欢每次减小或扩大三倍。
反向传播：从后向前，逐层求损失函数对每层神经元网络参数的偏导数，迭代更新所有参数。
更新后的W=更新前的W－学习率×损失函数对更新前W的偏导

4.tensorflow基本用法（不用记，要用随时查，看一眼有个印象就行）

注： 简单介绍一些后面会用到的方法，写的很简略，如果有不清楚的地方可以查阅tensorflow文档（https://tensorflow.google.cn/api_docs/python/tf）
创建一个tensor：tf.constant(张量内容，dtype=数据类型（可选））
将numpy的数据类型转换为tensor：tf.convert_to_tensor（数据名，dtype=数据类型（可选））
创建全为0、1、指定值的张量：tf.zeros（维度） tf.ones（维度） tf.fill（维度，指定值）
生成正态分布的随机数：tf.random.normal（维度，mean=均值，stddev=标准差）
生成截断式正太分布的随机数：tf.random.truncated_normal(维度，mean均值，stddev=标准差）
生成均匀分布随机数：tf.random.uniform(维度，minval=最小值，maxval=最大值）
强制tensor转化为该数据类型：tf.cast（张量名，dtype=数据类型）
计算张量上元素的最小、最大值：tf.reduce_min(张量名） tf.reduce_max（张量名）
理解axis：axis=0代表跨行，axis=1代表跨列，如果不指定则所有元素参与计算
计算张量沿着指定维度的平均值：tf.reduce_mean（张量名，axis=操作轴）
计算张量沿着指定维度的和：tf.reduce_sum（张量名，axis=操作轴）
标记变量为可训练：tf.Variable（变量）
四则运算：tf.add（张量1，张量2） tf.subtract（张量1，张量2） tf.multiply（张量1，张量2）tf.divide（张量1，张量2）
张量的平方、n次方、开方：tf.square（张量名） tf.pow（张量名，n次方数） tf.sqrt（张量名）
两个矩阵相乘：tf.matmul（矩阵1，矩阵2）
切分传入张量的第一维度，生成特征/标签对：tf.data.Dataset.from_tensor_slices((输入特征，标签))
with结构记录计算过程，gradient求出张量的梯度：
with tf.GradientTape（） as tape：
            计算过程
grad=tape.gradient(函数，对谁求导)
遍历每个元素，组合成（索引 元素）的形式：enmerate（可迭代对象）
将数据转换为one-hot形式的数据输出：tf.one_hot（待转换数据，depth=几分类）
将输出结果转化为概率分布：tf.nn.softmax（输出结果）
参数自减操作：w.assign_sub（自减值）
返回张量沿指定维度最大值的索引：tf.argmax（张量名，axis=操作轴）

5.撸代码（动手写，动手写，动手写，重要的事情说三遍）

# -*- coding: UTF-8 -*-
# 利用鸢尾花数据集，实现前向传播、反向传播，可视化loss曲线

# 导入所需模块
import tensorflow as tf
from sklearn import datasets
from matplotlib import pyplot as plt
import numpy as np

# 导入数据，分别为输入特征和标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target

# 随机打乱数据（因为原始数据是顺序的，顺序不打乱会影响准确率）
# seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样（为方便教学，以保每位同学结果一致）
np.random.seed(116)  # 使用相同的seed，保证输入特征和标签一一对应
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

# 将打乱后的数据集分割为训练集和测试集，训练集为前120行，测试集为后30行
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]

# 转换x的数据类型，否则后面矩阵相乘时会因数据类型不一致报错
x_train = tf.cast(x_train, tf.float32)
x_test = tf.cast(x_test, tf.float32)

# from_tensor_slices函数使输入特征和标签值一一对应。（把数据集分批次，每个批次batch组数据）
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

# 生成神经网络的参数，4个输入特征故，输入层为4个输入节点；因为3分类，故输出层为3个神经元
# 用tf.Variable()标记参数可训练
# 使用seed使每次生成的随机数相同（方便教学，使大家结果都一致，在现实使用时不写seed）
w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))

lr = 0.1  # 学习率为0.1
train_loss_results = []  # 将每轮的loss记录在此列表中，为后续画loss曲线提供数据
test_acc = []  # 将每轮的acc记录在此列表中，为后续画acc曲线提供数据
epoch = 500  # 循环500轮
loss_all = 0  # 每轮分4个step，loss_all记录四个step生成的4个loss的和

# 训练部分
for epoch in range(epoch):  #数据集级别的循环，每个epoch循环一次数据集
    for step, (x_train, y_train) in enumerate(train_db):  #batch级别的循环 ，每个step循环一个batch
        with tf.GradientTape() as tape:  # with结构记录梯度信息
            y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
            y = tf.nn.softmax(y)  # 使输出y符合概率分布（此操作后与独热码同量级，可相减求loss）
            y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式，方便计算loss和accuracy
            loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
            loss_all += loss.numpy()  # 将每个step计算出的loss累加，为后续求loss平均值提供数据，这样计算的loss更准确
        # 计算loss对各个参数的梯度
        grads = tape.gradient(loss, [w1, b1])

        # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
        w1.assign_sub(lr * grads[0])  # 参数w1自更新
        b1.assign_sub(lr * grads[1])  # 参数b自更新

    # 每个epoch，打印loss信息
    print("Epoch {}, loss: {}".format(epoch, loss_all/4))
    train_loss_results.append(loss_all / 4)  # 将4个step的loss求平均记录在此变量中
    loss_all = 0  # loss_all归零，为记录下一个epoch的loss做准备

    # 测试部分
    # total_correct为预测对的样本个数, total_number为测试的总样本数，将这两个变量都初始化为0
    total_correct, total_number = 0, 0
    for x_test, y_test in test_db:
        # 使用更新后的参数进行预测
        y = tf.matmul(x_test, w1) + b1
        y = tf.nn.softmax(y)
        pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引，即预测的分类
        # 将pred转换为y_test的数据类型
        pred = tf.cast(pred, dtype=y_test.dtype)
        # 若分类正确，则correct=1，否则为0，将bool型的结果转换为int型
        correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
        # 将每个batch的correct数加起来
        correct = tf.reduce_sum(correct)
        # 将所有batch中的correct数加起来
        total_correct += int(correct)
        # total_number为测试的总样本数，也就是x_test的行数，shape[0]返回变量的行数
        total_number += x_test.shape[0]
    # 总的准确率等于total_correct/total_number
    acc = total_correct / total_number
    test_acc.append(acc)
    print("Test_acc:", acc)
    print("--------------------------")

# 绘制 loss 曲线
plt.title('Loss Function Curve')  # 图片标题
plt.xlabel('Epoch')  # x轴变量名称
plt.ylabel('Loss')  # y轴变量名称
plt.plot(train_loss_results, label="$Loss$")  # 逐点画出trian_loss_results值并连线，连线图标是Loss
plt.legend()  # 画出曲线图标
plt.show()  # 画出图像

# 绘制 Accuracy 曲线
plt.title('Acc Curve')  # 图片标题
plt.xlabel('Epoch')  # x轴变量名称
plt.ylabel('Acc')  # y轴变量名称
plt.plot(test_acc, label="$Accuracy$")  # 逐点画出test_acc值并连线，连线图标是Accuracy
plt.legend()
plt.show()

---

二、神经网络的优化（第二天）

1.指数衰减学习率（在训练过程中自动调整学习率）

指数衰减学习率=初始学习率×学习率衰减率^（当前轮数/多少轮衰减一次）

LR_BASE = 0.2  # 最初学习率
LR_DECAY = 0.99  # 学习率衰减率
LR_STEP = 1  # 喂入多少轮BATCH_SIZE后，更新一次学习率

for epoch in range(epoch):  # for epoch 定义顶层循环，表示对数据集循环epoch次，此例数据集数据仅有1个w,初始化时候constant赋值为5，循环100次迭代。
    lr = LR_BASE * LR_DECAY ** (epoch / LR_STEP)
    pass

2.激活函数（对网络输出结果进行微调，使得输出值符合要求）

sigmoid函数： tf.nn.sigmoid（x）
Tanh函数： tf.math.tanh(x)
Relu函数： tf.nn.relu（x）
Leaky Relu函数： tf.nn.leaky_relu（x）

建议：初学者首选relu函数，学习率设置小值，输入特征前先标准化（输入特征满足以0为均值），初始参数中心化（随机参数满足以0为均值，（2/当前层输入特征个数）^1/2为标准差的正态分布）

3.损失函数（衡量网络效果，反向传播求导优化参数）

损失函数：预测值与真实值之间的差距

loss_ce1 = tf.losses.categorical_crossentropy([1, 0], [0.6, 0.4])
loss_ce2 = tf.losses.categorical_crossentropy([1, 0], [0.8, 0.2])
print("loss_ce1:", loss_ce1)
print("loss_ce2:", loss_ce2)

4.正则化缓解过拟合（防止过拟合，提高网络的泛化性）

正则化在损失函数中引入模型复杂度指标，利用给w加权值，弱化了训练数据的噪声

#-------正则化项---------
	 loss_regularization=[]
	 loss_regularization.append(tf.nn.l2_loss(w1))
	 loss_regularization.append(tf.nn.l2_loss(w2))
	 loss_regularization=tf.reduce_sum(loss_regularization)
	 loss=loss+REGULARTZER*loss_regularization

5.优化器更新网络参数（参数更新的方法）

SGD

# 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
        w1.assign_sub(lr * grads[0])  # 参数w1自更新
        b1.assign_sub(lr * grads[1])  # 参数b自更新

SGDM

# sgd-momentun  
        m_w = beta * m_w + (1 - beta) * grads[0]
        m_b = beta * m_b + (1 - beta) * grads[1]
        w1.assign_sub(lr * m_w)
        b1.assign_sub(lr * m_b)

Adagrad

# adagrad
        v_w += tf.square(grads[0])
        v_b += tf.square(grads[1])
        w1.assign_sub(lr * grads[0] / tf.sqrt(v_w))
        b1.assign_sub(lr * grads[1] / tf.sqrt(v_b))

RMSProp

# rmsprop
        v_w = beta * v_w + (1 - beta) * tf.square(grads[0])
        v_b = beta * v_b + (1 - beta) * tf.square(grads[1])
        w1.assign_sub(lr * grads[0] / tf.sqrt(v_w))
        b1.assign_sub(lr * grads[1] / tf.sqrt(v_b))

Adam

# adam
        m_w = beta1 * m_w + (1 - beta1) * grads[0]
        m_b = beta1 * m_b + (1 - beta1) * grads[1]
        v_w = beta2 * v_w + (1 - beta2) * tf.square(grads[0])
        v_b = beta2 * v_b + (1 - beta2) * tf.square(grads[1])

        m_w_correction = m_w / (1 - tf.pow(beta1, int(global_step)))
        m_b_correction = m_b / (1 - tf.pow(beta1, int(global_step)))
        v_w_correction = v_w / (1 - tf.pow(beta2, int(global_step)))
        v_b_correction = v_b / (1 - tf.pow(beta2, int(global_step)))

        w1.assign_sub(lr * m_w_correction / tf.sqrt(v_w_correction))
        b1.assign_sub(lr * m_b_correction / tf.sqrt(v_b_correction))

---

三、神经网络的搭建六步法（第三天）

前面说了这么多基本概念和基本用法，都是为了最后能在理解的基础上使用六步法快速搭建神经网络。下面进入最关键的也是最有意思的环节，利用六步法搭建神经网络。

1.废话少说先上六步大法

第一步导库：import
第二步划分训练集和测试集：train，test
第三步定义模型结构：model=tf.kears.models.Sequential
第四步定义优化器和损失函数：model.compile
第五步训练模型：model.fit
第六步打印网络结构：model.summary

2.第三步网络结构层

3.第四步优化器和损失函数

4.第五步优化器和损失函数

5.上代码

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)

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

model.summary()

6.补充

第三步网络结构可以用类的方式进行构建

上代码

import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
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 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),
              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)
model.summary()

---

总结

人懒此处省略，有任何意见建议或疑问欢迎评论区，阿巴阿巴阿巴。。。。。。。