【手写数字识别】数据挖掘实验二

用PyTorch实现MNIST手写数字识别（最新，非常详细）

Ⅰ、项目任务要求

任务描述：

• 图像识别（Image Recognition）是指利用计算机对图像进行处理、分析和理解，以识别各种不同模式的目标和对象的技术。 图像识别的发展经历了三个阶段：文字识别、数字图像处理与识别、物体识别。机器学习领域一般将此类识别问题转化为分类问题。

• 手写识别是常见的图像识别任务。计算机通过手写体图片来识别出图片中的字，与印刷字体不同的是，不同人的手写体风格迥异，大小不一，造成了计算机对手写识别任务的一些困难。 数字手写体识别由于其有限的类别（0~9共10个数字）成为了相对简单的手写识别任务。

• 此实验内容：分别采用决策树、KNN、朴素贝叶斯、SVM、BP、softmax、adaboost、袋装八种浅层学习分类方法中的任意二种方法（适于二人组）或 三种（适于三人组）对MNIST公共数据集、HWDG私有数据集进行分类，并写出实验结果分析。

• 说明：也可以多选方法做，比如四种、五种等。

主要任务要求(必须完成以下内容但不限于这些内容)：

• 1、采用MNIST公共数据集；或采用HWDG数据集为私有数据集，用爬虫工具或手工制作，有0-9手写数字共10类，样本总数不少于60个(相当于找60个人，每人都手写0-9数字，分别做好标签存成图片后再制成样本集。)
• 2、简述算法思想和实现原理。
• 3、写出实验结果分析：

  • (1) 数据集描述。包括数据集介绍、训练集和测试集介绍等。

  • (2) 实验运行环境描述。如开发平台、编程语言、调参情况等。

  • (3) 不同方法对MNIST数据集分类识别结果分析(不同方法识别对比率表及结果分析)，例如：
    

  • (4) 不同方法对HWDG数据集分类识别结果分析(不同方法识别率对比表及结果分析)。结果对比表如上表格式所示。

II、实现过程

数据集描述

• MNIST是一个包含数字0~9的手写体图片数据集，图片已归一化为以手写数 字为中心的28*28规格的图片。
• MNIST由训练集与测试集两个部分组成，各部分 规模如下：
  • 训练集：60,000个手写体图片及对应标签
  • 测试集：10,000个手写体图片及对应标签
    

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

import torch
import numpy as np
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F

"""
卷积运算 使用mnist数据集，和10-4，11类似的，只是这里：1.输出训练轮的acc 2.模型上使用torch.nn.Sequential
"""
# Super parameter ------------------------------------------------------------------------------------
batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10

# Todo：数据集准备 ------------------------------------------------------------------------------------
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
# softmax归一化指数函数(https://blog.csdn.net/lz_peter/article/details/84574716),其中0.1307是mean均值和0.3081是std标准差

train_dataset = datasets.MNIST(root='./data/demo2', train=True, transform=transform,
                               download=True)  # 本地没有就加上download=True
test_dataset = datasets.MNIST(root='./data/demo2', train=False, transform=transform,
                              download=True)  # train=True训练集，=False测试集
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 展示数据（12个）
fig = plt.figure()
for i in range(12):
    plt.subplot(3, 4, i + 1)
    plt.tight_layout()
    plt.imshow(train_dataset.train_data[i], cmap='gray', interpolation='none')
    plt.title("Labels: {}".format(train_dataset.train_labels[i]))
    plt.xticks([])
    plt.yticks([])
plt.show()

实验运行环境描述

• 开发平台：autoDL,3080
• 编程语言：python
• 调参情况：见实验过程
• 运行时间：4h+

KNN模型

KNN模型简介
KNN（K-Nearest Neighbors）算法是一种基本的机器学习方法，用于分类和回归问题。它的核心思想是：如果一个样本在特征空间中的k个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，则该样本也属于这个类别。KNN算法的步骤包括：计算待分类样本与训练集中样本的距离，选取距离最近的k个样本，根据这k个样本的类别进行投票（分类问题）或求平均（回归问题），将得票最多的类别或平均值作为待分类样本的预测类别或值。

• 优点：简单易懂，适用于小规模数据集，不需要训练过程，适用于多种类型的数据（数值型、离散型等）。
• 缺点：计算复杂度高，尤其在高维数据集上，存储空间大，对异常值敏感。

