机器学习》16-实验二 手写体数字识别参考代码[3页]
手写数字识别实验项目
手写数字识别实验项目
手写数字识别实验项目是一个涉及机器学习和计算机视觉的有趣且实用的项目。
该项目的目标是训练一个模型来识别手写数字，使得计算机能够像人一样理解并识别这些数字。
在项目的开始阶段，我们首先需要收集大量的手写数字数据。
这通常可以通过扫描文档、使用在线数据集或从用户那里收集样本来实现。
一旦我们有了足够的数据，我们就可以开始预处理这些数据，包括图像清理、尺寸归一化和像素值标准化等步骤。
接下来，我们需要选择一个合适的机器学习模型来进行训练。
常用的模型包括支持向量机（SVM）、随机森林、神经网络等。
在这个项目中，我们通常会选择神经网络，特别是卷积神经网络（CNN），因为它们在图像识别任务中表现出色。
在训练模型的过程中，我们需要设置合适的超参数，如学习率、批量大小、迭代次数等，并使用交叉验证等技术来防止过拟合。
同时，我们还需要对模型进行调优，以提高其识别准确率和泛化能力。
一旦模型训练完成，我们就可以使用它来识别新的手写数字了。
用户可以通过扫描或拍照将手写数字输入到系统中，然后系统会使用训练好的模型对这些数字进行识别，并输出结果。
除了基本的数字识别功能外，我们还可以为这个项目添加一些额外的功能，如数字分类、数字排序等。
这些功能可以进一步扩展项目的应用场景，使其更加实用和有趣。
总的来说，手写数字识别实验项目是一个非常有意义的项目，它不仅可以帮助我们了解机器学习和计算机视觉的基本原理，还可以为我们提供实用的工具来解决现实生活中的问题。
手写数字识别代码解释
一. 进行数据预处理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通道，单色），第二维和第三维是长度和宽度。
手写数字识别代码
function feature = scFeature(im)%把三层的RGB图像转化成二层的灰度图if length(size(im)) == 3I = im(:,:,1);elseI = im;end[row, col] = size(I);bwI = im2bw(I); %样本图像二值化bwI = ~bwI;count = 1;%提取样本特征for i = 1: 5for j = 1:5imTemp = bwI(row/5*(i-1) + 1:row/5*i,col/5*(j-1) + 1:col/5*j);%将数字区域平均分为5*5的小区域numTemp = sum(sum(imTemp)); %每个区域像素总数feature(count) = 25*numTemp/(row*col); %每个小区域黑像素所占比例count = count + 1;endend%函数功能建立样本库clcclearfor i= 1:10for j = 1:25I = imread(strcat('C:\Documents and Settings\Administrator\桌面\图片\',num2str(i-1),'\s',mynum2str(i),' (',num2str(j),')','.bmp'));I = I(:,:,1);%对读入的图像进行二值化bwI = im2bw(I);%裁剪读入图像[r,c] = find(bwI==0);rmin = min(r);rmax = max(r);cmin = min(c);cmax = max(c);II = I(rmin:rmax,cmin:cmax);%把裁剪图像放大成规格的150*150III = imresize(II,[150 150]);%生成样本特征feature(:,j,i) = scFeature(III);endend%以结构体形式存储样本特征for i = 1:10pattern(i).num = 25;pattern(i).feature = feature(:,:,i);endsave myTemplet%函数功能降维function [y1,y2]=pcapro(sample)load myTemplet pattern;%加载样品库mixedsig=[];sum1=0;%将所有类别的所有样品合并到mixedsigfor i=1:10;sum1=sum1+ pattern(i).num;mixedsig=[mixedsig pattern(i).feature];end[Dim,NumofSampl]=size(mixedsig);%Dim为特征值NumofSampl为样品总个数dsig_cov=cov(mixedsig');%求协方差矩阵%利用pcacov()函数求的从小到大的排序好的协方差矩阵的特征值latent和相应特征向量pc[pc,latent,tspuare]=pcacov(dsig_cov);temp=0;con=0;m=0;%根据贡献率取舍特征向量sum2=sum(latent);for i=1:25if(con<0.9)temp=temp+latent(i);con=temp/sum2;m=m+1;elsebreak;endendpc(:,m+1:25)=[];%求待测样品主成分x=sample*pc;%求样本库品成分y=mixedsig'*pc;y1=y';y2=x';%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%函数名称bayesleasterror()%参数sample待识别样品特征%返回值y待识别样品所属类别%函数功能最小错误率概率的贝叶斯分类器%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=bayesleasterror(sample)clc;load myTemplet pattern;%对样品库和待测样品进行主成分分析[pcapat,pcasamp]=pcapro(sample);temp=0;for i=1:10pattern(i).feature=pcapat(:,temp+1:temp+pattern(i).num);temp=temp+pattern(i).num;ends_cov=[];s_inv=[];s_det=[];for i=1:10s_cov(i).dat=cov(pattern(i).feature');%求各类别的协方差矩阵s_inv(i).dat=inv(s_cov(i).dat);%求协方差矩阵的逆矩阵s_det(i)=det(s_cov(i).dat);%求协方差矩阵的行列式endsum1=0;p=[];for i=1:10sum1=sum1+pattern(i).num;%求样品库样品总数endfor i=1:10p(i)=pattern(i).num/sum1;%求各类别的先验概率endh=[];mean_sap=[];for i=1:10mean_sap(i).dat=mean(pattern(i).feature')';%求每一类样品的特征值end%计算最大的判别函数for i=1:10h(i)=(pcasamp-mean_sap(i).dat)'*s_inv(i).dat*(pcasamp-mean_sap(i).dat)*(-0.5)+log(p(i))+ log(abs(s_det(i)))*(-0.5);end[maxval maxpos]=max(h);y=maxpos-1;%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %函数名称fisherclassify()%参数sample待识别样品特征class1 ,class2 :0-9中的任意两个类别%返回值classfit返回与样品sample最接近的类别%函数功能两类Fisher分类器%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%function classfit=fisherclassify(class1,class2,sample)load myTemplet pattern;%求两类样品均值向量m1=(mean(pattern(class1).feature'))';m2=mean(pattern(class2).feature')';%求两类样品类内离散度矩阵s1=cov(pattern(class1).feature')*(pattern(class1).num-1);s2=cov(pattern(class2).feature')*(pattern(class2).num-1);sw=s1+s2;%求总累间离散度矩阵sb=(m1-m2)*(m1-m2)';%求样品类间离散度矩阵w=inv(sw)*(m1-m2);%求w%求已知类别在w上的投影y1=w'*pattern(class1).feature;y2=w'*pattern(class2).feature;%求各类别样品在投影空间上的均值mean1=mean(y1');mean2=mean(y2');%求阈值y0y0=(pattern(class1).num*mean1+pattern(class2).num*mean2)/(pattern(class1).num+patter n(class1).num);%对于未知样本sample计算在w上的投影yy=w'*sample';%根据决策规则分类if y>y0classfit=class1;elseclassfit=class2;end%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%函数名称fisher()%参数sample待识别样品特征%返回值y待识别样品所属类别%函数功能Fisher分类器%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%function y=fisher(sample);clc;num=zeros(1,10);classnum=0;for i=1:10for j=1:iclassnum=fisherclassify(i,j,sample);num(classnum)=num(classnum)+1;endend[max_val,max_pos]=max(num);y=max_pos-1; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %函数名称caijian()%函数功能对图像进行裁剪然后进行特征提取%参数读入图像I%返回值特征y %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=caijian(I)I = I(:,:,1);%对读入的图像进行二值化bwI = im2bw(I);%裁剪读入图像[r,c] = find(bwI==0);rmin = min(r);rmax = max(r);cmin = min(c);cmax = max(c);II = I(rmin:rmax,cmin:cmax);%把裁剪图像放大成规格的150*150III = imresize(II,[150 150]);imshow(III)%生成特征y= scFeature(III);。
手写体数字识别
说明书手写体数字识别系统分为：图像数据的采集，图像预处理，特征抽取，分类识别和对识别结果进行统计几部分。
首先要将提前写好的数字转换成bmp格式的图片，将其导入，并将图像进行切分，即选中几个数并将其分成一个一个的。
然后对图像进行预处理，图像预处理就是将每一个数字进行灰度化处理、二值化处理、边缘检测、膨胀等处理。
然后分别对采集到的每一个数字图像进行特征提取，特征提取选用的方法是粗网格特征提取。
识别时用的是BP神经网络算法。
神经网络的原理是不断的对数据进行学习、训练，随着学习的不断进行，误差会越来越小。
完成后把上一步提取出来的特征用神经网络去识别。
图1系统整体设计准备一张手写数字的图片，首先要将其转换成MATLAB能识别的格式。
在本程序中将图片格式设为bmp格式。
进行图像采集的方法有两种，一种是先将数字图像导入到程序中，然后切分图像，得到一个一个的数字图像。
这样做主要是为了能够更方便快捷的进行预处理工作。
另一种方式则是先把图像做预处理，然后再进行数字的切分，这样做的好处是就省去了对多个图像进行预处理的繁琐过程，本软件的设计采用的是先分割图像再预处理的方法。
手写体数字识别的预处理过程主要分为：将每一个数字进行灰度化处理、二值化处理、边缘检测、膨胀等。
首先将彩色图像进行灰度化处理，得到灰度图像。
在灰度图像中，通常用0表示黑，255表示白，从0到255亮度逐渐增加，但是并没有色彩信息。
然后进行二值化处理得到二值化图像，即黑白图像。
就是图像像素只存在0,1两个灰度。
接着对图像进行边缘检测，边缘检测的目的是找出图像中亮度发生了巨大变化的点。
边缘检测可以减少数据量，去掉一些不相关的信息，加快运算速度，提高运行速率。
图像的膨胀的目的是扩大物体的边界，可以将断裂的部分连接起来，即使书写不准确补充完可以识别出来。
预处理对于系统的设计非常重要，预处理的好坏直接影响着识别结果。
经过预处理后的图像才能进行特征的提取，因此必须提高程序的预处理能力。
基于机器学习的手写体数字识别技术研究
基于机器学习的手写体数字识别技术研究随着数字化时代的到来，数字信息的处理已经成为一项必备的技能。
而现在，人工智能的加入又让数字信息处理变得更加轻松。
其中，机器学习技术被广泛应用于数字图像处理中，手写体数字识别技术也是其中的一个重要领域。
机器学习是一种以数据为中心的算法，可以让计算机自己学习，从而进行预测和决策。
而手写体数字识别技术正是利用机器学习技术对手写数字进行自动识别。
在机器学习的应用中，手写体数字识别技术算得上是一个很经典的例子。
它可以帮助人们把手写数字转化为计算机可以处理的数字化数据。
尤其是在一些需要对大量的手写数字进行处理的场景下，例如邮政编码、银行支票或者透过手写笔录入信息等领域，手写体数字识别技术可以极大地提高工作效率。
那么手写体数字识别的基本原理是什么呢？首先需要明白的是，计算机只能处理数字化信息。
而人们写的数字是以像素为基本单位的图片，因此首先需要将手写数字的图片转换为数字化数据。
以手写数字“0”为例，我们可以将其分割为若干像素点，每个像素点可以表示为0或1。
这样，一个手写数字的图片就可以被转换为一个数字矩阵，矩阵中每个元素表示该像素点的颜色值。
接下来，就需要对这些数字化的数据进行特征提取，以便分析数字的不同特征。
例如，在手写数字“0”的数字矩阵中，我们会发现它的中间是一个白色的圆形，周围围绕着黑色的边缘。
这些特征也可以被表示为数字化的数据。
通过特征提取，我们可以将数字矩阵转换为一组数字表示的特征向量。
在得到特征向量之后，就可以利用机器学习算法进行分类处理，并对不同的数字进行识别。
目前，常用的机器学习算法包括支持向量机（SVM）、神经网络、决策树等。
这些算法不仅可以对手写数字进行有效识别，还可以在遇到新的手写数字时进行自动学习和调整，提高识别的精度。
不过，手写体数字识别技术也存在着一些挑战与限制。
例如，不同人的手写风格可能存在着非常大的差异，这就需要技术能够在不同的人写的数字之间进行有效区分。
数据挖掘技术与应用：手写数字识别实训
实训内容
1. 导入必要的库。 2. 导入手写数字。 3. 以将数据转换为（样本，特征）矩阵。 4. 创建一个支持向量机分类器。 5. 取一半数据作为训练集。 6. 对剩余的数据进行预测。 7. 输出结果。
手写数字识别实现代码
导入数据包
from sklearn import datasets, svm, metrics
classifier = svm.SVC(gamma=0.001)
取一半数据作为训练集
classifier.fit(data[:n_samples // 2], digits.target[:n_samples // 2])
对剩余的数据进行预测
expected = digits.target[n_samples // 2:] predicted = classifier.predict(data[n_samples // 2:])
编辑器。
3. numpy、pandas、sklearn
实训数据
选取的数据集是由8x8的数字图像组成的，数据集 的images属性中的前4张图像。如果使用图像文件 ，则可以使用matplotlib.pyplot.imread加载它们。请 注意，每个图像必须具有相同的大小。对于这些 图像，需要指导它们代表哪个数字：它在数据集 的“目标”中给出。
digits = datasets.load_digits()
在对该数据应用分类器前，要将 展开图像，以将数据转换为（样
本，特征）矩阵：
n_samples = len(digits.images)
data = digits.images.reshape((n_samples, -1))
创建一个支持向量机分类器
手写体数字的识别
手写体数字的识别手写体数字识别第一章绪论 (4)1.1课题研究的意义 (4)1.2国内外究动态目前水平 (4)1.3手写体数字识别简介 (5)1.4识别的技术难点 (5)1.5主要研究工作 (6)第二章手写体数字识别基本过程： (6)2.1手写体数字识别系统结构 (6)2.2分类器设计 (7)2.2.1 特征空间优化设计问题 (7)2.2.2分类器设计准则 (8)2.2.3分类器设计基本方法 (9)3.4 判别函数 (9)3.5训练与学习 (10)第三章贝叶斯方法应用于手写体数字识别 (11)3.1贝叶斯由来 (11)3.2贝叶斯公式 (11)3.3贝叶斯公式Bayes决策理论： (12)3.4贝叶斯应用于的手写体数字理论部分： (16)3.4.1.特征描述： (16)3.4.2最小错误分类器进行判别分类 (17)第四章手写体数字识别的设计流程及功能的具体实现 (18) 4.1 手写体数字识别的流程图 (18)4.2具体功能实现方法如下： (19)结束语 (25)致谢词 (25)参考文献 (26)附录 (27)摘要数字识别就是通过计算机用数学技术方法来研究模式的自动处理和识别。
随着计算机技术的发展，人类对模式识别技术提出了更高的要求。
特别是对于大量己有的印刷资料和手稿，计算机自动识别输入己成为必须研究的课题，所以数字识别在文献检索、办公自动化、邮政系统、银行票据处理等方面有着广阔的应用前景。
对手写数字进行识别，首先将汉字图像进行处理，抽取主要表达特征并将特征与数字的代码存储在计算机中，这一过程叫做“训练”。
识别过程就是将输入的数字图像经处理后与计算机中的所有字进行比较，找出最相近的字就是识别结果。
本文主要介绍了数字识别的基本原理和手写的10个数字字符的识别系统的设计实现过程。
第一章介绍了数字识别学科的发展状况。
第二章手写体数字识别基本过程。
第三章贝叶斯方法应用于手写体数字识别。
第四章手写体数字识别的设计流程及功能的具体实现，并对实验结果做出简单的分析。
python实现手写数字识别(小白入门)
python实现手写数字识别（小白入门）要实现手写数字识别，可以使用机器学习库Scikit-learn和图像处理库OpenCV。
下面是一个简单的示例代码：```pythonimport cv2from sklearn import datasetsfrom sklearn.model_selection import train_test_splitfrom sklearn.neighbors import KNeighborsClassifier#加载手写数字数据集digits = datasets.load_digitsX = digits.images.reshape((len(digits.images), -1))y = digits.target#划分训练集和测试集X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)#创建K近邻分类器knn = KNeighborsClassifier#训练分类器knn.fit(X_train, y_train)#从图像文件中读取手写数字图像image = cv2.imread('handwritten_digit.png',cv2.IMREAD_GRAYSCALE)#调整图像大小为8x8image = cv2.resize(image, (8, 8))#将图像转换为一维数组image = image.reshape(1, -1)#使用分类器进行预测prediction = knn.predict(image)print("预测结果:", prediction[0])```在这个示例中，首先使用`datasets.load_digits(`函数加载Scikit-learn库中的手写数字数据集。
Python进阶教程：使用机器学习实现手写数字识别
Python进阶教程：使用机器学习实现手写数字识别在日常生活中，我们经常需要手写数字，包括填写表格、汽车牌照等等，然而如何让计算机识别手写数字成了一个问题。
随着机器学习的发展，使用Python编写代码实现手写数字识别已经不再是一个难题。
本文主要介绍如何使用机器学习实现手写数字识别，其中包括数据预处理、模型构建以及模型训练等步骤。
一、数据预处理在进行手写数字识别前，我们需要获取训练数据和测试数据。
这里，我们选用了著名的MNIST数据集。
该数据集包含60,000张训练图像和10,000张测试图像，图像大小均为28x28，像素值为0-255的灰度值。
我们可以使用Python中的numpy和matplotlib库来读取和显示图像。
代码如下：```pythonimport numpy as npimport matplotlib.pyplot as plt# 读取训练数据train_images = np.load('mnist_train_images.npy')train_labels = np.load('mnist_train_labels.npy')# 读取测试数据test_images = np.load('mnist_test_images.npy')test_labels = np.load('mnist_test_labels.npy')# 显示第一张图像和其标签plt.imshow(train_images[0], cmap='gray')plt.title('Label: ' + str(train_labels[0]))plt.show()```我们可以看到，第一张训练图像对应的标签是5。
使用同样的方法，我们可以查看其他图像以及其标签。
我们可以将每个28x28的图像展开成784维的向量，这样更方便我们后续的处理。
手写体两位数字识别
小结
是否能够改进图像预处理来提高正确率？ 通过使用其他方法来得到更好的结果？
10
问题提出
随着模式识别及相关理论和技术的发展，其在 现实生活中也得到越来越广泛的应用。 微软推出了kinect，可以通过人脸、手势、动 作进行控制以及人机交互，使得体感游戏开始 进入普通家庭。 可以预见不久之后的家用电视机也将会带上这 样的功能：可以用手势来操控电视频道。 那么，是否能通过临空手写数字来切换频道？ 于是提出这个问题，手写体数字识别。3Fra bibliotek数据处理
170×160
80×80
Figure2 processing
80×80
4
训练与识别
对每类30张图片使用PCA进行降维 每类前25张作为训练集，后5张作为测试集 使用SVM方法进行训练和识别
5
训练与识别
results
Figure3 some test results
6
实验结果
PCA n=60
1
问题简化
假设需要识别的是从0-99的频道，那么就是需 要识别100类，从原问题看，需要识别的是从 0-99这100类数字，且每个数字都是用一笔写 成的。
2
数据采集
采集100类数据，每类30个，并已经过二值化 处理，每幅图像分辨率为170×160
Figure1 some original images
Kernel type
0
Accuracy
46.6% (233/500)
1
46.6% (233/500)
2
24.8% (124/500)
7
实验结果
PCA n=20
Kernel type
0
Accuracy
手写数字识别案例
手写数字识别案例
手写数字识别是计算机视觉领域的一个经典问题，其目的是将手写数字图像转化为计算机能够识别和处理的数字数据。
在本案例中，我们将探索如何使用深度学习技术实现手写数字识别。
首先，我们需要准备一个手写数字数据集，通常可以使用MNIST 数据集。
该数据集包含了一系列28x28像素的手写数字图像，以及对应的数字标签。
我们可以使用Python的TensorFlow库来加载和处理这个数据集。
接着，我们可以定义一个深度学习模型，用于对手写数字图像进行分类。
在本案例中，我们将使用卷积神经网络（CNN）模型，该模型具有良好的图像识别性能。
我们可以使用TensorFlow的Keras API 来定义和训练CNN模型，然后在测试集上进行评估。
最后，我们可以使用手写数字图像输入到训练好的模型中，进行实时识别和预测。
在本案例中，我们将使用Python的OpenCV库来捕获和处理手写数字图像，并将其输入到训练好的模型中，输出相应的数字预测结果。
通过本案例的学习，我们可以了解深度学习技术在图像识别领域的应用，以及如何使用Python的TensorFlow和OpenCV库进行实现。
同时，该案例也可以为学习计算机视觉和深度学习提供一个实际应用的例子。
- 1 -。
python神经网络编程实现手写数字识别
python神经⽹络编程实现⼿写数字识别本⽂实例为⼤家分享了python实现⼿写数字识别的具体代码，供⼤家参考，具体内容如下import numpyimport scipy.special#import matplotlib.pyplotclass neuralNetwork:def __init__(self,inputnodes,hiddennodes,outputnodes,learningrate):self.inodes=inputnodesself.hnodes=hiddennodesself.onodes=outputnodesself.lr=learningrateself.wih=numpy.random.normal(0.0,pow(self.hnodes,-0.5),(self.hnodes,self.inodes))self.who=numpy.random.normal(0.0,pow(self.onodes,-0.5),(self.onodes,self.hnodes))self.activation_function=lambda x: scipy.special.expit(x)passdef train(self,inputs_list,targets_list):inputs=numpy.array(inputs_list,ndmin=2).Ttargets=numpy.array(targets_list,ndmin=2).Thidden_inputs=numpy.dot(self.wih,inputs)hidden_outputs=self.activation_function(hidden_inputs)final_inputs=numpy.dot(self.who,hidden_outputs)final_outputs=self.activation_function(final_inputs)output_errors=targets-final_outputshidden_errors=numpy.dot(self.who.T,output_errors)self.who+=self.lr*numpy.dot((output_errors*final_outputs*(1.0-final_outputs)),numpy.transpose(hidden_outputs))self.wih+=self.lr*numpy.dot((hidden_errors*hidden_outputs*(1.0-hidden_outputs)),numpy.transpose(inputs))passdef query(self,input_list):inputs=numpy.array(input_list,ndmin=2).Thidden_inputs=numpy.dot(self.wih,inputs)hidden_outputs=self.activation_function(hidden_inputs)final_inputs=numpy.dot(self.who,hidden_outputs)final_outputs=self.activation_function(final_inputs)return final_outputsinput_nodes=784hidden_nodes=100output_nodes=10learning_rate=0.1n=neuralNetwork(input_nodes,hidden_nodes,output_nodes,learning_rate)training_data_file=open(r"C:\Users\lsy\Desktop\nn\mnist_train.csv","r")training_data_list=training_data_file.readlines()training_data_file.close()#print(n.wih)#print("")epochs=2for e in range(epochs):for record in training_data_list:all_values=record.split(",")inputs=(numpy.asfarray(all_values[1:])/255.0*0.99)+0.01targets=numpy.zeros(output_nodes)+0.01targets[int(all_values[0])]=0.99n.train(inputs,targets)#print(n.wih)#print(len(training_data_list))#for i in training_data_list:# print(i)test_data_file=open(r"C:\Users\lsy\Desktop\nn\mnist_test.csv","r")test_data_list=test_data_file.readlines()test_data_file.close()scorecard=[]for record in test_data_list:all_values=record.split(",")correct_lable=int(all_values[0])inputs=(numpy.asfarray(all_values[1:])/255.0*0.99)+0.01outputs=n.query(inputs)label=numpy.argmax(outputs)if(label==correct_lable):scorecard.append(1)else:scorecard.append(0)scorecard_array=numpy.asarray(scorecard)print(scorecard_array)print("")print(scorecard_array.sum()/scorecard_array.size)#all_value=test_data_list[0].split(",")#input=(numpy.asfarray(all_value[1:])/255.0*0.99)+0.01#print(all_value[0])#image_array=numpy.asfarray(all_value[1:]).reshape((28,28))#matplotlib.pyplot.imshow(image_array,cmap="Greys",interpolation="None")#matplotlib.pyplot.show()#nn=n.query((numpy.asfarray(all_value[1:])/255.0*0.99)+0.01)#for i in nn :# print(i)《python神经⽹络编程》中代码，仅做记录，以备后⽤。
超详细PyTorch实现手写数字识别器的示例代码
超详细PyTorch实现⼿写数字识别器的⽰例代码前⾔深度学习中有很多玩具数据，mnist就是其中⼀个，⼀个⼈能否⼊门深度学习往往就是以能否玩转mnist数据来判断的，在前⾯很多基础介绍后我们就可以来实现⼀个简单的⼿写数字识别的⽹络了数据的处理我们使⽤pytorch⾃带的包进⾏数据的预处理import torchimport torchvisionimport torchvision.transforms as transformsimport numpy as npimport matplotlib.pyplot as plttransform = pose([transforms.ToTensor(),transforms.Normalize((0.5), (0.5))])trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True,num_workers=2)注释:transforms.Normalize⽤于数据的标准化，具体实现mean:均值总和后除个数std:⽅差每个元素减去均值再平⽅再除个数norm_data = (tensor - mean) / std这⾥就直接将图⽚标准化到了-1到1的范围，标准化的原因就是因为如果某个数在数据中很⼤很⼤，就导致其权重较⼤，从⽽影响到其他数据，⽽本⾝我们的数据都是平等的，所以标准化后将数据分布到-1到1的范围，使得所有数据都不会有太⼤的权重导致⽹络出现巨⼤的波动trainloader现在是⼀个可迭代的对象，那么我们可以使⽤for循环进⾏遍历了，由于是使⽤yield返回的数据，为了节约内存观察⼀下数据def imshow(img):img = img / 2 + 0.5 # unnormalizenpimg = img.numpy()plt.imshow(np.transpose(npimg, (1, 2, 0)))plt.show()# torchvision.utils.make_grid 将图⽚进⾏拼接imshow(torchvision.utils.make_grid(iter(trainloader).next()[0]))构建⽹络from torch import nnimport torch.nn.functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(in_channels=1, out_channels=28, kernel_size=5) # 14self.pool = nn.MaxPool2d(kernel_size=2, stride=2) # ⽆参数学习因此⽆需设置两个self.conv2 = nn.Conv2d(in_channels=28, out_channels=28*2, kernel_size=5) # 7self.fc1 = nn.Linear(in_features=28*2*4*4, out_features=1024)self.fc2 = nn.Linear(in_features=1024, out_features=10)def forward(self, inputs):x = self.pool(F.relu(self.conv1(inputs)))x = self.pool(F.relu(self.conv2(x)))x = x.view(inputs.size()[0],-1)x = F.relu(self.fc1(x))return self.fc2(x)下⾯是卷积的动态演⽰in_channels:为输⼊通道数彩⾊图⽚有3个通道⿊⽩有1个通道out_channels:输出通道数kernel_size:卷积核的⼤⼩stride:卷积的步长padding:外边距⼤⼩输出的size计算公式h = (h - kernel_size + 2*padding)/stride + 1w = (w - kernel_size + 2*padding)/stride + 1 MaxPool2d:是没有参数进⾏运算的实例化⽹络优化器，并且使⽤GPU进⾏训练net = Net()opt = torch.optim.Adam(params=net.parameters(), lr=0.001)device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")net.to(device)Net((conv1): Conv2d(1, 28, kernel_size=(5, 5), stride=(1, 1))(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(conv2): Conv2d(28, 56, kernel_size=(5, 5), stride=(1, 1))(fc1): Linear(in_features=896, out_features=1024, bias=True)(fc2): Linear(in_features=1024, out_features=10, bias=True))训练主要代码for epoch in range(50):for images, labels in trainloader:images = images.to(device)labels = labels.to(device)pre_label = net(images)loss = F.cross_entropy(input=pre_label, target=labels).mean()pre_label = torch.argmax(pre_label, dim=1)acc = (pre_label==labels).sum()/torch.tensor(labels.size()[0], dtype=torch.float32)net.zero_grad()loss.backward()opt.step()print(acc.detach().cpu().numpy(), loss.detach().cpu().numpy())F.cross_entropy交叉熵函数源码中已经帮助我们实现了softmax因此不需要⾃⼰进⾏softmax操作了torch.argmax计算最⼤数所在索引值acc = (pre_label==labels).sum()/torch.tensor(labels.size()[0], dtype=torch.float32)# pre_label==labels 相同维度进⾏⽐较相同返回True不同的返回False，True为1 False为0, 即可获取到相等的个数，再除总个数，就得到了Accuracy准确度了预测testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=True,num_workers=2)images, labels = iter(testloader).next()images = images.to(device)labels = labels.to(device)with torch.no_grad():pre_label = net(images)pre_label = torch.argmax(pre_label, dim=1)acc = (pre_label==labels).sum()/torch.tensor(labels.size()[0], dtype=torch.float32)print(acc)总结本节我们了解了标准化数据·、卷积的原理、简答的构建了⼀个⽹络，并让它去识别⼿写体，也是对前⾯章节的总汇了到此这篇关于超详细PyTorch实现⼿写数字识别器的⽰例代码的⽂章就介绍到这了,更多相关PyTorch ⼿写数字识别器内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
python实现手写数字识别（小白入门）
python实现⼿写数字识别（⼩⽩⼊门）⼿写数字识别（⼩⽩⼊门）今早刚刚上了节实验课，关于逻辑回归，所以⼿有点刺挠就想发个博客，作为刚刚⼊门的⼩⽩，看到代码运⾏成功就有点⼩激动，这个实验没啥含⾦量，所以路过的⼤⽜不要停留，我怕你们吐槽哈哈。
实验结果：1.数据预处理其实呢，原理很简单，就是使⽤多变量逻辑回归，将训练28*28图⽚的灰度值转换成⼀维矩阵，这就变成了求784个特征向量1个标签的逻辑回归问题。
代码如下：#数据预处理trainData = np.loadtxt(open('digits_training.csv','r'), delimiter=",",skiprows=1)#装载数据MTrain, NTrain = np.shape(trainData)#⾏列数print("训练集：",MTrain,NTrain)xTrain = trainData[:,1:NTrain]xTrain_col_avg = np.mean(xTrain, axis=0)#对各列求均值xTrain =(xTrain- xTrain_col_avg)/255#归⼀化yTrain = trainData[:,0]2.训练模型对于数学差的⼀批的我来说，学习算法真的是太太太扎⼼了，好在具体算法封装在了sklearn库中。
简单两⾏代码即可完成。
具体参数的含义随随便便⼀搜到处都是，我就不班门弄斧了，每次看见算法除了头晕啥感觉没有。
model = LogisticRegression(solver='lbfgs', multi_class='multinomial', max_iter=500)model.fit(xTrain, yTrain)3.测试模型，保存接下来测试⼀下模型，准确率能达到百分之90，也不算太⾼，训练数据集本来也不是很多。
【机器学习】手写数字识别算法
【机器学习】⼿写数字识别算法1.数据准备样本数据获取忽略，实际上就是将32*32的图⽚上数字格式化成⼀个向量，如下：本demo所有样本数据都是基于这种格式的训练数据：将图⽚数据转成1*1024的数组，作为⼀个训练数据。
训练数据集：测试数据集：样本的⽂件名格式为：真实值_xxx.txt转换代码：1def img2vector(filename):2 returnVect=zeros((1,1024))3 fr=open(filename)4for i in range(32):5 lineStr=fr.readline()6for j in range(32):7 returnVect[0,32*i+j]=int(lineStr[j])8return returnVect2.测试算法1def handwritingClassTest():2 hwLabels=[] # 训练样本的标签数组3 traningFileList=listdir("trainingDigits") # 获取所有的训练样本⽬录下的⽂件名4 m=len(traningFileList)5 traningMat=zeros((m,1024)) # 初始化训练样本数列67for i in range(m):8 fileNameStr=traningFileList[i] # 获取⽂件名9 fileStr=fileNameStr.split(".")[0]10 clasNumStr=int(fileStr.split("_")[0]) # 获取样本的实际值放⼊标签数组11 hwLabels.append(clasNumStr)12 traningMat[i,:]=img2vector("trainingDigits/{}".format(fileNameStr)) # 将样本转化成1*1024的⾏放⼊训练样本数列1314 testFileList=listdir("testDigits") # 测试样本⽬录15 error=016 mtest=len(testFileList)17for i in range(mtest):18 fileNameStr=testFileList[i]19 fileStr=fileNameStr.split(".")[0]20 clasNumStr=int(fileStr.split("_")[0])21 testMat=img2vector("testDigits/{}".format(fileNameStr))22 res=classify(testMat,traningMat,hwLabels,3) # 使⽤分类器分类23print"came bank with:{} the real anwser is:{}".format(clasNumStr,res)24if clasNumStr!=res: # 对⽐与真实的结果计算错误率25 error+=12627print"total:{}".format(mtest)28print"error:{}".format(error)29print"error:{}".format(float(error/mtest))这个案例中算法的识别率为：98.84% classify是分类器上上⼀篇⽂章中有写到，具体了解可以。
python神经网络编程之手写数字识别
python神经⽹络编程之⼿写数字识别⽬录写在之前⼀、代码框架⼆、准备⼯作三、框架的开始四、训练模型构建五、⼿写数字的识别六、源码七、思考写在之前⾸先是写在之前的⼀些建议：⾸先是关于这本书，我真的认为他是将神经⽹络⾥⾮常棒的⼀本书，但你也需要注意，如果你真的想⾃⼰动⼿去实现，那么你⼀定需要有⼀定的python基础，并且还需要有⼀些python数据科学处理能⼒然后希望⼤家在看这边博客的时候对于神经⽹络已经有⼀些了解了，知道什么是输⼊层，什么是输出层，并且明⽩他们的⼀些理论，在这篇博客中我们仅仅是展开⼀下代码；然后介绍⼀下本篇博客的环境等：语⾔:Python3.8.5环境:jupyter库⽂件: numpy | matplotlib | scipy⼀、代码框架我们即将设计⼀个神经⽹络对象，它可以帮我们去做数据的训练，以及数据的预测，所以我们将具有以下的三个⽅法：⾸先我们需要初始化这个函数，我们希望这个神经⽹络仅有三层，因为再多也不过是在隐藏层去做⽂章，所以先做⼀个简单的。
那么我们需要知道我们输⼊层、隐藏层和输出层的节点个数；训练函数，我们需要去做训练，得到我们需要的权重。
通过我们已有的权重，将给定的输⼊去做输出。
⼆、准备⼯作现在我们需要准备⼀下：1.将我们需要的库导⼊import numpy as npimport scipy.special as speimport matplotlib.pyplot as plt2.构建⼀个类class neuralnetwork:# 我们需要去初始化⼀个神经⽹络def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):passdef train(self, inputs_list, targets_list):passdef query(self, inputs_list):pass3.我们的主函数input_nodes = 784 # 输⼊层的节点数hidden_nodes = 88 # 隐藏层的节点数output_nodes = 10 # 输出层的节点数learn_rate = 0.05 # 学习率n = neuralnetwork(input_nodes, hidden_nodes, output_nodes, learn_rate)4.导⼊⽂件data_file = open("E:\sklearn_data\神经⽹络数字识别\mnist_train.csv", 'r')data_list = data_file.readlines()data_file.close()file2 = open("E:\sklearn_data\神经⽹络数字识别\mnist_test.csv")answer_data = file2.readlines()file2.close()这⾥需要介绍以下这个数据集，训练集在这⾥，测试集在这⾥三、框架的开始def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):self.inodes = inputnodes # 输⼊层节点设定self.hnodes = hiddennodes # 影藏层节点设定self.onodes = outputnodes # 输出层节点设定self.lr = learningrate # 学习率设定，这⾥可以改进的self.wih = (np.random.normal(0.0, pow(self.hnodes, -0.5),(self.hnodes, self.inodes))) # 这⾥是输⼊层与隐藏层之间的连接self.who = (np.random.normal(0.0, pow(self.onodes, -0.5),(self.onodes, self.hnodes))) # 这⾥是隐藏层与输出层之间的连接self.activation_function = lambda x: spe.expit(x) # 返回sigmoid函数Δw j,k =α∗E k ∗ sigmoid (O k )∗(1−sigmoid(O k ))⋅O j ⊤def query(self, inputs_list):inputs = np.array(inputs_list, ndmin=2).T # 输⼊进来的⼆维图像数据hidden_inputs = np.dot(self.wih, inputs) # 隐藏层计算，说⽩了就是线性代数中的矩阵的点积hidden_outputs = self.activation_function(hidden_inputs) # 将隐藏层的输出是经过sigmoid函数处理final_inputs = np.dot(self.who, hidden_outputs) # 原理同hidden_inputsfinal_outputs = self.activation_function(final_inputs) # 原理同hidden_outputsreturn final_outputs # 最终的输出结果就是我们预测的数据这⾥我们对预测这⼀部分做⼀个简单的解释：我们之前的定义输出的节点是10个，对应的是⼗个数字。
手写数字0-9的识别代码（SVM支持向量机）
⼿写数字0-9的识别代码（SVM⽀持向量机）帮⼀个贴吧的朋友改的⼀段代码，源代码来⾃《机器学习实战》原代码的功能是识别0和9两个数字经过改动之后可以识别0~9，并且将分类器的产⽣和测试部分分开来写，免得每次测试数据都要重新⽣成分类器⼀次。
from numpy import *from time import sleepdef loadDataSet(fileName):dataMat = []; labelMat = []fr = open(fileName)for line in fr.readlines():lineArr = line.strip().split('\t')dataMat.append([float(lineArr[0]), float(lineArr[1])])labelMat.append(float(lineArr[2]))return dataMat,labelMatdef selectJrand(i,m):j=i #we want to select any J not equal to iwhile (j==i):j = int(random.uniform(0,m))return jdef clipAlpha(aj,H,L):if aj > H:aj = Hif L > aj:aj = Lreturn ajdef smoSimple(dataMatIn, classLabels, C, toler, maxIter):dataMatrix = mat(dataMatIn); labelMat = mat(classLabels).transpose()b = 0; m,n = shape(dataMatrix)alphas = mat(zeros((m,1)))iter = 0while (iter < maxIter):alphaPairsChanged = 0for i in range(m):fXi = float(multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[i,:].T)) + bEi = fXi - float(labelMat[i])#if checks if an example violates KKT conditionsif ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and (alphas[i] > 0)):j = selectJrand(i,m)fXj = float(multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[j,:].T)) + bEj = fXj - float(labelMat[j])alphaIold = alphas[i].copy(); alphaJold = alphas[j].copy();if (labelMat[i] != labelMat[j]):L = max(0, alphas[j] - alphas[i])H = min(C, C + alphas[j] - alphas[i])else:L = max(0, alphas[j] + alphas[i] - C)H = min(C, alphas[j] + alphas[i])if L==H:#print "L==H";continueeta = 2.0 * dataMatrix[i,:]*dataMatrix[j,:].T - dataMatrix[i,:]*dataMatrix[i,:].T - dataMatrix[j,:]*dataMatrix[j,:].Tif eta >= 0:#print "eta>=0";continuealphas[j] -= labelMat[j]*(Ei - Ej)/etaalphas[j] = clipAlpha(alphas[j],H,L)if (abs(alphas[j] - alphaJold) < 0.00001): print"j not moving enough"; continuealphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])#update i by the same amount as j#the update is in the oppostie directionb1 = b - Ei- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[i,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[i,:]*dataMatrix[j,:].T b2 = b - Ej- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[j,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[j,:]*dataMatrix[j,:].T if (0 < alphas[i]) and (C > alphas[i]): b = b1elif (0 < alphas[j]) and (C > alphas[j]): b = b2else: b = (b1 + b2)/2.0alphaPairsChanged += 1#print "iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged)if (alphaPairsChanged == 0): iter += 1else: iter = 0#print "iteration number: %d" % iterreturn b,alphasdef kernelTrans(X, A, kTup): #calc the kernel or transform data to a higher dimensional spaceK = mat(zeros((m,1)))if kTup[0]=='lin': K = X * A.T #linear kernelelif kTup[0]=='rbf':for j in range(m):deltaRow = X[j,:] - AK[j] = deltaRow*deltaRow.TK = exp(K/(-1*kTup[1]**2)) #divide in NumPy is element-wise not matrix like Matlabelse: raise NameError('Houston We Have a Problem -- \That Kernel is not recognized')return Kclass optStruct:def__init__(self,dataMatIn, classLabels, C, toler, kTup): # Initialize the structure with the parametersself.X = dataMatInbelMat = classLabelsself.C = Cself.tol = tolerself.m = shape(dataMatIn)[0]self.alphas = mat(zeros((self.m,1)))self.b = 0self.eCache = mat(zeros((self.m,2))) #first column is valid flagself.K = mat(zeros((self.m,self.m)))for i in range(self.m):self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)def calcEk(oS, k):fXk = float(multiply(oS.alphas,belMat).T*oS.K[:,k] + oS.b)Ek = fXk - float(belMat[k])return Ekdef selectJ(i, oS, Ei): #this is the second choice -heurstic, and calcs EjmaxK = -1; maxDeltaE = 0; Ej = 0oS.eCache[i] = [1,Ei] #set valid #choose the alpha that gives the maximum delta EvalidEcacheList = nonzero(oS.eCache[:,0].A)[0]if (len(validEcacheList)) > 1:for k in validEcacheList: #loop through valid Ecache values and find the one that maximizes delta Eif k == i: continue#don't calc for i, waste of timeEk = calcEk(oS, k)deltaE = abs(Ei - Ek)if (deltaE > maxDeltaE):maxK = k; maxDeltaE = deltaE; Ej = Ekreturn maxK, Ejelse: #in this case (first time around) we don't have any valid eCache valuesj = selectJrand(i, oS.m)Ej = calcEk(oS, j)return j, Ejdef updateEk(oS, k):#after any alpha has changed update the new value in the cacheEk = calcEk(oS, k)oS.eCache[k] = [1,Ek]def innerL(i, oS):Ei = calcEk(oS, i)if ((belMat[i]*Ei < -oS.tol) and (oS.alphas[i] < oS.C)) or ((belMat[i]*Ei > oS.tol) and (oS.alphas[i] > 0)): j,Ej = selectJ(i, oS, Ei) #this has been changed from selectJrandalphaIold = oS.alphas[i].copy(); alphaJold = oS.alphas[j].copy();if (belMat[i] != belMat[j]):L = max(0, oS.alphas[j] - oS.alphas[i])H = min(oS.C, oS.C + oS.alphas[j] - oS.alphas[i])else:L = max(0, oS.alphas[j] + oS.alphas[i] - oS.C)H = min(oS.C, oS.alphas[j] + oS.alphas[i])if L==H:#print "L==H";return 0eta = 2.0 * oS.K[i,j] - oS.K[i,i] - oS.K[j,j] #changed for kernelif eta >= 0:#print "eta>=0";return 0oS.alphas[j] -= belMat[j]*(Ei - Ej)/etaoS.alphas[j] = clipAlpha(oS.alphas[j],H,L)updateEk(oS, j) #added this for the Ecacheif (abs(oS.alphas[j] - alphaJold) < 0.00001):#print "j not moving enough";return 0oS.alphas[i] += belMat[j]*belMat[i]*(alphaJold - oS.alphas[j])#update i by the same amount as jupdateEk(oS, i) #added this for the Ecache #the update is in the oppostie directionb1 = oS.b - Ei- belMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,i] - belMat[j]*(oS.alphas[j]-alphaJold)*oS.K[i,j] b2 = oS.b - Ej- belMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,j]- belMat[j]*(oS.alphas[j]-alphaJold)*oS.K[j,j] if (0 < oS.alphas[i]) and (oS.C > oS.alphas[i]): oS.b = b1elif (0 < oS.alphas[j]) and (oS.C > oS.alphas[j]): oS.b = b2else: oS.b = (b1 + b2)/2.0return 1def smoP(dataMatIn, classLabels, C, toler, maxIter,kTup=('lin', 0)): #full Platt SMOoS = optStruct(mat(dataMatIn),mat(classLabels).transpose(),C,toler, kTup)iter = 0entireSet = True; alphaPairsChanged = 0while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):alphaPairsChanged = 0if entireSet: #go over allfor i in range(oS.m):alphaPairsChanged += innerL(i,oS)#print "fullSet, iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged)iter += 1else:#go over non-bound (railed) alphasnonBoundIs = nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]for i in nonBoundIs:alphaPairsChanged += innerL(i,oS)#print "non-bound, iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged) iter += 1if entireSet: entireSet = False #toggle entire set loopelif (alphaPairsChanged == 0): entireSet = True#print "iteration number: %d" % iterreturn oS.b,oS.alphasdef calcWs(alphas,dataArr,classLabels):X = mat(dataArr); labelMat = mat(classLabels).transpose()m,n = shape(X)w = zeros((n,1))for i in range(m):w += multiply(alphas[i]*labelMat[i],X[i,:].T)return wdef img2vector(filename):returnVect = zeros((1,1024))fr = open(filename)for i in range(32):lineStr = fr.readline()for j in range(32):returnVect[0,32*i+j] = int(lineStr[j])return returnVectdef loadImages(dirName,num):from os import listdirhwLabels = []trainingFileList = listdir(dirName)#load the training setif trainingFileList[0] == '.DS_Store':del trainingFileList[0]m = len(trainingFileList)trainingMat = zeros((m,1024))for i in range(m):fileNameStr = trainingFileList[i]fileStr = fileNameStr.split('.')[0]#take off .txtclassNumStr = int(fileStr.split('_')[0])if classNumStr == num: hwLabels.append(-1)else: hwLabels.append(1)trainingMat[i,:] = img2vector('%s/%s' % (dirName, fileNameStr))return trainingMat, hwLabelsdef training(kTup=('rbf', 10)):num = 6;p = 0.01while num < 10:dataArr,labelArr = loadImages('trainingDigits',num)b,alphas = smoP(dataArr, labelArr, 200, 0.0001, 10000, kTup)datMat=mat(dataArr); labelMat = mat(labelArr).transpose()svInd=nonzero(alphas.A>0)[0]#print svInd,len(svInd)sVs=datMat[svInd]labelSV = labelMat[svInd]alpha = alphas[svInd]#print sVs.shape,labelSV.shape,alpha.shapeprint str(num)+":"+"there are %d Support Vectors" % shape(sVs)[0]datMat=mat(dataArr); labelMat = mat(labelArr).transpose()m,n = shape(datMat)errorCount = 0for i in range(m):kernelEval = kernelTrans(sVs,datMat[i,:],kTup)predict=kernelEval.T * multiply(labelSV,alpha) + bif sign(predict)!=sign(labelArr[i]): errorCount += 1print str(num)+":"+"the training error rate is: %f" % (float(errorCount)/m)if float(errorCount)/m < p:savez(str(num)+'re.npz',sVs,labelSV,alpha,b)num = num +1p = 0.01else:p = p + 0.01def test(kTup=('rbf', 10)):for num in range(0,10):r = load(str(num)+'re.npz')sVs = r['arr_0']labelSV = r['arr_1']alpha = r['arr_2']b = r['arr_3']dataArr,labelArr = loadImages('testDigits',num)errorCount = 0datMat=mat(dataArr); labelMat = mat(labelArr).transpose()m,n = shape(datMat)for i in range(m):kernelEval = kernelTrans(sVs,datMat[i,:],kTup)predict=kernelEval.T * multiply(labelSV,alpha) + bif sign(predict)!=sign(labelArr[i]): errorCount += 1print str(num)+":"+"the test error rate is: %f" % (float(errorCount)/m) #training(('rbf',20))#test(kTup=('rbf', 20))。
Python程序设计：手写数字识别(案例)
步骤：任务实施
任务 手写数字识别
设计思路
通过sklearn读取手写数字图片数据。 划分训练集和测试集。 创建随机森林分类器并训练模型。 使用网格搜索进行超参数寻优。 查看每一个超参数组合和其对应的分数。 绘制前64张图片，并标定其识别结果，观察识别正确性。
ቤተ መጻሕፍቲ ባይዱ
步骤：任务小结
任务 手写数字识别
机器学习的分类
机器学习算法实现简单图像识别
步骤：任务分析
任务 手写数字识别
需求分析
sklearn中封装有手写数字图片数据集，总共1797条数据。每条数据代表一张 图片，有64个特征，表示这张图片的像素（8*8）。数据集的输出为0-9的类 别，分别表示数字0到9。
现在编写一个程序，建立机器学习算法模型，使用手写数字识别数据集对模型 进行训练并进行超参数寻优。训练结束后，使用模型对图片进行识别，得到识 别结果，将识别结果与真实结果进行对比，观察识别的正确率。
小结
理解训练集与测试集的划分。 了解最优模型的选择。 了解模型中的参数作用。
谢谢观看
手写数字识别
任务 手写数字识别
任务背景
本任务是利用机器学习算法实现手写体数字识别，具体包括数据获取、模型创 建、模型训练、超参数寻优、利用模型进行预测等流程。从本任务出发，我们 将系统的学习机器学习相关知识，包括机器学习的概念、分类、经典的机器学 习算法原理及使用等。
任务 手写数字识别
任务目标
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
# encoding:utf-8
# 从sklearn.datasets里导入手写体数字加载器。
from sklearn.datasets import load_digits
# 从通过数据加载器获得手写体数字的数码图像数据
#并储存在digits变量中。
digits = load_digits()
# 检视数据规模和特征维度。
print(digits.data.shape)
#import matplotlib.pyplot as plt
#plt.gray()
#plt.matshow(digits.images[0])
#plt.show()
# 从sklearn.cross_validation中导入train_test_split用于数据分割。
from sklearn.model_selection import train_test_split
# 随机选取75%的数据作为训练样本；其余25%的数据作为测试样本。
X_train, X_test, y_train, y_test = train_test_split(\
digits.data, digits.target, test_size=0.25, random_state=33)
print(y_train.shape)
print(y_test.shape)
# 从sklearn.preprocessing里导入数据标准化模块。
from sklearn.preprocessing import StandardScaler
# 从仍然需要对训练和测试的特征数据进行标准化。
ss = StandardScaler()
X_train = ss.fit_transform(X_train)
X_test = ss.transform(X_test)
from sklearn.linear_model import LogisticRegression,SGDClassifier lgr = LogisticRegression()
lgr.fit(X_train, y_train)
lgr_predict = lgr.predict(X_test)
sgc = SGDClassifier()
sgc.fit(X_train, y_train)
sgc_predict = sgc.predict(X_test)
# 从sklearn.svm里导入基于线性假设的支持向量机分类器LinearSVC。
from sklearn.svm import LinearSVC,SVC,NuSVC
# 初始化线性假设的支持向量机分类器LinearSVC。
lsvc = LinearSVC(max_iter=3000)
#进行模型训练
lsvc.fit(X_train, y_train)
# 利用训练好的模型对测试样本的数字类别进行预测，
#预测结果储存在变量y_predict中。
lsvc_predict = lsvc.predict(X_test)
svc = SVC()
svc.fit(X_train, y_train)
svc_predict = svc.predict(X_test)
nusvc = NuSVC()
nusvc.fit(X_train, y_train)
nusvc_predict = nusvc.predict(X_test)
from sklearn.neighbors import KNeighborsClassifier
kneighbor = KNeighborsClassifier()
kneighbor.fit(X_train,y_train)
kneighbor_predict = kneighbor.predict(X_test)
from sklearn.naive_bayes import GaussianNB,BernoulliNB
gs = GaussianNB()
gs.fit(X_train,y_train)
gs_predict = gs.predict(X_test)
bnl = BernoulliNB()
bnl.fit(X_train,y_train)
bnl_predict = bnl.predict(X_test)
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
dtc.fit(X_train,y_train)
dtc_predict = dtc.predict(X_test)
from sklearn.ensemble import RandomForestClassifier
rfcc = RandomForestClassifier()
rfcc.fit(X_train,y_train)
rfcc_predict = rfcc.predict(X_test)
from sklearn.ensemble import GradientBoostingClassifier
gbcc = GradientBoostingClassifier()
gbcc.fit(X_train,y_train)
gbcc_predict = gbcc.predict(X_test)
from sklearn.metrics import classification_report
print('LogisticRegression',classification_report(y_test,
lgr_predict))
print('SGDClassifier',classification_report(y_test, sgc_predict)) print('LinearSVC',classification_report(y_test,
lsvc_predict))
print('SVC',classification_report(y_test,
svc_predict))
print('NuSVC',classification_report(y_test,
nusvc_predict))
print('KNeighbors',classification_report(y_test,
kneighbor_predict))
print('GaussianNB',classification_report(y_test,
gs_predict))
print('BernoulliNB',classification_report(y_test,
bnl_predict))
print('DecisionTreeClassifier',
classification_report(y_test,dtc_predict))
print('RandomForestClassifier',
classification_report(y_test,rfcc_predict))
print('GradientBoostingClassifier',
classification_report(y_test,gbcc_predict))。