02-TensorFlow 神经网络实现鸢尾花分类

鸣鼓ming

已于 2022-01-23 10:31:00 修改

阅读量2.1k

点赞数 1

分类专栏： TensorFlow入门文章标签： tensorflow 神经网络分类

于 2022-01-23 10:10:30 首次发布

本文链接：https://blog.csdn.net/qq_41865229/article/details/122637331

版权

TensorFlow入门专栏收录该内容

14 篇文章 7 订阅

订阅专栏

1.数据集介绍

共有数据150组，每组包括花萼长、花萼宽、花瓣长、花瓣宽4个输入特征。同时给出了，这一组特征对应的鸢尾花类别。类别包括Setosa Iris（狗尾草鸢尾），Versicolour Iris（杂色鸢尾），Virginica Iris（弗吉尼亚鸢尾）三类，分别用数字0，1，2表示。
在这里插入图片描述

2.准备数据

1.数据集读入

这个数据集可以通过代码直接从网上导入

from sklearn import datasets

if __name__ == '__main__':
	#共有150组数据
    x_data = datasets.load_iris().data      #返回iris数据集所有输入特征
    y_data = datasets.load_iris().target    #返回iris数据集所有标签
    print(x_data)
    print(y_data)

运行结果
在这里插入图片描述

2.数据集乱序


    np.random.seed(116)  # 使用相同的seed，使输入特征/标签一一对应
    np.random.shuffle(x_data)
    np.random.seed(116)
    np.random.shuffle(y_data)
    tf.random.set_seed(116)

3.划分数据集

数据集分出永不相见的训练集和测试集, 取前120组数据作为训练集, 后30组作为测试集

    #训练集
    x_train = x_data[:-30]   #取倒数第30个元素之前的所有元素, 也就是有120组
    y_train = y_data[:-30]   #取倒数第30个元素之前的所有元素, 也就是有120组

    #测试集
    x_test = x_data[-30:]    #取倒数第30个元素之后的所有元素, 也就是有30组
    y_test = y_data[-30:]    #取倒数第30个元素之后的所有元素, 也就是有30组

4.配成特征标签对

配成[输入特征，标签]对，每次喂入一小撮（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)

所以数据准备操作的完整代码如下

import tensorflow as tf
from sklearn import datasets
import numpy as np

if __name__ == '__main__':
    x_data = datasets.load_iris().data      #返回iris数据集所有输入特征, 共150组
    y_data = datasets.load_iris().target    #返回iris数据集所有标签

    np.random.seed(116)  # 使用相同的seed，使输入特征/标签一一对应
    np.random.shuffle(x_data)
    np.random.seed(116)
    np.random.shuffle(y_data)
    tf.random.set_seed(116)

    #训练集
    x_train = x_data[:-30]   #取倒数第30个元素之前的所有元素, 也就是有120组
    y_train = y_data[:-30]   #取倒数第30个元素之前的所有元素, 也就是有120组

    #测试集
    x_test = x_data[-30:]    #取倒数第30个元素之后的所有元素, 也就是有30组
    y_test = y_data[-30:]    #取倒数第30个元素之后的所有元素, 也就是有30组
	
	#注意:需要转换x的数据类型, 否则后面矩阵相乘会因数据类型不一致报错
    x_train = tf.cast(x_train, tf.float32)
    x_test = tf.cast(x_test, tf.float32)

    #特征标签配对
    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)

    print(train_db)
    print(test_db)

在这里插入图片描述

3.搭建网络

花萼长、花萼宽、花瓣长、花瓣宽4个特征, 对应4个输入, Setosa Iris（狗尾草鸢尾），Versicolour Iris（杂色鸢尾），Virginica Iris（弗吉尼亚鸢尾）三类对应3个输出

y=wx+b
在这里插入图片描述
定义神经网路中所有可训练参数

    #4个输入3个输出
    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))

