python使用BP算法实现Iris数据集分类（python 文件读取，BP算法，误差计算）

最新推荐文章于 2024-06-06 10:47:58 发布
最新推荐文章于 2024-06-06 10:47:58 发布
阅读量3.6k 收藏 53
点赞数 10
文章标签： 算法 python 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58196051/article/details/124225660
版权

一、数据集（150)

具体数据如下（如果不能运行，尝试在末尾加回车）

5.1	3.5	1.4	0.2	1
4.9	3	1.4	0.2	1
4.7	3.2	1.3	0.2	1
4.6	3.1	1.5	0.2	1
5	3.6	1.4	0.2	1
5.4	3.9	1.7	0.4	1
4.6	3.4	1.4	0.3	1
5	3.4	1.5	0.2	1
4.4	2.9	1.4	0.2	1
4.9	3.1	1.5	0.1	1
5.4	3.7	1.5	0.2	1
4.8	3.4	1.6	0.2	1
4.8	3	1.4	0.1	1
4.3	3	1.1	0.1	1
5.8	4	1.2	0.2	1
5.7	4.4	1.5	0.4	1
5.4	3.9	1.3	0.4	1
5.1	3.5	1.4	0.3	1
5.7	3.8	1.7	0.3	1
5.1	3.8	1.5	0.3	1
5.4	3.4	1.7	0.2	1
5.1	3.7	1.5	0.4	1
4.6	3.6	1	0.2	1
5.1	3.3	1.7	0.5	1
4.8	3.4	1.9	0.2	1
5	3	1.6	0.2	1
5	3.4	1.6	0.4	1
5.2	3.5	1.5	0.2	1
5.2	3.4	1.4	0.2	1
4.7	3.2	1.6	0.2	1
4.8	3.1	1.6	0.2	1
5.4	3.4	1.5	0.4	1
5.2	4.1	1.5	0.1	1
5.5	4.2	1.4	0.2	1
4.9	3.1	1.5	0.1	1
5	3.2	1.2	0.2	1
5.5	3.5	1.3	0.2	1
4.9	3.1	1.5	0.1	1
4.4	3	1.3	0.2	1
5.1	3.4	1.5	0.2	1
5	3.5	1.3	0.3	1
4.5	2.3	1.3	0.3	1
4.4	3.2	1.3	0.2	1
5	3.5	1.6	0.6	1
5.1	3.8	1.9	0.4	1
4.8	3	1.4	0.3	1
5.1	3.8	1.6	0.2	1
4.6	3.2	1.4	0.2	1
5.3	3.7	1.5	0.2	1
5	3.3	1.4	0.2	1
7	3.2	4.7	1.4	2
6.4	3.2	4.5	1.5	2
6.9	3.1	4.9	1.5	2
5.5	2.3	4	1.3	2
6.5	2.8	4.6	1.5	2
5.7	2.8	4.5	1.3	2
6.3	3.3	4.7	1.6	2
4.9	2.4	3.3	1	2
6.6	2.9	4.6	1.3	2
5.2	2.7	3.9	1.4	2
5	2	3.5	1	2
5.9	3	4.2	1.5	2
6	2.2	4	1	2
6.1	2.9	4.7	1.4	2
5.6	2.9	3.6	1.3	2
6.7	3.1	4.4	1.4	2
5.6	3	4.5	1.5	2
5.8	2.7	4.1	1	2
6.2	2.2	4.5	1.5	2
5.6	2.5	3.9	1.1	2
5.9	3.2	4.8	1.8	2
6.1	2.8	4	1.3	2
6.3	2.5	4.9	1.5	2
6.1	2.8	4.7	1.2	2
6.4	2.9	4.3	1.3	2
6.6	3	4.4	1.4	2
6.8	2.8	4.8	1.4	2
6.7	3	5	1.7	2
6	2.9	4.5	1.5	2
5.7	2.6	3.5	1	2
5.5	2.4	3.8	1.1	2
5.5	2.4	3.7	1	2
5.8	2.7	3.9	1.2	2
6	2.7	5.1	1.6	2
5.4	3	4.5	1.5	2
6	3.4	4.5	1.6	2
6.7	3.1	4.7	1.5	2
6.3	2.3	4.4	1.3	2
5.6	3	4.1	1.3	2
5.5	2.5	4	1.3	2
5.5	2.6	4.4	1.2	2
6.1	3	4.6	1.4	2
5.8	2.6	4	1.2	2
5	2.3	3.3	1	2
5.6	2.7	4.2	1.3	2
5.7	3	4.2	1.2	2
5.7	2.9	4.2	1.3	2
6.2	2.9	4.3	1.3	2
5.1	2.5	3	1.1	2
5.7	2.8	4.1	1.3	2
6.3	3.3	6	2.5	3
5.8	2.7	5.1	1.9	3
7.1	3	5.9	2.1	3
6.3	2.9	5.6	1.8	3
6.5	3	5.8	2.2	3
7.6	3	6.6	2.1	3
4.9	2.5	4.5	1.7	3
7.3	2.9	6.3	1.8	3
6.7	2.5	5.8	1.8	3
7.2	3.6	6.1	2.5	3
6.5	3.2	5.1	2	3
6.4	2.7	5.3	1.9	3
6.8	3	5.5	2.1	3
5.7	2.5	5	2	3
5.8	2.8	5.1	2.4	3
6.4	3.2	5.3	2.3	3
6.5	3	5.5	1.8	3
7.7	3.8	6.7	2.2	3
7.7	2.6	6.9	2.3	3
6	2.2	5	1.5	3
6.9	3.2	5.7	2.3	3
5.6	2.8	4.9	2	3
7.7	2.8	6.7	2	3
6.3	2.7	4.9	1.8	3
6.7	3.3	5.7	2.1	3
7.2	3.2	6	1.8	3
6.2	2.8	4.8	1.8	3
6.1	3	4.9	1.8	3
6.4	2.8	5.6	2.1	3
7.2	3	5.8	1.6	3
7.4	2.8	6.1	1.9	3
7.9	3.8	6.4	2	3
6.4	2.8	5.6	2.2	3
6.3	2.8	5.1	1.5	3
6.1	2.6	5.6	1.4	3
7.7	3	6.1	2.3	3
6.3	3.4	5.6	2.4	3
6.4	3.1	5.5	1.8	3
6	3	4.8	1.8	3
6.9	3.1	5.4	2.1	3
6.7	3.1	5.6	2.4	3
6.9	3.1	5.1	2.3	3
5.8	2.7	5.1	1.9	3
6.8	3.2	5.9	2.3	3
6.7	3.3	5.7	2.5	3
6.7	3	5.2	2.3	3
6.3	2.5	5	1.9	3
6.5	3	5.2	2	3
6.2	3.4	5.4	2.3	3
5.9	3	5.1	1.8	3

