公告

昵称： po3a
园龄： 1年11个月
粉丝： 5
关注： 6
+加关注

日历

2025年3月

日

一

二

三

四

五

六

随笔档案

交叉验证结果分析

准确度 (Accuracy):
平均值为 96.67% ± 2.93%，表明 SVM 模型在交叉验证中的表现非常稳定。交叉验证通过多次分割训练集和验证集，评估了模型的泛化能力，结果显示模型在不同数据划分上的性能波动较小。

精确率 (Precision):
平均值为 96.95% ± 2.77%，说明模型在预测正类样本时，错误率非常低。

召回率 (Recall):
平均值为 96.67% ± 2.93%，意味着模型能够很好地捕获所有类别的样本。

F1 值 (F1-score):
平均值为 96.65% ± 3.00%，综合了精确率和召回率的权衡，说明模型在所有类别的分类任务上表现良好。

测试集结果分析

测试集的 准确度 为 96.00%，略低于交叉验证的平均准确度，但仍然处于合理范围内。

从分类报告看：

类别 0 的精确率、召回率和 F1 值均为 1.00，说明模型完全正确地预测了该类别样本。

类别 1 和 2 的精确率和召回率接近于 94%，性能稍有下降，但依然较高。

宏平均 (Macro avg) 和 加权平均 (Weighted avg) 均为 96%，表明模型对每个类别都较为平衡。

交叉验证与测试集对比

性能接近：

测试集准确度为 96%，与交叉验证的平均准确度（96.67%）非常接近。这说明模型的性能在训练、验证和测试阶段保持了一致性，没有明显的过拟合或欠拟合现象。

交叉验证结果稍优：

交叉验证结果的精确率和召回率稍高于测试集，可能是因为交叉验证平均了多个数据分割的结果，而单一测试集可能受到随机划分的影响。

测试集表现稳定：

测试集的分类报告显示所有类别的预测性能都非常高，且差异较小，说明模型在实际测试中的表现稳定且可靠。

实验五：BP 神经网络算法实现与测试

一、实验目的

深入理解 BP 神经网络的算法原理，能够使用 Python 语言实现 BP 神经网络的训练与测试，并且使用五折交叉验证算法进行模型训练与评估。

二、实验内容

（1）从 scikit-learn 库中加载 iris 数据集，使用留出法留出 1/3 的样本作为测试集（注意同分布取样）；

（2）使用训练集训练 BP 神经网络分类算法；

（3）使用五折交叉验证对模型性能（准确度、精度、召回率和 F1 值）进行评估和选择；

（4）使用测试集，测试模型的性能，对测试结果进行分析，完成实验报告中实验五的部分。

三、算法步骤、代码、及结果

1. 算法伪代码

（1）加载 Iris 数据集

使用 `load_iris()` 获取数据集，存储特征数据为 `X`，标签数据为 `y`。

（2）划分数据集

使用 `train_test_split()` 将数据集分割为训练集和测试集

训练集占 2/3，测试集占 1/3，确保类别分布一致（通过 `stratify=y`）。

存储划分后的数据为 `X_train`, `X_test`, `y_train`, `y_test`。

（3）训练支持向量机（SVM）模型

创建 SVM 分类模型 `svm_model`，选择线性核函数。

使用 `X_train` 和 `y_train` 数据训练模型。

（4）使用交叉验证评估模型性能

创建五折交叉验证对象 `StratifiedKFold`。

定义评估指标：准确度、加权精度、加权召回率、加权 F1 分数。

使用 `cross_validate()` 对训练集进行五折交叉验证，获取不同评估指标的平均值。

（5）打印交叉验证结果

输出交叉验证中的平均准确度、精度、召回率和 F1 分数。

（6）使用测试集评估模型性能

使用 `svm_model` 对测试集 `X_test` 进行预测，得到预测结果 `y_pred`。

计算测试集上的性能指标：准确度、加权精度、加权召回率和加权 F1 分数。

（7）打印测试集上的评估结果

输出测试集的准确度、精度、召回率和 F1 分数。

2. 算法主要代码

完整源代码\调用库方法（函数参数说明）

# 导入必要的库

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score

from sklearn.neural_network import MLPClassifier

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report

import numpy as np

# 1. 加载 Iris 数据集

