python 使用前馈神经网络处理IrIs数据集（BP）

本文章包含以下内容：

        数据: lris数据集;

        模型: 前馈神经网络;

        激活函数: Logistic

        损失函数: 交叉嫡损失;

        优化器: 梯度下降法;

        评价指标 :准确率。

输出层使用了Softmax分类

通过使用前馈神经网络实现BP学习算法，进一步理解前馈神经网络的分类任务。
 

1.实验数据集

        Iris(1).csv无法上传，这里就不提供下载了，它长这样

        lris数据集，也称为鸢尾花数据集，包含了3种鸢尾花类别(Setosa · Versicolour - Virginica),每种类别有50个样本，共计150个样本。其中每个样本中包含了4个属性:花尊长度﹑花芎宽度﹑花瓣长度以及花瓣宽度，本实验通过鸢尾花这4个属性来判断该样本的类别。

2.读取数据集

        实验中将数据集划分为两部分:训练集:用于确定模型参数;测试集:用于估计应用效果。
在本实验中，将2/3数据用于模型训练, 1/3数据用于模型测试。

3.模型构建

        使用前馈神经网络模型进行鸢尾花分类实验，将模型的输入神经元个数定义为4，隐藏层神经元个数定义为6，输出神经元个数定义为3。

4.模型训练与预测

        使用训练集进行模型训练，使用测试数据对模型进行预测，观察模型在测试集上的准确率情况。

代码如下：

import numpy as np
import pandas as pd
import torch


# 读取数据
def read_data(file):
    # 读取csv文件，并存入data，带标签 dataframe
    data = pd.read_csv(file)
    data = data.sample(frac=1).reset_index(drop=True)  # 打乱数据集
    y = list(data['Species'])  # 标签
    len_data = len(y)  # 数据个数
    # labels 删除的列标签，axis=1 删除列，inplace=True 改变原数据
    data.drop(labels=['Id', 'Species'], axis=1, inplace=True)  # 删除Id，Species列
    # Species 转独热向量
    for i in range(len(y)):
        if y[i] == 'Iris-setosa':
            y[i] = [1, 0, 0]
        elif y[i] == 'Iris-versicolor':
            y[i] = [0, 1, 0]
        elif y[i] == 'Iris-virginica':
            y[i] = [0, 0, 1]
    y = torch.Tensor(y)  # 转张量
    data = torch.Tensor(data.values)  # 转张量
    # train 训练
    # test 测试
    return [[data[0:int(len_data * 0.8)], y[0:int(len_data * 0.8)]],
            [data[int(len_data * 0.8):len_data], y[int(len_data * 0.8):len_data]]]


# 初始化参数 通过从均值为0﹑标准差为0.01的正态分布中采样随机数来初始化权重
# 并将偏置初始化为0。
def chushi():
    # 返回从正态分布中提取的随机数的张量，该正态分布的均值是mean，标准差是std。
    # requires_grad=True 表示需要计算梯度
    w1 = torch.normal(mean=0.01, std=0.01, size=(4, 6), requires_grad=True)
    w2 = torch.normal(mean=0.01, std=0.01, size=(6, 3), requires_grad=True)
    # 返回6个类型为torch.dtype，值为 0 的tensor
    b = torch.zeros(6, requires_grad=True)
    return w1, w2, b


# 测试函数，比较准确率
def ceshi(w1, w2, b, f, l):
    c = 0
    # 模型计算出所有的结果
    l1 = Model(f, w1, w2, b)
    for i in range(len(l)):
        # 如果最大值对应的l值是1，说明验证正确。
        s = -1
        t = float('-inf')
        for j in range(len(l[0])):
            if l1[i][j] > t:
                t = l1[i][j]
                s = j
        if l[i][s]:
            c = c + 1
    return c / len(l)


# 该函数接收批量大小﹑特征矩阵和标签向量作为输入，生成大小为batch_size的小批量，每个小批量包含一组特征和标签。
def data_iter(batch_size, features, labels):  # 批量 特征 标签
    for i in range(len(labels) - batch_size):
        test_index = np.random.choice(len(features), batch_size, replace=False)
        yield features[test_index], labels[test_index]


