【机器学习】任务十：从函数分析到机器学习应用与BP神经网络

目录

1.从函数分析到机器学习应用

[1.1 3D曲面图可视化报告](#1.1 3D曲面图可视化报告)

[1.1.1 目标](#1.1.1 目标)

[1.1.2 代码分析](#1.1.2 代码分析)

[1.1.3 结果分析](#1.1.3 结果分析)

[1.1.4 观察与总结](#1.1.4 观察与总结)

[1.1.5 结论](#1.1.5 结论)

[1.2 一元函数梯度计算报告](#1.2 一元函数梯度计算报告)

[1.2.1 目标](#1.2.1 目标)

[1.2.2 代码分析](#1.2.2 代码分析)

[1.2.4 计算结果](#1.2.4 计算结果)

[1.2.5 优势与意义](#1.2.5 优势与意义)

[1.2.6 结论](#1.2.6 结论)

[1.3 一元函数梯度和二阶导数计算报告](#1.3 一元函数梯度和二阶导数计算报告)

[1.3.1 目标](#1.3.1 目标)

[1.3.2 代码分析](#1.3.2 代码分析)

[1.3.3 计算结果](#1.3.3 计算结果)

[1.3.4 优势与意义](#1.3.4 优势与意义)

[1.3.5 结论](#1.3.5 结论)

[1.4 多元函数梯度计算报告](#1.4 多元函数梯度计算报告)

[1.4.1 目标](#1.4.1 目标)

[1.4.2 代码分析](#1.4.2 代码分析)

[1.4.3 梯度计算解析](#1.4.3 梯度计算解析)

[1.4.4 优势与意义](#1.4.4 优势与意义)

[1.4.5 结论](#1.4.5 结论)

[1.5 线性回归模型训练报告](#1.5 线性回归模型训练报告)

[1.5.1 目标](#1.5.1 目标)

[1.5.2 代码分析](#1.5.2 代码分析)

[1.5.3 结果分析](#1.5.3 结果分析)

[1.5.4 优势与意义](#1.5.4 优势与意义)

[1.5.5 结论](#1.5.5 结论)

2.基于BP神经网络的鸢尾花分类任务

2.1神经网络

[2.1.1 BP神经](#2.1.1 BP神经)

[2.1.2 BP神经网络的工作流程](#2.1.2 BP神经网络的工作流程)

[2.1.3 总结](#2.1.3 总结)

[2.1.4 任务目标](#2.1.4 任务目标)

[2.2 实验过程](#2.2 实验过程)

[2.2.1 数据加载与预处理](#2.2.1 数据加载与预处理)

[2.2.2 激活函数及其导数](#2.2.2 激活函数及其导数)

[2.2.3 BP神经网络实现](#2.2.3 BP神经网络实现)

[2.2.4 模型训练与测试](#2.2.4 模型训练与测试)

[2.3 总结与改进建议](#2.3 总结与改进建议)

---

1.从函数分析到机器学习应用

1.1 3D曲面图可视化报告

1.1.1 目标

本次代码的目标是生成一个3D曲面图，用于展示数学函数 f(x,y)=−(x2+y2)的特性。通过在指定范围内绘制该函数，直观展示其三维空间中的变化情况。

1.1.2 代码分析

（1）函数定义:

def fun(x, y):
    return -(np.power(x, 2) + np.power(y, 2))

函数 fun(x, y) 用于计算 −(x2+y2)的值，这是一种二次函数，其结果用于生成曲面图的Z轴值，构成抛物面。

（2）3D图表设置:

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

通过 plt.figure() 初始化图表，并添加了一个3D子图（projection='3d'）用于绘制三维曲面。

（3）数据生成:

X0 = np.arange(-3, 3, 0.25)
X1 = np.arange(-3, 3, 0.25)
X0, X1 = np.meshgrid(X0, X1)
Z = fun(X0, X1)

使用 np.arange 生成从-3到3的范围，步长为0.25的数列。np.meshgrid 将生成的X0和X1网格化，形成二维坐标平面，随后通过 fun(X0, X1) 计算Z轴值。

（4）曲面绘制:

surf = ax.plot_surface(X0, X1, Z, cmap=plt.cm.winter)

使用 plot_surface 绘制曲面图，并通过 cmap=plt.cm.winter 设置了颜色映射，以便通过颜色反映Z值的大小。

（5）坐标轴标签:

ax.set_xlabel('X0', color='r')
ax.set_ylabel('X1', color='g')
ax.set_zlabel('f(x)', color='b')

设置了每个坐标轴的标签，并分别使用红色（X轴）、绿色（Y轴）和蓝色（Z轴）标注，增强了图表的可视化效果。

（6）颜色条:

fig.colorbar(surf)

添加了颜色条，帮助解释图表中颜色和Z值的对应关系。

（7）总体代码：

import numpy as np
import matplotlib.pyplot as plt

# 定义函数
def fun(x, y):
    return -(np.power(x, 2) + np.power(y, 2))

# 创建 3D 图形对象
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')  # 添加3D子图

# 生成数据
X0 = np.arange(-3, 3, 0.25)
X1 = np.arange(-3, 3, 0.25)
X0, X1 = np.meshgrid(X0, X1)
Z = fun(X0, X1)

# 绘制曲面图，并使用 cmap 着色
surf = ax.plot_surface(X0, X1, Z, cmap=plt.cm.winter)
ax.set_xlabel('X0', color='r')
ax.set_ylabel('X1', color='g')
ax.set_zlabel('f(x)', color='b')  # 给三个坐标轴注明坐标名称

# 添加颜色条
fig.colorbar(surf)
plt.show()

1.1.3 结果分析

生成的图表展示了函数 f(x,y)=−(x2+y2)的抛物面特性，呈现一个以原点为中心的对称碗状结构。颜色从蓝到绿，代表Z值从低到高的变化。右侧的颜色条清晰标注了每种颜色对应的具体值范围。

1.1.4 观察与总结

• 图表清晰地展示了函数的形态，其对称性和凹形特性一目了然。
• 使用颜色渐变提高了数据的直观表现能力，有助于快速理解函数的深度和高度变化。
• 坐标轴的颜色标注增强了可读性，使得三个维度的意义更加明确。

1.1.5 结论

该3D曲面图成功地将数学函数的空间特性可视化，为多变量函数的探索提供了直观的工具。类似的图表对于研究函数的分布特性、对称性或寻找极值点具有重要意义。

1.2 一元函数梯度计算报告

1.2.1 目标

本次代码的目标是通过TensorFlow框架，计算函数 f(x)=x2+2x−1 在指定点 x=2 处的一阶梯度（即导数）。

1.2.2 代码分析

（1）函数定义:

def func(x):
    return x ** 2 + 2 * x - 1

定义了一元二次函数 f(x)=x2+2x−1。该函数的导数可通过自动微分工具计算，或手动计算为 f′(x)=2x+2。

（2）自动梯度计算:

with tf.GradientTape() as tape:
    tape.watch(x)
    y = func(x)

使用 TensorFlow 的 tf.GradientTape 实现自动梯度计算。tape.watch(x) 监测变量 x 的变化，确保其参与梯度计算。

（3）梯度提取:

order_1 = tape.gradient(target=y, sources=x)

调用 tape.gradient 方法，计算目标函数 y 对变量 x 的一阶梯度。

（4）输出结果:

print("函数 x ** 2 + 2 * x - 1 在 x = 2 处的梯度为: ", order_1.numpy())

将计算出的梯度转为NumPy数组，并在终端打印结果。

1.2.4 计算结果

根据代码执行，函数 f(x)=x2+2x−1 在 x=2 处的一阶导数为： f′(x)=2x+2代入 x=2，可得： f′(2)=2×2+2=6

程序输出与手动计算一致，验证了代码的正确性。

1.2.5 优势与意义

（1）代码优势:

• 利用 TensorFlow 自动微分机制，无需手动推导导数公式，适合复杂函数梯度计算。
• 可扩展至更高维度、多变量函数的梯度和偏导数计算。

（2）应用场景:

• 自动梯度计算在机器学习中十分重要，广泛应用于反向传播算法中优化模型参数。
• 数学建模或科学计算中，也可用于快速验证导数或梯度公式的正确性。

1.2.6 结论

本代码成功计算了一元二次函数在给定点的梯度，结果准确无误。TensorFlow 的自动梯度工具不仅提升了计算效率，也大幅减少了手动推导的可能错误。

1.3 一元函数梯度和二阶导数计算报告

1.3.1 目标

本次代码的目标是通过TensorFlow框架，计算函数 f(x)=x2+2x−1 在指定点 x=2 处的一阶梯度和二阶导数，验证自动微分机制的准确性。

1.3.2 代码分析

（1）变量定义:

x = tf.Variable(2.0, trainable=True)

定义变量 xxx，设置其值为 2.0，并声明其为可训练变量，以便被 GradientTape 监测并参与梯度计算。

（2）嵌套的梯度计算:

with tf.GradientTape() as tape1:
    with tf.GradientTape() as tape2:
        y = x ** 2 + 2 * x - 1
        order_1 = tape2.gradient(y, x)
    order_2 = tape1.gradient(order_1, x)

• 第一层 tape2 负责计算目标函数 f(x)f(x)f(x) 的一阶梯度。
• 第二层 tape1 监测一阶梯度的变化，计算其对 xxx 的导数，从而得到函数的二阶导数。

（3）结果输出:

print("在 x = 2 处的一阶梯度为: ", order_1.numpy())
print("在 x = 2 处的二阶梯度为: ", order_2.numpy())

将一阶梯度和二阶梯度的计算结果打印出来。

1.3.3 计算结果

根据程序输出：

• 一阶梯度（导数）：f′(x)=2x+2，在 x=2 时，f′(2)=2×2+2=6。
• 二阶导数：f′′(x)=2，为常数。在 x=2 时，f′′(2)=2。

两项结果与手动计算完全一致，验证了代码的正确性。

1.3.4 优势与意义

代码优势:

• 利用 GradientTape 实现嵌套梯度计算，无需显式推导复杂函数的二阶导数，尤其适用于多变量函数的高阶导数计算。
• 灵活性高，可扩展至任意阶梯度计算。

应用场景:

• 高阶导数计算在物理建模（如加速度计算）和机器学习优化中（如Hessian矩阵计算）具有广泛应用。
• 自动微分降低了复杂计算的门槛，适合分析函数的曲率和极值点。

1.3.5 结论

本代码成功计算了一元二次函数在指定点的梯度和二阶导数，结果精确，充分体现了 TensorFlow 自动微分工具的强大功能。代码逻辑清晰，适合作为高阶导数计算的模板。

1.4 多元函数梯度计算报告

1.4.1 目标

本次代码的目标是利用 TensorFlow 框架，计算多元函数

在点 x=[1.0,2.0,3.0] 处的梯度。

1.4.2 代码分析

（1）函数定义:

def func(x):
    return x[0] ** 2 + 3 * x[0] * x[1] + x[1] ** 2 + x[2] ** 3

定义了一个多元函数 f(x)f(x)f(x)，其中 xxx 是一个三维张量。该函数包含二次项和三次项的组合。

（2）自动梯度计算:

x = tf.Variable([1.0, 2.0, 3.0], dtype=tf.float32)
with tf.GradientTape() as tape:
    tape.watch(x)
    y = func(x)

• 变量 x 被定义为可训练张量，初值为 [1.0,2.0,3.0]。
• 通过 GradientTape 监控张量 x，对其参与的运算生成梯度。

（3）梯度提取:

order_1 = tape.gradient(target=y, sources=x)
print("多元函数 x = [1.0, 2.0, 3.0] 的梯度为:", [grad.numpy() for grad in order_1])

• 使用 tape.gradient 方法计算目标函数 f(x) 对 x 的一阶梯度。
• 因为 x 是一个张量列表，其梯度也是一个张量列表，逐项提取值后输出。

（4）输出结果: 程序输出：

多元函数 x = [1.0, 2.0, 3.0] 的梯度为: [8.0, 7.0, 27.0]

1.4.3 梯度计算解析

多元函数的梯度为：

在 x=[1.0,2.0,3.0]x = [1.0, 2.0, 3.0]x=[1.0,2.0,3.0] 处，逐项计算：

程序计算的结果与手动推导一致，验证了代码的正确性。

1.4.4 优势与意义

（1）代码优势:

• 自动计算多元函数的梯度，无需手动推导偏导数公式。
• 对任意维度和复杂度的函数，均能通过 GradientTape 快速计算梯度。

（2）应用场景:

• 梯度计算在机器学习中至关重要，用于优化目标函数。
• 多元函数梯度计算也适用于科学计算、最优控制和物理建模等领域。

1.4.5 结论

本代码准确计算了多元函数在指定点的梯度，结果精确，代码结构清晰，体现了 TensorFlow 自动微分的高效性和灵活性。代码适用于复杂多维问题的梯度计算，是学习和实践自动微分的优秀示例。

1.5 线性回归模型训练报告

1.5.1 目标

通过 TensorFlow 框架实现一个简单的线性回归模型，拟合目标函数 y=10x+5。最终验证模型对新输入数据的预测能力。

1.5.2 代码分析

（1）损失函数定义:

def loss(y_true, y_pred):
    return tf.keras.losses.MeanSquaredError()(y_true, y_pred)

使用均方误差（MSE）作为损失函数，衡量预测值 ypred 和真实值 ytrue 的差距。

（2）训练数据生成:

x_train_inch = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], dtype=np.float32)
y_train_price = np.array([10 * num + 5 for num in x_train_inch], dtype=np.float32)

模拟生成线性关系的数据：输入 x 为从 1 到 11 的整数，目标输出 y 通过公式 y=10x+5 计算。

（3）模型参数初始化:

w1 = tf.Variable(random.random(), trainable=True, dtype=tf.float32)
w0 = tf.Variable(random.random(), trainable=True, dtype=tf.float32)

初始化两个可训练参数 w1 和 w0​ ，分别对应线性回归模型的斜率和截距。

（4）梯度下降更新函数:

def step_gradient(real_x, real_y, learning_rate):
    with tf.GradientTape() as tape:
        pred_y = w1 * real_x + w0
        reg_loss = loss(real_y, pred_y)
    w1_gradients, w0_gradients = tape.gradient(reg_loss, (w1, w0))
    w1.assign_sub(w1_gradients * learning_rate)
    w0.assign_sub(w0_gradients * learning_rate)

• 使用 GradientTape 计算损失函数对 w1 和 w0 的梯度。
• 更新规则：参数值减去学习率乘以梯度。

（5）训练循环:

learning_rate = 0.01
num_iterations = 1000

for _ in range(num_iterations):
    step_gradient(tf.convert_to_tensor(x_train_inch), tf.convert_to_tensor(y_train_price), learning_rate)

通过 1000 次迭代，不断更新模型参数，最终使其拟合数据分布。

（6）模型评估:

wheat = 0.9
price = w1 * wheat + w0
print("price = {:.2f}".format(price.numpy()))

使用训练好的模型预测 x=0.9 对应的 y 值，并输出预测结果。

1.5.3 结果分析

拟合的模型: 程序输出：

拟合得到的模型近似为: y ≈ 10.005026817321777x + 4.961641311645508

说明模型基本收敛，参数 w1 和 w0​ 的值非常接近目标函数的真实值 w1=10、w0=5。

预测结果: 对于输入 x=0.9，程序输出：

price = 13.97

预测结果接近真实值 y=10×0.9+5=14，误差很小，说明模型拟合效果良好。

1.5.4 优势与意义

（1）代码优势:

• 使用 TensorFlow 的自动微分和变量更新功能，简化了梯度计算过程。
• 代码清晰明了，易于理解和扩展。

（2）应用场景:

• 线性回归模型是数据建模的基础，可扩展至多元线性回归、逻辑回归等。
• 适用于简单预测任务或作为复杂模型的初步验证工具。

1.5.5 结论

本代码成功实现了线性回归模型的训练，最终模型参数与真实目标函数参数非常接近，预测结果准确，证明了模型的拟合能力和代码的有效性。

2.基于BP神经网络的鸢尾花分类任务

2.1神经网络

2.1.1 BP神经

BP神经网络（Back Propagation Neural Network，反向传播神经网络）是一种前馈神经网络，通过误差反向传播算法来训练模型权重和偏置。它是人工神经网络中最常见的模型之一，特别适用于非线性函数的拟合和分类问题。

（1）BP神经网络的基本组成

1. 输入层：负责接收输入数据，每个节点对应一个特征。
2. 隐藏层：通过权重和激活函数进行非线性变换，可以有一层或多层。
3. 输出层：生成预测结果，节点数由任务的输出维度决定（如分类问题中类别数，回归问题中输出值数）。

（2）BP神经网络的特点

• 基于误差反向传播算法，即将输出误差反向传播，调整网络参数（权重和偏置）。
• 可以处理多维输入和非线性问题。
• 通过梯度下降法或其变种来优化目标函数。

2.1.2 BP神经网络的工作流程

BP神经网络主要包括两个阶段：前向传播（Forward Propagation） 和 反向传播（Backward Propagation）。

（1）前向传播

• 输入数据通过输入层传递到隐藏层，再通过激活函数变换，最终传递到输出层。
• 计算输出值 ypred。
• 如果输出值与实际值（目标值）不符，计算误差（损失函数）。

计算公式：

• 假设权重矩阵为 W，偏置为 b，激活函数为 f(⋅)，则：
• 
• 其中 l表示第 l层，a(l−1)是上一层的输出。

（2）误差计算

• 定义损失函数 L，例如平方误差：
• 

（3）反向传播

通过链式法则计算每个参数对损失函数的梯度，调整参数以减少误差。

步骤：

1.输出层误差：

其中 z(L)是输出层的输入，f′(z)是激活函数的导数。

2.隐藏层误差：

3.梯度更新： 使用梯度下降法调整权重和偏置：

其中 η是学习率。

（4）参数更新

• 通过多次迭代（Epoch）优化损失函数，直到达到期望的精度或停止条件。

2.1.3 总结

（1）BP神经网络的核心思想是：

1. 前向传播：计算预测值。
2. 误差计算：定义损失函数。
3. 反向传播：计算梯度并更新参数。
4. 迭代训练：通过多轮训练优化模型。

（2）优点：

• 能有效处理复杂的非线性问题。
• 在适当设置网络结构和参数时，具有很强的拟合能力。

（3）缺点：

• 容易陷入局部最优。
• 梯度消失问题影响深层网络训练。

为了改进其性能，可以结合改进优化算法（如Adam、RMSProp）或使用更深层的网络架构（如卷积神经网络、深度学习网络）。

2.1.4 任务目标

使用BP（反向传播）神经网络实现对鸢尾花数据集的分类，主要包括以下步骤：

1. 数据加载与预处理。
2. 自定义BP神经网络的实现，包括前向传播、反向传播和梯度更新。
3. 训练模型并在测试集上评估分类性能。

2.2 实验过程

2.2.1 数据加载与预处理

（1）代码

# 1.加载和预处理数据
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, StandardScaler

# 加载鸢尾花数据集
iris = load_iris()
X, y = iris.data, iris.target

# 数据标准化和独热编码
# 标准化：将每个特征的值调整到均值为0，标准差为1
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 独热编码：将类别标签转化为独热向量 (如 0 -> [1, 0, 0])
encoder = OneHotEncoder()
y = encoder.fit_transform(y.reshape(-1, 1)).toarray()

# 划分训练集和测试集
# 将80%的数据用于训练，20%用于测试
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

（2）分析

1. 标准化处理 ：使用StandardScaler将特征数据的均值调整为0，标准差调整为1，提升训练的稳定性。
2. 独热编码：将分类标签（0, 1, 2）转为独热向量形式，便于多分类任务的神经网络训练。
3. 数据划分：将数据集按8:2比例划分为训练集和测试集。

2.2.2 激活函数及其导数

（1）代码

# 2.定义激活函数和导数
# Sigmoid 激活函数
def sigmoid(x):
    """
    将输入值压缩到 (0, 1) 范围，用于激活神经元。
    """
    return 1 / (1 + np.exp(-x))

# Sigmoid 激活函数的导数
def sigmoid_derivative(x):
    """
    用于计算反向传播中的梯度。
    对 Sigmoid 函数求导的结果是 f'(x) = f(x) * (1 - f(x))。
    """
    return x * (1 - x)

（2）解析

1. Sigmoid激活函数：将输入值映射到(0, 1)范围，用于神经元的激活操作。 f(x)=11+e−x
2. Sigmoid函数的导数：用于反向传播中梯度计算： f′(x)=f(x)⋅(1−f(x))

2.2.3 BP神经网络实现

（1）代码

# 3.定义 BP 神经网络类
class BPNeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size, learning_rate=0.01):
        """
        初始化神经网络参数，包括权重、偏置和学习率。
        参数：
        - input_size: 输入层节点数
        - hidden_size: 隐藏层节点数
        - output_size: 输出层节点数
        - learning_rate: 学习率，控制梯度更新步长
        """
        # 输入层到隐藏层的权重矩阵，初始化为随机值
        self.weights_input_hidden = np.random.uniform(-1, 1, (input_size, hidden_size))
        # 隐藏层的偏置
        self.bias_hidden = np.zeros((1, hidden_size))
        
        # 隐藏层到输出层的权重矩阵，初始化为随机值
        self.weights_hidden_output = np.random.uniform(-1, 1, (hidden_size, output_size))
        # 输出层的偏置
        self.bias_output = np.zeros((1, output_size))
        
        # 学习率
        self.learning_rate = learning_rate

    def forward(self, X):
        """
        执行前向传播，计算隐藏层和输出层的激活值。
        参数：
        - X: 输入数据
        返回：
        - final_output: 网络的最终输出
        """
        # 计算隐藏层的加权输入 (Z = X * W + b)
        self.hidden_input = np.dot(X, self.weights_input_hidden) + self.bias_hidden
        # 隐藏层的激活输出 (A = Sigmoid(Z))
        self.hidden_output = sigmoid(self.hidden_input)

        # 计算输出层的加权输入 (Z = H * W + b)
        self.final_input = np.dot(self.hidden_output, self.weights_hidden_output) + self.bias_output
        # 输出层的激活输出 (A = Sigmoid(Z))
        self.final_output = sigmoid(self.final_input)

        return self.final_output

    def backward(self, X, y, output):
        """
        执行反向传播，计算误差并更新权重和偏置。
        参数：
        - X: 输入数据
        - y: 实际标签
        - output: 模型输出
        """
        # 输出层误差 (Error = y - output)
        output_error = y - output
        # 输出层梯度 (Delta = Error * f'(output))
        output_delta = output_error * sigmoid_derivative(output)

        # 隐藏层误差 (传播到隐藏层的误差)
        hidden_error = np.dot(output_delta, self.weights_hidden_output.T)
        # 隐藏层梯度 (Delta = Error * f'(hidden_output))
        hidden_delta = hidden_error * sigmoid_derivative(self.hidden_output)

        # 更新隐藏层到输出层的权重和偏置
        self.weights_hidden_output += self.learning_rate * np.dot(self.hidden_output.T, output_delta)
        self.bias_output += self.learning_rate * np.sum(output_delta, axis=0, keepdims=True)

        # 更新输入层到隐藏层的权重和偏置
        self.weights_input_hidden += self.learning_rate * np.dot(X.T, hidden_delta)
        self.bias_hidden += self.learning_rate * np.sum(hidden_delta, axis=0, keepdims=True)

    def train(self, X, y, epochs):
        """
        训练神经网络。
        参数：
        - X: 训练数据
        - y: 训练标签
        - epochs: 训练的迭代次数
        """
        for epoch in range(epochs):
            # 前向传播
            output = self.forward(X)

            # 反向传播
            self.backward(X, y, output)

            # 每隔100个 epoch 打印一次损失值
            if epoch % 100 == 0:
                loss = np.mean(np.square(y - output))  # 均方误差
                print(f"Epoch {epoch}, Loss: {loss}")

    def predict(self, X):
        """
        使用训练好的网络进行预测。
        参数：
        - X: 测试数据
        返回：
        - 预测类别（最大概率对应的索引）
        """
        output = self.forward(X)
        return np.argmax(output, axis=1)  # 返回概率最大的类别索引

（2）详细解析

1. 初始化网络参数

• 输入层到隐藏层、隐藏层到输出层的权重和偏置分别初始化。
• 使用随机值初始化权重，偏置初始化为0，学习率控制参数更新步长。

2. 前向传播

• 隐藏层计算：
• 
• 输出层计算：
• 

3. 反向传播

• 输出层误差：
• 
• 隐藏层误差：
• 

4. 权重更新

• 

---

2.2.4 模型训练与测试

（1）代码

# 4.训练和评估模型
# 4.1 初始化神经网络
input_size = X_train.shape[1]  # 输入层节点数：特征数量
hidden_size = 2  # 隐藏层节点数：可以调节
output_size = y_train.shape[1]  # 输出层节点数：类别数量
learning_rate = 0.1  # 学习率

# 创建网络实例
bp_nn = BPNeuralNetwork(input_size, hidden_size, output_size, learning_rate)

# 训练神经网络
bp_nn.train(X_train, y_train, epochs=1000)

# 使用测试集进行预测
predictions = bp_nn.predict(X_test)

# 计算准确率
accuracy = np.mean(predictions == np.argmax(y_test, axis=1))
print(f"Test Accuracy: {accuracy * 100:.2f}%")

（2）实验结果

1.训练过程：

Epoch 0, Loss: 0.22128556516365086
Epoch 100, Loss: 0.021410587809142765
Epoch 200, Loss: 0.013800814452345782
Epoch 300, Loss: 0.012100929959213873
Epoch 400, Loss: 0.011392964488187917
Epoch 500, Loss: 0.011017511806778143
Epoch 600, Loss: 0.010790199253609335
Epoch 700, Loss: 0.010640489751476679
Epoch 800, Loss: 0.010535921139959336
Epoch 900, Loss: 0.01045957534860003

测试集准确率：

Test Accuracy: 100.00%

2.3 总结与改进建议

（1）模型表现：

• BP神经网络成功实现对鸢尾花数据的分类，测试集准确率达到100%。

（2）改进建议：

• 非线性激活函数：可尝试ReLU等激活函数，加速训练。
• 优化算法：引入Adam等优化算法提升收敛速度。
• 正则化：通过Dropout或L2正则防止过拟合。