第18节：6种传统方法实战项目（MNIST分类）

为了探究不同传统算法在分类上的表现，本文实现了6种算法，这些脚本都遵循相同的模式：

1. 加载MNIST数据集

2. 划分训练集和测试集

3. 训练指定模型

4. 评估并输出结果

要运行这些脚本，只需分别执行每个文件即可。

通过比较不同算法的结果，可以了解它们在MNIST数据集上的相对性能表现。

1. 逻辑回归

代码如下：

from sklearn.datasets import fetch_openml
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import time

# 加载MNIST数据集
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data, mnist.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建并训练逻辑回归模型
start_time = time.time()
model = LogisticRegression(max_iter=1000, random_state=42)
model.fit(X_train, y_train)
train_time = time.time() - start_time

# 评估模型
start_time = time.time()
y_pred = model.predict(X_test)
test_time = time.time() - start_time

# 输出结果
print("逻辑回归结果:")
print(f"训练时间: {train_time:.2f}秒")
print(f"测试时间: {test_time:.2f}秒")
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))

算法解释：
逻辑回归是一种线性分类模型，尽管名字中有"回归"，但它用于分类任务。它通过sigmoid函数将线性回归的输出映射到(0,1)区间，表示属于某类的概率。

• 优点：计算效率高，容易实现和解释

• 缺点：只能学习线性决策边界

• 适用场景：当特征与目标大致呈线性关系时表现良好

• 参数说明：max_iter=1000确保在这个大数据集上有足够迭代次数收敛

2. 支持向量机

代码如下：

from sklearn.datasets import fetch_openml
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
from sklearn.preprocessing import StandardScaler
import time

# 加载MNIST数据集
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data, mnist.target

# 划分数据集并标准化
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 创建并训练SVM模型
start_time = time.time()
model = SVC(probability=True, random_state=42)
model.fit(X_train, y_train)
train_time = time.time() - start_time

# 评估模型
start_time = time.time()
y_pred = model.predict(X_test)
test_time = time.time() - start_time

# 输出结果
print("支持向量机结果:")
print(f"训练时间: {train_time:.2f}秒")
print(f"测试时间: {test_time:.2f}秒")
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))

算法解释：
支持向量机(SVM)通过寻找最大间隔超平面来分隔不同类别。我们使用默认的RBF核，可以处理非线性分类问题。

• 优点：在高维空间中表现良好，能够处理非线性决策边界

• 缺点：训练时间较长，对大规模数据不友好

• 适用场景：中小规模数据集，特别是特征维度较高时

• 注意：必须进行特征标准化，因为SVM对特征尺度敏感

3. 决策树

代码如下：

from sklearn.datasets import fetch_openml
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import time

# 加载MNIST数据集
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data, mnist.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建并训练决策树模型
start_time = time.time()
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)
train_time = time.time() - start_time

# 评估模型
start_time = time.time()
y_pred = model.predict(X_test)
test_time = time.time() - start_time

# 输出结果
print("决策树结果:")
print(f"训练时间: {train_time:.2f}秒")
print(f"测试时间: {test_time:.2f}秒")
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))

算法解释：
决策树通过递归地分割数据来构建树结构，每个内部节点表示一个特征测试，每个分支代表测试结果，每个叶节点代表一个类别。

• 优点：直观易懂，不需要特征缩放，能处理非线性关系

• 缺点：容易过拟合，对噪声敏感

• 适用场景：需要模型解释性的场合，或特征有复杂交互关系时

• 注意：可以通过剪枝来减少过拟合

4. 随机森林

代码如下：

from sklearn.datasets import fetch_openml
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import time

# 加载MNIST数据集
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data, mnist.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建并训练随机森林模型
start_time = time.time()
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
train_time = time.time() - start_time

# 评估模型
start_time = time.time()
y_pred = model.predict(X_test)
test_time = time.time() - start_time

# 输出结果
print("随机森林结果:")
print(f"训练时间: {train_time:.2f}秒")
print(f"测试时间: {test_time:.2f}秒")
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))

算法解释：
随机森林是决策树的集成方法，通过构建多棵决策树并综合它们的预测结果来提高泛化能力。

• 优点：通常比单棵决策树表现更好，能自动处理特征重要性

• 缺点：训练时间比单棵决策树长，模型解释性降低

• 适用场景：当单棵决策树过拟合时，或需要更稳定、更准确的模型时

• 特点：通过特征和数据的随机采样增加多样性

5. 朴素贝叶斯

代码如下：

from sklearn.datasets import fetch_openml
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import time

# 加载MNIST数据集
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data, mnist.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建并训练朴素贝叶斯模型
start_time = time.time()
model = GaussianNB()
model.fit(X_train, y_train)
train_time = time.time() - start_time

# 评估模型
start_time = time.time()
y_pred = model.predict(X_test)
test_time = time.time() - start_time

# 输出结果
print("朴素贝叶斯结果:")
print(f"训练时间: {train_time:.2f}秒")
print(f"测试时间: {test_time:.2f}秒")
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))

算法解释：
朴素贝叶斯基于贝叶斯定理，假设特征之间相互独立。虽然这个假设在现实中很少成立，但该算法仍常常表现良好。

• 优点：训练速度快，对小规模数据表现好

• 缺点：特征独立性假设通常不成立

• 适用场景：文本分类等特征维度高且样本较少的场景

• 注意：适合处理连续特征的GaussianNB变体

6. K近邻

代码如下：

from sklearn.datasets import fetch_openml
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import time

# 加载MNIST数据集
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data, mnist.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建并训练KNN模型
start_time = time.time()
model = KNeighborsClassifier()
model.fit(X_train, y_train)
train_time = time.time() - start_time

# 评估模型
start_time = time.time()
y_pred = model.predict(X_test)
test_time = time.time() - start_time

# 输出结果
print("K近邻结果:")
print(f"训练时间: {train_time:.2f}秒")
print(f"测试时间: {test_time:.2f}秒")
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))

算法解释：
K近邻(KNN)是一种基于实例的学习算法，它不构建显式模型，而是通过比较新样本与训练样本的相似度来进行预测。

• 优点：简单直观，无需训练过程(惰性学习)

• 缺点：预测阶段计算量大，对高维数据效果差

• 适用场景：低维数据，当决策边界非常不规则时

• 注意：特征缩放很重要，因为依赖于距离度量