人工智能-----鸢尾花分类实现

鸢尾花数据集

从sklearn包datasets读入数据集，语法为：

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

---

神经网络实现鸢尾花分类

准备数据

• 数据集读入
• 数据集乱序
• 生成训练集和测试集（即x_train/y_train,x_test/y_test)
• 配成（输入特征，标签）对，每次读入一小撮（batch)

搭建网络

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

参数优化

• 嵌套循环迭代，with结构更新参数，显示当前loss

测试效果

• 计算当前参数前向传播后的准确率，显示当前acc

acc/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
print(x_data)
#随机打乱数据（因为原始数据是顺序的，顺序不打乱会影响准确率）
# seed：随机数种子，是一个整数，当设置之后，每次生成的随机数都一样
np.random.seed(116)
np.random.shuffle(x_data)
print(x_data)
print("---------------")
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个输入节点，因分三类，输出层为三个神经元
#使用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))

#学习率为0.1
lr=0.1
#将每轮的loss记录在此列表当中，为后续画loss曲线提供数据
train_loss_results=[]
#将每轮的acc记录在此列表中，为后续画acc曲线提供数据
test_acc=[]
#循环500轮
epoch=500
#每轮分4个step，loss_all记录四个step生成的4个loss的和
loss_all=0
#训练部分
#数据集级别循环，每个epoch循环一次数据集
for epoch in range(epoch):
    #batch级别的循环，每个step循环一个batch
    for step,(x_train,y_train) in enumerate(train_db):
        #with结构记录神经梯度
        with tf.GradientTape() as tape:
            #神经网络乘法加法运算
            y=tf.matmul(x_train,w1)+b1
            #使输出y符合概率分布
            y=tf.nn.softmax(y)
            #将标签值转换成独热码格式，方便计算loss和accuracy
            y_=tf.one_hot(y_train,depth=3)
            #采用均方差损失函数mse=mean（sum（y-out）^2)
            loss=tf.reduce_mean(tf.square(y_-y))
            #将每个step计算出来的loss累加，为后续求loss平均值提供数据，这样计算的loss更准确
            loss_all+=loss.numpy()
            #计算loss对各个参数的梯度
        grads=tape.gradient(loss,[w1,b1])
        #实现梯度更新w1=w1-lr*w1_grad b=b-lr*b_grad
        w1.assign_sub(lr*grads[0])
        b1.assign_sub(lr*grads[1])
    #每个epoch打印loss信息
    print("Epoch{},loss:{}".format(epoch,loss_all/4))
    #将4个step的loss求平均记录在此变量中
    train_loss_results.append(loss_all/4)
    #loss_all归零，为记录下一个epoch的loss做准备
    loss_all=0



    #测试部分
    #total_correct为测试对的样本个数，total_number为测试总样本数
    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)
        #返回y中的最大值的索引，即预测的分类
        pred=tf.argmax(y,axis=1)
        #将pred转换为y_test的数据类型
        pred=tf.cast(pred,dtype=y_test.dtype)
        #若分类正确，则cirrect=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的行数，shap[0]返回变量的行数
        total_number+=x_test.shape[0]
        #总的准确率为  总准确的个数/总个数
    acc=total_correct/total_number
    test_acc.append(acc)
    print("test_acc",acc)
    print("------------------")

#绘制loss曲线
plt.title('Loss Function Curve')
plt.xlabel('Epoch')
plt.ylabel('loss')
#逐点画出值并连线，连线图标使loss
plt.plot(train_loss_results,label="$Loss$")
#画出曲线图标
plt.legend()
#画出图像
plt.show()

#绘制Accuracy曲线
plt.title('ACC Curve')
plt.xlabel('Epoch')
plt.ylabel('ACC')
plt.plot(test_acc,label="$Accuracy$")
plt.legend()
plt.show()