iris = load_iris()

X = iris.data # 特征数据

y = iris.target # 目标标签

# 2. 使用留出法划分训练集和测试集（留出 1/3 数据作为测试集）

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42, stratify=y)

# 3. 使用训练集训练 BP 神经网络

# 配置 BP 神经网络的参数

bp_model = MLPClassifier(

hidden_layer_sizes=(10, 10), # 两层隐藏层，每层 10 个神经元

activation='relu', # 激活函数使用 ReLU

solver='adam', # 优化算法使用 Adam

max_iter=1000, # 最大迭代次数

random_state=42

)

# 模型训练

bp_model.fit(X_train, y_train)

# 4. 使用五折交叉验证评估模型性能

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# 计算交叉验证的各项指标

accuracy_scores = cross_val_score(bp_model, X, y, cv=cv, scoring='accuracy')

precision_scores = cross_val_score(bp_model, X, y, cv=cv, scoring='precision_weighted')

recall_scores = cross_val_score(bp_model, X, y, cv=cv, scoring='recall_weighted')

f1_scores = cross_val_score(bp_model, X, y, cv=cv, scoring='f1_weighted')

# 输出交叉验证的评估结果

print("交叉验证性能：")

print(f"准确度 (Accuracy): {accuracy_scores.mean():.4f} ± {accuracy_scores.std():.4f}")

print(f"精确率 (Precision): {precision_scores.mean():.4f} ± {precision_scores.std():.4f}")

print(f"召回率 (Recall): {recall_scores.mean():.4f} ± {recall_scores.std():.4f}")

print(f"F1 值 (F1-score): {f1_scores.mean():.4f} ± {f1_scores.std():.4f}")

# 5. 使用测试集评估模型性能

y_pred = bp_model.predict(X_test)

# 输出测试集的评估结果

print("\n测试集性能：")

print(f"准确度 (Accuracy): {accuracy_score(y_test, y_pred):.4f}")

print(f"精确率 (Precision): {precision_score(y_test, y_pred, average='weighted'):.4f}")

print(f"召回率 (Recall): {recall_score(y_test, y_pred, average='weighted'):.4f}")

print(f"F1 值 (F1-score): {f1_score(y_test, y_pred, average='weighted'):.4f}")

# 输出分类报告

print("\n分类报告：")

print(classification_report(y_test, y_pred))

· load_iris()：加载 Iris 数据集，无参数，返回特征矩阵和目标标签。

· train_test_split(X, y, test_size=0.33, random_state=42, stratify=y)：将数据集划分为训练集和测试集，其中 X 为特征矩阵，y 为目标标签，test_size 指定测试集占比（默认为 0.33），random_state 确保划分可复现，stratify 保证划分后类别分布一致。

· MLPClassifier(hidden_layer_sizes=(100,),activation='relu', solver='adam', random_state=42)：构建 BP 神经网络分类模型，其中 hidden_layer_sizes 设置隐藏层神经元数量（默认为单层 100 个神经元），activation 指定激活函数（默认为 ReLU），solver 设置优化算法（默认为 Adam），random_state 确保结果可复现。

· StratifiedKFold(n_splits=5, shuffle=True, random_state=42)：实现分层 K 折交叉验证，其中 n_splits 为折数（默认为 5），shuffle 表示是否打乱数据，random_state 用于保持随机性可复现。

· cross_val_score(estimator, X, y, cv=5, scoring='accuracy')：对模型进行交叉验证，estimator 为待评估模型，X 和 y 分别为特征矩阵和目标标签，cv 指定折数，scoring 为评估指标（如 accuracy、precision 等）。

· classification_report(y_true, y_pred, target_names=None)：输出分类报告，y_true 为真实标签，y_pred 为预测标签，target_names 指定类别名称（可选）。

· accuracy_score(y_true, y_pred)：计算预测的准确率，y_true 为真实标签，y_pred 为预测标签。

· precision_score(y_true, y_pred, average='weighted')：计算加权精确率，y_true 为真实标签，y_pred 为预测标签，average 指定加权方式（默认为 weighted）。

· recall_score(y_true, y_pred, average='weighted')：计算加权召回率，y_true 为真实标签，y_pred 为预测标签，average 指定加权方式（默认为 weighted）。