二、代码

import math  # 数学
import random  # 随机


def sigmoid(x):
    return 1 / (1 + math.exp(-x))


def BP(x1, y, by, b, xb, c, u_1, u_2, t):
    e_h = [0, 0, 0, 0]  # 储存b的梯度eh
    g_j = [0, 0, 0]  # 储存y的梯度gj
    for n in range(c):  # 循环：c次
        for i in range(len(x1[0])):  # 对每个样例
            # 重置变量
            b_a = [0, 0, 0, 0]  # 储存b的输入αh
            b_h = [0, 0, 0, 0]  # 储存b的输出bh
            y_b = [0, 0, 0]  # 储存y的输入βj
            y_j = [0, 0, 0]  # 储存y的输出yj
            for j in range(len(b)):  # 每个隐藏层节点
                for k in range(len(x1) - 1):  # 每个属性
                    b_a[j] += x1[k][i] * xb[k][j]  # 计算出所有的b_a（隐藏层的输入）
                b_h[j] = sigmoid(b_a[j] - b[j])  # 激活（隐藏层的输出）
                for k in range(len(y)):  # 每个输出节点
                    y_b[k] += b_h[j] * by[k][j]  # 输出层的输入
            for j in range(len(y)):  # 每个输出节点
                y_j[j] = sigmoid(y_b[j] - y[j])  # 激活（输出层的输出）
                g_j[j] = y_j[j] * (1 - y_j[j]) * (x1[4][i][j] - y_j[j])  # 计算输出层梯度
            for j in range(len(b)):  # 每个隐藏层节点
                e = 0  # 初始化e
                for k in range(len(y)):  # 每个输出节点
                    e += g_j[k] * by[k][j]
                e_h[j] = b_h[j] * (1 - b_h[j]) * e  # 计算隐藏层梯度
            for j in range(len(b)):  # 每个隐藏层节点
                for k in range(len(x1) - 1):  # 每个属性
                    xb[k][j] += u_1 * e_h[j] * x1[k][i]  # 更新输入到隐层
                for k in range(len(y)):  # 每个输出节点
                    by[k][j] += u_2 * g_j[k] * b_h[j]  # 更新隐层到输出
                b[j] += -u_1 * e_h[j]  # 更新隐藏层阈值
            for j in range(len(y)):  # 每个输出节点
                y[j] += -u_2 * g_j[j]  # 更新输出层阈值
        if n % t == 0:  # 计算当前误差
            print('第', n, '轮,误差为：', ceshi(x1, y, by, b, xb), '%')