4.参数优化

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

  	lr = 0.1 #学习率0.1
    tran_loss_result = [] #将每轮的loss记录在此列表中, 为后续化loss曲线提供数据
    test_acc = []  #将每轮的acc记录在此列表中, 为后续化acc曲线提供数据
    epoch = 500 #循环500次
    loss_all = 0 #每轮分为4个step, loss_all记录四个step生成的4个loss的和
    for epoch in range(epoch):  # 数据集级别迭代
        for step, (x_train, y_train) in enumerate(train_db):  # batch级别迭代
            with tf.GradientTape() as tape:  # with结构记录梯度信息
                # 前向传播过程计算y
                y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算2
                y = tf.nn.softmax(y)  # 使输出y符合概率分布
                y_ = tf.one_hot(y_train, depth=3)
                loss = tf.reduce_mean(tf.square(y_-y)) #采用均方差损失函数
                loss_all += loss.numpy() # 计算总loss

            grads = tape.gradient(loss, [w1, b1])
            w1.assign_sub(lr * grads[0])  # 参数自更新
            b1.assign_sub(lr * grads[1])
        print("Epoch {}, loss: {}".format(epoch, loss_all / 4))
        tran_loss_result.append(loss_all / 4)
        loss_all = 0

在这里插入图片描述

5.测试部分

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

	    total_correct = 0
	    total_number = 0
	    for x_test, y_test in test_db:
	        y = tf.matmul(x_test, w1) + b1  # y为预测结果
	        y = tf.nn.softmax(y)  # 使y符合概率分布
	        pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引，即预测的分类
	        pred = tf.cast(pred, dtype=y_test.dtype)  # 调整数据类型与标签一致
	        correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
	        correct = tf.reduce_sum(correct)  # 将每个batch的correct数加起来
	        total_correct += int(correct)  # 将所有batch中的correct数加起来
	        total_number += x_test.shape[0]
	    acc = total_correct / total_number
	    test_acc.append(acc)
	    print("test_acc:", acc)

在这里插入图片描述
b.acc / loss可视化

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

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

在这里插入图片描述

6.完整代码

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

if __name__ == '__main__':
    x_data = datasets.load_iris().data      #返回iris数据集所有输入特征, 共150组
    y_data = datasets.load_iris().target    #返回iris数据集所有标签

    np.random.seed(116)  # 使用相同的seed，使输入特征/标签一一对应
    np.random.shuffle(x_data)
    np.random.seed(116)
    np.random.shuffle(y_data)
    tf.random.set_seed(116)

    #训练集
    x_train = x_data[:-30]   #取倒数第30个元素之前的所有元素, 也就是有120组
    y_train = y_data[:-30]   #取倒数第30个元素之前的所有元素, 也就是有120组

    #测试集
    x_test = x_data[-30:]    #取倒数第30个元素之后的所有元素, 也就是有30组
    y_test = y_data[-30:]    #取倒数第30个元素之后的所有元素, 也就是有30组

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

    #特征标签配对
    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)

    # print(train_db)
    # print(test_db)

    #4个输入3个输出
    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
    tran_loss_result = [] #将每轮的loss记录在此列表中, 为后续化loss曲线提供数据
    test_acc = []  #将每轮的acc记录在此列表中, 为后续化acc曲线提供数据
    epoch = 500 #循环500次
    loss_all = 0 #每轮分为4个step, loss_all记录四个step生成的4个loss的和
    for epoch in range(epoch):  # 数据集级别迭代
        for step, (x_train, y_train) in enumerate(train_db):  # batch级别迭代
            with tf.GradientTape() as tape:  # with结构记录梯度信息
                # 前向传播过程计算y
                y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算2
                y = tf.nn.softmax(y)  # 使输出y符合概率分布
                y_ = tf.one_hot(y_train, depth=3)
                loss = tf.reduce_mean(tf.square(y_-y)) #采用均方差损失函数
                loss_all += loss.numpy() # 计算总loss

            grads = tape.gradient(loss, [w1, b1])
            w1.assign_sub(lr * grads[0])  # 参数自更新
            b1.assign_sub(lr * grads[1])
        print("Epoch {}, loss: {}".format(epoch, loss_all / 4))
        tran_loss_result.append(loss_all / 4)
        loss_all = 0

        total_correct = 0
        total_number = 0
        for x_test, y_test in test_db:
            y = tf.matmul(x_test, w1) + b1  # y为预测结果
            y = tf.nn.softmax(y)  # 使y符合概率分布
            pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引，即预测的分类
            pred = tf.cast(pred, dtype=y_test.dtype)  # 调整数据类型与标签一致
            correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
            correct = tf.reduce_sum(correct)  # 将每个batch的correct数加起来
            total_correct += int(correct)  # 将所有batch中的correct数加起来
            total_number += x_test.shape[0]
        acc = total_correct / total_number
        test_acc.append(acc)
        print("test_acc:", acc)

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

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