· f1_score(y_true, y_pred, average='weighted')：计算加权 F1 值，y_true 为真实标签，y_pred 为预测标签

3. 训练结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

四、实验结果分析

1. 测试结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

2. 对比分析

1. 留出法 vs 五折交叉验证

数据分割：

留出法将数据集直接划分为训练集和测试集（33% 数据为测试集）。

五折交叉验证将数据分成五等份，每次选一份作为验证集，其余作为训练集，循环五次。

优点：

留出法简单快速，适合小规模实验。

五折交叉验证通过多次评估减小过拟合风险，更适合在大规模实验中选择最优模型。

性能比较：

留出法的测试集结果显示准确度为 96%，模型在测试集上的表现较好。

五折交叉验证的结果（平均准确度为 96.67% ± 2.93%）显示模型具有较高稳定性和较小波动。

2. 分类性能对比

从分类报告中可以看出：

类别 0（Setosa）的精确率、召回率和 F1 值均为 1.00，说明模型对该类别的分类效果最好。

类别 1 和 2 的性能略低，F1 值分别为 0.94 和 0.94，可能与类别分布或模型的泛化能力有关。

3. BP 神经网络的表现

BP 神经网络通过隐层提取数据特征，适合非线性分类问题。
在 Iris 数据集上的性能接近完美，表明该算法足以应对数据规模小、分类任务明确的场景。
若数据量更大或特征更复杂，可以增加隐藏层神经元数量或使用更高级优化方法（如 SGD），以提升泛化能力。

实验六：朴素贝叶斯算法实现与测试

一、实验目的

深入理解朴素贝叶斯的算法原理，能够使用 Python 语言实现朴素贝叶斯的训练与测试，并且使用五折交叉验证算法进行模型训练与评估。

二、实验内容

（1）从 scikit-learn 库中加载 iris 数据集，使用留出法留出 1/3 的样本作为测试集（注意同分布取样）；

（2）使用训练集训练朴素贝叶斯分类算法；

（3）使用五折交叉验证对模型性能（准确度、精度、召回率和 F1 值）进行评估和选择；

（4）使用测试集，测试模型的性能，对测试结果进行分析，完成实验报告中实验六的部分。

三、算法步骤、代码、及结果

1. 算法伪代码

（1）导入必要的库：

导入 numpy

导入 scikit-learn 中的模块：datasets, train_test_split, cross_val_score, StratifiedKFold, GaussianNB, accuracy_score, precision_score, recall_score, f1_score, classification_report

（2）加载 Iris 数据集：

使用 datasets.load_iris() 加载数据集

将特征数据赋值给 X

将标签数据赋值给 y

（3）划分数据集：

使用 train_test_split 将数据划分为训练集和测试集

设置测试集大小为 33%，并确保数据按标签（y）分层（stratify=y）

（4）训练朴素贝叶斯分类器：

创建朴素贝叶斯分类器实例 nb_classifier

使用训练集 X_train 和 y_train 拟合分类器

（5）使用交叉验证评估模型性能：

创建 StratifiedKFold 交叉验证对象 cv，指定 5 折交叉验证

计算交叉验证中的各项指标：

使用 cross_val_score 计算准确度、精度、召回率和 F1 值，分别使用 'accuracy', 'precision_macro', 'recall_macro', 'f1_macro' 评分标准

输出交叉验证结果的均值和标准差

（6）在测试集上评估模型：

使用 nb_classifier 在测试集 X_test 上进行预测，得到 y_pred

使用 accuracy_score、precision_score、recall_score 和 f1_score 计算测试集上的性能评估指标

输出测试集上的各项指标

（7）生成详细的分类报告：

使用 classification_report 生成并输出分类报告，展示测试集上的各类指标

2. 算法主要代码

完整源代码\调用库方法（函数参数说明）

# 导入必要的库
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report

# 1. 从 scikit-learn 库中加载 iris 数据集
iris = datasets.load_iris()
X = iris.data # 特征数据
y = iris.target # 标签数据

# 2. 使用留出法（holdout）将数据分为训练集和测试集，1/3 的样本作为测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42, stratify=y)

# 3. 使用训练集训练朴素贝叶斯分类算法
nb_classifier = GaussianNB() # 朴素贝叶斯分类器
nb_classifier.fit(X_train, y_train)

