图像分类网络8——3种方式实现lirs鸢尾花分类

1 自定义前向传播和训练

# 利用鸢尾花数据集，实现前向传播，反向传播，可视化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 #150个数据
y_data = datasets.load_iris().target

# 随机打乱数据（因为原始数据是顺序排列的，不打乱会影响准确率）
#seed:随机数种子，当设置后，每次生成的随机数都一样,这样x和y保持一致
np.random.seed(116)
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函数使输入特征和标签值对应,32组数据为一组
train_bd = tf.data.Dataset.from_tensor_slices((x_train,y_train)).batch(32)
test_bd = tf.data.Dataset.from_tensor_slices((x_test,y_test)).batch(32)

# 生成神经网络的参数，4个输入特征值，所以输入为4个节点，分为3类，输出层为3个节点
# tf.variable()标记参数可以训练
w1 = tf.Variable(tf.random.truncated_normal([4,3],stddev=0.1))  # 4行3列
b1 = tf.Variable(tf.random.truncated_normal([3],stddev=0.1))    # 3个b

lr = 0.1 # 学习率为0.1
train_loss_results = [] # 将每轮的loss记录在这个表里面，为了画最后的曲线
test_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_bd): # batch级别的循环
        with tf.GradientTape() as tape: # with 记录梯度信息
            y = tf.matmul(x_train,w1) + b1  # 前向传播
            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()  # 将每个step计算出的loss累加
        # 计算loss对每个参数的梯度
        grads = tape.gradient(loss,[w1,b1])  # 求偏导

        # 实现梯度更新 w1 = w1-lr*w1_grad ,b1=......
        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)  # 记录好每轮的loss平均值
    loss_all = 0 # 为下一轮做准备

   # 测试部分
    # total_corrent为预测对的样本个数，total_number为测试样本总数
    total_corrent,total_number = 0,0
    for x_test,y_test in test_bd:
        # 使用更新后的参数进行预测
        y = tf.matmul(x_test,w1) + b1
        y = tf.nn.softmax(y)
        pred = tf.argmax(y,axis=1) # 返回预测值，取每一行的最大值。返回一个一维列表

        # 将pred转换为y_test的数据类型
        pred = tf.cast(pred,dtype=y_test.dtype)

        # 若分为正确，corrent为1，否则为0，将bool结果转为int型
        corrent =tf.cast(tf.equal(pred,y_test),dtype=tf.int32)

        # 将每个batch的corrent数加起来
        corrent = tf.reduce_sum(corrent)

        # 将所有batch的corrent的数加起来
        total_corrent +=int(corrent) # 这里的所有的和每个不一样吗?一共一个batch,一样的，因为这个for循环只循环了一次，但是int把张量变成int型是必须的。
        total_number += x_test.shape[0]
    # 总是正确率
    acc = total_corrent/total_number
    test_acc.append(acc)  # 加到列表中
    print("Teat_acc:",acc)
    print("…………………………………………………………")
# 绘制loss曲线
plt.title("损失曲线")  # 标题
plt.xlabel("epoch")    # x轴名
plt.ylabel("loss")     # y轴名
plt.plot(train_loss_results,label="$loss$")  # 逐点画出损失值并连线,连线图标是loss
plt.legend()   # 画出曲线图例
plt.show()     # 画出图像

# 绘制accuracy曲线
plt.title("准确率")  # 标题
plt.xlabel("epoch")    # x轴名
plt.ylabel("accuracy")     # y轴名
plt.plot(test_acc,label="$Accuracy$")  # 逐点画出损失值并连线
plt.legend()   # 画出曲线图例
plt.show()     # 画出图像

2 tf.keras.models.Sequential

# 用普通的sequantial实现
import tensorflow as tf
from sklearn import datasets
import numpy as np

#导入数据集，分为输入特征和标签
x_train = datasets.load_iris().data #150个数据
y_train = datasets.load_iris().target

# 随机打乱数据（因为原始数据是顺序排列的，不打乱会影响准确率）
#seed:随机数种子，当设置后，每次生成的随机数都一样,这样x和y保持一致
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(10,activation=tf.nn.relu),
    tf.keras.layers.Dense(3,activation='softmax',kernel_regularizer=tf.keras.regularizers.l2())
])

# 反向传播，因为用了softmax，输出是概率分布，不是原始输出，用from_logits=False
# 原来的标签不是0，1，2，所以用aparse_categorical_accuracy为评测指标
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])
# 训练，split告诉从训练集拿出20%为测试集，validation_freq表示迭代20次训练集验证一次测试集的准确率
model.fit(x_train,y_train,batch_size=32,epochs=500,validation_split=0.2,validation_freq=20)

model.summary()

3 class 方法

# 用class实现
import tensorflow as tf
from sklearn import datasets
import numpy as np
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model

#导入数据集，分为输入特征和标签
x_train = datasets.load_iris().data #150个数据
y_train = datasets.load_iris().target

# 随机打乱数据（因为原始数据是顺序排列的，不打乱会影响准确率）
#seed:随机数种子，当设置后，每次生成的随机数都一样,这样x和y保持一致
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 = tf.keras.layers.Dense(10,activation="relu")
        self.d2 = Dense(3,activation="sigmoid",kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x):
        y1 = self.d1(x)
        y = self.d2(y1)
        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()