总之，KNN是一种直观、易于理解的算法，但在处理大规模高维度数据时性能可能受限。

调整的参数
KNN模型主要用到一个参数，即K值，它表示在预测时要考虑多少个最近邻居的信息。K值的选择对KNN模型的性能有很大影响。较小的K值会使模型更加敏感，容易受到噪声的影响，而较大的K值会使模型更加平滑，减小了波动。

• 选择合适的K值通常使用交叉验证（Cross Validation）的方法。在交叉验证中，将训练数据分成多个折叠（folds），然后使用其中一部分数据作为验证集，剩余的部分作为训练集，多次训练模型并计算模型在验证集上的性能。
• 通过比较不同K值下模型的性能，选择在验证集上性能最好的K值。

除了K值，KNN模型还可以使用不同的距离度量方法。在默认情况下，通常使用欧氏距离（Euclidean distance）作为距离度量，但可以根据具体问题选择其他距离度量方法，例如曼哈顿距离（Manhattan distance）或闵可夫斯基距离（Minkowski distance）等。不同的距离度量方法会影响模型的性能，因此在选择距离度量方法时也需要进行实验和比较。

# 准备数据
X_train = train_dataset.train_data.numpy().reshape(-1, 28 * 28)  # 将图像展平成一维数组
y_train = train_dataset.train_labels.numpy()
X_test = test_dataset.test_data.numpy().reshape(-1, 28 * 28)
y_test = test_dataset.test_labels.numpy()

# 初始化并训练KNN模型
knn_classifier = KNeighborsClassifier(n_neighbors=3)  # 选择邻居数为3
knn_classifier.fit(X_train, y_train)

# 预测并评估模型
y_pred = knn_classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("KNN 模型在测试集上的准确率: {:.2f}%".format(accuracy * 100))

决策树模型

决策树模型简介
决策树模型是一种用于解决分类和回归问题的机器学习算法，模拟人类决策过程。它通过一系列特征判断将数据集分割成不同子集，最终确定数据属于哪个类别或预测数值。决策树由节点、边和叶节点组成，通过选择特征、递归划分和叶节点分类或回归构建。具有易解释性和适用性广泛的特点，但需要注意防止过拟合问题。

调整的参数
决策树模型有许多参数可以调整，不同的参数设置可以影响模型的性能和泛化能力。以下是一些常见的决策树模型参数，你可以根据具体的问题和数据集来调整它们：

1. 树的深度（max_depth）： 决定树的最大深度。如果设置得太大，容易过拟合；设置得太小，容易欠拟合。

2. 最小分割样本数（min_samples_split）： 一个节点在分裂前必须有的最小样本数。如果节点的样本数少于这个值，就不会再分裂。

3. 叶节点的最小样本数（min_samples_leaf）： 一个叶节点必须有的最小样本数。如果一个叶节点的样本数少于这个值，该叶节点会和兄弟节点一起被剪枝。

4. 最大特征数（max_features）： 在寻找最佳分割时考虑的特征数。可以是固定的整数，也可以是一个比例。

5. 节点分裂的标准（criterion）： 衡量节点纯度的方法，可以是基尼指数（‘gini’）或信息增益（‘entropy’）。

6. 决策树数量（n_estimators）： 仅在集成方法（如随机森林）中使用，指定树的数量。

7. 学习率（learning_rate）： 仅在梯度提升树（Gradient Boosting Trees）中使用，控制每棵树的贡献程度。

8. 子采样比例（subsample）： 仅在梯度提升树中使用，表示每棵树所使用的样本比例。

9. 正则化参数（alpha）： 控制树的复杂度，用于防止过拟合。

这些参数的最佳取值通常依赖于具体的数据集和问题。可以使用交叉验证等技术来选择最佳的参数组合，以提高模型的性能和泛化能力。

print("Training Decision Tree Classifier...")
decision_tree_classifier = DecisionTreeClassifier(random_state=42)
decision_tree_classifier.fit(X_train, y_train)

# Predict and evaluate the model
y_pred = decision_tree_classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Decision Tree Classifier Accuracy: {:.2f}%".format(accuracy * 100))

朴素贝叶斯模型

SVM模型

不同方法对MNIST数据集分类识别结果分析(不同方法识别对比率表及结果分析)

评估模型方法（准确率）
分类结果分析

