精华内容
下载资源
问答
  • 手写识别字中input_data文件和数据集,用来做手写识别字练习的基础
  • cnn实现手写识别字体代码详解

    千次阅读 2017-02-27 00:45:48
    cnn实现手写识别字体代码详解 tf.nn.max_pool tf.nn.conv2d

    按照tensorflow 官方文档 实现,并对代码进行了详解

    #!/usr/bin/env python
    #-*- coding: utf-8 -*-
    
    # File Name: mnist_beginners/mnist_pros.py
    # Author: pcf
    # Created Time: 2017-02-25
    
    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    
    # 创建一个多层卷积网络
    
    # 权重初始化
    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.1)
        return tf.Variable(initial)
    
    # bias 初始化
    def bias_variable(shape):
        initial = tf.constant(0.1, shape=shape)
        return tf.Variable(initial)
    
    # 卷积
    def conv2d(x, w):
        return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding="SAME")
    
    # 2x2 max pooling
    # ksize=[patch, height, width, channel], 该参数为[1,2,2,1]表示
    # 不在patch 和channel上池化.  
    # strides=[patch, height,width,channel] 1表示跨越为1,当stride大于一的时候,
    # stride>1相当于卷积和下采样两个操作,在实际操作中,strides>1比卷积加下采样计算量少了好几倍,具有很强的实践意义
    def max_pool_2x2(x):
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    
    
    mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
    sess = tf.InteractiveSession()
    
    x = tf.placeholder("float", shape=[None, 784])
    y_ = tf.placeholder("float", shape=[None, 10])
    
    W = tf.Variable(tf.zeros([784,10]))
    b = tf.Variable(tf.zeros([10]))
    
    # 第一层卷积
    # 前三个是patch大小,patch的shape是(5,5,1),第三个参数是输入的通道数目,这个一般是和上层相同的,即深度上保持一致。最后一个是输出通道的数目
    # 输入通道的数目代表输入通道侧有几个卷积核,输出通道的数目代表输出通道侧
    # 到下一层有几个卷积核. 这一层卷积产生了32个28x28的feature map. 
    # 第一层卷积一共有32个卷积核需要学习.因为下面的图像是黑白图像输入通道为1,
    # 故而这儿第三个参数设置为1。如果图片为彩色, 这儿第三个参数应该设置为3
    w_conv1 = weight_variable([5, 5, 1, 32])
    
    b_conv1 = bias_variable([32])
    
    # x_image用于卷积的输入。shape的四个元素。  
    # 第二个,第三个对应图片的宽高,最后一维代表图片的颜色通道数,如果是彩色则为3,代表了3基色,
    # 相当于图像由三张图像叠加形成的,每张图像由其中一种基色组成. 
    # 第一个数-1表示元素的个数除以后三个数后的数,表示训练时一个batch的图片数量.
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    
    # relu神经元, 相比sogmoid函数优势是引入稀疏性,可以加快训练,
    # 防止梯度消失, 学习特征快,deeplearning中的大部分激活函数应该选择relu
    # 在训练的时候relu单元可能'死掉', 特别是学习率比较高的时候
    h_conv1 = tf.nn.relu(conv2d(x_image, w_conv1)+ b_conv1)
    
    # 通过stride为2的卷积,这个地方的图像shape变成了[-1,14,14,1]。
    # 通过池化讲这一层的32个28x28的feature map 变成了32个14x14 feature map
    h_pool1 = max_pool_2x2(h_conv1)
    
    # 第二层卷积
    # 第二层卷积核的参数初始化,cnn虽然参数共享,但是参数共享是同一层而言的,每一层都有自己的卷积核需要学习. 
    # 这一层有64个通道,代表着这一层一共有64个卷积核需要学习. 每个卷积核的shape=(5,5,32)
    # 因为上一层池化后传过来的是14x14的feature map, 这一层将产生64个14x14个feature map。
    w_conv2 = weight_variable([5, 5, 32, 64])   
    b_conv2 = bias_variable([64])
    
    h_conv2 = tf.nn.relu(conv2d(h_pool1, w_conv2) + b_conv2)
    
    # 这一层卷积的产生了64个14x14个feature map。
    # 通过这一层的池化产生了64个7*7的feature map
    h_pool2 = max_pool_2x2(h_conv2) 
    
    # 密集连接层
    # 第二个卷积层(这儿将一系列的卷积操作,relu操作,池化操作看做一个卷积层)
    #产生了64个7x7的feature map, 这儿使输出是1024个特征(这个数是可以根据选择定的,
    # 和前面的操作没有关系,比如可以设置为1000),讲每一个像素看成一个特征的话,
    # 那么第二层卷积层产生了64*7*7个feature,他们和输出层设定的1024个单元全连接,
    # 其实就是[64*7*7,1024]个参数需要学习(其实这一层和前面的卷积层没什么区别,
    # 不失一般性,我们拿第二层卷积层说,第二个卷积层卷积核是w_conv2(暂时不考虑偏执,
    # w_conv2的shape是[5,5,32,64])第二层接受的是32个5x5 feature map ,
    # 需要输出64个channel,对于每个feature map(14x14) 需要学习5*5*64个参数, 
    # 一共有32个feature map。如果没有参数共享,需要学习32*14*14*64个参数)
    w_fc1 = weight_variable([7*7*64, 1024])
    b_fc1 = bias_variable([1024])
    
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])    # 讲特征展平
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1)+b_fc1)
    
    # dropout, 输出层之前加入dropout防止过拟合
    keep_prob = tf.placeholder('float')
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    
    # output layer, softmax
    w_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])
    y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, w_fc2) + b_fc2)    # tf.matmul(x,w) 为矩阵相乘
    
    
    # y= tf.nn.softmax(tf.matmul(x,W) + b)
    cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
    
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    
    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
    
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    sess.run(tf.global_variables_initializer())
    for i in range(20000):
        batch = mnist.train.next_batch(50)
        if i % 100 == 0:
            train_accuracy = accuracy.eval(feed_dict={
                x:batch[0], y_:batch[1], keep_prob:1.0})
            print "step %d, training accuracy %g" % (i, train_accuracy)
            train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob:0.5})
    
    print "test accuracy %g" % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob:1.0})
    
    参考

    tf.nn.max_pool参考
    tf.nn.conv2d是怎样实现卷积的?
    CNN 卷积神经网络结构
    padding 详解
    feature map详解

    展开全文
  • Python实现KNN算法手写识别数字

    千次阅读 2017-04-01 16:53:01
    本文实现用KNN算法实现手写识别数字功能。 语言:Python 训练材料:手写数字素材32*32像素from numpy import * import os from os import listdir import operator #将文件32*32转成1*1024 def img2vector...

    本文实现用KNN算法实现手写识别数字功能。
    语言:Python
    训练材料:手写数字素材32*32像素

    from numpy import *
    import os
    from os import listdir
    import operator
    #将文件32*32转成1*1024
    def img2vector(filename):
        vect=zeros((1,1024))
        f=open(filename)
        for i in range(32):
            line=f.readline()
            for j in range(32):
                vect[0,32*i+j]=int(line[j])
        return vect
    
    def dict2list(dic:dict):
        #''' 将字典转化为列表 '''
        keys = dic.keys()
        vals = dic.values()
        lst = [(key, val) for key, val in zip(keys, vals)]#zip是一个可迭代对象
        return lst
    #inputvector:输入的用于测试的向量
    #trainDataSet:训练的样本集
    #labels:标签
    #k:k邻近的个数
    def knntest(inputvector,trainDataSet,labels,k):
        datasetsize=trainDataSet.shape[0]
        #tile(a,[2,3]) ([a a a],[a,a,a])用第一个参数来构造
        #这里用输入向量来构造一个1024行 1列的矩阵,刚好和训练矩阵同样大小
        diffmat=tile(inputvector,(datasetsize,1))-trainDataSet
    
        #求平方和
        #每个元素都平方
        sqdiffmat=diffmat**2
        #按行求和
        sqdistance=sqdiffmat.sum(axis=1)
        #平方根,得到的是一个一维的矩阵
        distance=sqdistance**0.5
    
        #按照从低到高排序
        #argsort函数排列后得到的是按下标进行排列的矩阵,
        #在原先distance中的下标按距离最近排列 argsort函数返回的是数组值从小到大的索引值
        sortdistance=distance.argsort()
        classcout={}#用来存储key(标签)value(标签出现的次数,选取次数最大的前几个数,找到其标签)
    
        #依次取出最近的样本数据
        for i in range(k):
            #记样本的类别
            votelabel=labels[sortdistance[i]]
            #统计每个标签的次数
            classcout[votelabel]=classcout.get(votelabel,0)+1#获取votelabel键对应的值,无返回默认
        #print("*************")
        #print(classcout)
        #classcout.iteritems()在Python3中取消了,key=lambda x:x[0](按第0个元素排序)字典排序,按照value来排序,返回键
        sortclasscount=sorted(dict2list(classcout),key=operator.itemgetter(1),reverse=True)
        #返回出现频次最高的类别
        return sortclasscount[0][0]
    
    
    
    #手写识别
    def handwritingClassTest():
        print(os.getcwd())
        #将训练数据存储到一个矩阵中1024维,并存储对应的标签
        handlabel=[]
        trainName=listdir(r'digits\trainingDigits')
        trainNum=len(trainName)
        trainNumpy = zeros((trainNum,1024))
        #print("trainNum=%d"%trainNum)
        #对文件名进行分析,训练文本对应的标签
        for i in range(trainNum):
            filename=trainName[i]#文件名
            filestr=filename.split('.')[0]#不带后缀的文件名
            filelabel=int(filestr.split('_')[0])#文件的标签
            #将标签添加至handlabel中
            handlabel.append(filelabel)
            trainNumpy[i,:]=img2vector(r'digits\trainingDigits\%s'%filename)#转成1024
        #print(handlabel[:20])
        testfilelist=listdir(r'digits\testDigits')
        errornum=0
        testnum=len(testfilelist)
        errfile=[]
        #将每一个测试样本放入训练集中使用KNN进行测试
        for i in range(testnum):
            testfilename=testfilelist[i]
            testfilestr=testfilename.split('.')[0]
            testfilelabel=int(testfilestr.split('_')[0])#实际的数字标签
            #将测试样本1024
            testvector=img2vector(r'digits\testDigits\%s'%testfilename)
            #进行测试
            #print("-----------")
            result=knntest(testvector,trainNumpy,handlabel,3)
            print("test value is %d, real value is %d"%(result,testfilelabel))
            if(result!=testfilelabel):
                errornum+=1
                errfile.append(testfilename)
        print("the num of error is %d"%errornum)
        print("the right rate of test is %f "%(1-errornum/float(testnum)))
        print("the error of file are ")
        count=0
        for i in range(len(errfile)):
            if(count==9):
                print()
            print(errfile[i]+' ',end="")
            count+=1
    
    def main():
        #path=os.getcwd()
        handwritingClassTest()
    
    
    if __name__=='__main__':
        main();
    
    

    转载自k-近邻算法实现手写数字识别系统
    并自身进行了测试。

    展开全文
  • 从《python神经网络编程》一书中提取的识别手写字体的神经网络代码 训练集:http://www.pjreddie.com/media/files/mnist_train.csv 测试集:http://www.pjreddie.com/media/files/mnist_test.csv import numpy # ...

    从《python神经网络编程》一书中提取的识别手写字体的神经网络代码

    训练集:http://www.pjreddie.com/media/files/mnist_train.csv
    测试集:http://www.pjreddie.com/media/files/mnist_test.csv

    import numpy
    # scipy.special for the sigmoid function expit()
    import scipy.special
    import matplotlib.pyplot
    from matplotlib import pyplot as plt
    %matplotlib inline
    
    class neuralNetwork :
        def __init__(self, inputnodes, hiddennodes, outputnodes,learningrate) :
    #        定义输入层。隐藏层和输出层的节点数
            self.inodes = inputnodes
            self.hnodes = hiddennodes
            self.onodes = outputnodes
    #       定义,系数矩阵,服从高斯分布的概率密度函数(正态分布),numpy.random.normal(loc=0.0, scale=1.0, size=None)    
    #       loc:float概率分布的均值,对应着整个分布的中心center
    #       scale:float概率分布的标准差,对应于分布的宽度,scale越大越矮胖,scale越小,越瘦高
    #      size:int or tuple of ints输出的shape,默认为None,只输出一个值我们更经常会用到
    #      np.random.randn(size)所谓标准正太分布(μ=0, σ=1),对应于np.random.normal(loc=0, scale=1, size)
    #   (self.onodes, self.hnodes)是得到的数组形状,pow(self.onodes, -0.5)对self.onodes进行-0.2开方
            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.lr是学习率
            self.lr = learningrate
    #     激活函数sigmoid
            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))
    
            #     返回输出结果
        def query(self, inputs_list) :
            inputs = numpy.array(inputs_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
        
        pass
    
    
    input_nodes = 784
    hidden_nodes = 100
    output_nodes = 10
    learning_rate = 0.2
    n = neuralNetwork(input_nodes,hidden_nodes,output_nodes,learning_rate)
    training_data_file= open("F:/matlabCode/hands datasets/mnist_train.csv", 'r')
    training_data_list= training_data_file.readlines()
    training_data_file.close()
    
    
    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)
        pass
    
    
    
    
    test_data_file=open("F:/matlabCode/hands datasets/mnist_test.csv", 'r')
    test_data_list=test_data_file.readlines()
    test_data_file.close()
    all_values=test_data_list[0].split(',')
    
    
    scorecard = []
    for record in test_data_list:
    #     record是字符串,split将字符串进行切割并以list存储
        all_values = record.split(',')
    #     将列表第一个元素得到,即标签值,并将其强制转换为int型
        correct_label = int(all_values[0])
    #     print(correct_label, "correct label")
    # 输入值是0-255,将其范围进行转换,使其范围在0.01-0.99之间
        inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
        outputs = n.query(inputs)
        label = numpy.argmax(outputs)
    #     print(label, "network's answer")
        if (label == correct_label):
            scorecard.append(1)
        else:
            scorecard.append(0)
            pass
    pass
    
    scorecard_array = numpy.asarray(scorecard)
    print(scorecard_array.sum())
    # 输出成功率
    print ("performance = ", scorecard_array.sum() /scorecard_array.size)
    
    
    

    这段代码输出结果为成功率%

    
    9448
    performance =  0.9448
    import numpy
    import matplotlib.pyplot
    %matplotlib inline
    # all_values= training_data_list[0].split(',')
    image_array= numpy.asfarray(all_values[1:]).reshape((28,28))
    # 将值转换在0到1之间
    # scaled_input=(numpy.asfarray(all_values[1:])/255.0*0.99+0.01)
    
    matplotlib.pyplot.imshow( image_array, cmap='Greys',interpolation=None)
    
    
    
    # input_nodes=3
    # hidden_nodes=3
    # out_puts=3
    # learning_rate=0.3
    # n=neuralNetwork(input_nodes,hidden_nodes,out_puts,learning_rate)
    # n.query([1.0,0.5,-1.5])

    输出为具体的数字

    展开全文
  • 基于贝叶斯手写识别的关键还是在于统计学 以下是余下全文一、什么是贝叶斯公式P(Wi/X)=P(X/Wi)*P(Wi)/P(X)二、贝叶斯公式和手写识别的关系(解释上述公式) Wi:分类器(相当于数字’0’类、数字’1’类等) X:...

    基于贝叶斯手写识别的关键还是在于统计学

    以下是余下全文

    一、什么是贝叶斯公式

    P(Wi/X)=P(X/Wi)*P(Wi)/P(X)

    二、贝叶斯公式和手写识别的关系(解释上述公式)

    • Wi:分类器(相当于数字’0’类、数字’1’类等)   X:输入样本(相当于输入识别的图片,样本是由特征组成在,也就是样本和特征有时候是可以等价理解的

    • P(Wi/X):当前输入样本X,将样本X归到Wi类的概率值。(越大,说明越有可能归到此类中)

    • P(X/Wi):在Wi类下面,样本值(特征)为X的概率。(已知一个人,此人有头发(特征)的概率)

    • P(Wi):Wi类下的样本数目占总样本数目的百分比(训练样本中,数字’0’类的样本数目有100张,总的样本数目为1000张,那么P(Wi)=100/1000)

    • P(X):可以展开为P(X/W1)*P(W1)+P(X/W2)*P(W2)+······+P(X/Wi)*P(Wi),某个样本(特征)的概率总和

    三、具体实现步骤

    1.预处理

    采用的是只是添加了一个高斯过滤器(GaussianBlur)

    2.图像分割

    图像分割成7*7个子区域,每个子区域就是一个特征。

    3.特征提取

    图像在上一步中已经分割成7*7个子区域,每块区域的黑色像素点多于总的黑色像素点在每块区域的均值(总的像素点/(7*7))就设置为1,反之设置为0;(此处的阈值可以自定义,不一定是要均值,但是可以参考均值)

    4.图像训练

    训练关键的两个部分:

    1.P(X/wi)的计算:由于X代表的特征向量,我们暂且将每个特征都假定为独立变量,也就是P(X/wi)=P(x1/wi)* P(x2/wi)* P(x3/wi)*…………,现在我们的问题在于如何求解P(x1/wi)P(x2/wi)等。在之前对训练样本做了特征提取之后,假定我们的样本数目为N,我们得到了N*25的矩阵,一行代表每张图像的特征向量,每列代表同一个特征,而我们要求的P(x1/wi)就是在同一列中指定的几行中值为1的数量除以指定的几行的行数。其中同一列代表了同一特征(x1),而制定的几行代表了是同一个分类(wi)。
    2.P(wi)的计算:这个相当简单的,就是每类的数量除以总样本的数量。

    5.图形识别

    分别计算P(wi/X)概率,哪类概率大就是判定为分到哪类中。

    此处的关键点:首先将图像进行特征提取,当第j个特征值为1的时候的概率为P(xj/wi),而当特征值为0的时候的概率为1-P(xj/wi).(P(xj/Wi)已经在训练中计算出来)

    四、界面展示

    识别界面

    识别界面

    识别成功界面

    识别成功界面

    五、源代码下载

    手写识别数字源代码下载

    数字样本数据下载

    展开全文
  •  创建一个.png的文件,背景是白色的,手写的字体是黑色的, 下面是数据测试的代码,一个两层的卷积神经网,然后用save进行模型的保存。 # coding: UTF-8 import tensorflow as tf import numpy as np ...
  • 手写数字识别

    千人学习 2017-06-28 20:34:23
    手写数字识别,使用简化后的近邻算法实现手写数字识别
  • 简单的手写识别代码,可以识别字母和数字

    千次下载 热门讨论 2010-05-04 09:40:03
    使用VS2005实现的简单的手写识别代码,可以识别字母和数字。
  • 你知道手写文字识别吗?你手写的文字有识别的经历吗?很多人想把手写的文字进行手别,但是找不到比较好的手写文字识别软件,今天给大家推荐一种在线进行手写文字识别的软件-迅捷PDF在线转换器,怎么操作这款软件,...
  • 图像识别 图像识别(Image Recognition)是指利用计算机对...手写识别手写识别是常见的图像识别任务。计算机通过手写体图片来识别出图片中的,与印刷字体不同的是,不同人的手写体风格迥异,大小不一,造成了...
  • matlab手写体数字识别

    千人学习 2019-10-09 09:35:59
    matlab手写体数字识别
  • MATLAB 字体手写字识别

    2018-04-10 11:18:21
    matlab 图像处理,基于matlab的图像处理手写字识别系统
  • matlab手写数字识别

    热门讨论 2016-07-17 21:56:51
    毕业设计,matlab神经网络实现手写数字的识别
  • Python手写体数字识别

    2017-01-25 23:13:17
    基于sklearn的手写体数字识别
  • 手写字体识别

    千次阅读 2019-07-10 13:40:28
    1.完成手写字体识别kaggle比赛:https://www.kaggle.com/c/digit-recognizer 2.环境:谷歌云盘(内有GPU运算,速度比我自己电脑快好多倍) 3.手写字体文件 train.csv文件第一列是图像标签,后面784(28*28)列是...
  • Matlab手写数字识别

    2017-06-18 23:44:13
    利用matlab制作的手写数字识别系统、代码可读性强,结构清晰、GUI运行界面、在Matlab R2014b下编辑完成,有手写版,也可导入图片识别
  • Python(TensorFlow框架)实现手写数字识别系统

    万次阅读 多人点赞 2019-07-31 11:27:55
    本文使用Tensorflow框架进行Python编程实现基于卷积神经网络的手写数字识别算法,并将其封装在一个GUI界面中,最终,设计并实现了一个手写数字识别系统。
  • MATLAB手写数字识别

    千次阅读 2020-01-02 16:58:38
    MATLAB手写字体识别 使用svm进行手写字体识别 测试图片 处理图片,拿到数字区域并分割保存 clc,clear,close all; f=imread('num.jpg'); bw=~im2bw(f); se=strel('line',200,0); bw_dilate=imdilate(bw,...
  • python_手写数字识别案例、手写数字图片处理 #1、手写数字识别案例 步骤: 收集数据 带有标签的训练数据集来源于trainingDigits文件夹里面所有的文件,接近2000个文件,每个文件中有32*32的二维数组,由01构成...
  • 听说世界上只有百分之3的人关注Jayson,很幸运你是其中一位识别手写的阿拉伯数字,对于人类来说十分简单,但是对于程序来说还是有些复杂的。不过随着机器学习技术的普及,使用10几行代码,实现一个能够识别手写数字...
  • opencv opengl 手写英文字母识别

    热门讨论 2014-12-10 16:46:33
    opencv opengl 手写英文字母识别
  • TensorFlow实战教程,该课程主要分享两个TensorFlow卷积神经网络实战的案例,第一个是手写数字识别案例,第二个是人脸识别案例。
  • 手写数字识别是一个经典的机器学习问题,通过识别手写体图片来判断数字 因为数字类别是0——9,所以是十分类问题 本文以KNN算法为例,来实现手写数字的识别 文章目录实现简单的手写数字识别关于load_digits简介调用...
  • 手写数字识别问题实战

    千次阅读 2020-04-02 11:04:46
    1、何为手写数字识别问题? 手写数字识别即将如下图所示的各种各样的手写体阿拉伯数字识别出来的一个过程,这个问题已经被研究的很成熟了,也有人搜集和整理了手写数字的数据集-mnist。 2、如何解决手写数字...
  • 华宇OCR在通用印刷体文字识别上取得了成功,但随着业务的不断深入,客户对于手写识别的需求越来越大,其他厂商也相继推出了手写识别产品,我们在评估了当前技术以及数据基础等条件后,在19年末立项了手写识别研究...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,042
精华内容 7,216
关键字:

手写识别字