def softexp(A):
    A = A.exp()
    A_sum = A.sum(axis=1, keepdims=True)
    A = A / A_sum
    return A


# 输出层为 softmax 输入特征为x﹑权重为w
def softmax(X, w):
    S = torch.matmul(X, w)
    return softexp(S)


# 激活函数计算神经元的净活性值 （输出）
def Activation(z):
    # Logistic
    return 1 / (1 + torch.exp(-z))


# 激活函数导数
def Activation_(z):
    return torch.exp(-z)*(Activation(z)**2)


# 计算神经元的活性值 （输入） 输入特征为x﹑权重为w
def Calculation(z_old, w, b):
    return torch.matmul(z_old, w) + b


# 模型，计算网络输出
def Model(x, w1, w2, b):
    y_hat = softmax(Activation(Calculation(x, w1, b)), w2)
    return y_hat


# 交叉熵损失函数,返回损失值，其中y_hat为预测值, y为真实值。
def cross_entropy_loss(y_hat, y):
    lo = -(torch.log(y_hat) * y)
    return lo / len(y)


# 从数据集中随机抽取小批量样本，根据参数计算损失的梯度;然后朝着减少损失的方向更新参数。
# 实现小批量随机梯度下降更新，该函数接受模型参数集合﹑学习速率和批量大小作为输入。
def sgd(params, lr, batch_size):
    # wi_new = wi - lr * g(wi)
    for param in params:
        param.data = param - lr * param.grad / batch_size
        param.grad.zero_()  # 梯度清零


def xunlian(batch_size, features, labels, w1, w2, b):
    lr = 0.03  # 学习率
    num_epochs = 83  # 循环次数
    net = Model  # 模型
    loss = cross_entropy_loss  # 损失函数
    for epoch in range(num_epochs):
        for X, y in data_iter(batch_size, features, labels):
            # l = loss(Model(X, w1, w2, b), y)
            # l.sum().backward()
            # sgd([w1, w2, b], lr, batch_size)
            z = Calculation(X, w1, b)  # 隐藏层输入
            a = Activation(z)  # 隐藏层输出
            a_y = softmax(a, w2)  # 输出层输出
            S_2 = (a_y - y)
            S_1 = Activation_(z) * torch.matmul(S_2, w2.T)  # 第l层误差项 δ(l) = f'(z(l)).*(w(l+1).T*δ(l+1))
            w1.data = w1 - lr * torch.matmul(X.T, S_1)  # w的梯度为： δ(l)a(l-1).T
            b.data = b - lr * S_1.sum(0)  # b->6 S_1->6 S_2->3
            w2.data = w2 - lr * torch.matmul(a.T, S_2)  # 更新w2
        if epoch % 10 == 0:  # 每循环10次执行
            with torch.no_grad():  # 输出当前误差，循环次数
                train_l = loss(net(features, w1, w2, b), labels)
                print(f'epoch {epoch}, loss {float(train_l.mean()):f}')
                c = ceshi(w1, w2, b, features, labels, )  # 看一看在训练集上的准确率
                print('训练集准确率：', c * 100, "%")


file = 'Iris(1).csv'  # 数据文件
[[X_train, y_train],
 [X_test, y_test, ]] = read_data(file)  # 读取数据集
w1, w2, b = chushi()  # 初始化 w,b
batch_size = 8  # 批量大小为 8
# 训练函数
xunlian(batch_size, X_train, y_train, w1, w2, b)
print('训练完成====================================')
c = ceshi(w1, w2, b, X_test, y_test)  # 测试集准确率
print('测试集准确率：', c * 100, "%")
print('所得参数如下：\n', w1, '\n', w2, '\n', b, '\n')
print('例子：\n X值:', X_test[0:1])
print('实际y', y_test[0:1])
print('预测y', Model(X_test[0:1], w1, w2, b))
# print(w)

结果示例：