完整代码I

import numpy as np
import torch
import torchvision
import torch.nn.functional as F
from sklearn.neighbors import KNeighborsClassifier
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import StratifiedKFold, GridSearchCV
from sklearn.metrics import accuracy_score
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
import matplotlib.pyplot as plt

# 超参数
batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10

# 数据集准备
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
train_dataset = datasets.MNIST(root='./data/demo2', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data/demo2', train=False, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 数据准备
X_train = train_dataset.train_data.numpy().reshape(-1, 28 * 28)
y_train = train_dataset.train_labels.numpy()
X_test = test_dataset.test_data.numpy().reshape(-1, 28 * 28)
y_test = test_dataset.test_labels.numpy()

# 决策树模型参数调优
decision_tree_classifier = DecisionTreeClassifier(random_state=42)
param_grid_dt = {
    'max_depth': [3, 5, 7, 9],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}
cv = StratifiedKFold(n_splits=5, random_state=42, shuffle=True)
grid_search_dt = GridSearchCV(estimator=decision_tree_classifier, param_grid=param_grid_dt, cv=cv)
grid_search_dt.fit(X_train, y_train)
best_decision_tree_classifier = grid_search_dt.best_estimator_

# 朴素贝叶斯模型参数调优
naive_bayes_classifier = GaussianNB()
param_grid_nb = {
    'var_smoothing': np.logspace(0, -9, num=100)
}
grid_search_nb = GridSearchCV(estimator=naive_bayes_classifier, param_grid=param_grid_nb, cv=cv)
grid_search_nb.fit(X_train, y_train)
best_naive_bayes_classifier = grid_search_nb.best_estimator_

# SVM模型参数调优
svm_classifier = SVC(kernel='linear', random_state=42)
param_grid_svm = {
    'C': [0.1, 1, 10]
}
grid_search_svm = GridSearchCV(estimator=svm_classifier, param_grid=param_grid_svm, cv=cv)
grid_search_svm.fit(X_train, y_train)
best_svm_classifier = grid_search_svm.best_estimator_

# 评估模型
y_pred_dt = best_decision_tree_classifier.predict(X_test)
accuracy_dt = accuracy_score(y_test, y_pred_dt)

y_pred_nb = best_naive_bayes_classifier.predict(X_test)
accuracy_nb = accuracy_score(y_test, y_pred_nb)

y_pred_svm = best_svm_classifier.predict(X_test)
accuracy_svm = accuracy_score(y_test, y_pred_svm)

print("决策树模型在测试集上的准确率: {:.2f}%".format(accuracy_dt * 100))
print("朴素贝叶斯模型在测试集上的准确率: {:.2f}%".format(accuracy_nb * 100))
print("SVM模型在测试集上的准确率: {:.2f}%".format(accuracy_svm * 100))

# 可视化对比展示
models = ['决策树', '朴素贝叶斯', 'SVM']
accuracies = [accuracy_dt, accuracy_nb, accuracy_svm]

plt.figure(figsize=(8, 6))
plt.bar(models, accuracies, align='center', alpha=0.7)
plt.xlabel('模型')
plt.ylabel('准确率')
plt.title('不同模型的准确率对比')
plt.ylim(min(accuracies) - 0.01, max(accuracies) + 0.01)
plt.show()

完整代码II

import numpy
import torch
import torchvision
import torch.nn.functional as F
import sklearn
from sklearn.neighbors import KNeighborsClassifier
from torch.utils.data import DataLoader

from torchvision import transforms
from torchvision import datasets

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import StratifiedKFold, GridSearchCV
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt

import numpy as np


"""
numpy, sklearn, matplotlib, torch, torchvision
"""

"""
卷积运算 使用mnist数据集，和10-4，11类似的，只是这里：1.输出训练轮的acc 2.模型上使用torch.nn.Sequential
"""
# Super parameter ------------------------------------------------------------------------------------
batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10

# Todo：数据集准备 ------------------------------------------------------------------------------------
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
# softmax归一化指数函数(https://blog.csdn.net/lz_peter/article/details/84574716),其中0.1307是mean均值和0.3081是std标准差

train_dataset = datasets.MNIST(root='./data/demo2', train=True, transform=transform,
                               download=True)  # 本地没有就加上download=True
test_dataset = datasets.MNIST(root='./data/demo2', train=False, transform=transform,
                              download=True)  # train=True训练集，=False测试集
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 展示数据（12个）
fig = plt.figure()
for i in range(12):
    plt.subplot(3, 4, i + 1)
    plt.tight_layout()
    plt.imshow(train_dataset.train_data[i], cmap='gray', interpolation='none')
    plt.title("Labels: {}".format(train_dataset.train_labels[i]))
    plt.xticks([])
    plt.yticks([])
plt.show()

# 准备数据
X_train = train_dataset.train_data.numpy().reshape(-1, 28 * 28)  # 将图像展平成一维数组
y_train = train_dataset.train_labels.numpy()
X_test = test_dataset.test_data.numpy().reshape(-1, 28 * 28)
y_test = test_dataset.test_labels.numpy()

# Todo: KNN 模型 ------------------------------------------------------------------------------------
print('Todo: KNN 模型 ------------------------------------------------------------------------------------')
neighbors = [3, 4, 5]
best_accuracy = 0
best_neighbor = 0
accuracies = []

for n in neighbors:
    knn_classifier = KNeighborsClassifier(n_neighbors=n)  # 设置邻居数
    print('正在训练 KNN 模型 (邻居数={}）...'.format(n))
    knn_classifier.fit(X_train, y_train)

    # 预测并评估模型
    y_pred = knn_classifier.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    accuracies.append(accuracy)
    print("KNN 模型 (邻居数={}）在测试集上的准确率: {:.2f}%".format(n, accuracy * 100))

    # 更新最优准确率和对应的邻居数
    if accuracy > best_accuracy:
        best_accuracy = accuracy
        best_neighbor = n

# 可视化不同邻居数下的准确率
plt.figure(figsize=(8, 6))
plt.bar(neighbors, accuracies, align='center', alpha=0.7)
plt.xlabel('Number of Neighbors')
plt.ylabel('Accuracy')
plt.title('KNN Accuracy for Different Number of Neighbors')
plt.xticks(neighbors)
plt.ylim(min(accuracies) - 0.01, max(accuracies) + 0.01)
plt.show()
plt.savefig('data/demo2/knn_accuracy_plot.png')

print("最优的KNN模型 (邻居数={}）在测试集上的准确率: {:.2f}%".format(best_neighbor, best_accuracy * 100))

# Todo: 决策树 模型 ------------------------------------------------------------------------------------
print('Todo: 决策树 模型 ------------------------------------------------------------------------------------')
# 定义决策树分类器
decision_tree_classifier = DecisionTreeClassifier(random_state=42)

# 定义要调优的超参数组合
param_grid = {
    'max_depth': [3, 5, 7, 9],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

# 定义StratifiedKFold交叉验证对象
cv = StratifiedKFold(n_splits=5, random_state=42, shuffle=True)

# 存储每次交叉验证的准确度
cross_val_scores = []
best_accuracy_DT = 0

# 手动进行交叉验证并打印进度
for i, (train_index, test_index) in enumerate(cv.split(X_train, y_train), 1):
    print(f"Processing Fold {i}...")

    X_train_fold, X_test_fold = X_train[train_index], X_train[test_index]
    y_train_fold, y_test_fold = y_train[train_index], y_train[test_index]

    # 使用网格搜索进行参数组合的交叉验证
    grid_search = GridSearchCV(estimator=decision_tree_classifier, param_grid=param_grid, cv=5)
    grid_search.fit(X_train_fold, y_train_fold)

    # 使用最优参数的模型进行预测
    best_decision_tree_classifier = grid_search.best_estimator_
    y_pred = best_decision_tree_classifier.predict(X_test_fold)

    # 计算每次交叉验证的准确度并存储
    accuracy = accuracy_score(y_test_fold, y_pred)
    cross_val_scores.append(accuracy)

    # 输出每次交叉验证的准确度
    print(f"Accuracy for Fold {i}: {accuracy:.2f}")
    print("-----------------------")
    if (accuracy > best_accuracy_DT):
        best_accuracy = accuracy

# 绘制交叉验证准确度折线图
plt.figure(figsize=(8, 6))
plt.plot(range(1, 6), cross_val_scores, marker='o', linestyle='-', color='b')
plt.xlabel('Fold')
plt.ylabel('Accuracy')
plt.title('Cross Validation Accuracy')
plt.xticks(np.arange(1, 6, 1))
plt.show()
plt.savefig('data/demo2/DT_accuracy_plot.png')
print("最优的决策树模型在测试集上的准确率: {:.2f}%".format(best_accuracy * 100))

# Todo: 朴素贝叶斯 模型 ------------------------------------------------------------------------------------
print('Todo: 朴素贝叶斯 模型 ------------------------------------------------------------------------------------')

from sklearn.naive_bayes import GaussianNB

# 定义朴素贝叶斯分类器
naive_bayes_classifier = GaussianNB()
# 定义要调优的超参数
param_grid_nb = {'var_smoothing': np.logspace(0, -9, num=100)}

# 使用GridSearchCV进行参数调优
grid_search_nb = GridSearchCV(estimator=naive_bayes_classifier, param_grid=param_grid_nb, cv=5)
grid_search_nb.fit(X_train, y_train)
# 获取最优参数的朴素贝叶斯模型
best_naive_bayes_classifier = grid_search_nb.best_estimator_
# 在测试集上进行预测
y_pred_nb = best_naive_bayes_classifier.predict(X_test)

# 计算准确度
accuracy_nb = accuracy_score(y_test, y_pred_nb)
# 输出朴素贝叶斯模型的准确度
print("朴素贝叶斯模型在测试集上的准确率: {:.2f}%".format(accuracy_nb * 100))

# 获取最优超参数
best_var_smoothing = grid_search_nb.best_params_['var_smoothing']
# 输出最优超参数
print("最优的超参数 var_smoothing: {:.2e}".format(best_var_smoothing))

# Todo: SVM 模型 ------------------------------------------------------------------------------------
print('Todo: SVM 模型 ------------------------------------------------------------------------------------')

from sklearn.svm import SVC

# 定义SVM分类器
svm_classifier = SVC()

# 定义要调优的超参数
param_grid_svm = {
    'C': [0.1, 1, 10],
    'gamma': [0.01, 0.1, 1],
    'kernel': ['linear', 'rbf']
}

# 使用GridSearchCV进行参数调优
grid_search_svm = GridSearchCV(estimator=svm_classifier, param_grid=param_grid_svm, cv=5)
grid_search_svm.fit(X_train, y_train)

# 获取最优参数的SVM模型
best_svm_classifier = grid_search_svm.best_estimator_

# 在测试集上进行预测
y_pred_svm = best_svm_classifier.predict(X_test)

# 计算准确度
accuracy_svm = accuracy_score(y_test, y_pred_svm)

# 输出SVM模型的准确度
print("SVM模型在测试集上的准确率: {:.2f}%".format(accuracy_svm * 100))

# 获取最优超参数
best_C = grid_search_svm.best_params_['C']
best_gamma = grid_search_svm.best_params_['gamma']
best_kernel = grid_search_svm.best_params_['kernel']

# 输出最优超参数
print("最优的超参数 C: {}, gamma: {}, kernel: {}".format(best_C, best_gamma, best_kernel))

# Todo: 四种模型准确率对比 ------------------------------------------------------------------------------------
print('Todo: 四种模型准确率对比 ------------------------------------------------------------------------------------')

# 可视化四种模型的准确率
models = ['KNN', 'Decision Tree', 'Naive Bayes', 'SVM']
accuracies = [best_accuracy * 100, best_accuracy_DT * 100, accuracy_nb * 100, accuracy_svm * 100]

plt.figure(figsize=(8, 6))
plt.bar(models, accuracies, align='center', alpha=0.7)
plt.xlabel('Models')
plt.ylabel('Accuracy')
plt.title('Model Accuracy Comparison')
plt.ylim(min(accuracies) - 2, max(accuracies) + 2)
plt.show()
plt.savefig('data/demo2/accuracy_db.png')

autoDL运行

• 按照“资料”租用并搭建autoDL项目
• 安装sklearn库pip install scikit-learn
• 新建jupyter文件项目
• 运行代码

KNN准确率：

决策树准确率：

SVM没跑出来…(5小时）

事实上，Scikit-Learn的SVM实现并不直接支持GPU加速，所以在CPU上进行训练是唯一的选择。
其中KNN和决策树可以使用cpu，其gpu加速效果不强，其他模型建议使用gpu加速文章来源地址https://www.toymoban.com/news/detail-725838.html

到了这里，关于【手写数字识别】数据挖掘实验二的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！