def ceshi(x1, y, by, b, xb):
    sum = 0  # 错误输出数
    for i in range(len(x1[0])):  # 对每个样例
        # 重置变量
        b_a = [0, 0, 0, 0]  # 储存b的输入αh
        b_h = [0, 0, 0, 0]  # 储存b的输出bh
        y_b = [0, 0, 0]  # 储存y的输入βj
        y_j = [0, 0, 0]  # 储存y的输出yj
        for j in range(len(b)):  # 每个隐藏层节点
            for k in range(len(x1) - 1):  # 每个属性
                b_a[j] += x1[k][i] * xb[k][j]  # 计算出所有的b_a（隐藏层的输入）
            b_h[j] = sigmoid(b_a[j] - b[j])  # 激活（隐藏层的输出）
            for k in range(len(y)):  # 每个输出节点
                y_b[k] += b_h[j] * by[k][j]  # 输出层的输入
        for j in range(len(y)):  # 每个输出节点
            y_j[j] = sigmoid(y_b[j] - y[j])  # 激活（输出层的输出）
        if x1[4][i][y_j.index(max(y_j))] == 0:  # 输出向量最大的数下标对应在x0中不为1
            sum += 1;  # 错误数+1
    return (sum / len(x1[0])) * 100


# 主函数=======================================================
f = open('Iris.txt', 'r')  # 读文件
x = [[], [], [], [], []]  # 花朵属性，(0,1,2,3),花朵种类
while 1:
    yihang = f.readline()  # 读一行
    if len(yihang) <= 1:  # 读到末尾结束
        break
    fenkai = yihang.split('\t')  # 按\t分开
    for i in range(4):  # 分开的四个值
        x[i].append(eval(fenkai[i]))  # 化为数字加到x中
    if (eval(fenkai[4]) == 1):  # 将标签化为向量形式
        x[4].append([1, 0, 0])
    else:
        if (eval(fenkai[4]) == 2):
            x[4].append([0, 1, 0])
        else:
            x[4].append([0, 0, 1])

print('\n数据集=======================================================')
print(len(x[0]))  # 数据大小
for i in range(len(x)):
    print(x[i])
x1 = x[:]

