TensorFlow神经网络计算过程及模型搭建：以鸢尾花分类为例

人工智能三大学派

  人工智能是指，让机器具备人的思维和意识。人工智能主要有三个学派：

• 行为主义：基于控制论，构建感知、动作控制系统。（控制论，如平衡、行走、避障等自适应控制系统）单脚站立是行为主义一个典型例子，通过感知要摔倒的方向，控制两只手的动作，保持身体的平衡。
• 符号主义：基于算数逻辑表达式，求解问题时先把问题描述为表达式，再求解表达式。（可用公式描述、实现理性思维，如专家系统）符号主义是能用公式描述的人工智能，它让计算机具备了理性思维。
• 连接主义：仿生学，模仿神经元连接关系，使人类不仅具备理性思维，还具备无法用公式描述的感性思维，如对某些知识产生记忆。（仿脑神经元连接，实现感性思维，如神经网络）
  • 随着大量的数据通过视觉、听觉涌入大脑，使我们的神经网络连接，也就是这些神经元连接线上的权重发生了变化，有些线上的权重增强了，有些线上的权重减弱了
    

神经网络设计过程

  上图给出了搭建与使用神经网络的流程示意图。具体地，

1. 准备数据
  数据量越大越好，要构成特征和标签对。

2. 搭建网络
  搭建神经网络的网络结构。

3. 优化参数
  通过反向传播，优化连线的权重，直到模型的识别准确率达到要求，得到最优的连线权重，把这个模型保存起来。

4. 应用网络
  用保存的模型，输入从未见过的新数据，它会通过前向传播，输出概率值，概率值最大的一个，就是分类或预测的结果。

鸢尾花分类

  人们通过经验总结出了规律：通过测量花的花萼长、花萼宽、花瓣长、花瓣宽，可以得出鸢尾花的类别。比如，若某鸢尾花满足：花萼长>花萼宽且花瓣长/花瓣宽>2，则为1杂色鸢尾。

• 专家系统：使用if语句case语句，把专家的经验告知计算机，计算机执行逻辑判别（理性计算），给出分类。
• 神经网络：采集大量（花萼长、花萼宽、花瓣长、花瓣宽（输入特征），对应的类别（标签））数据对构成数据集，把数据集喂入搭建好的神经网络结构，网络优化参数得到模型，模型读入新输入特征，输出识别结果。

数据集介绍

  鸢尾花数据集：提供了150组鸢尾花数据，每组数据包含鸢尾花花萼长、花萼宽、花瓣长、花瓣宽及对应的类别。其中前4个属性作为输入特征，类别作为标签，0代表狗尾草鸢尾，1代表杂色鸢尾，2代表弗吉尼亚鸢尾。

网络搭建与训练

网络结构

搭建网络，初始化参数

喂入数据，前向传播

损失函数
损失函数（loss function）：预测值（y）与标准答案（y_）的差距。
损失函数可以定量判断W、b的优劣，当损失函数输出最小时，参数W、b会出现最优值。
$$MSE(y,\bar{y})=\frac{1}{n}\sum _{k=0}^n(y-\bar{y}{)}^2$$

目的：想找到一组参数w和b，使得损失函数最小。

梯度下降，反向传播

• 梯度下降法：沿损失函数梯度下降的方向，寻找损失函数的最小值，得到最优参数的方法。
  

学习率（learning rate，lr）：当学习率设置的过小时，收敛过程将变得十分缓慢。而当学习率设置的过大时，梯度可能会在最小值附近来回震荡，甚至可能无法收敛。

• 反向传播：从后向前，逐层求损失函数对每层神经元参数的偏导数，迭代更新所有参数。

TensorFlow实现

导入所需模块：

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

1. 准备数据

1.1 读入数据集

• 法一：从sklearn包datasets 读入数据集，分别为输入特征和标签

from sklearn.datasetsimport load_iris
x_data= datasets.load_iris().data # 返回iris数据集所有输入特征
y_data= datasets.load_iris().target # 返回iris数据集所有标签

• 法二：本地读取数据集
  • 利用pandas中函数读取，并处理成神经网络需要的数据结构：pd.read_csv('文件名'，header=第几行作为表头，sep='分割符号')
  • 利用open函数打开txt文件，并处理成神经网络需要的数据结构：open('文件名'，'r')

df = pd.read_csv('iris.txt',header = None,sep=',') #读取本地文件
data = df.values # 去掉索引并取值
x_data = [lines[0:4] for lines in data] # 取输入特征
x_data = np.array(x_data,float) # 转换为numpy格式
y_data = [lines[4] for lines in data] # 取标签
for i in range(len(y_data)):
	if y_data[i] == 'Iris-setosa':
		y_data[i] = 0
	elif y_data[i] == 'Iris-versicolor':
		y_data[i] = 1
	……
y_data = np.array(y_data)

f = open('iris.txt','r') # 取本地文件
contents = f.readlines() # 按行读取
i=0
for content in contents:
	temp = content.split(',') # 按逗号分隔
	x_data[i] = np.array([temp[0:4]],dtype=float) # 取输入特征
	if temp[4] == 'Iris-setosa\n': # 判断标签并赋值
		y_data[i] = 0
	elif temp[4] == 'Iris-versicolor\n':
		y_data[i] = 1
	……
	i = i + 1

1.2 数据集乱序

• 随机打乱数据：因为原始数据是顺序的，顺序不打乱会影响准确率；
• seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样；
• 使用相同的seed，使输入特征/标签一一对应

np.random.seed(116) 
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

1.3 数据集分割成永不相见的训练集和测试集

• 将打乱后的数据集分割为训练集和测试集，训练集为前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)

1.4 配成[输入特征，标签]对，每次喂入一小撮(batch)

• 将每32组输入特征标签对打包为一个batch，在喂入神经网络时会以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)

2. 搭建网络，定义神经网络中的所有可训练参数

• 生成神经网络的参数，4个输入特征故，输入层为4个输入节点；因为3分类，故输出层为3个神经元
• 用tf.Variable()标记参数可训练
• 使用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))

3. 优化可训练的参数

初始化超参数

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的和

优化可训练的参数

• 嵌套循环迭代，with结构更新参数，显示当前loss；
• 因为训练集有120组数据，batch是32，每个step只能喂入32组数据，需要batch级别循环4次，所以loss除以4，求得每次step迭代的平均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
            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
            loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数
            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做准备

当前参数前向传播后的准确率
为了查看效果，程序中可以加入每遍历一次数据集显示当前参数前向传播后的准确率

    # 测试部分（每个epoch下均进行一次计算）
    # 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("--------------------------")

4. acc/loss可视化

# 绘制 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()

---

北大人工智能实践：Tensorflow笔记