案例一：鸢尾花数据的分类

一：准备数据

1.1：读入数据集

from sklearn.datasets import load_iris
from sklearn import datasets
import pandas
import matplotlib.pyplot as plt

x_data = datasets.load_iris().data
y_data = datasets.load_iris().target
print(x_data.shape)
print(y_data.shape)

1.2： 数据集乱序

print(y_data)

# seed()+shuffle
import random

seed=10
random.seed(seed)
random.shuffle(x_data)
random.seed(seed)# 一定得重复在写一遍,和上面的seed要相同,不然y_batch和x_batch打乱顺序会不一样
random.shuffle(y_data)

print(y_data)

1.3：生成训练集和测试集

from sklearn.model_selection import train_test_split
(X_train,X_test,y_train,y_test) = train_test_split(x_data, y_data, train_size=0.8, random_state=seed)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

1.4：（特征 - 标签）配对，且每次只读入一部分（batch）进行训练

import tensorflow as tf
# import tensorflow.compat.v1 as tf
# tf.enable_eager_execution()

train_data = tf.data.Dataset.from_tensor_slices((X_train, y_train)).batch(30)
test_data = tf.data.Dataset.from_tensor_slices((X_test, y_test)).batch(30)

batch(30)：以每组30个的形式，喂入模型时以bacth为单位。一般选2的幂次。

# DatasetV1Adapter类型
train_data
test_data

二：搭建网络

定义神经网络中所有可训练参数

w1 = tf.Variable(tf.random.truncated_normal([4,3], stddev=0.1, seed=1, dtype=tf.float64))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1, dtype=tf.float64))

因为X的特征有4个，所以第一层有4个输入。
且最终分类结果只有3个，所以最后一层输入为3
又因为模型只有两层，所以第一层的输出 = 下一层的输入，为3。
所以：

• w1维度为：(4, 3)
• b1维度为：(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

for epoch in range(epoch):# 数据集级别迭代
    for step,(x_train,y_train) in enumerate(train_data):# batch级别迭代
        with tf.GradientTape() as tape: # 记录梯度信息
            # 正向传播
            y = tf.matmul(x_train, w1) + b1 # 神经网络乘、加运算
            y = tf.nn.softmax(y) # 使分类输出转换成概率的形式，（注意：此操作后，与独热码同量级，可相减求loss）
            y_one_hot = tf.one_hot(y_train, depth=3, dtype=tf.float64)# 将标签值转换成独热码格式，方便计算loss和acc
            
            # 计算损失loss
            loss = tf.reduce_mean(tf.square(y_one_hot - y))
#            # 这两句话的区别是 loss = tf.reduce_mean(tf.square(y_one_hot, y))
            loss_all += loss.numpy()

        # 计算loss对各个参数的梯度（导数）
        grads = tape.gradient(loss, [w1, b1])
        
        # 梯度自更新 w1 = w1 - lr*grads[0]; b1 = b1- lr*grads[1]
        w1.assign_sub(lr*grads[0])
        b1.assign_sub(lr*grads[1])  
    print("Epoch {}, loss: {}".format(epoch, loss_all/4))
    train_loss_results.append(loss_all / 4)
    loss_all = 0
    
    # 求模型的准确率
    total_correct, total_number = 0, 0
    for x_test, y_test in test_data:
        y = tf.matmul(x_test, w1)+b1 # 模型对三个分类的预测概率
        y = tf.nn.softmax(y) # 对y进行归一化
        pred = tf.argmax(y, axis=1) # 获取概率值最大的下标（也就是获取y的分类）
        pred = tf.cast(pred, dtype=y_test.dtype)
        # 若分类正确，则correct=1，否则为0
        correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
        total_correct += int(tf.reduce_sum(correct)) # 把一个批次的分类结果累加起来，保存到变量中
        total_number += x_test.shape[0]

    acc = total_correct / total_number
    test_acc.append(acc)
    print("Test acc: ", acc)
    print("-----------------------------------------------")

这里的 y 相当于是 y_predict，y_test 相当于y_true。通过softmax将 y 转换成符合概率分布的概率值（不是很理解为什么要加这一步，不加好像也可以）。

因为 y 的维度为[batch, 3]，y_test 的维度为 [batch, 1]。采取的方法是将 y_test 转换成（三维）独热编码。

损失函数 loss 即为两者的方差。

acc/loss可视化

plt.title("Loss Function Curve")
plt.xlabel("Epoch")
plt.ylabel("Loss")
# 画出trian_loss_results曲线，且连线图标是Loss
plt.plot(train_loss_results, label="$Loss$")
# 画出曲线的图标（右上角）
plt.legend()
plt.show()

plt.title("Acc Curve")
plt.xlabel("Epoch")
plt.ylabel("Acc")
plt.plot(test_acc, label="$Accuracy$")# 连线图标是Accuracy
plt.legend()
plt.show()