# 4. 使用五折交叉验证对模型性能进行评估
# 使用交叉验证评估模型的准确度、精度、召回率和 F1 值
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# 交叉验证的准确度
accuracy = cross_val_score(nb_classifier, X, y, cv=cv, scoring='accuracy')
# 交叉验证的精度
precision = cross_val_score(nb_classifier, X, y, cv=cv, scoring='precision_macro')
# 交叉验证的召回率
recall = cross_val_score(nb_classifier, X, y, cv=cv, scoring='recall_macro')
# 交叉验证的 F1 值
f1 = cross_val_score(nb_classifier, X, y, cv=cv, scoring='f1_macro')

# 输出交叉验证结果
print(f"Accuracy (Cross-validation): {accuracy.mean():.4f} ± {accuracy.std():.4f}")
print(f"Precision (Cross-validation): {precision.mean():.4f} ± {precision.std():.4f}")
print(f"Recall (Cross-validation): {recall.mean():.4f} ± {recall.std():.4f}")
print(f"F1 Score (Cross-validation): {f1.mean():.4f} ± {f1.std():.4f}")

# 5. 使用测试集测试模型性能
y_pred = nb_classifier.predict(X_test)

# 计算模型的评估指标
accuracy_test = accuracy_score(y_test, y_pred)
precision_test = precision_score(y_test, y_pred, average='macro')
recall_test = recall_score(y_test, y_pred, average='macro')
f1_test = f1_score(y_test, y_pred, average='macro')

# 输出测试集上的结果
print("\nTest Set Performance:")
print(f"Accuracy: {accuracy_test:.4f}")
print(f"Precision: {precision_test:.4f}")
print(f"Recall: {recall_test:.4f}")
print(f"F1 Score: {f1_test:.4f}")

# 生成详细的分类报告
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

参数说明：

X: 特征数据，可以是数组或 pandas DataFrame，表示输入变量。

y: 标签数据，表示目标变量，通常是数组或列表。

test_size: 测试集占整个数据集的比例，默认为 0.33（即 33% 的数据为测试集）。

random_state: 用于控制数据划分的随机性，设定一个整数值以确保可复现结果。默认为 None，表示每次运行时划分可能不同。

3. 训练结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

四、实验结果分析

1. 测试结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

2. 对比分析

评估方法	优点	缺点
留出法（Holdout）	简单快速，易于实现；适用于大规模数据	可能无法充分利用所有数据；结果对数据划分敏感
交叉验证（Cross-validation）	能有效评估模型泛化能力；减少过拟合风险；综合考虑多个评估指标	计算成本高，尤其是对于大数据集；评估结果有时受数据划分影响
测试集评估	直接反映模型在独立数据上的性能；能够生成详细分类报告	可能存在偶然性，且仅依赖单一数据划分，不能完全反映模型性能

实验七：K均值聚类算法实现与测试

一、实验目的

深入理解 K 均值聚类算法的算法原理，进而理解无监督学习的意义，能够使用 Python语言实现 K 均值聚类算法的训练与测试，并且使用五折交叉验证算法进行模型训练与评估。

二、实验内容

（1）从 scikit-learn 库中加载 iris 数据集，使用留出法留出 1/3 的样本作为测试集（注

意同分布取样）；

（2）使用训练集训练 K 均值聚类算法，类别数为 3；

（3）使用五折交叉验证对模型性能（准确度、精度、召回率和 F1 值）进行评估和选

择；

（4）使用测试集，测试模型的性能，对测试结果进行分析，完成实验报告中实验七的部分。

三、算法步骤、代码、及结果

1. 算法伪代码

输入：数据集 X = {x1, x2, ..., xn}，簇的数量 K

输出：每个数据点的簇标签，以及簇的中心点

1. 初始化 K 个簇中心（可以随机选择 K 个数据点作为初始中心，或通过某种启发式方法选择）

- 设簇中心为 C1, C2, ..., CK

2. 重复以下步骤直到收敛：

1. 为每个数据点 xi 分配一个簇标签 ci，使得它属于距离其最近的簇中心：

- 对于每个数据点 xi，计算 xi 到各个簇中心 Cj 的距离（一般使用欧几里得距离）

