精华内容
下载资源
问答
  • #输出错误率 t2 =time.time()print "Cost time: %.2fmin, %.4fs."%((t2-t1)//60,(t2-t1)%60) #测试耗时 if __name__ == "__main__": handwritingTest() 运行结果如下: 利用knn算法识别手写数字数据集,错误率为1.6%...

    在上一篇博文中,我们对KNN算法思想及流程有了初步的了解,KNN是采用测量不同特征值之间的距离方法进行分类,也就是说对于每个样本数据,需要和训练集中的所有数据进行欧氏距离计算。这里简述KNN算法的特点:

    优点:精度高,对异常值不敏感,无数据输入假定

    缺点:计算复杂度高,空间复杂度高

    适用数据范围:数值型和标称型(具有有穷多个不同值,值之间无序)

    knn算法代码:

    #-*- coding: utf-8 -*-

    from numpy import *

    importoperator

    import time

    from os import listdirdefclassify(inputPoint,dataSet,labels,k):

    dataSetSize= dataSet.shape[0] #已知分类的数据集(训练集)的行数

    #先tile函数将输入点拓展成与训练集相同维数的矩阵,再计算欧氏距离

    diffMat = tile(inputPoint,(dataSetSize,1))-dataSet #样本与训练集的差值矩阵

    sqDiffMat = diffMat ** 2 #差值矩阵平方

    sqDistances = sqDiffMat.sum(axis=1) #计算每一行上元素的和

    distances = sqDistances ** 0.5 #开方得到欧拉距离矩阵

    sortedDistIndicies = distances.argsort() #按distances中元素进行升序排序后得到的对应下标的列表

    #选择距离最小的k个点

    classCount ={}for i inrange(k):

    voteIlabel=labels[ sortedDistIndicies[i] ]

    classCount[voteIlabel]= classCount.get(voteIlabel,0)+1

    #按classCount字典的第2个元素(即类别出现的次数)从大到小排序

    sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse =True)return sortedClassCount[0][0]

    下面介绍如何使用knn算法对手写识别数据进行分类,这里构造的分类系统只能识别数字0到9,数字经图形处理软件处理成具有相同的色彩和大小,宽高为32x32像素,为了便于处理,已将图像转换为文本格式,其效果图如下:

    261043352604865.jpg

    数据集可在这里下载,解压后有两个目录,其中目录trainingDigits中包含了1934个例子,命名规则如 9_45.txt,表示该文件的分类是9,是数字9的第45个实例,每个数字大概有200个实例。testDigits目录中包含946个例子。使用trainingDigits中的数据作为训练集,使用testDigits中的数据作为测试集测试分类的效果。两组数据没有重叠。

    算法应用步骤如下:

    1. 数据准备:数字图像文本向量化,这里将32x32的二进制图像文本矩阵转换成1x1024的向量。循环读出文件的前32行,存储在向量中。

    #文本向量化 32x32 -> 1x1024

    defimg2vector(filename):

    returnVect=[]

    fr=open(filename)for i in range(32):

    lineStr=fr.readline()for j in range(32):

    returnVect.append(int(lineStr[j]))return returnVect

    2. 构建训练数据集:利用目录trainingDigits中的文本数据构建训练集向量,以及对应的分类向量

    #从文件名中解析分类数字

    defclassnumCut(fileName):

    fileStr= fileName.split('.')[0]

    classNumStr= int(fileStr.split('_')[0])returnclassNumStr

    #构建训练集数据向量,及对应分类标签向量deftrainingDataSet():

    hwLabels=[]

    trainingFileList= listdir('trainingDigits') #获取目录内容

    m =len(trainingFileList)

    trainingMat= zeros((m,1024)) #m维向量的训练集

    for i inrange(m):

    fileNameStr=trainingFileList[i]

    hwLabels.append(classnumCut(fileNameStr))

    trainingMat[i,:]= img2vector('trainingDigits/%s' %fileNameStr)return hwLabels,trainingMat

    3. 测试集数据测试:通过测试testDigits目录下的样本,来计算算法的准确率。

    #测试函数

    defhandwritingTest():

    hwLabels,trainingMat= trainingDataSet() #构建训练集

    testFileList = listdir('testDigits') #获取测试集

    errorCount = 0.0 #错误数

    mTest = len(testFileList) #测试集总样本数

    t1 =time.time()for i inrange(mTest):

    fileNameStr=testFileList[i]

    classNumStr=classnumCut(fileNameStr)

    vectorUnderTest= img2vector('testDigits/%s' %fileNameStr)#调用knn算法进行测试

    classifierResult = classify(vectorUnderTest, trainingMat, hwLabels, 3)print "the classifier came back with: %d, the real answer is: %d" %(classifierResult, classNumStr)if (classifierResult != classNumStr): errorCount += 1.0

    print "\nthe total number of tests is: %d" % mTest #输出测试总样本数

    print "the total number of errors is: %d" % errorCount #输出测试错误样本数

    print "the total error rate is: %f" % (errorCount/float(mTest)) #输出错误率

    t2 =time.time()print "Cost time: %.2fmin, %.4fs."%((t2-t1)//60,(t2-t1)%60) #测试耗时

    if __name__ == "__main__":

    handwritingTest()

    运行结果如下:

    261223526508319.png

    利用knn算法识别手写数字数据集,错误率为1.6%,算法的准确率还算可观。也可以通过改变变量k的值,观察错误率的变化,关于k值的选择,一般取一个比较小的数值,例如采用交叉验证法(简单来说,就是一部分样本做训练集,一部分做测试集)来选择最优的K值。

    通过运行以上代码,我们会发现knn算法的执行效率并不高,因为算法需要为每个测试向量计算约2000次欧氏距离,每个距离计算包括1024个维度浮点运算,全部样本要执行900多次,可见算法实际耗时长,另外,knn算法必须保存全部数据集,每次需为测试向量准备2MB的存储空间(2个1024x1024矩阵的空间)。所以如何优化算法,减少存储空间和计算时间的开销,需要我们进一步深入学习。

    参考资料:

    《机器学习实战》

    展开全文
  • 前言手写数字识别作为机器学习中一个比较有趣的内容,结合 K210 芯片强大的 KPU 算力,可以蹦出很多好玩的点子。本次以通俗易懂的方式记录一波玩耍手写数字识别的案例。目录相关理论基于 KNN 分类算法的模型搭建...

    前言

    手写数字识别作为机器学习中一个比较有趣的内容,结合 K210 芯片强大的 KPU 算力,可以蹦出很多好玩的点子。本次以通俗易懂的方式记录一波玩耍手写数字识别的案例。

    目录

    1. 相关理论
    2. 基于 KNN 分类算法的模型搭建(代码展示)
    3. 图片导入与分类预测(代码展示)

    1、相关理论

    1.1 图像二值化

    bdfb9dbd32a99962f3371bbadd6f2737.png

    如上图:是一个红色的数字4,像素尺寸为 32*32,即一共有1024个像素点,每个像素点的色彩值范围是0-255,其中0代表黑色,255代表白色,故本文以128为阈值进行划分。

    令单个像素点的色彩值为 x ,则:x<=128 时,取 x = 1,反之 x = 0

    经过上述变换,整张图片的色彩值就只有 0,1 两种了,此过程就是图片的二值化过程。

    1.2 二值化数据的存储

    经过二值化的图片,仍然有1024个像素点,只是其值仅有0,1两种,那么,怎样将图片的信息和模型之间建立联系呢?

    下图是一份包含多张手写图像信息的 EXCEL 表格。从第一行来看,其第一列代表图片中的数字,其它列为分别为1024个像素点的值。这样,每一行就包含了一张图片的信息。

    92d468dc35dca14a19baeb333e3b3da2.png

    所以后面需要做的工作就是训练模型,通过 1024 个像素点的信息推断出该行第一列所对应的信息。

    当然啦,上图中的训练数据均有结果对应,用于训练模型和检验模型的有效性;而手写的数字只有1024个像素点信息,所以需要通过训练好的模型进行预测,推断出图片中对应的数字。

    2、KNN 分类算法

    KNN 分类算法就比较简单了。盯着下图,最中间的这个圆当中有2个三角形和一个方块,它们各属于一个阵营。突然新来了一个五角星,那怎么判断五角星是属于哪个阵营呢?

    很明显,找出 K 个距离五角星最近的形状,比如 K=3,那么就选中了刚刚提到的这2个三角形和1个方块。其中,三角形比正方形多,显然三角形更牛逼,所以五角星跟它同阵营。这就是 KNN 分类的原理。

    41a6025af6d73e58a679ad1bbd0b069e.png

    至于距离的计算,高中数学里的欧式距离公式就能搞定:

    832c327bcc871a79d7e4f56448d29c82.png

    推广到多维变量,则有:

    d679a08933f19d41c83e8e11720955e8.png

    3、图片导入及分类预测

    3.1 导入 EXCEL 中的训练数据

    import pandas as pd
    df = pd.read_excel('data.xlsx')
    x = df.drop(columns = '对应数字')  # 抛弃第一列的因变量数据,保留自变量数据
    y = df['对应数字']                 # 第一列的因变量数据

    3.2 训练 KNN 模型

    from sklearn.model_selection import train_test_split
    xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size = 0.2,random_state = 123)
    from sklearn.neighbors import KNeighborsClassifier as KNN
    knn = KNN(n_neighbors=5)           # 算法 K 参数设置 [1:8]
    model = knn.fit(xtrain,ytrain)
    print(model)

    3.3 对预测模型进行评价

    from sklearn.metrics import accuracy_score
    y_pred = knn.predict(xtest)
    score2 = knn.score(xtest,ytest)    # 计算 knn 分类预测得分
    print('KNN预测模型评分为: ' + str(score2))

    3.4 图片数字导入及模型验证

    from PIL import Image
    img = Image.open('数字6.png')
    img = img.resize ((32,32))
    img = img.convert('L')  # 转换为灰度图
    # 图片二值化处理
    import numpy as np
    img_new = img.point (lambda x: 0 if x >128 else 1)   # 像素点控制,0为黑,255为白,所以取中间128作为阈值,对像素点二值化处理
    arr = np.array(img_new)                              # arr 为 32*32 像素点矩阵
    # 打印二值化图形
    for i in range(arr.shape[0]):                        # shape[0]代表行数,1代表列数
        print(arr[i])
    arr1 = arr.reshape(1,-1)                             # arr 转换为 1 行,(-1,1)为 1 列
    result = knn.predict(arr1)
    print('识别的数字为:' + str(result))

    4、效果展示

    4.1 KNN 模型评分情况

    从下图可以看出, KNN 模型的预测精度 score 表现还是非常不错的!

    16e3e9a9d8221aa1be2289f972d3c6ee.png

    4.2 图片二值化处理后的像素数据

    不难看出,1代表黑色部分,0代表白色部分;在像素矩阵中可以明显地体现 6 这个数字。

    cab10359dbff33927da9244fce804931.png

    4.3 预测结果

    64d887655163cfba344c3e61f79df48b.png

    其实,从 0 到 9 均测试了一遍,只有数字 8 比较刁钻,好几次预测成了 9;最后发现是截图的方式有点小问题,纠正以后,所有的数字均能够精准识别。

    5、结论

    最后,接 4.3 涉及的问题,有一个注意事项:截图的时候尽可能小,让数字充满整张图片,这样才能够有效保证识别的准确度。

    展开全文
  • 本文实例为大家分享了SVM手写数字识别功能的具体代码,供大家参考,具体内容如下1、SVM手写数字识别识别步骤:(1)样本图像的准备。(2)图像尺寸标准化:将图像大小都标准化为8*8大小。(3)读取未知样本图像,提取图像...

    3a2c5c47719654b2eb3ed26ac95e70d8.png

    本文实例为大家分享了SVM手写数字识别功能的具体代码,供大家参考,具体内容如下

    1、SVM手写数字识别

    识别步骤:

    (1)样本图像的准备。

    (2)图像尺寸标准化:将图像大小都标准化为8*8大小。

    (3)读取未知样本图像,提取图像特征,生成图像特征组。

    (4)将未知测试样本图像特征组送入SVM进行测试,将测试的结果输出。

    识别代码:

    #!/usr/bin/env python

    import numpy as np

    import mlpy

    import cv2

    print 'loading ...'

    def getnumc(fn):

    '''返回数字特征'''

    fnimg = cv2.imread(fn) #读取图像

    img=cv2.resize(fnimg,(8,8)) #将图像大小调整为8*8

    alltz=[]

    for now_h in xrange(0,8):

    xtz=[]

    for now_w in xrange(0,8):

    b = img[now_h,now_w,0]

    g = img[now_h,now_w,1]

    r = img[now_h,now_w,2]

    btz=255-b

    gtz=255-g

    rtz=255-r

    if btz>0 or gtz>0 or rtz>0:

    nowtz=1

    else:

    nowtz=0

    xtz.append(nowtz)

    alltz+=xtz

    return alltz

    #读取样本数字

    x=[]

    y=[]

    for numi in xrange(1,10):

    for numij in xrange(1,5):

    fn='nums/'+str(numi)+'-'+str(numij)+'.png'

    x.append(getnumc(fn))

    y.append(numi)

    x=np.array(x)

    y=np.array(y)

    svm = mlpy.LibSvm(svm_type='c_svc', kernel_type='poly',gamma=10)

    svm.learn(x, y)

    print u"训练样本测试:"

    print svm.pred(x)

    print u"未知图像测试:"

    for iii in xrange (1,10):

    testfn= 'nums/test/'+str(iii)+'-test.png'

    testx=[]

    testx.append(getnumc(testfn))

    print

    print testfn+":",

    print svm.pred(testx)

    样本:

    结果:

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。

    展开全文
  • 使用Python基于TensorFlow 卷积神经网络设计手写数字识别算法,并编程实现GUI 界面,构建手写数字识别系统。本系统界面设计友好,功能完善。通过测试,本识别系统对于较规范的手写体数字的识别达到了很好的识别效果...
  • 本文实例为大家分享了python实现手写数字识别的具体代码,供大家参考,具体内容如下import numpyimport scipy.special#import matplotlib.pyplotclass neuralNetwork:def __init__(self,inputnodes,hiddennodes,...

    本文实例为大家分享了python实现手写数字识别的具体代码,供大家参考,具体内容如下

    import numpy

    import scipy.special

    #import matplotlib.pyplot

    class neuralNetwork:

    def __init__(self,inputnodes,hiddennodes,outputnodes,learningrate):

    self.inodes=inputnodes

    self.hnodes=hiddennodes

    self.onodes=outputnodes

    self.lr=learningrate

    self.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)

    pass

    def train(self,inputs_list,targets_list):

    inputs=numpy.array(inputs_list,ndmin=2).T

    targets=numpy.array(targets_list,ndmin=2).T

    hidden_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_outputs

    hidden_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))

    pass

    def query(self,input_list):

    inputs=numpy.array(input_list,ndmin=2).T

    hidden_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_outputs

    input_nodes=784

    hidden_nodes=100

    output_nodes=10

    learning_rate=0.1

    n=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=2

    for 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.01

    targets=numpy.zeros(output_nodes)+0.01

    targets[int(all_values[0])]=0.99

    n.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.01

    outputs=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神经网络编程》中代码,仅做记录,以备后用。 

    ```python

    image_file_name=r"*.JPG"

    img_array=scipy.misc.imread(image_file_name,flatten=True)

    img_data=255.0-img_array.reshape(784)

    image_data=(img_data/255.0*0.99)+0.01

    图片对应像素的读取。因训练集灰度值与实际相反,故用255减取反。

    import numpy

    import scipy.special

    #import matplotlib.pyplot

    import scipy.misc

    from PIL import Image

    class neuralNetwork:

    def __init__(self,inputnodes,hiddennodes,outputnodes,learningrate):

    self.inodes=inputnodes

    self.hnodes=hiddennodes

    self.onodes=outputnodes

    self.lr=learningrate

    self.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)

    pass

    def train(self,inputs_list,targets_list):

    inputs=numpy.array(inputs_list,ndmin=2).T

    targets=numpy.array(targets_list,ndmin=2).T

    hidden_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_outputs

    hidden_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))

    pass

    def query(self,input_list):

    inputs=numpy.array(input_list,ndmin=2).T

    hidden_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_outputs

    input_nodes=784

    hidden_nodes=100

    output_nodes=10

    learning_rate=0.1

    n=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=2

    #for 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.01

    targets=numpy.zeros(output_nodes)+0.01

    targets[int(all_values[0])]=0.99

    n.train(inputs,targets)

    #image_file_name=r"C:\Users\lsy\Desktop\nn\1000-1.JPG"

    '''

    img_array=scipy.misc.imread(image_file_name,flatten=True)

    img_data=255.0-img_array.reshape(784)

    image_data=(img_data/255.0*0.99)+0.01

    #inputs=(numpy.asfarray(image_data)/255.0*0.99)+0.01

    outputs=n.query(image_data)

    label=numpy.argmax(outputs)

    print(label)

    '''

    #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=[]

    total=[0,0,0,0,0,0,0,0,0,0]

    rightsum=[0,0,0,0,0,0,0,0,0,0]

    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.01

    outputs=n.query(inputs)

    label=numpy.argmax(outputs)

    total[correct_lable]+=1

    if(label==correct_lable):

    scorecard.append(1)

    rightsum[correct_lable]+=1

    else:

    scorecard.append(0)

    scorecard_array=numpy.asarray(scorecard)

    print(scorecard_array)

    print("")

    print(scorecard_array.sum()/scorecard_array.size)

    print("")

    print(total)

    print(rightsum)

    for i in range(10):

    print((rightsum[i]*1.0)/total[i])

    #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)

    尝试统计了对于各个数据测试数量及正确率。

    原本想验证书后向后查询中数字‘9'识别模糊是因为训练数量不足或错误率过高而产生,然最终结果并不支持此猜想。

    另书中只能针对特定像素的图片进行学习,真正手写的图片并不能满足训练条件,实际用处仍需今后有时间改进。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持python博客。

    展开全文
  • 因为之前学习Python不是很深入,所以我需要对Python进一步学习。...三、因为我要做Python手写数字识别,所以还要接触一些深度学习,神经网络的知识,所以同时进行才好。 深度学习入门 一、网上找这部分的书籍,...
  • 看了上一篇内容之后,相信对K近邻算法有了一个清晰的认识,今天的内容——手写数字识别是对上一篇内容的延续,这里也是为了自己能更熟练的掌握k-NN算法。我们有大约2000个训练样本和1000个左右测试样本,训练样本...
  • 【实例简介】【实例截图】│ 8.png│ checkpoint│ demo01_ce.py│ demo02_tfdemo.py│ demo03_mnist.py│ demo04_mnist_test.py│ mnist_model.ckpt.data-00000-of-00001│ mnist_model.ckpt.index│ mnist_model....
  • 写在前面这一段的内容可以说是最难的一部分之一了,因为是识别图像,所以涉及到的算法会相比之前的来说比较困难,所以我尽量会讲得清楚一点。而且因为在编写的过程中,把前面的一些逻辑也修改了一些,将其变得更完善...
  • python 手写数字识别知识不用多说,本文只要讲解在手写数字识别开发过程中所遇到的坑。 1、训练模型 通过keras训练模型,并保存该模型 import numpy from keras.datasets import mnist from keras.models ...
  • 模式识别课程小作业老师要求:用MATLAB实现手写数字识别,用GUI设计出可以用鼠标来写数字的输入板(竟然不是直接给图片)沉浸在Python+Tensorflow/Caffe的世界里,完全没用过GUI的我眼泪掉下来。玉米找了好久的资料...
  • 本文实例讲述了Python利用逻辑回归模型解决MNIST手写数字识别问题。分享给大家供大家参考,具体如下:1、MNIST手写识别问题MNIST手写数字识别问题:输入黑白的手写阿拉伯数字,通过机器学习判断输入的是几。可以通过...
  • Python 手写数字识别实战分享

    千次阅读 2020-05-13 21:25:28
    手写数字识别作为一个深度学习类入门级别的应用,被广大爱好者所使用,在实际的工作中正好有一个实际的场景需求用到了数字和字母的识别,这里先以手写数字识别为例来对该类型的任务进行讲解。 本文的实践主要是...
  • Python手写数字识别+GUI界面+手写板设计

    千次阅读 多人点赞 2020-01-22 16:11:36
    本文使用Python基于TensorFlow 卷积神经网络设计手写数字识别算法,并编程实现GUI 界面,构建手写数字识别系统。本系统界面设计友好,功能完善。通过测试,本识别系统对于较规范的手写体数字的识别达到了很好的识别...
  • Pytorch实战1:LeNet手写数字识别 (MNIST数据集)发布时间:2018-04-26 10:57,浏览次数:935, 标签:...Pytorch实战1:LeNet手写数字识别 (MNIST数据集)实验环境:* Pytorch 0.4.0* torchvision 0.2.1* Python 3.6* ...
  • MINIST手写数字识别——06.总结训练之后,检查模型的预测准确度。用 MNIST 训练的时候,一般 softmax 回归模型的分类准确率为约为 92.64%,多层感知器为98.15%,卷积神经网络可以达到 99.01%。应用模型可以使用训练...
  • 以下是 ANN MNIST 手写数字识别程序和结果,数据集是经典的 Yann LeCun (人工智能 界大佬) MNIST 数据集,每张照片大小是 28 * 28 的灰度图,训练集 5000 张图片,验证集 1000 张图片,测试集 10000 张:
  • fileNameStr.split('.')[0] ##获取列表中每一个文件名(不包含扩展名) numClass = fileName.split('_')[0] ##获取该文件所属的类别(因为文件名都是以‘数字类别_第几个样本.txt’形式的,所以需要进行两次的split函数...
  • PythonOpenCV用HOG+SVM识别手写数字实例程序。采用附件的图作为训练与测试集。
  • 恩墨大数据系列免费课之《图像识别揭秘 -Python 手写数字识别》于今晚 20 : 00 开讲了,由 9 年 IT 从业经...
  • 1 importnumpy as np2 importscipy.special as ss3 importmatplotlib.pyplot as plt4 importimageio as im5 importglob as gl678 classNeuralNetwork:9 #initialise the network10 def __init__(self, input...
  • 导库import numpy as npimport matplotlib.pyplot as pltimport tensorflow as tffrom tensorflow import kerasfrom tensorflow.keras import layers读取mnist数据import numpy as nppath='./mnist.npz'f = np.load...
  • Talk is cheap , show U the code....手写数字识别 MNIST 数据集基于线性假设的支持向量机分类器LinearSVC# coding: utf-8# In[1]:# 从sklearn.datasets里导入手写体数字加载器。from sklearn.datasets ...
  • 本文使用Python基于TensorFlow 卷积神经网络设计手写数字识别算法,并编程实现GUI 界面,构建手写数字识别系统。本系统界面设计友好,功能完善。通过测试,本识别系统对于较规范的手写体数字的识别达到了很好的识别...
  • 补充:由于很多同学找我要原数据集和代码,所以我上传到了资源里,https://download..net/download/zugexiaodui/10913834初学机器学习,第一步是做一个简单的手写数字识别,我选用的是MNIST数据集(用其他数据集也...
  • 准备:使用python导入数据 第一部分是关于数据的导入。 from numpy import * import operator def createDataSet(): group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]]) labels = ['A','A','B','B'] return group...
  • 42019-04-21 16:02:01 +08:00# import tensorflow as tf# dnn 神经网络import osos.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'# x = tf.Variable(3, name="x")# y = tf.Variable(4, name="y")# f = x*x*y + y + 2# # ...
  • fileNameStr.split('.')[0] ##获取列表中每一个文件名(不包含扩展名) numClass = fileName.split('_')[0] ##获取该文件所属的类别(因为文件名都是以‘数字类别_第几个样本.txt’形式的,所以需要进行两次的split...
  • 爬虫Python基础、数据分析扩展包Numpy、pandas、matplotlib,Python读取MySQL数据,Python爬虫及Scrapy框架,无监督机器学习算法聚类分析等,以及案例:互联网金融行业客户价值分析等。机器学习机器学习是一门多领域...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,452
精华内容 980
关键字:

python手写数字识别

python 订阅