MNIST 手写数字识别 matlab
手写数字识别代码解释
一. 进行数据预处理1导入相关库from keras.datasets import mnist 从keras的datasets中导入mnist数据集from keras.utils import np_utils 从keras导入将整型标签转换方法utilsimport numpy as np 导入Python扩充程序库numPy，作为np调用。
numPy支持大量的维度数组与矩阵运算，也针对数组运算提供大量的数学函数库。
np.random.seed(10)设置随机数种子为10 。
将随机数发生器初始化为恒定值，以获得可重复结果。
2.读取MNIST数据(X_train, y_train), (X_test, y_test) = mnist.load_data()返回手写图片的两个tuple，第一个tuple存储已经人工分类好的图片及标签，标签指出该图片表示的数字（0—9），供训练使用；第二个tuple存储未分类的图片，在用第一个tuple 训练完后，可以对第二个tuple利用神经网络进行分类，根据实验结果的真实值与预测值对比得到相应的损失值，再利用反向传播进行参数更新，再进行分类，然后重复前述步骤直至损失值最小。
元组不能修改reshape to be [samples][pixels][width][height]X_train = X_train.reshape(X_train.shape[0], 28, 28, 1).astype('float32')X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype('float32')将fetures（数字图像特征值）转换（reshape）为6000 x 28 x 28 x 1的四维矩阵CNN的输入是4维的张量（可看做多维向量），第一维是样本规模（图像数量），第四维是像素通道（这里为1通道，单色），第二维和第三维是长度和宽度。
matlab deep network designer例子
Matlab的Deep Network Designer是一个用于创建和训练深度学习网络的工具。
以下是一个简单的例子，展示了如何使用Deep Network Designer来识别手写数字。
首先，打开Matlab并输入“deepNetworkDesigner”命令，或者通过点击图标的形式进入。
然后，创建一个新的深度学习网络项目。
在创建过程中，可以选择预设的神经网络模板，也可以从头开始构建自己的神经网络。
在本例中，我们选择从头开始构建神经网络。
接下来，需要定义输入和输出。
在本例中，输入是手写数字的图像，输出是对应的数字标签。
因此，需要将图像数据和标签加载到Matlab中，并设置图像数据为输入数据，标签为输出数据。
然后，需要配置神经网络的层数、每层的神经元数量、激活函数等参数。
在本例中，我们选择一个简单的三层神经网络，其中第一层有64个神经元，第二层有32个神经元，第三层是输出层，有10个神经元（对应0~9的数字）。
激活函数选择ReLU函数。
接下来，使用训练数据对神经网络进行训练。
在本例中，我们使用MNIST数据集进行训练。
训练过程中，可以选择不同的优化器和损
失函数。
在本例中，我们选择Adam优化器和交叉熵损失函数。
最后，使用测试数据对神经网络的性能进行评估。
在本例中，我们使用测试集对神经网络进行评估，并计算准确率和损失值。
以上是一个简单的例子，展示了如何使用Matlab的Deep Network Designer来识别手写数字。
当然，在实际应用中，还需要考虑更多的因素，如数据预处理、超参数调优等。
基于MATLAB的手写体数字识别算法的实现与分析毕业论文
基于MATLAB的手写体数字识别算法的实现与分析摘要手写体数字识别是利用计算机自动辨认手写体阿拉伯数字的一种技术，是光学字符识别技术的一个分支。
手写体数字识别在邮政编码、财务报表、银行票据、各种凭证以及调查表格的识别等等方面有着重要应用，由于数字识别经常涉及财会、金融领域，其严格性更是不言而喻的。
所以，对识别系统的可靠性和识别率要求很高，构成了手写体数字识别面临的主要困难，大批量数据处理对系统速度又有相当高的要求。
本文基于MNIST数据集，通过Matlab平台，对决策树算法、SVM算法和人工神经网络（ANN）算法进行实现，并对分类算法的准确率进行评估。
实验结果表明，人工神经网络（ANN）的准确率最高，为99.69%，SVM算法次之，准确率为94.53%，决策树算法的准确率为83.53%。
三种分类算法中，决策树算法的速度最快，SVM算法的速度最慢。
另外，针对每一种分类算法在MNIST数据集上的实验结果，本文还得出以下结论：第一，MNIST数据集的归一化与否对决策树的分类效果几乎没有影响；对SVM的分类效果影响较大，未归一化时的准确率为11.35%，归一化之后的准确率为94.53%；对人工神经网络的分类效果影响较小，未归一化时的准确率为82.11%，归一化之后的准确率为99.69%。
这说明三种分类算法对数据的不平衡分布的敏感程度各不相同。
第二，对于SVM分类算法，当训练数据集的样本容量小于60000（MNIST训练数据集的最大样本容量）时，该算法对测试数据集分类预测的准确率随样本容量的增大而增大。
第三，针对人工神经网络，数据类标签的表示形式对分类预测的准确率的影响较大。
使用10位数据表示类标签是的准确率为99.69%，远远高于使用1位数据表示类标签时的准确率60.24%。
关键词：手写体数字识别；决策树算法；SVM算法；人工神经网络算法ABSTRACTHandwritten numeral recognition is a technique that uses computer to recognize handwritten Arabic numerals automatically and is a branch of optical character recognition technology. Handwritten numeral recognition has important applications in postal codes, financial statements, bank notes, various kinds of vouchers and the identification of survey forms. Since digital identification often involves accounting and finance, its strictness is self-evident. The demand for identification system of the reliability and recognition rate is very high, constituting a handwritten digital identification facing major difficulties, high-volume data processing on the system speed and a very high demand.In this paper, we use Matlab to implement decision tree algorithm, SVM algorithm and artificial neural network (ANN) algorithm based on MNIST dataset, and the accuracy of classification algorithms is calculated by using the real data tag. Experimental results show that the artificial neural network (ANN) the highest accuracy rate for 99.69%, SVM algorithm, followed by 94.53 percent accuracy rate, decision tree algorithm accuracy is 83.53%. In terms of speed, decision tree algorithm is the fastest, SVM algorithm is the slowest. In addition, for each classification algorithm we also concluded that:Firstly, whether or not the MNIST dataset is normalized has no effect in the classification tree; While it has a great impact on SVM classification. When it is not normalized the accuracy is 11.35%, and after normalized the accuracy is 94.53% ; The artificial neural network classification is less affected, and when it is not normalized the accuracy is 82.11% while after normalized the accuracy is 99.69%. This shows the sensitivity of the three classification algorithms to unbalanced distribution of data.Secondly, for the SVM classification algorithm, when the sample size is less than 60,000(maximum size of MNIST test data set), the accuracy increases with the increasing of sample size.Thirdly, for the artificial neural network, the impact of class label representation is large on the classification accuracy. When using 10 bits to represent class labels, the accuracy is 99.69%, far higher than the accuracy of 60.24% when using 1 bit to represent data labels.KEY WORDS: Handwritten numeral recognition; Decision tree algorithm; SVM algorithm; Artificial neural network algorithm目录ABSTRACT (II)1. 引言 (1)1.1 手写数字识别 (1)2. 分类算法 (1)2.1 决策树算法 (2)2.1.1 ID3算法 (2)2.1.2 C4.5算法 (3)2.1.3 CART算法 (3)2.1.4 SLIQ算法 (3)2.1.5 SPRINT算法 (3)2.1.6 经典决策树算法的比较 (4)2.2 支持向量机 (4)2.3 人工神经网络 (6)2.3.1人工神经网络的原理 (6)2.3.2反向传播网络（BP） (6)2.3.3 Hopfield网络 (8)3 实验过程与结果分析 (10)3.1 实验环境 (10)3.2实验数据集 (10)3.3数据预处理 (10)3.4决策树分类实验 (11)3.4.1实验过程 (11)3.4.2实验结果 (12)3.5 SVM分类实验 (13)3.5.1实验过程 (13)3.5.2实验结果 (14)3.6人工神经网络分类实验 (14)3.6.1实验过程 (14)3.6.2实验结果 (15)4 结论 (19)4.1 三种分类算法的比较 (19)4.2 决策树算法的分析 (19)4.3 SVM算法分析 (19)4.4 神经网络算法分析 (20)参考文献 (21)1.引言1.1手写数字识别手写数字识别是模式识别领域的一个重要分支，它研究的核心问题是：如何利用计算机自动识别人手写在纸张上的阿拉伯数字。
minist手写数字识别sklearn案例
minist手写数字识别sklearn案例在sklearn中，使用手写数字识别通常使用MNIST数据集。
下面是一个简单的例子：首先，你需要安装必要的库。
如果你还没有安装，可以使用以下命令进行安装：```pythonpip install numpy pandas sklearn matplotlib```然后，你可以使用以下代码进行手写数字识别：```pythonfrom sklearn import datasetsfrom _selection import train_test_splitfrom import StandardScalerfrom import KNeighborsClassifierfrom import classification_report, confusion_matriximport as pltimport numpy as npimport pandas as pd加载MNIST数据集digits = _digits()获取数据和标签data =target =划分训练集和测试集X_train, X_test, y_train, y_test = train_test_split(data, target, test_size=, random_state=42)数据标准化处理scaler = StandardScaler()X_train = _transform(X_train)X_test = (X_test)使用K近邻算法进行分类knn = KNeighborsClassifier(n_neighbors=3)(X_train, y_train)y_pred = (X_test)输出分类结果和性能指标print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))print("\nClassification Report:\n", classification_report(y_test, y_pred)) ```这个例子使用了K近邻算法进行手写数字识别。
matlab mnist训练实例
matlab mnist训练实例什么是MNIST数据集？MNIST数据集是机器学习领域中最常用的数据集之一。
它包含了一系列由手写数字图像组成的训练样本和测试样本。
每个图像都是28x28像素的灰度图像，经过预处理并转换为数字矩阵，具有相应的标签来表示图像中的实际数字。
MNIST数据集是一个用于图像分类任务的经典数据集，特别适用于训练用于手写体数字识别的模型。
准备工作在使用MNIST数据集进行训练之前，我们需要准备一些环境和工具。
首先，我们需要下载并导入MNIST数据集。
在MATLAB中，可以使用以下命令来下载并导入MNIST数据集：matlab[XTrain, YTrain, XTest, YTest] = digitTrain4DArrayData;这个命令会自动将MNIST数据集下载并加载到MATLAB的工作环境中。
其中，XTrain和XTest是训练数据和测试数据的图像矩阵，YTrain和YTest 是对应的标签。
另外，为了训练分类模型，我们还需要选择合适的分类算法。
在这个例子中，我们将使用卷积神经网络（Convolutional Neural Network，CNN）来进行训练。
MATLAB提供了一个方便的工具箱，即“Deep Learning Toolbox”，可以帮助我们构建和训练CNN模型。
构建CNN模型接下来，我们开始构建CNN模型。
在MATLAB的“Deep Learning Toolbox”中，可以使用以下命令创建一个简单的CNN模型：matlablayers = [imageInputLayer([28 28 1])convolution2dLayer(5, 20)reluLayer()maxPooling2dLayer(2, 'Stride', 2)fullyConnectedLayer(10)softmaxLayer()classificationLayer()];这个CNN模型包含了一系列的层，从输入层到输出层，依次是图像输入层、卷积层、ReLU层、池化层、全连接层、softmax层和分类层。
如何使用MATLAB进行模式识别与检测
如何使用MATLAB进行模式识别与检测MATLAB是一款强大的计算工具，它在模式识别与检测领域拥有广泛的应用。
本文将介绍如何使用MATLAB进行模式识别与检测的基本方法和技巧。
一、引言模式识别与检测是一门研究如何通过计算机识别和解释具有特定模式的数据的学科。
在实际应用中，我们常常需要通过对数据进行分析和处理，来发现其中的规律和模式，以实现自动识别和检测。
二、数据预处理数据预处理是模式识别与检测的第一步，它包括数据标准化、降维和特征提取等操作。
在MATLAB中，可以使用一系列函数和工具箱来实现这些操作。
1. 数据标准化数据标准化可以使得数据的均值为零，方差为一，从而使得不同特征具有相同的标度。
在MATLAB中，可以使用`zscore`函数来实现数据的标准化。
2. 降维降维是指将高维数据映射到低维空间，以减少数据的复杂性和提高计算效率。
常用的降维方法有主成分分析（PCA）和线性判别分析（LDA）。
在MATLAB中，可以使用`pca`和`lda`函数来进行降维操作。
3. 特征提取特征提取是从原始数据中提取出能够代表数据特点的特征。
常用的特征提取方法有傅里叶变换、小波变换和小波包变换等。
在MATLAB中，可以使用相应的函数和工具箱来实现特征提取。
三、模型建立与训练在进行模式识别与检测任务时，我们需要建立一个合适的模型并对其进行训练。
在MATLAB中，有多种模型可以选择，例如支持向量机（SVM），神经网络和决策树等。
1. 支持向量机（SVM）SVM是一种常用的模式识别与检测方法，它可以在高维空间中构造一个超平面，用于分类和回归。
在MATLAB中，可以使用`fitcsvm`函数来建立SVM模型，并使用`train`函数对模型进行训练。
2. 神经网络神经网络是一种模拟人脑神经元间连接方式的计算模型。
在MATLAB中，可以使用`patternnet`函数建立一个多层感知机（MLP）神经网络，并使用`train`函数对网络进行训练。
MNIST手写数字识别的深度学习算法研究
MNIST手写数字识别的深度学习算法研究深度学习是机器学习的一种分支，近年来在图像、语音、自然语言和视频等领域中表现优秀，引起了广泛的关注。
MNIST是一个十分常见的手写数字识别数据集，被广泛应用于深度学习算法研究。
本文旨在研究MNIST手写数字识别中的深度学习算法，探究如何通过深度学习算法提高手写数字识别的准确率。
一、MNIST手写数字识别介绍MNIST是一个包含70000张28x28像素大小的手写数字图片数据集，其中训练集为60000张，测试集为10000张。
每张图像都有相应的数字标签，标签取值范围为0-9。
MNIST手写数字识别是机器学习领域中一个经典的问题，深度学习在该问题的解决上表现优越。
二、深度学习算法介绍1.卷积神经网络（CNN）卷积神经网络是一种深度神经网络，主要应用于视觉识别的领域。
CNN模型通常包含输入层、卷积层、池化层和全连接层。
卷积层可以提取图像的特征，池化层可以缩小特征图的大小，全连接层可以输出分类结果。
2.循环神经网络（RNN）循环神经网络是一种可以处理序列数据的模型，主要应用于语音识别、自然语言处理等领域。
RNN模型通常包含输入层、隐藏层和输出层。
隐藏层可以保留之前输入的信息，帮助模型处理序列数据。
三、N模型利用卷积神经网络对MNIST手写数字数据集进行训练，可以得到较高的准确率。
此处使用了4个卷积层和2个全连接层组成的CNN模型，每个卷积层都包含卷积核和激活函数，每个全连接层都包含神经元和激活函数。
此外，还使用了dropout技术进行模型正则化，避免过拟合问题。
在训练过程中，使用交叉熵作为损失函数，采用梯度下降法进行参数优化。
训练集使用随机梯度下降方法训练，测试集用作验证集。
经过多次实验，探究最佳参数组合，实验结果表明，在卷积核大小为5x5，使用Relu激活函数，最大池化层大小为2x2的情况下，模型在测试集上的准确率可以达到99.2%。
2.RNN模型循环神经网络可以处理序列数据，因此可以用于处理MNIST手写数字数据集。
matlab基于mnist数据集的数字分类(一)
matlab基于mnist数据集的数字分类(一)MATLAB基于MNIST数据集的数字1. 简介在本文中，我将介绍MATLAB在基于MNIST数据集进行数字分类方面的应用。
MNIST数据集是一个包含手写数字图片的经典数据集，通常用于训练和评估数字图像分类算法。
2. 数据集加载首先，我们需要加载MNIST数据集。
MATLAB提供了一个方便的函数loadMNISTImages来加载图像数据，以及loadMNISTLabels来加载对应的标签。
3. 数据预处理在进行数字分类之前，我们需要对数据进行预处理。
常见的预处理步骤包括：数据标准化由于MNIST数据集中的像素值范围在0到255之间，我们可以将其标准化到0到1之间，便于模型更好地学习。
在构建分类模型之前，我们需要将数据集分割成训练集和测试集。
一般来说，我们可以将70%的数据用于训练，30%的数据用于测试。
4. 构建分类器K最近邻（K-Nearest Neighbors）K最近邻是一种简单而有效的分类算法，其原理是通过计算新样本与训练集中所有样本的距离，选取距离最近的K个邻居的标签来进行分类。
支持向量机（Support Vector Machines）支持向量机是一种强大的分类算法，其目标是找到一个最优的超平面来将不同类别的数据样本分隔开。
深度学习模型近年来，深度学习在图像分类任务上取得了巨大的成功。
MATLAB提供了一个强大的深度学习框架，可以用于构建和训练各种深度学习模型，如卷积神经网络（Convolutional Neural Network）。
5. 模型评估在对数字进行分类后，我们需要评估分类器的性能。
常见的评估指标包括准确率、精确率、召回率和F1分数等。
通过使用MATLAB和MNIST数据集，我们可以轻松地构建和训练数字分类模型。
从简单的K最近邻算法到复杂的深度学习模型，MATLAB 提供了丰富的工具和函数来支持数字图像分类任务。
使用这些方法，我们可以更好地理解和识别手写数字。
MATLAB手写识别课程设计
MATLAB手写识别课程设计一、课程目标知识目标：1. 掌握MATLAB编程基础，了解其在手写识别领域的应用；2. 学习并理解常见的手写识别算法原理，如神经网络、支持向量机等；3. 了解手写识别的数据预处理方法，如图像二值化、特征提取等。
技能目标：1. 能够运用MATLAB编写简单的手写识别程序，实现基本的手写数字识别；2. 学会使用MATLAB工具箱进行手写识别算法的仿真与优化；3. 能够对手写识别算法进行性能评估，分析识别效果。
情感态度价值观目标：1. 培养学生对人工智能领域的兴趣，激发探索精神；2. 培养学生的团队协作意识，学会与他人共同解决问题；3. 增强学生的实践能力，使其认识到理论知识在实际应用中的价值。
课程性质：本课程为实践性较强的课程，结合理论知识与实际操作，让学生在学习过程中充分了解手写识别技术的原理与应用。
学生特点：学生具备一定的编程基础，对MATLAB有所了解，对手写识别技术感兴趣。
教学要求：通过本课程的学习，使学生能够掌握手写识别的基本原理和方法，具备实际操作能力，为后续相关领域的研究或工作打下基础。
教学过程中，注重理论与实践相结合，以学生为主体，引导他们主动探究、解决问题。
最终通过课程目标的实现，提高学生的综合素质。
二、教学内容1. MATLAB编程基础：变量与数据类型、矩阵运算、流程控制、函数编写等；教材章节：第一章《MATLAB基础》2. 手写识别算法原理：a. 神经网络：多层感知器、反向传播算法；b. 支持向量机：最大间隔分类器、核函数；教材章节：第二章《手写识别算法》3. 数据预处理方法：a. 图像二值化：全局阈值法、局部阈值法；b. 特征提取：HOG特征、小波特征等；教材章节：第三章《图像预处理与特征提取》4. MATLAB手写识别程序编写：a. 数据集准备：手写数字数据集MNIST；b. 算法实现：基于神经网络的识别、基于支持向量机的识别；c. 性能评估：准确率、召回率、F1值等；教材章节：第四章《MATLAB手写识别编程实践》5. MATLAB工具箱应用：a. 神经网络工具箱：建立、训练和测试神经网络模型；b. 深度学习工具箱：搭建卷积神经网络进行手写识别；教材章节：第五章《MATLAB工具箱在手写识别中的应用》教学进度安排：共10课时，其中：1. MATLAB编程基础：2课时；2. 手写识别算法原理：3课时；3. 数据预处理方法：2课时；4. MATLAB手写识别程序编写：2课时；5. MATLAB工具箱应用：1课时。
matlab基于mnist数据集的数字分类
matlab基于mnist数据集的数字分类MNIST 是一个大型的手写数字数据库，通常用于训练各种图像处理系统。
以下是一个简单的MATLAB 代码示例，用于基于MNIST 数据集进行数字分类。
首先，确保你已经安装了MATLAB 的Deep Learning Toolbox。
1.加载数据：matlab% 加载 MNIST 数据集[XTrain, YTrain] = mnistDatastore();2.数据预处理：对于深度学习，通常需要将图像数据展平为一维向量。
此外，为了使模型更容易训练，我们通常还会增加一个偏置单元。
matlabXTrain = double(XTrain); % 转为双精度浮点数XTrain = permute(XTrain, [213]); % 将维度 [784, 28, 28] 变为 [28, 28, 784]XTrain = reshape(XTrain, [], 784); % 展平为 [28*28, 784]YTrain = double(YTrain); % 转为双精度浮点数3.定义模型：这里我们使用一个简单的全连接网络作为示例。
你可以根据需要调整网络结构。
matlablayers = [ ...imageInputLayer([28281]) % 输入层，图像大小为 28x28，灰度图，所以有1个通道convolution2dLayer(5,20) % 卷积层，5x5的卷积核，20个输出通道（或称为滤波器）batchNormalizationLayer % 批量标准化层reluLayer % ReLU 激活层maxPooling2dLayer(2,'Stride',2) % 最大池化层，步长为2fullyConnectedLayer(10) % 全连接层，10个输出节点（对应于0-9的数字）softmaxLayer % Softmax 层，用于多分类问题classificationLayer]; % 分类层4.训练模型：使用训练数据和上面的网络结构进行训练。
python手写数字识别（从导入数据到导出模型）总结
python⼿写数字识别（从导⼊数据到导出模型）总结python ⼿写数字识别（mnist库）import numpy as npimport pandas as pdimport tensorflow as tffrom tensorflow.keras import layersimport matplotlib.pyplot as plt'''1.打开数据集⽂件，并且读取mnist数据'''data = np.load('mnist.npy')print(data.files)x_train = data['x_train']y_train = data['y_train']x_test = data['x_test']y_test = data['y_test']print(x_train.shape)'''对数据进⾏预处理，将图像数据转成四维数据，第⼀维度为batch_size,第⼆三维度为图⽚⼤⼩，第四个维度表⽰通道数⽬，mnist数据集为单⾊灰度图像，所以值为1，如果是彩⾊则为3。
''''''2.数据预处理'''x_train4D = x_train.reshape(x_train.shape[0],28,28,1).astype('float32') #shape[0]表⽰有多少张图⽚，即batch_sizex_test4D = x_test.reshape(x_test.shape[0],28,28,1).astype('float32')#然后对x数据标准化处理，使取值范围在0，1之间; 对y数据进⾏One-Hot编码,将0~9映射成⼀组相同长度的01编码x_train4D = x_train4D/255x_test4D = x_test4D/255y_train01 = tf.keras.utils.to_categorical(y_train)y_test01 = tf.keras.utils.to_categorical(y_test)'''3.搭建模型'''model = tf.keras.models.Sequential() #选择keras模型库中的线性堆叠模型Sequential()model.add(layers.Conv2D(filters=16, kernel_size=(5,5), padding='same', input_shape=(28,28,1),activation='relu'))model.add(layers.MaxPooling2D(pool_size=(2,2))) #每⼀层卷积层后⾯⼀定要池化，不然起不到降维度的作⽤,⽆参数，这⼀步只是为了浓缩数据model.add(layers.Conv2D(filters=32, kernel_size=(5,5),padding='same', activation='relu'))#后⾯层其实可以根据前⾯层的输出得到input_shape,所以可以不写，但是每⼀个卷积层都必须写激活函数和padding,# 因为后⾯层需要知道输出数据的规模shape是多少model.add(layers.MaxPooling2D(pool_size=(2,2))) # 此时28x28的图⽚现在只有7x7model.add(layers.Dropout(0.3)) #使百分之30的神经元失活，避免过拟合model.add(layers.Flatten()) #转为⼀维向量输⼊model.add(layers.Dense(128,activation='relu'))#后⾯再加隐藏层，128代表这⼀层有128个神经元，input_shape依然不⽤填，Dense()全连接层，只适⽤于⼀维数据#所以前⾯需要加⼀个Flatten()层来讲7x7的⼆维数据转为⼀维数据输⼊model.add(layers.Dropout(0.5)) #卷积层和隐藏层都各需要⼀个dropout函数来防⽌过拟合。
分类-MNIST（手写数字识别）
分类-MNIST（⼿写数字识别）这是学习《Hands-On Machine Learning with Scikit-Learn and TensorFlow》的笔记，如果此笔记对该书有侵权内容，请联系我，将其删除。
这⾥⾯的内容⽬前条理还不是特别清析，后⾯有时间会更新整理⼀下。
下⾯的代码运⾏环境为jupyter + python3.6获取数据# from sklearn.datasets import fetch_mldata# from sklearn import datasets# mnist = fetch_mldata('MNIST original')# mnist好像下载不到它的数据，直接从⽹上找到它的数据，放到当⾯⽬录下的\datasets\mldata⽬录下。
MNIST data的百度⽹盘链接: 提取码: 9dq2，如果链接失效，可在下⾯评论区告知我，或者⾃⼰去⽹上找⼀样的，相信各位⼩伙伴的能⼒呀。
输⼊如下代码：from sklearn.datasets import fetch_mldatafrom sklearn import datasetsimport numpy as npmnist = fetch_mldata('mnist-original', data_home = './datasets/')mnist上⾯的代码中的data_home表⽰你的数据集的⽂件路径，写的是⼀个相对路径，如果你没有将你的数据集放在你当前代码的⽬录下，你可能需要使⽤绝对路径。
输出：{'DESCR': ' dataset: mnist-original','COL_NAMES': ['label', 'data'],'target': array([0., 0., 0., ..., 9., 9., 9.]),'data': array([[0, 0, 0, ..., 0, 0, 0],[0, 0, 0, ..., 0, 0, 0],[0, 0, 0, ..., 0, 0, 0],...,[0, 0, 0, ..., 0, 0, 0],[0, 0, 0, ..., 0, 0, 0],[0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}可以看出，我们成功读到了它的数据，⽹上有很多的说法是错误的，没有办法读成功，只有这个才是正解 。
Python实战之MNIST手写数字识别详解
Python实战之MNIST⼿写数字识别详解⽬录数据集介绍1.数据预处理2.⽹络搭建3.⽹络配置关于优化器关于损失函数关于指标4.⽹络训练与测试5.绘制loss和accuracy随着epochs的变化图6.完整代码数据集介绍MNIST数据集是机器学习领域中⾮常经典的⼀个数据集，由60000个训练样本和10000个测试样本组成，每个样本都是⼀张28 * 28像素的灰度⼿写数字图⽚，且内置于keras。
本⽂采⽤Tensorflow下Keras（）神经⽹络API进⾏⽹络搭建。
开始之前，先回忆下机器学习的通⽤⼯作流程（ √表⽰本⽂⽤到，×表⽰本⽂没有⽤到 )1.定义问题，收集数据集（√）2.选择衡量成功的指标（√）3.确定评估的⽅法（√）4.准备数据（√）5.开发⽐基准更好的模型（×）6.扩⼤模型规模（×）7.模型正则化与调节参数（×）关于最后⼀层激活函数与损失函数的选择下⾯开始正⽂～1.数据预处理⾸先导⼊数据，要使⽤mnist.load()函数我们来看看它的源码声明：12 3 4 5 6 7 8 9 10 11 12 13 14 15def load_data(path='mnist.npz'):"""Loads the [MNIST dataset](/exdb/mnist/).This is a dataset of 60,000 28x28 grayscale images of the 10 digits, along with a test set of 10,000 images.More info can be found at the[MNIST homepage](/exdb/mnist/).Arguments:path: path where to cache the dataset locally(relative to `~/.keras/datasets`).Returns:Tuple of Numpy arrays: `(x_train, y_train), (x_test, y_test)`.**x_train, x_test**: uint8 arrays of grayscale image data with shapes1617181920(num_samples, 28, 28).**y_train, y_test**: uint8 arrays of digit labels (integers in range 0-9)with shapes (num_samples,). """可以看到，⾥⾯包含了数据集的下载链接，以及数据集规模、尺⼨以及数据类型的声明，且函数返回的是四个numpy array 组成的两个元组。
使用PCA+KNN对MNIST数据集进行手写数字识别
使⽤PCA+KNN对MNIST数据集进⾏⼿写数字识别⾸先引⼊需要的包%matplotlib inlineimport numpy as npimport scipy as spimport pandas as pdimport matplotlib.pyplot as pltimport sysimport ospath = os.path.abspath('..')if not path in sys.path:sys.path.append(path)载⼊数据集，使数据中⼼化（减去平均值）from dataset.cleardata import mnisttrain_img, train_lbl = mnist(dataset='training')test_img, test_lbl = mnist(dataset='testing')先看⼀下前16张训练机和数据集都长什么样，使⽤plt画出图像plt.figure(figsize=(8,7),dpi=198)for i in range(16):plt.subplot(4, 4, i + 1)plt.imshow(train_img[i])plt.figure(figsize=(8,7),dpi=198)for i in range(16):plt.subplot(4, 4, i + 1)plt.imshow(test_img[i])求出平均脸，简单计算，其实就是把每个像素求出平均值, 画出来看看，就长这样#mean facemean_num = train_img.mean(0)plt.imshow(mean_num)train_img = train_img - mean_numtest_img = test_img - mean_num所有图⽚都减去平均脸plt.figure(figsize=(8,7),dpi=198)for i in range(16):plt.subplot(4, 4, i + 1)plt.imshow(train_img[i])plt.figure(figsize=(8,7),dpi=198)for i in range(16):plt.subplot(4, 4, i + 1)plt.imshow(test_img[i])把所有像素摊平（都变成以为向量）train_plain = np.array([train_img[i].reshape(28 * 28, ) for i in xrange(train_img.shape[0])])test_plain = np.array([test_img[i].reshape(28 * 28, ) for i in xrange(test_img.shape[0])])执⾏PCA处理数据这⼀步发现python报了⼀个异常，可以看到python跑出⼀个错误ComplexWarning: Casting complex values to real discards the imaginary part，原因是pca求出来的特征向量有复数，这时候我舍弃了复数from pre_process.pca import pcadata, ft = pca(plain, 40)data = data.astype(float) # training data after pac mapping to 40 dimensionft = ft.astype(float)g:\Anaconda2\lib\site-packages\ipykernel\__main__.py:4: ComplexWarning: Casting complex values to real discards the imaginary part g:\Anaconda2\lib\site-packages\ipykernel\__main__.py:5: ComplexWarning: Casting complex values to real discards the imaginary part 画出前16特征脸这些特征脸按照投影⽅差⼤⼩排列，第⼀个⽅差最⼤，效果应该会最好的plt.figure(figsize=(8,7),dpi=198)for i in range(16):plt.subplot(4, 4, i + 1)plt.imshow(ft.T[i].reshape(28, 28))把测试数据使⽤40维的特征向量投影的40维平⾯train_maped = np.dot(train_plain, ft)test_maped = np.dot(test_plain, ft)使⽤KNN算法，对测试数据进⾏⽐较这⾥由于算法没有优化，复杂度⽐较⾼，所以只取了前1000的测试数据，有待优化输出了预测label，计算准确率from algorithm import distance as distout_lbl = []for i in xrange(1000):res = np.array([dist.euclidean(train_maped[m], maped[i]) for m in xrange(test_img.shape[0])])out_lbl.append(train_lbl[res.argsort()[0]])out_lbl[array([7], dtype=int8),array([2], dtype=int8),array([1], dtype=int8),array([0], dtype=int8),array([4], dtype=int8),array([1], dtype=int8),array([9], dtype=int8),array([9], dtype=int8),array([5], dtype=int8),array([9], dtype=int8),array([0], dtype=int8),array([6], dtype=int8),array([9], dtype=int8),array([0], dtype=int8),array([1], dtype=int8),array([5], dtype=int8),array([9], dtype=int8),array([7], dtype=int8),array([3], dtype=int8),array([4], dtype=int8),array([9], dtype=int8),array([6], dtype=int8),array([6], dtype=int8),array([5], dtype=int8),array([4], dtype=int8),array([0], dtype=int8),array([7], dtype=int8),array([4], dtype=int8),array([0], dtype=int8),array([1], dtype=int8),array([3], dtype=int8),array([1], dtype=int8),array([3], dtype=int8),array([0], dtype=int8),array([7], dtype=int8),array([2], dtype=int8),array([7], dtype=int8),array([1], dtype=int8),array([2], dtype=int8),array([1], dtype=int8),array([1], dtype=int8),array([4], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([5], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([9], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([7], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([2], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([6], dtype=int8), array([9], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([4], dtype=int8), array([8], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([4], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([7], dtype=int8),array([7], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([1], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([9], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([4], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([2], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([0], dtype=int8), array([8], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([0], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([9], dtype=int8), array([0], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([3], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([5], dtype=int8), array([2], dtype=int8),array([6], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([7], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([5], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([8], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([5], dtype=int8), array([8], dtype=int8), array([8], dtype=int8), array([7], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([5], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([5], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([5], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([9], dtype=int8),array([7], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([0], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([5], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([2], dtype=int8), array([0], dtype=int8), array([8], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([9], dtype=int8),array([1], dtype=int8), array([6], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([5], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([5], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([0], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([4], dtype=int8), array([5], dtype=int8), array([9], dtype=int8), array([8], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([5], dtype=int8),array([5], dtype=int8), array([8], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([0], dtype=int8), array([8], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([5], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([0], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([5], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([8], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([8], dtype=int8), array([8], dtype=int8), array([4], dtype=int8),array([8], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([9], dtype=int8), array([0], dtype=int8), array([9], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([5], dtype=int8), array([9], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([8], dtype=int8), array([6], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([8], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([9], dtype=int8),array([3], dtype=int8), array([5], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([0], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([0], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([0], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([8], dtype=int8), array([6], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([3], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([6], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([4], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([0], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([4], dtype=int8), array([8], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([4], dtype=int8),array([0], dtype=int8), array([4], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([7], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([9], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([6], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([0], dtype=int8), array([6], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([5], dtype=int8), array([4], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([9], dtype=int8), array([8], dtype=int8), array([4], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([5], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([9], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([3], dtype=int8), array([6], dtype=int8), array([8], dtype=int8), array([9], dtype=int8), array([4], dtype=int8), array([1], dtype=int8), array([5], dtype=int8), array([3], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([2], dtype=int8),array([8], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([3], dtype=int8), array([5], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([7], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([4], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([8], dtype=int8), array([0], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([3], dtype=int8), array([1], dtype=int8), array([0], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([2], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([6], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([3], dtype=int8), array([5], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([8], dtype=int8), array([2], dtype=int8), array([9], dtype=int8), array([2], dtype=int8), array([8], dtype=int8), array([6], dtype=int8), array([8], dtype=int8), array([8], dtype=int8), array([7], dtype=int8),array([1], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([9], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([0], dtype=int8), array([5], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([6], dtype=int8), array([0], dtype=int8), array([2], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([8], dtype=int8), array([8], dtype=int8), array([4], dtype=int8), array([7], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([1], dtype=int8), array([2], dtype=int8), array([2], dtype=int8), array([3], dtype=int8), array([7], dtype=int8), array([3], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([4], dtype=int8), array([0], dtype=int8), array([3], dtype=int8), array([5], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([6], dtype=int8), array([5], dtype=int8), array([2], dtype=int8), array([6], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([2], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([1], dtype=int8), array([1], dtype=int8), array([7], dtype=int8), array([7], dtype=int8), array([6], dtype=int8), array([4], dtype=int8), array([9], dtype=int8), array([5], dtype=int8), array([6], dtype=int8), array([3], dtype=int8), array([3], dtype=int8), array([9], dtype=int8), array([7], dtype=int8), array([8], dtype=int8), array([9], dtype=int8), array([1], dtype=int8), array([1], dtype=int8),array([6], dtype=int8),array([2], dtype=int8),array([2], dtype=int8),array([8], dtype=int8),array([1], dtype=int8),array([5], dtype=int8),array([1], dtype=int8),array([2], dtype=int8),array([0], dtype=int8),array([8], dtype=int8),array([8], dtype=int8),array([1], dtype=int8),array([2], dtype=int8),array([6], dtype=int8),array([7], dtype=int8),array([1], dtype=int8),array([6], dtype=int8),array([2], dtype=int8),array([3], dtype=int8),array([9], dtype=int8),array([0], dtype=int8),array([1], dtype=int8),array([2], dtype=int8),array([2], dtype=int8),array([0], dtype=int8),array([8], dtype=int8),array([9], dtype=int8)]看⼀看错误率，还算⽐较⼩~ 到此结束但是只是作为测试使⽤，还有很多东西还需要很多改进np.sum(test_lbl[:1000] != out_lbl[:1000]) / 1000.00.059999999999999998。
三种方法实现MNIST手写数字识别
三种⽅法实现MNIST⼿写数字识别MNIST数据集下载：import tensorflow as tffrom tensorflow.examples.tutorials.mnist import input_datamnist = input_data.read_data_sets("MNIST_data/", one_hot=True) #one_hot 独热编码，也叫⼀位有效编码。
在任意时候只有⼀位为1，其他位都是0 1 使⽤逻辑回归：import tensorflow as tf# 导⼊数据集#from tensorflow.examples.tutorials.mnist import input_datamnist = input_data.read_data_sets("MNIST_data/", one_hot=True)# 变量batch_size = 50#训练的x(image),y(label)# x = tf.Variable()# y = tf.Variable()x = tf.placeholder(tf.float32, [None, 784])y = tf.placeholder(tf.float32, [None, 10])# 模型权重#[55000,784] * W = [55000,10]W = tf.Variable(tf.zeros([784, 10]))b = tf.Variable(tf.zeros([10]))# ⽤softmax构建逻辑回归模型pred = tf.nn.softmax(tf.matmul(x, W) + b)# 损失函数(交叉熵)cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), 1))# 低度下降optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(cost)# 初始化所有变量init = tf.global_variables_initializer()# 加载session图with tf.Session() as sess:sess.run(init)# 开始训练for epoch in range(25):avg_cost = 0.total_batch = int(mnist.train.num_examples/batch_size)for i in range(total_batch):batch_xs, batch_ys = mnist.train.next_batch(batch_size)sess.run(optimizer, {x: batch_xs,y: batch_ys})#计算损失平均值avg_cost += sess.run(cost,{x: batch_xs,y: batch_ys}) / total_batchif (epoch+1) % 5 == 0:print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))print("运⾏完成")# 测试求正确率correct = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))print("正确率:", accuracy.eval({x: mnist.test.images, y: bels}))结果：Extracting MNIST_data/train-images-idx3-ubyte.gzExtracting MNIST_data/train-labels-idx1-ubyte.gzExtracting MNIST_data/t10k-images-idx3-ubyte.gzExtracting MNIST_data/t10k-labels-idx1-ubyte.gzEpoch: 0005 cost= 0.394426425Epoch: 0010 cost= 0.344705163Epoch: 0015 cost= 0.323814137Epoch: 0020 cost= 0.311426675Epoch: 0025 cost= 0.302971779运⾏完成正确率: 0.91882 使⽤神经⽹络：import tensorflow as tfimport numpy as npfrom tensorflow.examples.tutorials.mnist import input_datadef init_weights(shape):return tf.Variable(tf.random_normal(shape, stddev=0.01))def model(X, w_h, w_o):h = tf.nn.sigmoid(tf.matmul(X, w_h)) # this is a basic mlp, think 2 stacked logistic regressionsreturn tf.matmul(h, w_o) # note that we dont take the softmax at the end because our cost fn does that for us mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)trX, trY, teX, teY = mnist.train.images, bels, mnist.test.images, belsX = tf.placeholder("float", [None, 784])Y = tf.placeholder("float", [None, 10])w_h = init_weights([784, 625]) # create symbolic variablesw_o = init_weights([625, 10])py_x = model(X, w_h, w_o)cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y)) # compute coststrain_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost) # construct an optimizerpredict_op = tf.argmax(py_x, 1)# Launch the graph in a sessionwith tf.Session() as sess:# you need to initialize all variablestf.global_variables_initializer().run()for i in range(100):for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+1, 128)):sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end]})print(i, np.mean(np.argmax(teY, axis=1) ==sess.run(predict_op, feed_dict={X: teX})))结果：0 0.68981 0.82442 0.86353 0.8814 0.88815 0.89316 0.89727 0.90058 0.90429 0.90623 使⽤卷积神经⽹络：import tensorflow as tfimport numpy as npfrom tensorflow.examples.tutorials.mnist import input_databatch_size = 128test_size = 256def init_weights(shape):return tf.Variable(tf.random_normal(shape, stddev=0.01))def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden):l1a = tf.nn.relu(tf.nn.conv2d(X, w, # l1a shape=(?, 28, 28, 32)strides=[1, 1, 1, 1], padding='SAME'))l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1], # l1 shape=(?, 14, 14, 32)strides=[1, 2, 2, 1], padding='SAME')l1 = tf.nn.dropout(l1, p_keep_conv)l2a = tf.nn.relu(tf.nn.conv2d(l1, w2, # l2a shape=(?, 14, 14, 64)strides=[1, 1, 1, 1], padding='SAME'))l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1], # l2 shape=(?, 7, 7, 64)strides=[1, 2, 2, 1], padding='SAME')l2 = tf.nn.dropout(l2, p_keep_conv)l3a = tf.nn.relu(tf.nn.conv2d(l2, w3, # l3a shape=(?, 7, 7, 128)strides=[1, 1, 1, 1], padding='SAME'))l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1], # l3 shape=(?, 4, 4, 128)strides=[1, 2, 2, 1], padding='SAME')l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]]) # reshape to (?, 2048)l3 = tf.nn.dropout(l3, p_keep_conv)l4 = tf.nn.relu(tf.matmul(l3, w4))l4 = tf.nn.dropout(l4, p_keep_hidden)pyx = tf.matmul(l4, w_o)return pyxmnist = input_data.read_data_sets("MNIST_data/", one_hot=True)trX, trY, teX, teY = mnist.train.images, bels, mnist.test.images, bels trX = trX.reshape(-1, 28, 28, 1) # 28x28x1 input imgteX = teX.reshape(-1, 28, 28, 1) # 28x28x1 input imgX = tf.placeholder("float", [None, 28, 28, 1])Y = tf.placeholder("float", [None, 10])w = init_weights([3, 3, 1, 32]) # 3x3x1 conv, 32 outputsw2 = init_weights([3, 3, 32, 64]) # 3x3x32 conv, 64 outputsw3 = init_weights([3, 3, 64, 128]) # 3x3x32 conv, 128 outputsw4 = init_weights([128 * 4 * 4, 625]) # FC 128 * 4 * 4 inputs, 625 outputsw_o = init_weights([625, 10]) # FC 625 inputs, 10 outputs (labels)p_keep_conv = tf.placeholder("float")p_keep_hidden = tf.placeholder("float")py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden)cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y)) train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)predict_op = tf.argmax(py_x, 1)# Launch the graph in a sessionwith tf.Session() as sess:# you need to initialize all variablestf.global_variables_initializer().run()for i in range(10):training_batch = zip(range(0, len(trX), batch_size),range(batch_size, len(trX)+1, batch_size))for start, end in training_batch:sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end],p_keep_conv: 0.8, p_keep_hidden: 0.5})test_indices = np.arange(len(teX)) # Get A Test Batchnp.random.shuffle(test_indices)test_indices = test_indices[0:test_size]print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==sess.run(predict_op, feed_dict={X: teX[test_indices],Y: teY[test_indices],p_keep_conv: 1.0,p_keep_hidden: 1.0})))结果：0 0.94531251 0.97656252 0.99218753 0.988281254 0.9843755 0.99218756 0.9843757 0.99218758 0.988281259 0.99609375。
详解PyTorch手写数字识别（MNIST数据集）
详解PyTorch⼿写数字识别（MNIST数据集）MNIST ⼿写数字识别是⼀个⽐较简单的⼊门项⽬，相当于深度学习中的 Hello World，可以让我们快速了解构建神经⽹络的⼤致过程。
虽然⽹上的案例⽐较多，但还是要⾃⼰实现⼀遍。
代码采⽤ PyTorch 1.0 编写并运⾏。
导⼊相关库import torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torchvision import datasets, transformsimport torchvisionfrom torch.autograd import Variablefrom torch.utils.data import DataLoaderimport cv2torchvision ⽤于下载并导⼊数据集cv2 ⽤于展⽰数据的图像获取训练集和测试集# 下载训练集train_dataset = datasets.MNIST(root='./num/',train=True,transform=transforms.ToTensor(),download=True)# 下载测试集test_dataset = datasets.MNIST(root='./num/',train=False,transform=transforms.ToTensor(),download=True)root ⽤于指定数据集在下载之后的存放路径transform ⽤于指定导⼊数据集需要对数据进⾏那种变化操作train是指定在数据集下载完成后需要载⼊的那部分数据，设置为 True 则说明载⼊的是该数据集的训练集部分，设置为 False 则说明载⼊的是该数据集的测试集部分download 为 True 表⽰数据集需要程序⾃动帮你下载这样设置并运⾏后，就会在指定路径中下载 MNIST 数据集，之后就可以使⽤了。
基于pytorch框架的手写数字识别（mnist数据集）
基于pytorch框架的⼿写数字识别（mnist数据集）⼿写数字识别前段时间开始学习pytorch，学习了⼀点pytorch的⼩语法，在⽹上找到了pytorch⼊门写CNN的代码，⾃⼰尝试读懂加上注释。
更多的了解⼀下pytorch，代码注释写的还算清楚，在阅读代码之前可以看⼀下我收获的知识都是在代码⾥遇到的不会的语句，我⾃⼰通过阅读别博客获取的知识，⼤多数都是torch在读取数据的操作。
先读⼀下这个有利于阅读代码。
收获的知识:1.torch.maual_seed()在神经⽹络中,好⽐BP神经⽹络⾥⾯所有的参数都是随机的，我们使⽤这样⽅式来⽣成随机数，这些随机数是固定的，可以复现的import torchtorch.manual_seed(1)print(torch.rand(2))连续执⾏两次：1.2.import torch#torch.manual_seed(1)print(torch.rand(2))1.2.2.train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)刚开始不知道什么意思后来看到是 torch.utils.data的简称在我了解到了 torch.utlis.data.DataLoader是pytorch读取数据的重要接⼝，pytorch模型的训练数据⼤多会⽤到这个接⼝来读取数据,该接⼝的源代码(也来⾃于我看的那篇博⽂)：torch.utils.data.DataLoader（dataset，#数据加载batch_size = 1，#批处理⼤⼩设置shuffle = False，#是否进项洗牌操作sampler = None，#指定数据加载中使⽤的索引/键的序列batch_sampler = None，#和sampler类似num_workers = 0，#是否进⾏多进程加载数据设置collat e_fn = None，#是否合并样本列表以形成⼀⼩批Tensorpin_memory = False，#如果True，数据加载器会在返回之前将Tensors复制到CUDA固定内存drop_last = False，#True如果数据集⼤⼩不能被批处理⼤⼩整除，则设置为删除最后⼀个不完整的批处理。
使用PyTorch实现MNIST手写体识别代码
使⽤PyTorch实现MNIST⼿写体识别代码实验环境win10 + anaconda + jupyter notebookPytorch1.1.0Python3.7gpu环境（可选）MNIST数据集介绍MNIST 包括6万张28x28的训练样本，1万张测试样本，可以说是CV⾥的“Hello Word”。
本⽂使⽤的CNN⽹络将MNIST数据的识别率提⾼到了99%。
下⾯我们就开始进⾏实战。
导⼊包import torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torchvision import datasets, transformstorch.__version__定义超参数BATCH_SIZE=512EPOCHS=20DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")数据集我们直接使⽤PyTorch中⾃带的dataset，并使⽤DataLoader对训练数据和测试数据分别进⾏读取。
如果下载过数据集这⾥download可选择Falsetrain_loader = torch.utils.data.DataLoader(datasets.MNIST('data', train=True, download=True,transform=pose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])),batch_size=BATCH_SIZE, shuffle=True)test_loader = torch.utils.data.DataLoader(datasets.MNIST('data', train=False, transform=pose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])),batch_size=BATCH_SIZE, shuffle=True)定义⽹络该⽹络包括两个卷积层和两个线性层，最后输出10个维度，即代表0-9⼗个数字。
手写文字识别报告
数据集制作预处理
数据集制作预处理
接着，我们编写了 MATLAB 代码，将数 据解析为图像和标签 ，并进行了预处理。 这包括读取字节数据 、转换为图像矩阵、 归一化等步骤，因为 matlab online一直 提示文件没有权限， 所以这里使用了临时 文件目录
8
数据集制作打包
数据集制作打包
网上在线的数据不能 直接导入到matlab online，因此选择第 一步的自行下载的方 式，因此也要进行手 动打包，这里打包为 "minist.mat"
10
搭建卷积神经网络(CNN)
搭建卷积神经网络(CNN)
我们选择了卷积神经 网络作为模型，用于 学习图像特征并进行 分类。通过 MATLAB 的神经网络工具箱， 我们搭建了一个包含 卷积层、批量归一化 层、激活函数、全连 接层和 Softmax 分 类层的网络结构
12
模型训练与评估
模型训练与评估
通过使用 MATLAB 环境，我们成功地搭建了一个卷积 神经网络(CNN)模型，通过对图像进行学习和训练， 实现了对手写数字的高效识别
数据准备
数据准备
首先，我们从 MNIST 官方网站下载了四个 数据集文件，其中包 括训练集图像、训练 集标签、测试集图像 和测试集标签。通过 以下 MATLAB 代码完 成了下载和解压
在搭建好网络后， 我们使用训练选项 (trainingOptions) 配置了模型的训练 参数，并在训练数 据上进行了训练
14
测试集预测与混淆矩阵
测试集预测与混淆矩阵
最后，我们使用训练好的模型对测试集进行了预测，并绘制了混淆矩阵，以评估模型的性 能
16
结果
结果
模型在 MNIST 测试 集上取得了良好的性 能，准确率为 97.78%。混淆矩阵的 可视化结果显示，模 型能够有效地对手写 数字进行分类
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
文结构如下：第二章介绍了实验目标和实验 原则和结构，第三章对手写数字特征进行了 全面总结，第四章应用单特征和多特征对 MNIST 数据库手写数字进行了识别，并引入 了一种新的特征提取方法改进了识别能力， 第五章对实验内容进行了总结和展望。
另外实验数据采用 NEC 研究中心的 MNIST 手 写 数 字 数 据 库， 许 多 实 验 研 究 基 于此库 [4] ，里面包含了 60000 个训练样本 和 10000 个测试样本，每个样本为 28 × 28 像 素的 bmp 图片。我们在文中默认有以下定 义： 识别率 错误识别数／样本 总数 ×100%
样本和 10000 个测试样本，每个特征提取都 对所有的训练样本进行了学习，提取出特征 值，每次识别测试都对所有的测试样本进行 了识别，与测试样本正确值比较（test.txt） ， 并把记录错误（log.txt）, 最后根据记录进行 比较。
4.2
单特征识别
图 6: 4×4 粗网格特征每个数字识别 该方法选取了 4×4=16 个特征值，经实 验 10000 个测试中正确识别了 6628 个，识别 率达 66.28%，具体每个数字识别如图 6 ，横 轴代表每个数字，纵轴红色代表每个数字测 试样本个数，蓝色代表失误识别个数（下文 均同此） 。 4×4 粗网格特征识别对每个数字 的识别率都不高，最好的数字 6 识别率也不 过 80% 左右，部分是因为选取的网格过大所 致。 4.2.2 7×7 粗网格特征识别
单特征识别是指仅采用第三章中一种特 征值的方法对手写数字进行识别。本实验中 采用了 4×4 粗网格和 7×7 粗网格特征，以 及一种新的特征对手写数字进行了识别，得 到了不同的效果。 4.2.1 4×4 粗网格特征识别
粗网格的特征提取过程主要是将处理后 的样本图像分划为不重叠的局部块，将每个 块中的黑色像素个数占全部像素的百分比 作为特征。本文实验中如图 3 将 28 × 28 样 本 数 字 手 写 图 像 横 向、纵 向 各 用 间 距 为 4 pixels 和 7 pixels 的水平线和竖直线将图像分 为 7 × 7 = 49 块和 4 × 4 = 16 块区域，统 计每块区域黑色像素所占比例作为特征值。 所取块越小，对数字分辨能力相对越强。考 虑一种极端情况：当块大小只有一个像素点， 判断标准即此像素点是否为黑色像素，特征 值只有 0 、 1 两个可能，这样相当于有一个 模块对测试数字进行匹配。
M ∑ N ∑ m=1 n=1
笔画密度特征是指不同数字在水平方向、 竖直方向以及其他角度方向上笔画密度特征。 如图 2 数字 1 在竖直方向上笔画密度大，而 在水平方向上笔画密度小，而数字 8 在倾斜 方向上笔画密度大。找到这样的特征我们可 以间隔一定行数对样本进行横向和纵向进行 扫描，记录下单行黑色像素点个数为特征值， 笔画密度特征对数字畸变和抗噪声能力一般。
MNIST 手写数字库识别实现
摘要
处理，单字的分割等等，必要时修补缺口。 特征提取阶段，细化过后的图像包括有很多 手写数字识别是模式识别的应用之一。 特征，这些特征将在第三章中有介绍，识别 文中介绍了手写数字的一些主要特征，并提 时不可能利用所有的特征，因此需要提取出 出了截断次数特征并利用截断次数特征进行 一些对所用方法有效的特征。在识别阶段， 了实验。并在 MNIST 库上通过单特征和多 利用上一步所抽取的特征对待识别的字符进 特征实验得出了选择好的特征以及控制特征 行识别处理。 在识别判决中的权重可以提高识别率的结论， 根据手写数字识别方法不同，可以分为 具体方法是加大识别能力强的特征的系数。 几类：模板匹配法、统计决策法、模糊判别 法 [5] 、句法结构法、逻辑推理法、神经网络 关键字：手写数字、特征提取、多特征、 法。神经网络法是研究的比较热门的方法， 识别 其基本原理就是利用神经网络的学习和记忆 功能，先让神经网络学习各个模式类别中的 大量学习样本，以记住各模式类别中的样本 1 引言 特征，然后在识别待识样本时，神经网络回 数字识别 (Digital Recognition) 是光学字 忆起之前记住的各模式类别的特征并将他们 符识别技术 (Optical Character Recognition , 逐个与样本特征相比较，从而确定样本所属 简称 OCR) 的一个分支，数字识别分为印刷 的模式类别。这种方法的优点是抗干扰能力 数字识别和手写数字识别，手写数字具有广 强，允许样本有较大的变化，但是它也依赖 泛的研究价值 [3] ，本文工作对象的就是手写 特征向量的选取。逻辑推理法基础是人工智 数字。手写数字识别难度主要在于：一、数 能；模糊判别的基础是模糊数学；句法结构 字相似性大，但字形相差不大；二、数字虽 是利用形式语言和自动机的基础，但对无规 只有十种，但笔划简单，同一个数字写法差 则单个手写数字无效；统计决策法发展较为 别巨大；三、手写数字存在大量断笔和毛刺， 成熟，其基础是概率论和数理统计；模板匹 配是通过对每个手写数字都给定了一个模板， 对识别造成影响。 手写数字识别过程主要分为预处理、特 通过比较样本和模板差别的方法。 征提取和识别三个阶段。预处理阶段，是对 采集到的图像进行识别前所必要的一些处理 工作，这主要包括: 对图像进行几何校正、去 噪、复原、二值化，对二值化图像进行滤波 本 文 对 MNIST 手 写 数 字 库 训 练 样 本 进行了多个特征值的提取，并根据特征值 对 10000 个测试样本进行了测试，同时利用 了单特征值和多特征值得到了不同结果。本
3.3
粗网格特征
粗网格特征是指不同数字在不同位置块 内的黑色像素点个数特征。它代表的是图像 的整体分布特征。虽然手写数字书写的风格 变化多、因人而异，但十个字符黑色像素分
∑M
nfm,n
∑N
n=1
m=1
fm,n
1 3 5 度
9 0 度
4 5 度 0 度
1 3 5 度
9 0 度
4 5 度 0 度
1 8 0 度
3.2
笔画密度特征 3.4 重心以及重心距特征
重心以及中心距特征是指不同数字重心 位置和四个象限中像素值偏离重心的整体特 ¯ 、Q ¯ 分别代表是重心的横 征，如下公式中 P 坐标和纵坐标， fm,n 代表坐标 (m, n) 像素的 值，需要注明的是该值应该是 255 减去像素 值，因为在 8bits 图像中 255 代表白色， 0 代 表黑色，如果拿像素值作为 fm,n 的值算出来 的是白色区域的重心，而不是黑色像素的重 心。 M ∑ N ∑ mfm,n ¯= P ∑M ∑N m=1 n=1 fm,n m=1 n=1 ¯= Q 3
m=(i−1) M n=(j −1) N 2 2
...
F (1, N ) . . . . F (M, N )
F (M, 0) . . .
4
4.1
实验应用
实验环境
3.7
空间域变换特征
空间域变换特征利用了数字信息主要集 中在变换空间域的低频。常见的空间域变换 4
实验所用编程语言为 MATLAB R2009b ， 低于此版本可能存在兼容性问题，数据集采 用 MNIST 手写数字库，共计 60000 个训练
1 8 0 度
4 5 度 1 3 5 度 9 0 度 1 3 5 度 9 0 度
4 5 度
图 4: 手写数字 1 和 2 首个黑点特征 对应的我们重心距 Zi,j 定义为： Zi,j =
2 ∑
iM
2 ∑
jN
图 5: 手写数字投影特征 (m − m ¯ )(n − n ¯)
有傅里叶变换和小波变换等，傅里叶变换是 那么当 i, j 分别为 1,1 、 1,2 、 2,1 、 2,2 时， 数字图像处理中广泛采用的二维正交变换， Zi,j 分别代表着四个象限到重心的重心距， 傅里叶变换后平均值即直流项正比于图像灰 这样就可以得到包括二维重心特征和四个一 度值平均值，低频分量则是图像内容边缘的 维重心距特征。 强度和方向，较好地保存了图像原始内容的 主要信息（这点小波变换可更直观的看出） ， 这种效果类似于对图像进行了数据压缩。对 3.5 首个黑点位置特征 于二维数字信号 {f (m, n)(m = 1, . . . , M, n = 首个黑点位置特征是指不同数字首个黑 1, . . . , N )}，其离散傅里叶变换定义为： 色像素出现的位置特征。可以如图 4 依次 M ∑ N ∑ 从 0 度、 45 度、 90 度、 135 度、 180 度、 nv mu 1 √ √ F (u, v ) = f (m, n)e−j 2π( M + N ) -135 度、 -90 度、 -45 度方向统计第一个黑 M N m=1 n=1 点出现的位置，得到 8 个二维特征。 如果手写数字图像稍大，可以进行多次变换， 得到合适个数的傅里叶系数作为特征值（如 3.6 投影特征 下选取 M × N 个傅里叶系数作为特征） ： 投影特征是指不同数字向四周和象限线 上投影长度特征。如图 5 所示，四周和象限 线将数字分为四部分，每部分内黑色像素分 别向四个方向投影，共计得到 12 个投影长度 特征。投影特征一定程度上反映字符内部结 构和笔划分布。 F (0, 0) . . F = .
x % y % 0 % z %
图 1: 不满足单个数字特征的例子
图 3: 手写数字 6 粗网格特征 布具有一定的整体特征。
水 平 宽 度
竖直高度
图 2: 手写数字笔画密度特征 助其他特征进行识别。 单个数字特征可以辨别出那些具有典型 数字特征的手写数字，但计算复杂并且在手 写数字识别中误差大，但是作为正式识别过 程前的预识别可减少运算量和时间。
2
实验原则和结构
实验目的在于设计并实现一种手写数字 算法，并通过单特征值识别组合为多特征识 别，以提高识别率，并在多特征值下得到最 优的线性组合。我们有以下原则：
3
手写数字特征
数字类别不但少，而且笔划简单，尤其 单特征识别和多特征识别结合：每个特 是手写数字个个差异大。数字识别的关键在 征都是针对可区分数字的一个属性，但单特 于能否找到有效的特征， [2] 就给出了数字 征识别的能力有限，实验通过结合多个单个 的多个特征，选取的特征应具有可分辨能力 特征进行多特征的识别提高了识别率，并得 并尽可能的少，分辨能力在应用中而言就是 到多特征线性最优组合。 特征能够使得不同类别的个体在特征值上相 特征对每个数字的识别能力：特征对每 差大，同类别特征值相差小。特征值小一方 个数字的识别能力不同，通过实验可以得到 面是为了减少计算量，另一方面也减少了信 每个特征对各个数字的识别率，从而为多特 息冗余。目前研究的手写数字特征主要有笔 征组合识别中提供参考，哪些特征识别的哪 画密度特征、粗网格特征、重心以及重心距 些数字更准确，在判定中应该具有较大比重， 特征、首个黑点位置特征、投影特征以及空 文章虽然没有实现特征权重的优化，却精确 间域变换特征等，除了以上特征，也不断的 给出了每个特征对每个数字的识别率。 有新的特征 [1] 被提出。 为达到以上原则，我们设计了 5 部分实 验，一是 4×4 粗网格单特征识别实验；二 3.1 单个数字特征 是 7×7 粗网格单特征识别实验；三是阶段次 数单特征识别实验；四是 7×7 粗网格和截断 单个数字特征是指特定数字普遍具有的 次数多特征识别实验；五是比较了单特征识 特征。例如如果数字竖直长度比上横向宽度 别和多特征识别中特征没有归一化的影响。 大于某个值比如 4 ，那么很有可能是数字 1 ， 每 个 实 验 都 包 括 了 训 练 （study.m） 和 识 别 测 试 （recognize.m） 两 个 部 分， 首 先 从 MNIST 训 练 集 中 训 练 得 到 特 征 值 （features.txt） ，然后通过所得特征值测试识 别 MNIST 测试集内容，记录总识别率和每 个数字的误识别个数。 2 如果数字内有两个封闭的区域则很可能是数 字 8 ，如果只有一个封闭的区域，且封闭区 域的重心偏上则很可能是数字 9 （同理可判 断数字 6 ） ，以上都是这些数字普遍具有的 特征，但因为数字手写的原因，也包含了大 量不规则的例子，如图 1 ，则需要进一步借