epoch 0, loss 0.001769
训练集准确率： 89.16666666666667 %
epoch 10, loss 0.000364
训练集准确率： 95.0 %
epoch 20, loss 0.000290
训练集准确率： 95.83333333333334 %
epoch 30, loss 0.000243
训练集准确率： 96.66666666666667 %
epoch 40, loss 0.000414
训练集准确率： 93.33333333333333 %
epoch 50, loss 0.000163
训练集准确率： 99.16666666666667 %
epoch 60, loss 0.000198
训练集准确率： 96.66666666666667 %
epoch 70, loss 0.000196
训练集准确率： 97.5 %
epoch 80, loss 0.000161
训练集准确率： 98.33333333333333 %
训练完成====================================
测试集准确率： 96.66666666666667 %
所得参数如下：
 tensor([[ 0.9806,  3.0590, -0.8039, -0.5332,  3.0937, -1.1383],
        [ 1.3435,  3.1047, -1.8155, -1.8243,  3.6250, -2.1197],
        [-1.9728, -5.2749,  2.0337,  3.0097, -5.6045,  2.5650],
        [-2.3027, -4.6498,  2.3441,  1.5330, -4.8966,  2.7566]],
       requires_grad=True) 
 tensor([[ 2.9231,  0.0412, -2.9310],
        [ 2.7915,  1.0842, -3.8255],
        [-2.7528, -0.1600,  2.9669],
        [-5.7803,  4.2794,  1.5421],
        [ 3.0054,  1.1464, -4.1305],
        [-2.7934, -0.3414,  3.1587]], requires_grad=True) 
 tensor([ 1.5407,  3.5230, -1.5978, -0.3448,  3.7239, -1.9607],
       requires_grad=True) 

例子：
 X值: tensor([[5.8000, 2.7000, 4.1000, 1.0000]])
实际y tensor([[0., 1., 0.]])
预测y tensor([[1.6022e-03, 9.9839e-01, 4.5279e-06]], grad_fn=<DivBackward0>)

进程已结束，退出代码为 0

epoch 0, loss 0.001729
训练集准确率： 69.16666666666667 %
epoch 10, loss 0.000181
训练集准确率： 98.33333333333333 %
epoch 20, loss 0.000888
训练集准确率： 84.16666666666667 %
epoch 30, loss 0.000198
训练集准确率： 96.66666666666667 %
epoch 40, loss 0.000119
训练集准确率： 98.33333333333333 %
epoch 50, loss 0.000122
训练集准确率： 98.33333333333333 %
epoch 60, loss 0.000104
训练集准确率： 98.33333333333333 %
epoch 70, loss 0.000119
训练集准确率： 98.33333333333333 %
epoch 80, loss 0.000130
训练集准确率： 98.33333333333333 %
训练完成====================================
测试集准确率： 96.66666666666667 %
所得参数如下：
 tensor([[ 2.6183, -0.4223,  3.1955,  3.5719, -0.5553, -0.0769],
        [ 1.8743, -1.8185,  1.9431,  3.4956, -2.2456, -2.2022],
        [-3.6397,  2.7688, -4.2452, -4.6510,  1.8316,  1.3680],
        [-4.6315,  1.4771, -5.4197, -6.4368,  2.3386,  1.7676]],
       requires_grad=True) 
 tensor([[ 2.7592,  0.5953, -3.3437],
        [-5.3697,  3.2962,  2.1221],
        [ 2.7891,  0.7843, -3.5567],
        [ 2.9859,  0.7118, -3.6540],
        [-3.0911, -0.2803,  3.4012],
        [-3.8995,  0.2174,  3.7301]], requires_grad=True) 
 tensor([ 2.2708, -0.2802,  2.6552,  3.3875, -1.1425, -0.7772],
       requires_grad=True) 

例子：
 X值: tensor([[6.4000, 3.1000, 5.5000, 1.8000]])
实际y tensor([[0., 0., 1.]])
预测y tensor([[3.3414e-08, 3.7522e-02, 9.6248e-01]], grad_fn=<DivBackward0>)

进程已结束，退出代码为 0