tensorflow实现iris分类

最新推荐文章于 2024-04-17 00:42:53 发布

忧郁奔向冷的天

最新推荐文章于 2024-04-17 00:42:53 发布

阅读量1.6k

点赞数 3

CC 4.0 BY-SA版权

分类专栏：深度学习

本文链接：https://blog.csdn.net/qq_37083038/article/details/107832941

深度学习专栏收录该内容

17 篇文章

订阅专栏

本文通过三种不同方法，包括手动搭建神经网络、使用Sequential模型及自定义Model类，详细介绍了如何利用TensorFlow对鸢尾花数据集进行分类，展示了神经网络的学习过程。

内容来自MOOC《人工智能实践：Tensorflow笔记2》

八股搭建网络：我觉得是指按照固定模式搭建神经网络，八股只是呆板的意思，并不是按照八个步骤搭建。我们抨击的应该是八股取士制度，而不是八股文。

1.iris数据集

iris数据集：从sklearn包中导入iris数据集；去官网下载http://archive.ics.uci.edu/ml/datasets/Iris/
特征数：4，sepal length in cm 花萼长，sepal width in cm 花萼宽，petal length in cm 花瓣长，petal width in cm 花瓣宽
类别数：3，Iris Setosa狗尾鸢尾，Iris Versicolour杂色鸢尾，Iris Virginica弗吉尼亚鸢尾
这个图只是为了展示什么是花萼与花瓣，并不是鸢尾花

2.实现鸢尾花分类——方一

2.1 步骤

import模块
load数据集，打乱数据集顺序，将打乱后的数据集分为train与test
train与test的features与labels配对，并且给出batch大小
初始化权重与偏置 (神经网络为全连接，输入层：4个神经元，隐藏层：3个神经元，输出层：3个神经元)
给出学习率、epoch大小
训练
计算每个epoch的训练集损失与测试集准确率进行绘图

2.2 具体的训练过程

如120组数据，90组用于训练，30组用于测试
batch=30，则训练集分为3个batch，测试集为1个batch
epoch=3，进行3次循环

epoch1
--train_batch1
--train_batch2
--train_batch3
--test_batch1
epoch2
--train_batch1
--train_batch2
--train_batch3
--test_batch1
epoch3
--train_batch1
--train_batch2
--train_batch3
--test_batch1

2.3疑问

像train_db、test_db这种BatchDataset类只能通过循环展示或调用？
反正我目前没找到其他方法。如果直接输出print(train_db)是显示不出内容的。

2.4 代码

# -*- 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()

3.实现鸢尾花分类——方二

3.1 六步法

import
train, test
model=tf.keras.models.Sequential
model.compile
model.fit
model.summary

3.2 model=tf.keras.models.Sequential

model=tf.keras.models.Sequential([]) 定义神经层的类型、激活函数类型、正则化类型

拉直层 tf.keras.layers.Flatten() 将输入特征拉直变为一维数组
全连接层 tf.keras.layers.Dense(神经元个数,activation=激活函数, kernel_regularizer=正则化)
卷积层 tf.keras.layers.Conv2D(filters=卷积核个数,kernel_size=卷积核尺寸, strides=卷积步长,padding="valid" or "same")
LSTM层 tf.keras.layers.LSTM()

activation = 'relu', 'softmax', 'sigmoid', 'tanh'
kernel_regularizer = tf.keras.regularizers.l1(), tf.keras.regularizers.l2()

3.3 model.compile

model.compile(optimizer=优化器,loss=损失函数,metrics=["准确率"]) 定义优化器损失函数评测指标

优化器：
'sgd' or tf.optimizers.SGD(lr=学习率, decay=学习率衰减率, momentum=动量参数)
'adagrad' or tf.keras.optimizers.Adagrad(lr=学习率, decay=学习率衰减率)
'adadelta' or tf.keras.optimizers.Adadelta(lr=学习率, decay=学习率衰减率)
'adam' or tf.keras.optimizers.Adam (lr=学习率, decay=学习率衰减率)

损失函数：
'mse' or tf.keras.losses.MeanSquaredError()
'sparse_categorical_crossentropy' or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
from_logits：原始输出是否经过概率分布, from_logits=False表示经过概率分布，from_logits=True表示原始输出

评测指标：
'accuracy'：y_和y 都是数值，如y_=[1] y=[1]。
'categorical_accuracy'：y_和y 是以独热码和概率分布表示。如y_=[0, 1, 0], y=[0.256, 0.695, 0.048]
'sparse_ categorical_accuracy'：y_和y是以数值和概率分布表示。如y_=[1], y=[0.256, 0.695, 0.048]

3.4 疑问

以下是我百度到的，可能不对
binary_crossentropy 二分类交叉熵，使用sigmoid激活函数
categorical_crossentropy 多分类交叉熵，使用softmax激活函数得到输出的概率分布，y_和y 以独热码和概率分布表示
sparse_categorical_crossentrop 稀疏多分类交叉熵，使用softmax激活函数得到输出的概率分布，y_和y是以数值和概率分布表示

3.5 model.fit

进行训练与测试，定义batch，epoch

model.fit(训练集的输入特征,训练集的标签,batch_size= ,epochs= ,validation_data = (测试集的输入特征，测试集的标签),validataion_split = 从测试集划分多少比例给训练集,validation_freq = 多少次epoch测试一次)

validation_data与validataion_split都是定义测试集，只能选择一个

3.6 model.summary

model.summary() 打印网络结构与参数统计

3.7 代码

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

4.实现鸢尾花分类——方三

同方二，只是方法三使用继承自Model的类来定义神经网络，而方法二使用了Sequential函数来定义神经网络

4.1 步骤

class IrisModel(Model):
    def __init__(self):
        #定义网络结构
        super(IrisModel, self).__init__()
        self.d1 = Dense(3, activation='sigmoid', kernel_regularizer=tf.keras.regularizers.l2())
   
    def call(self, x):
        #调用网络结构块，实现前向传播
        y = self.d1(x)
        return y
model = IrisModel()

4.2 代码

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