- 将数据点 xi 分配给最近的簇中心 Cj，更新其簇标签 ci

2. 重新计算每个簇的中心点（即每个簇的均值）：

- 对于每个簇 j，更新簇中心 Cj 为簇内所有数据点的均值：

Cj = (1/mj) * Σ(xi ∈ cluster j) xi

其中 mj 是簇 j 中的样本数量，Σ 表示对所有属于簇 j 的样本 xi 求和。

3. 判断是否收敛：

- 如果簇中心不再变化，或者变化非常小，则停止迭代

- 否则，继续执行步骤 2

返回：每个数据点的簇标签及最终的簇中心

2. 算法主要代码

完整源代码\调用库方法（函数参数说明）

# 导入必要的库
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.cluster import KMeans
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score
from sklearn.metrics import make_scorer

# 1. 加载 Iris 数据集
iris = datasets.load_iris()
X = iris.data # 特征矩阵
y = iris.target # 目标标签

# 2. 留出法拆分数据集（训练集 2/3，测试集 1/3）
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42, stratify=y)

# 3. 使用 K 均值聚类算法进行训练，类别数设置为 3
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X_train)

# 4. 使用五折交叉验证进行模型性能评估
# 定义交叉验证评分（准确度、精度、召回率、F1 值）
scoring = ['accuracy', 'precision_macro', 'recall_macro', 'f1_macro']

# 使用 cross_val_score 进行五折交叉验证
for score in scoring:
cv_score = cross_val_score(kmeans, X_train, y_train, cv=5, scoring=score)
print(f'Cross-validation {score}: {cv_score.mean():.4f} ± {cv_score.std():.4f}')

# 5. 使用测试集评估模型性能
y_pred = kmeans.predict(X_test)

# 输出分类报告，评估模型的性能
print("\nClassification Report on Test Set:")
print(classification_report(y_test, y_pred))

# 输出聚类的中心点
print("\nCluster Centers:")
print(kmeans.cluster_centers_)

函数参数：

n_clusters: 聚类簇数，默认 8。

init: 初始化方法，'k-means++'（默认）或 'random'。

n_init: 运行次数，默认 10。

max_iter: 最大迭代次数，默认 300。

tol: 收敛阈值，默认 1e-4。

random_state: 随机数种子，控制结果一致性，默认 None。

algorithm: 算法选择，'auto'（默认），'full'，'elkan'。

verbose: 输出详细信息，0（默认）为不输出。

n_jobs: 并行计算的作业数，-1为使用所有核心，默认 1。

3. 训练结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

四、实验结果分析

1. 测试结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

2. 对比分析

K 均值：适合球形簇，要求预设簇数，处理大数据集高效，但对离群点敏感。

层次聚类：适合小数据集，能发现任意形状簇，但计算复杂度高。

DBSCAN：适合任意形状簇，能有效处理噪声和离群点，但对密度差异敏感。

实验八：随机森林算法实现与测试

一、实验目的

深入理解随机森林的算法原理，进而理解集成学习的意义，能够使用 Python 语言实现随机森林算法的训练与测试，并且使用五折交叉验证算法进行模型训练与评估。

二、实验内容

（1）从 scikit-learn 库中加载 iris 数据集，使用留出法留出 1/3 的样本作为测试集（注意同分布取样）；

（2）使用训练集训练随机森林分类算法；

（3）使用五折交叉验证对模型性能（准确度、精度、召回率和 F1 值）进行评估和选择；

（4）使用测试集，测试模型的性能，对测试结果进行分析，完成实验报告中实验八的部分。

三、算法步骤、代码、及结果

1. 算法伪代码

输入：训练数据集 D = {(x1, y1), (x2, y2), ..., (xn, yn)}，其中 xi 是特征向量，yi 是标签

树的数量 T，树的最大深度 max_depth，最小样本分裂数 min_samples_split

1. 初始化一个空的随机森林模型 Forest = []

2. 对于 i = 1 到 T:

a. 从 D 中有放回地随机抽取一个样本子集 D_i，样本数与原数据集大小相同（Bootstrap抽样）

b. 对于每棵树:

i. 使用随机特征选择：对于每个分裂点，从总特征集合中随机选择一个特征子集（例如，选择√m个特征）来决定最佳分裂。