print('\n\n全训练BP神经网络==============================================')
cycles = 1000  # 循环次数
u1 = 0.1  # 学习率输入到隐层
u2 = 0.1  # 学习率隐层到输出
t = 100  # t轮计算一次当前误差
y = []  # 输出层阈值
by = [[], [], []]  # 隐藏层到输出层权值
b = []  # 隐藏层阈值
xb = [[], [], [], []]  # 输入层到隐藏层权值

# 随机化阈值权值开始========================
for i in range(4):  # 隐藏层节点4个
    b.append(random.random())  # 隐藏层阈值
    for j in range(3):  # 隐藏层到3个输出层节点
        by[j].append(random.random())  # 隐藏层到输出层权值
    for j in range(4):  # 4个输入层节点到隐藏层
        xb[i].append(random.random())  # 输入层到隐藏层权值
for i in range(3):  # 输出层节点3个
    y.append(random.random())  # 输出层阈值
# 随机化阈值权值完成========================
l = list(range(150))  # 得到一个顺序序列
random.shuffle(l)  # 打乱序列
x1 = [[], [], [], [], []]   #初始化
for i in l:  # 训练集
    for j in range(len(x)):  # D属性遍历
        x1[j].append(x[j][i])  # D的属性加到x1上
BP(x1, y, by, b, xb, cycles, u1, u2, t)  # 开始训练
print('\n全训练BP神经网络在训练集误差率：', ceshi(x1, y, by, b, xb), '%')

print('\n\n2/3训练BP神经网络============================================')
cycles = 1200  # 循环次数
u1 = 0.01  # 学习率输入到隐层
u2 = 0.01  # 学习率隐层到输出
t = 100  # t轮计算一次当前误差
y = []  # 输出层阈值
by = [[], [], []]  # 隐藏层到输出层权值
b = []  # 隐藏层阈值
xb = [[], [], [], []]  # 输入层到隐藏层权值

# 随机化阈值权值开始========================
for i in range(4):  # 隐藏层节点4个
    b.append(random.random())  # 隐藏层阈值
    for j in range(3):  # 隐藏层到3个输出层节点
        by[j].append(random.random())  # 隐藏层到输出层权值
    for j in range(4):  # 4个输入层节点到隐藏层
        xb[i].append(random.random())  # 输入层到隐藏层权值
for i in range(3):  # 输出层节点3个
    y.append(random.random())  # 输出层阈值
# 随机化阈值权值完成========================

l = list(range(150))  # 得到一个顺序序列
random.shuffle(l)  # 打乱序列
x1 = [[], [], [], [], []] #初始化x1
x2 = [[], [], [], [], []] #初始化x2
for i in l[0:100]:  # 截取部分训练集
    for j in range(len(x)):  # D属性遍历
        x1[j].append(x[j][i])  # D的属性加到v1上
for i in l[100:150]:  # 截取部分训练集
    for j in range(len(x)):  # D属性遍历
        x2[j].append(x[j][i])  # D的属性加到v1上
BP(x1, y, by, b, xb, cycles, u1, u2, t)  # 开始训练
print('\n2/3训练BP神经网络在训练集误差率：', ceshi(x1, y, by, b, xb), '%')
print('2/3训练BP神经网络在测试集误差率：', ceshi(x2, y, by, b, xb), '%')

三、结果及分析

        由于随机选取数据，训练误差可能不一样

​​

        训练结果具有偶然性，可以考虑在每轮训练前都对训练集进行随机处理，使得结果更具有统计学意义。

        由于初始权值阈值都随机取得，为避免陷入局部最优解，可以考虑训练多个模型，将每次训练结果保存下来，最后取最优模型。

        全训练误差率经常在2%徘徊，可以考虑是否为学习率过大，使得取值在最优质附近震荡，可以尝试更改学习率。为避免步长过小，训练轮数过多，可以考虑将学习率于训练轮数相关，开始较大，随训练轮数逐渐减少。

        此次训练有大量冗余运算，可以考虑将训练结束条件由轮数改为误差率，在误差小于某个值后停止训练。

        可以看出BP算法容易过拟合，训练集上效果好不一定测试集上效果同样好，可以考虑增加训练停止条件，在测试集误差率上升时提前停止训练。

        此结果为多次训练取结果较好者。若你的训练结果误差率较高（高于10%），可以尝试更改代码中的循环次数和学习率，重新训练。期待你能尝试出更好的训练次数以及学习率。

