基于KNN的手写数字模式识别设计与实现代码大全
Python实现识别手写数字Python图片读入与处理
Python实现识别⼿写数字Python图⽚读⼊与处理写在前⾯在上⼀篇⽂章中，我们已经讲过了我们想要写的全部思路，所以我们不再说全部的思路。
我这⼀次将图⽚的读⼊与处理的代码写了⼀下，和⼤纲写的过程⼀样，这⼀段代码分为以下⼏个部分：读⼊图⽚；将图⽚读取为灰度值矩阵；图⽚背景去噪；切割图⽚，得到⼿写数字的最⼩矩阵；拉伸/压缩图⽚，得到标准⼤⼩为100x100⼤⼩矩阵；将图⽚拉为1x10000⼤⼩向量，存⼊训练矩阵中。
所以下⾯将会对这⼏个函数进⾏详解。
代码分析基础内容⾸先我们现在最前⾯定义基础变量import osfrom skimage import ioimport numpy as np##Essential vavriable 基础变量#Standard size 标准⼤⼩N = 100#Gray threshold 灰度阈值color = 100/255其中标准⼤⼩指的是我们在最后经过切割、拉伸后得到的图⽚的尺⼨为NxN。
灰度阈值指的是在某个点上的灰度超过阈值后则变为1.接下来是这图像处理的⼀部分的主函数filenames = os.listdir(r"./num/")pic = GetTrainPicture(filenames)其中filenames得到在num⽬录下所有⽂件的名称组成的列表。
pic则是通过函数GetTrainPicture得到所有训练图像向量的矩阵。
这⼀篇⽂章主要就是围绕这个函数进⾏讲解。
GetTrainPicture函数GetTrainPicture函数内容如下#Read and save train picture 读取训练图⽚并保存def GetTrainPicture(files):Picture = np.zeros([len(files), N**2+1])#loop all pictures 循环所有图⽚⽂件for i, item in enumerate(files):#Read the picture and turn RGB to grey 读取这个图⽚并转为灰度值img = io.imread('./num/'+item, as_grey = True)#Clear the noise 清除噪⾳img[img>color] = 1#Cut the picture and get the picture of handwritten number#将图⽚进⾏切割，得到有⼿写数字的的图像img = CutPicture(img)#Stretch the picture and get the standard size 100x100#将图⽚进⾏拉伸，得到标准⼤⼩100x100img = StretchPicture(img).reshape(N**2)#Save the picture to the matrix 将图⽚存⼊矩阵Picture[i, 0:N**2] = img#Save picture's name to the matrix 将图⽚的名字存⼊矩阵Picture[i, N**2] = float(item[0])return Picture可以看出这个函数的信息量⾮常⼤，基本上今天做的所有步骤我都把封装到⼀个个函数⾥⾯了，所以这⾥我们可以看到图⽚处理的所有步骤都在这⾥。
knn算法手写数字识别案例
knn算法手写数字识别案例1. 啥是knn算法呀？咱得先搞清楚这个knn算法是个啥玩意儿。
简单来说呢，knn算法就是K近邻算法啦。
它的想法可挺有意思的哦，就好比你想知道一个新同学的性格特点，你就去看看他身边那几个最亲近的同学是啥样的，然后大致就能猜出这个新同学的性格啦。
在数据世界里呢，这个算法就是通过找离某个数据点最近的K个邻居，然后根据这K个邻居的情况来判断这个数据点的类别。
比如说，我们要识别手写数字，那就看看和这个手写数字长得最像的那K个数字都是啥，然后就可以猜猜这个数字是几啦，是不是挺好玩的呀？2. 手写数字识别这事儿。
咱再来说说手写数字识别哈。
想象一下，每个人写数字的风格都不太一样，有的人写得规规矩矩，有的人写得龙飞凤舞。
那计算机怎么能认出这些千奇百怪的数字呢？这就需要一些巧妙的办法啦。
咱得把这些手写数字变成计算机能理解的形式，一般就是把图像转化成数字矩阵，每个像素点都有一个数值来表示它的亮度或者颜色啥的。
这样，计算机就能对这些数字矩阵进行处理啦。
3. 用knn算法来识别手写数字。
那knn算法在手写数字识别里是怎么干活的呢？当我们有了一堆已经知道是啥数字的手写数字样本（这就好比是有了很多已经熟悉的同学），然后来了一个新的手写数字（这就是那个新同学啦）。
算法就会计算这个新数字和那些样本数字之间的距离，比如说欧几里得距离或者曼哈顿距离啥的，反正就是看它们长得像不像。
然后找出离这个新数字最近的K个样本数字。
如果这K个数字里大多数都是数字“3”，那我们就很有可能认为这个新数字也是“3”啦。
4. 举个小例子呗。
给大家举个简单的例子哈。
假设我们有100张手写数字的图片，已经知道每张图片上写的是啥数字了。
现在来了一张新的手写数字图片，我们设K = 5。
算法一算，发现离这张新图片最近的5张样本图片里，有3张写的是“5”，1张写的是“6”，1张写的是“4”。
那按照少数服从多数的原则，我们就可以认为这张新图片上写的是“5”啦。
手写数字识别系统的设计与实现
手写数字识别系统的设计与实现一、绪论随着机器学习及神经网络技术的发展，人工智能正在不断向更广泛的领域渗透，尤其是在图像处理领域。
手写数字识别系统也因此应运而生，被广泛应用于各种场景中，例如验证码识别、手写板输入、银行支票识别等。
本文将介绍一种手写数字识别系统的设计与实现，以帮助读者深入了解该领域的技术。
二、系统设计本手写数字识别系统采用支持向量机（SVM）算法。
系统开发基于Python编程语言和OpenCV图像处理库进行，共分为以下四个模块：2.1 数据采集模块数据采集模块通过获取手写数字原始图像，采集大量的训练数据集和测试数据集。
该模块通过调用计算机的摄像头进行数据采集，将原始图像转化为数字图像，表示手写数字的像素。
在采集数据时，需要注意手写数字应该尽可能接近正方形，大小需要尽量一致，以保证后续的数字处理和识别效果。
数据采集完成后，需要对采集到的数据进行分类标注，即手写数字的分类，一般采用数字0-9进行标注。
2.2 特征提取模块在特征提取模块中，我们需要将数字图像转化为一组数字特征，以便于后续的数字图像比较和分类识别。
目前最常用的数字特征是手写数字的边界轮廓。
该模块通过调用OpenCV库中的边界检测函数获取数字的边界轮廓。
检测出轮廓后，我们可以使用等高线函数对其进行平滑处理，再通过描绘轮廓的关键点获取有效特征向量。
2.3 训练模型模块在训练模型模块中，我们需要将已经提取出的数字特征向量和其分类标注进行学习，训练得到一个能够正确识别数字的模型。
本系统采用了支持向量机（SVM）算法来实现数字的分类识别。
SVM算法有着很好的泛化性能和分类性能，并且适用于高维特征的数据集。
在训练模型时，我们首先对原始数据进行归一化处理，使其在相同量级内。
然后使用SVM训练模型，通过交叉验证的方式调整模型超参数，以达到最优分类效果。
2.4 数字识别模块数字识别模块是手写数字识别系统最核心的部分。
在该模块中，输入待识别的数字，对它进行特征提取，然后将其送入训练得到的SVM分类模型中进行分类，最终输出数字的识别结果。
手写数字识别代码解释
一. 进行数据预处理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通道，单色），第二维和第三维是长度和宽度。
KNN算法实现代码（Java）
KNN算法实现代码（Java）public class KNN {/*** 设置优先级队列的比较函数，距离越大，优先级越高*/private Comparator comparator =new Comparator(){ public int compare(KNNNode o1, KNNNode o2) {if (o1.getDistance() >= o2.getDistance())return -1;elsereturn 1;}};/*** 获取K个不同的随机数* @param k 随机数的个数* @param max 随机数最大的范围* @return 生成的随机数数组*/public List getRandKNum(int k, int max) {List rand = new ArrayList(k);for (int i = 0; i < k; i++) {int temp = (int) (Math.random() * max);if (!rand.contains(temp))rand.add(temp);elsei--;}return rand;}/*** 计算测试元组与训练元组之前的距离* @param d1 测试元组* @param d2 训练元组* @return 距离值*/public double calDistance(List d1, List d2) {double distance = 0.00;for (int i = 0; i < d1.size(); i++)distance += (d1.get(i) - d2.get(i)) *(d1.get(i)-d2.get(i)); return distance;}/*** 执行KNN算法，获取测试元组的类别* @param datas 训练数据集* @param testData 测试元组* @param k 设定的K值* @return 测试元组的类别*/public String knn(List<list> datas, List testData, int k) { PriorityQueue pq = new PriorityQueue (k,comparator);List randNum = getRandKNum(k, datas.size());for (int i = 0; i < k; i++) {int index = randNum.get(i);List currData = datas.get(index);String c = currData.get(currData.size() - 1).toString(); KNNNode node = new KNNNode(index,calDistance(testData, currData), c);pq.add(node);}for (int i = 0; i < datas.size(); i++) {List t = datas.get(i);double distance = calDistance(testData, t);KNNNode top = pq.peek();if (top.getDistance() > distance) {pq.remove();pq.add(new KNNNode(i, distance, t.get(t.size() - 1). toString()));}}return getMostClass(pq);}/*** 获取所得到的k个最近邻元组的多数类* @param pq 存储k个最近近邻元组的优先级队列* @return 多数类的名称*/private String getMostClass(PriorityQueue pq) {Map classCount=new HashMap();int pqsize = pq.size();for (int i = 0; i < pqsize; i++) {KNNNode node = pq.remove();String c = node.getC();if (classCount.containsKey(c))classCount.put(c, classCount.get(c) + 1);elseclassCount.put(c, 1);}int maxIndex = -1;int maxCount = 0;Object[] classes = classCount.keySet().toArray();for (int i = 0; i < classes.length; i++) {if (classCount.get(classes[i]) > maxCount) maxIndex = i; maxCount = classCount.get(classes[i]); }return classes[maxIndex].toString();}}</list。
基于KNN算法的手写数字识别
基于KNN算法的手写数字识别作者：李诗语王峰曹彬梅琪肖飞来源：《电脑知识与技术》2017年第25期摘要：一直以来，让机器具有模式识别能力一直是计算机科学家们的努力方向。
研究模式识别，是理解人类智能的本质的重要途径。
字符识别是一个典型的模式识别问题，手写数字识别具有不同字符体型相差不大，相同字符有多种不同写法，数字没有上下文关联等特点，这些特点使手写数字识别比较困难。
该论文设计了一套基于KNN算法，用Python语言实现手写数字识别系统。
先对图片进行预处理，预处理包括灰度化、去噪、二值化等等，再用KNN算法对图片进行分类，手写数字识别也是一个十分类的问题。
实验结果表明该文所设计的手写数字识别具有较好的识别率，同时也说明KNN算法在手写数字识别上具有良好的应用。
关键词：KNN算法；Python语言；模式识别；预处理；手写数字识别中图分类号：TP391.43 文献标识码：A 文章编号：1009-3044（2017）25-0175-03Abstract： All along， There always been a direction of computer scientists' efforts of Making the machine a pattern recognition capability. Research pattern recognition is an important way to understand the essence of human intelligence. Character recognition is a typical pattern recognition problem. Handwritten digital recognition has different characters. The same characters have many different Wordings， and the numbers are not context-sensitive. These features make handwritten digital recognition difficult. This paper designs a set of KNN algorithm Based on Python language to achieve handwritten digital recognition system. First of all， the image preprocessing， including gray， denoising， binarization， etc.， and then use KNN algorithm to classification image， the handwritten digital recognition is a ten classification problem. The experimental results show that the handwritten digital recognition in this paper has a good recognition rate， and also shows that KNN algorithm has a good application in handwritten numeral recognition.Key words： KNN algorithm； Python language； pattern recognition； preprocessing；handwritten numeral recognition1 绪论1.1 研究的背景光学字符识别是图像处理与模式识别领域的一个重要分支。
kNN（k近邻）算法代码实现
kNN（k近邻）算法代码实现⽬标：预测未知数据(或测试数据)X的分类y批量kNN算法1.输⼊⼀个待预测的X(⼀维或多维)给训练数据集,计算出训练集X_train中的每⼀个样本与其的距离2.找到前k个距离该数据最近的样本-->所属的分类y_train3.将前k近的样本进⾏统计，哪个分类多，则我们将x分类为哪个分类# 准备阶段：import numpy as np# import matplotlib.pyplot as pltraw_data_X = [[3.393533211, 2.331273381],[3.110073483, 1.781539638],[1.343808831, 3.368360954],[3.582294042, 4.679179110],[2.280362439, 2.866990263],[7.423436942, 4.696522875],[5.745051997, 3.533989803],[9.172168622, 2.511101045],[7.792783481, 3.424088941],[7.939820817, 0.791637231]]raw_data_y = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]X_train = np.array(raw_data_X)y_train = np.array(raw_data_y)x = np.array([8.093607318, 3.365731514])核⼼代码：⽬标：预测未知数据(或测试数据)X的分类y批量kNN算法1.输⼊⼀个待预测的X(⼀维或多维)给训练数据集,计算出训练集X_train中的每⼀个样本与其的距离2.找到前k个距离该数据最近的样本-->所属的分类y_train3.将前k近的样本进⾏统计，哪个分类多，则我们将x分类为哪个分类from math import sqrtfrom collections import Counter# 已知X_train，y_train# 预测x的分类def predict(x, k=5):# 计算训练集每个样本与x的距离distances = [sqrt(np.sum((x-x_train)**2)) for x_train in X_train] # 这⾥⽤了numpy的fancy⽅法，np.sum((x-x_train)**2) # 获得距离对应的索引，可以通过这些索引找到其所属分类y_trainnearest = np.argsort(distances)# 得到前k近的分类ytopK_y = [y_train[neighbor] for neighbor in nearest[:k]]# 投票的⽅式，得到⼀个字典，key是分类，value数个数votes = Counter(topK_y)# 取出得票第⼀名的分类return votes.most_common(1)[0][0] # 得到y_predictpredict(x, k=6)⾯向对象的⽅式，模仿sklearn中的⽅法实现kNN算法：import numpy as npfrom math import sqrtfrom collections import Counterclass kNN_classify:def__init__(self, n_neighbor=5):self.k = n_neighborself._X_train = Noneself._y_train = Nonedef fit(self, X_train, y_train):self._X_train = X_trainself._y_train = y_trainreturn selfdef predict(self, X):'''接收多维数据，返回y_predict也是多维的'''y_predict = [self._predict(x) for x in X]# return y_predictreturn np.array(y_predict) # 返回array的格式def _predict(self, x):'''接收⼀个待预测的x，返回y_predict'''distances = [sqrt(np.sum((x-x_train)**2)) for x_train in self._X_train] nearest = np.argsort(distances)topK_y = [self._y_train[neighbor] for neighbor in nearest[:self.k]]votes = Counter(topK_y)return votes.most_common(1)[0][0]def__repr__(self):return'kNN_clf(k=%d)' % self.k。
05-05主成分分析代码（手写数字识别）
05-05主成分分析代码（⼿写数字识别）⽬录⼈⼯智能从⼊门到放弃完整教程⽬录：主成分分析代码(⼿写数字识别)⼀、导⼊模块import timeimport numpy as npimport matplotlib.pyplot as pltfrom matplotlib.font_manager import FontPropertiesfrom sklearn import datasetsfrom sklearn.model_selection import train_test_splitfrom sklearn.decomposition import PCAfrom sklearn.neighbors import KNeighborsClassifier%matplotlib inlinefont = FontProperties(fname='/Library/Fonts/Heiti.ttc')⼆、数据预处理# 导⼊⼿写识别数字数据集digits = datasets.load_digits()X = digits.datay = digits.targetX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)三、KNN训练数据knn = KNeighborsClassifier()knn.fit(X_train, y_train)KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',metric_params=None, n_jobs=None, n_neighbors=5, p=2,weights='uniform')3.1 准确度knn.score(X_train, y_train)0.9866369710467706四、降维(2维)pca = PCA(n_components=2)pca.fit(X_train)X_train_reduction = pca.transform(X_train)X_test_reduction = pca.transform(X_test)4.1 KNN训练数据begin = time.time()knn = KNeighborsClassifier()knn.fit(X_train_reduction, y_train)end = time.time()print('训练耗时:{}'.format(end-begin))训练耗时:0.00115680694580078124.2 准确度knn.score(X_test_reduction, y_test)0.62666666666666674.3 ⼆维特征⽅差⽐例pca.explained_variance_ratio_array([0.14566794, 0.13448185])五、查看原始数据特征⽅差⽐例pca = PCA(n_components=X_train.shape[1])pca.fit(X_train)pca.explained_variance_ratio_array([1.45667940e-01, 1.34481846e-01, 1.19590806e-01, 8.63833775e-02,5.90548655e-02, 4.89518409e-02, 4.31561171e-02, 3.63466115e-02,3.41098378e-02, 3.03787911e-02, 2.38923779e-02, 2.24613809e-02,1.81136494e-02, 1.81125785e-02, 1.51771863e-02, 1.39510696e-02,1.32079987e-02, 1.21938163e-02, 9.95264723e-03, 9.39755156e-03,9.02644073e-03, 7.96537048e-03, 7.64762648e-03, 7.10249621e-03,7.04448539e-03, 5.89513570e-03, 5.65827618e-03, 5.08671500e-03,4.97354466e-03, 4.32832415e-03, 3.72181436e-03, 3.42451450e-03,3.34729452e-03, 3.20924019e-03, 3.03301292e-03, 2.98738373e-03,2.61397965e-03, 2.28591480e-03, 2.21699566e-03, 2.14081498e-03,1.86018920e-03, 1.57568319e-03, 1.49171335e-03, 1.46157540e-03,1.17829304e-03, 1.06805854e-03, 9.41934676e-04, 7.76116004e-04,5.59378443e-04, 3.65463486e-04, 1.71625943e-04, 8.78242589e-05,5.20662123e-05, 5.19689192e-05, 4.16826522e-05, 1.50475650e-05,4.42917130e-06, 3.53610879e-06, 7.14554374e-07, 6.80092943e-07,3.48757835e-07, 8.17776361e-34, 8.17776361e-34, 7.97764241e-34])5.1 主成分所占⽅差⽐例plt.plot([i for i in range(X_train.shape[1])],[np.sum(pca.explained_variance_ratio_[:i+1]) for i in range(X_train.shape[1])],c='r') plt.xlabel('前n个主成分',fontproperties=font)plt.ylabel('前n个主成分⽅差所占⽐例',fontproperties=font)plt.show()通过上图可以确定取多少⽐例的主成分能平衡模型的准确率和训练速度。
基于python模式识别系统的设计与实现代码大全
题目基于python模式识别系统的设计与实现1．1 题目的主要研究内容（宋体四号加粗左对齐）（1）工作的主要描述（宋体小四号不加粗1.5倍行距）设计一个车牌识别系统，有GUI界面。
选择一张有车牌的图片后，完成车牌定位、倾斜校正、字符分割，最后通过k-NN算法对车牌的字母和数字进行识别，将识别结果在GUI界面中显示出来。
（2）系统流程图1．2 题目研究的工作基础或实验条件软件环境：语言：python IDLE：prcharm1．3 数据集描述采用了大量的拥有不同细节的从A到Z的26个英文字母以及从0到9的数字图片作为该项目的训练数据集1．4 特征提取过程描述首先进行车牌定位：车牌定位就是在图片中识别出哪个位置有车牌，是字符分割和字母数字识别的前提，是车牌识别系统的关键和难点。
具体算法如下：1.对原始图像进行高斯模糊，减少噪点。
2.提取图像边缘。
首先将彩色图像转为灰度图gray，利用大核对灰度图进行开操作得到图像open，相当于对灰度图进行涂抹操作，将灰度图gray和开操作后的图像open按1：-1的比例融合得到图像add，以上操作可以将大面积灰度值相似的地方置黑，可以减少车灯、背景、地面、挡风玻璃等细节。
接着使用canny算法对融合图像add提取边缘，得到图像canny。
以下是得到图像canny 的步骤图：3.使用横向长条作为核对边缘图像进行一次闭操作，得到图像close，相当于对边缘横向涂抹，因为一般视角车牌是宽大于高的矩形。
再对图像close进行一次开操作，得到图像open2，消除较细的线条和不大的竖向线条，从而将车牌位置的连通区域独立出来。
4.查找连通区域，通过最小外接矩形的宽高比2~5.5筛选合适的连通区域。
5.将最小外接矩形图像旋转矫正，上下左右向外扩展一点范围，避免连通区域没能覆盖车牌造成影响。
6.将连通区域原图转为HSV图像，确定图像的主要颜色，若不为蓝、黄、绿，则排除。
按照3种颜色对车牌进行精细定位，缩小范围。
python的knn算法代码
python的knn算法代码KNN（K-近邻）算法是一种基于实例的学习方法，它的本质思想是：如果一个样本在特征空间中的k个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，则该样本也属于这个类别。
下面是Python实现KNN的代码：1. 导入必要的库```pythonimport numpy as npimport pandas as pdfrom sklearn.datasets import load_irisfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score```2. 加载数据```pythoniris = load_iris()x = iris.datay = iris.target```3. 划分数据集```pythonx_train, x_test, y_train, y_test = train_test_split(x, y,test_size=0.2, random_state=42)```4. 定义KNN算法```pythondef knn(x_train, y_train, x_test, k):y_pred = []for i in range(len(x_test)):# 计算测试样本与每个训练样本的距离distances = np.sqrt(np.sum(np.square(x_train - x_test[i, :]), axis=1))# 距离从小到大排序，取前k个sorted_dist_idx = np.argsort(distances)[:k]# 统计这k个样本中每个类别的数量class_count = np.zeros(3)for j in range(k):class_count[y_train[sorted_dist_idx[j]]] += 1 # 找到数量最多的类别max_count_idx = np.argmax(class_count)y_pred.append(max_count_idx)return y_pred```5. 调用KNN算法进行预测```pythony_pred = knn(x_train, y_train, x_test, 3)```6. 计算模型的准确率```pythonaccuracy = accuracy_score(y_test, y_pred)print('accuracy:', accuracy)```KNN算法是一个简单而又有效的分类算法，其实现也比较容易，可以通过上述代码实现KNN算法的功能。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
基于模式识别系统的设计与实现
1．1 题目的主要研究内容
（1）运用KNN算法实现手写数字识别过程的主要描述：直接从sklearn 中加载自带的手写数字数据集，通过可视化的方式来查看图像的呈现；接着让数据规范化可以让数据都在同一个数量级的维度。
将全部的图像数据作为特征值矩阵；最后通过训练可以得到KNN分类器，然后用测试集进行准确率的计算。
下图是系统流程图：
（2）运用图像特征提取算法LBP，在图像颜色调成黑白色的基础上，以及使用像素点描绘图像和画出图像的大致轮廓。
1．2 题目研究的工作基础或实验条件
（1）硬件环境Win10 Intel(R)
（2）软件环境（开发工具python）
1．3 数据集描述
（1）手写数字数据集：
包含1797个0-9的手写数字数据，每个数据由8 * 8 大小的矩阵构成，矩阵中值的范围是0-16，代表颜色的深度。
（2）在网上下载的16张演员图像
1．4 特征提取过程描述
（1）手写数字数据集中的1797个数据，代表了0~9是个数字类别，每个数据由8 * 8 大小的矩阵构成，矩阵中值的范围是0-16，代表颜色的深度，颜色越深，矩阵中的值越大。
根据颜色的深度可以描绘出大致轮廓，因此可以判断此数据属于那一个数。
（2）运用cv2.cvtColor将原图像进行灰色处理，接着利用图像特征提取算法：LBP，实现在灰色图像的基础上用像素点处理，再用filters.sobel对图像进行轮廓的提取。
1．5 分类过程以及准确率描述
（1）通过上文的特征提取过程，将1797个包含0-9的手写数字的数据，识别出了0、1、2、3、4、5、6、7、8、9十个数，如果以0~9中的每个数代表一类，这样就把1797个数据集分成了0~9一共十个类别。
分割数据，将25%的数据作为测试集，其余作为训练集，创建KNN分类器对准确率进行计算。
（2）无分类过程
1．6 主要程序代码(要求必须有注释)
（1）程序一：
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_digits
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
#加载数据
digits = load_digits()
data = digits.data
#数据探索
print(data.shape)
# 查看第七幅图像
print(digits.images[6])
# 第七幅图像代表的数字含义
print(digits.target[6])
# 将第七幅图像显示出来
plt.gray()
plt.imshow(digits.images[6])
plt.show()
# 分割数据，将25%的数据作为测试集，其余作为训练集
train_x, test_x, train_y, test_y = train_test_split(data, digits.target, test_size=0.25, random_state=33)
# 采用Z-Score规范化
ss = preprocessing.StandardScaler()
train_ss_x = ss.fit_transform(train_x)
test_ss_x = ss.transform(test_x)
# 创建KNN分类器
knn = KNeighborsClassifier(n_neighbors=4)
knn.fit(train_ss_x, train_y)
predict_y = knn.predict(test_ss_x)
print("KNN准确率: %.4lf" % accuracy_score(test_y, predict_y))
（2）程序二：
import skimage
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import cv2
# settings for LBP
radius = 1 # LBP算法中范围半径的取值
n_points = 8 * radius # 领域像素点数
# 读取图像
image = cv2.imread('D:\SogouDownload/a/16.jpeg')
#显示到plt中，需要从BGR转化到RGB，若是cv2.imshow(win_name, image)，则不需要转化
#显示原图像
image1 = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
plt.subplot(111)
plt.imshow(image1)
plt.show()
#将图像颜色调成灰色
image = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
plt.subplot(111)
plt.imshow(image, plt.cm.gray)
plt.show()
#利用像素点描绘图像
lbp = local_binary_pattern(image, n_points, radius)
plt.subplot(111)
plt.imshow(lbp, plt.cm.gray)
plt.show()
#进行轮廓提取
edges = filters.sobel(image)
plt.subplot(111)
plt.imshow(edges, plt.cm.gray)
plt.show()
1．7 运行结果及分析
（1）第七幅图像
（2）图像特征后的图像（示例）
原图像
描绘图像轮廓用像素点处理图像。