ii. 训练决策树 T_i 使用样本集 D_i，直到达到最大深度或其他停止条件（如最小样本分裂数）

iii. 将训练好的树 T_i 加入随机森林模型 Forest

3. 对于测试数据 x_test，计算其预测结果：

a. 每棵树 T_i 给出一个分类预测 y_pred_i

b. 最终预测结果 y_pred 由投票机制决定：选择出现次数最多的类别作为最终结果

4. 返回最终的预测结果 y_pred

2. 算法主要代码

完整源代码\调用库方法（函数参数说明）

# 导入所需库

import numpy as np

from sklearn.model_selection import train_test_split, cross_val_score

from sklearn.ensemble import RandomForestClassifier

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report

from sklearn.datasets import load_iris

# 1. 加载数据集

data = load_iris()

X = data.data

y = data.target

# 2. 数据划分：训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42, stratify=y)

# 3. 初始化随机森林分类器

rf = RandomForestClassifier(n_estimators=100, random_state=42)

# 4. 使用五折交叉验证评估模型

cv_accuracy = cross_val_score(rf, X_train, y_train, cv=5, scoring='accuracy')

cv_precision = cross_val_score(rf, X_train, y_train, cv=5, scoring='precision_macro')

cv_recall = cross_val_score(rf, X_train, y_train, cv=5, scoring='recall_macro')

cv_f1 = cross_val_score(rf, X_train, y_train, cv=5, scoring='f1_macro')

print(f"五折交叉验证准确率: {cv_accuracy.mean()}")

print(f"五折交叉验证精度: {cv_precision.mean()}")

print(f"五折交叉验证召回率: {cv_recall.mean()}")

print(f"五折交叉验证F1值: {cv_f1.mean()}")

# 5. 训练模型

rf.fit(X_train, y_train)

# 6. 预测与测试集评估

y_pred = rf.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

precision = precision_score(y_test, y_pred, average='macro')

recall = recall_score(y_test, y_pred, average='macro')

f1 = f1_score(y_test, y_pred, average='macro')

print("\n测试集性能:")

print(f"准确率: {accuracy}")

print(f"精度: {precision}")

print(f"召回率: {recall}")

print(f"F1值: {f1}")

# 输出测试集的分类报告

print("\n测试集分类报告:")

print(classification_report(y_test, y_pred))

函数参数：

RandomForestClassifier：

n_estimators：树的数量（默认 100）。

random_state：随机数种子，用于结果的可重复性。

max_depth：树的最大深度（默认 None，表示直到所有叶节点纯净）。

min_samples_split：分裂节点时的最小样本数。

min_samples_leaf：叶子节点的最小样本数。

train_test_split：

test_size：测试集的比例（默认 0.25）。

random_state：控制数据划分的随机性。

stratify：是否进行分层抽样，确保类别分布一致。

cross_val_score：

scoring：评估指标，可以是 'accuracy'、'precision'、'recall'、'f1' 等。

accuracy_score：计算准确率，y_true 和 y_pred 为真实标签和预测标签。

precision_score：计算精度（查准率），适用于二分类或多分类问题，average='macro' 表示计算每类的精度并取平均。

recall_score：计算召回率（查全率），average='macro' 同理。

f1_score：计算 F1 值，是精度与召回率的调和均值。

3. 训练结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

四、实验结果分析

1. 测试结果截图（包括：准确率、精度（查准率）、召回率（查全率）、F1）

2. 对比分析

高准确性：通过集成多棵决策树，随机森林能有效提高分类精度，减少过拟合。

抗噪声能力强：由于每棵树的训练数据是随机抽样的，因此对噪声的鲁棒性更强。

自动处理特征选择：随机森林在训练过程中通过随机选择特征来进行分裂，能够自动发现数据中重要的特征。

高效并行训练：每棵树是独立训练的，因此可以并行处理，加速训练过程。

较少的参数调优：随机森林不需要复杂的参数调整，默认参数就能达到较好的效果。

实验总结

通过这一系列实验的学习与实践，我对机器学习领域的理论知识和算法实现有了更加深入的理解。从基础的逻辑回归到复杂的 BP 神经网络，以及从分类算法到聚类方法的实现，这些实验为我提供了全方位的实践机会和理论巩固。同时，我也尝试了主流深度学习框架 TensorFlow 和 PyTorch 的基本使用，为未来的学习打下了良好的基础。