其他训练结果：

 

 

i道i
关注
  • 10
    点赞
  • 踩
  • 53
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python数据分析——探索Iris纸鸢花数据
Waitind_的博客
04-15 1615
DataFrame 中设置特定的值为学生数组（None 在 Python 中通常表示 NoneType 类型，但在 pandas 中它代表 NaN，即 Not a Number，表示缺失值）。DataFrame 的前 3 行（包含第 1 行、第 2 行和第 3 行），以及所有列，并将这些行的所有值设置为 None。指定了填充缺失值的方法为 “backfill” 或 “bfill”，这是一种向前填充缺失值的方法，即用前一个非缺失值来填充缺失值。这是一种处理缺失数据的方法，可以避免缺失值对数据分析结果的影响。
Jupiter Notebook：IRIS 数据集/鸢尾花数据集
Yummy的博客
03-19 2905
前言： 过着有史以来最长的寒假，这阵子在学习Python数据分析，接触到了iris.csv，当时就感觉这东西有点神奇[○･｀Д´･ ○]，后来了解到，原来它就是所谓的鸢尾花卉数据集。 IRIS 数据集 Iris数据集也称鸢尾花卉数据集，是一类多重变量分析，在数据挖掘、数据分类中非常常用的测试集、训练集。该数据集包含150个数据样本，分为3类，每类50个数据，...
【Python数据挖掘实战案例】机器学习LightGBM算法原理、特点、应用---基于鸢尾花iris数据集分类实战
最新发布
qq_38614074的博客
06-06 1万+
在数字化时代，数据已经成为企业和社会决策的重要依据。数据挖掘作为一门交叉学科，结合了统计学、机器学习、数据库技术和可视化等多个领域的知识，旨在从海量数据中提取有价值的信息，以支持商业决策、科学研究和社会治理。通过数据挖掘，企业可以发现市场趋势、优化产品设计、提升用户体验；科研人员可以揭示自然规律、推动学科发展；政府部门可以优化资源配置、提高治理效率。因此，数据挖掘在当今社会具有极其重要的地位和应用价值。
Python学习笔记9——基于iris数据集的决策树分类算法实战
制了个仗的博客
06-03 3984
本文以iris数据集为例，利用Python的决策树分类算法对鸢尾花进行分类实战，主要环节是数据预处理、模型训练及效果评估。预处理主要是对数据集进行拆分，得到训练数据和测试数据模型训练是利用拆分得到的训练集来训练模型；效果评估主要用到了准确率、精确率、召回率、F1值、混淆矩阵的指标，还用到了学习曲线进行过拟合、欠拟合评估，以及用到ROC曲线结合AUC值分析的方法。为了便于新手入门，大部分过程都写得比较细，希望能够对读者在学习和应用机器学习算法时有所帮助，若有不对的地方也请评论指正~
BP神经网络（Python代码实现）基于pytorch
热门推荐
阿伟的博客
03-07 3万+
BP神经网络（Python代码实现）基于pytorch
四层BP网络python代码实现
A1042236172的博客
11-07 1524
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
python 使用Softmax回归处理IrIs数据集
i道i的博客
10-20 2093
数据: lris数据集;模型: Softmax回归模型;损失函数:交叉嫡损失;优化器:梯度下降法;评价指标:准确率。
基于python的BP神经网络优化MNIST数据集算法设计与实现
05-01
在本项目中，我们主要探讨的是如何利用Python编程语言来设计和实现一个基于BP（Backpropagation）神经网络的优化算法，以处理经典的MNIST手写数字识别数据集。MNIST数据集是机器学习领域中广泛使用的基准，用于训练...
bp_python_BP算法_测试集预测集
09-11
使用鸢尾花数据集，预测鸢尾花种类。并随机选取100个样本作为训练数据，剩下50个作为测试数据。设置输入层四个神经元，接收输入的四个向量数据。设置一层隐含层，使用sigmoi激活函数，此问题为三分类问题，输出层...
【机器学习算法】手动Python实现KNN分类算法，并用iris数据集检验模型效果
12-22
目录一、KNN算法Python实现1、导入包2、 画图，展示不同电影在图上的分布3、训练样本和待测样本准备4、计算待测样本点到每个训练样本点的距离5、查找离待测样本点最近的K个训练样本点的类型6、找出数量最多的类7、写...
贝叶斯分类_iris_python贝叶斯分类iris数据集_
10-04
综上所述，这个项目是关于使用Python和贝叶斯分类算法对著名的iris数据集进行分类。通过编写和运行“iris1.py”脚本，我们可以实现并评估一个朴素贝叶斯分类器的性能。在整个过程中，我们会涉及到数据处理、模型训练...
BP神经网络模型求解iris分类-pycharm.rar
04-12
主要用BP神经网络求解iris分类，用pycharm实现。内含实验报告
BP神经网络用于分类iris数据集
06-15
BP神经网络用于分类iris数据集，编程的思路不错，值得初学者学习。
BP神经网络对iris数据集进行分类 MATLAB
05-11
对isir数据集进行分类，各选取三种花的25个样本作为训练数据，其余作为测试数据，多训练几次，准确率可以达到98%左右
用于三分类的BP程序算法
05-24
用于三分类的BP程序算法
python实现bp算法详代码和描述.zip
11-22
这个zip文件“python实现bp算法详代码和描述.zip”提供了Python语言实现BP算法的详细代码，以及两个用于测试的实例，即test1和test2。通过分析这些内容，我们可以深入了解BP算法的基本原理和Python实现。 BP算法...
Python:读取iris数据集中鸢尾花的萼片，花瓣长度，并对其进行排序、去重、并求出和，累计和，均值，标准差、方差、最大值和最小值
m0_56107252的博客
10-14 7242
Python:读取iris数据集中鸢尾花的萼片，花瓣长度，并对其进行排序、去重、并求出和，累计和，均值，标准差、方差、最大值和最小值
BP经典入门算法实例—鸢尾花的分类（Python）
E_vens
04-06 1万+
Iris数据集（鸢尾花数据集下载，密码：ae1e）是常用的分类实验数据集，由Fisher,1936收集整理。Iris也称鸢尾花卉数据集，是一类多重变量分析的数据集。数据集包含150个数据集，分为3类，每类50个数据，每个数据包含4个属性。可通过花萼长度，花萼宽度，花瓣长度，花瓣宽度4个属性预测鸢尾花卉属于（Setosa，Versicolour，Virginica）三个种类中的哪一类。...
用matlab实现用Bp神经网络对iris数据集进行分类（以及影响分类性能的参数条件）
qq_42517365的博客
11-05 2万+
一、实验内容 Iris鸢尾花卉数据集，是一类多重变量分析的数据集。数据集包含150个数据样本，分为3类，每类50个数据，每个数据包含4个属性，分别对应花萼长度，花萼宽度，花瓣长度，花瓣宽度。 本次实验目的是用Bp神经网络对iris数据集进行分类，并进行分析。 二、实验过程 1.将数据集加载到工作区：load iris.dat; 2.数据预处理 （1）将原始iris数据集随机抽取118行作为训练数...
python使用BP算法实现Iris数据集分类
04-21
很高兴回答你的问题！Python可以使用BP算法实现Iris数据集的分类。Iris数据集是一个常用的分类实验数据集，它包含了三个品种共150个花的测量数据，分别是山鸢尾、变色鸢尾和维吉尼亚鸢尾。在Python中，利用BP神经网络算法可以对这三种花进行分类。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值