1. 数据准备与模型评估

在实验一中，通过数据预处理和模型评估方法的学习，我认识到数据的质量对模型性能至关重要。特征归一化、缺失值处理以及合理的样本划分策略（如留出法和交叉验证）不仅能提升模型效果，还可以让评估更加客观可靠。这一阶段的学习为后续实验的算法实现奠定了坚实的基础。

2. 分类算法的学习与实现

实验二至实验六涵盖了多种分类算法，包括逻辑回归、C4.5 决策树、支持向量机（SMO 算法）、BP 神经网络和朴素贝叶斯。
这些实验让我体会到不同算法的特点与应用场景：

逻辑回归：适合解决线性二分类问题，具有较好的可解释性，适用于特征独立的场景。

C4.5 决策树：通过信息增益率构造树状模型，便于理解和使用，预剪枝与后剪枝进一步提升了泛化能力。

支持向量机（SVM）：适合高维数据分类，实验中的 SMO 算法让我理解了 SVM 优化问题的求解过程。

BP 神经网络：具备强大的非线性拟合能力，在复杂的多分类问题上表现优异，但训练时对超参数敏感。

朴素贝叶斯：简单高效，适合条件独立的特征场景，但当特征存在相关性时表现有限。

这些实验让我体会到，不同算法有其独特的适用场景和局限性，选择时需要根据实际任务需求和数据特性做出权衡。

3. 聚类与集成算法的实践

实验七和实验八分别涉及了 K 均值聚类算法和随机森林算法。

K 均值聚类作为一种无监督学习方法，强调簇内样本的相似性和簇间样本的差异性。在实验中，我深刻认识到初始聚类中心选择对结果的重要性，以及如何通过肘部法则确定合适的簇数。

随机森林则是典型的集成学习方法，通过构建多棵决策树并融合其结果，提升了模型的鲁棒性和泛化能力。在高维、复杂数据上，随机森林表现出色，但也需要注意训练时间随数据量增大的显著增加。

4. TensorFlow 与 PyTorch 的学习

在实验过程中，我还学习了 TensorFlow 和 PyTorch 这两大主流深度学习框架。

TensorFlow 强调工业化和大规模分布式训练，适合生产环境，2.x 版本的动态图特性也让实验更加直观易懂。

PyTorch 则以其动态计算图和简洁的 API 深受研究者喜爱。它的灵活性和直观性让我在构建和调试神经网络时更加高效。
通过对这两种框架的学习，我不仅掌握了基本的深度学习模型构建方法，还深入理解了梯度下降、自动微分等核心概念，为未来的深度学习研究奠定了基础。

5. 总体感想

这一阶段的实验让我全面了解了监督学习、无监督学习、集成学习等多个机器学习领域的核心算法。同时，通过五折交叉验证和各种性能指标（如准确率、精度、召回率和 F1 值）的分析，我学会了如何科学评估模型性能，从而更合理地选择算法。

此外，我深刻认识到数据的重要性。在机器学习中，模型的性能不仅取决于算法本身，更与数据的质量密不可分。优质的数据准备和特征工程，往往能够显著提升模型效果。

未来，我将进一步探索更复杂的深度学习模型和优化方法，并尝试将所学知识应用到实际问题中，解决更具挑战性的任务。通过不断实践和总结，我相信自己能够在机器学习领域取得更大的进步。

posted on 2024-12-19 22:21 po3a 阅读(9) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 混凝土承重等级预测

· 《从零开始绘制DeepSeek R1架构和训练流程》读后感

· 上机实验二：逻辑回归算法实现与测试

· ML@sklearn@ML流程Part2@数据划分@交叉验证法

· 机器学习B：实验二：逻辑回归算法实现与测试

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· winform 绘制太阳，地球，月球运作规律
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 上周热点回顾（3.3-3.9）

导航

搜索

常用链接

我的标签

随笔档案

阅读排行榜

评论排行榜

最新评论

交叉验证结果分析

测试集结果分析

交叉验证与测试集对比


Copyright © 2025 po3a Powered by .NET 9.0 on Kubernetes 博客园