精华内容
下载资源
问答
  • mnist手写数字项目中输入的手写数字,在机器学习入门项目mnist手写数字识别中,需要用到的输入图片,.png格式,免费共享。
  • BP神经网络手写数字1和9识别实现效果实现过程读取样本实现思路正向传播反向传播输出层的误差计算隐含层的误差计算权重更新效果验证 实现效果 上面是训练样本集,下面是测试样本集,识别的是黑色,未识别的是红色 ...

    实现效果

    上面是训练样本集,下面是测试样本集,识别的是黑色,未识别的是红色
    在这里插入图片描述

    实现过程

    读取样本

    样本读取的过程参考这里:过程参考这里

    实现思路

    我们这里将神经网络的实现过程分为三部曲:
    注意:
    正向传播的其实就是神经元的分类过程,只不过这里要注意激活函数的使用,图中正向f指的就是激活函数;
    反向传播指的是传递回来的误差Error,注意理解图中反向误差的体现形式;
    最后就是更新权重了;
    在这里插入图片描述
    这里以一个神经元带两个输出为练习:这里从最最简单的一个神经元做起,其实就是隐含层中只有一个神经元的过程,我们的目标是识别手写的1和9,所以,我们的输出层这里有两个输出常规的输出表示中用1和0表示,我们这里为了后期的计算编程,将1和0的标识方式变为{1,0}{0,1}.
    在这里插入图片描述

    正向传播

    这里的计算编程过程紧紧扣住前面的三部曲。不过编程的时候注意,正向输入包含两个各部分的正向输入:
    隐含层的正向输出以及输出层的正向输出。
    在下面的程序解释中做了详细的说明,这个要结合前面的说明细细体会。
    在这里插入图片描述

    反向传播

    记得前面说的,反向传播传递的是一个误差,这个误差中包含两个部分,一个就是常说的损失函数,我们这里简单的理解说就是目标值与目前实际计算值之间的差值,这里我们还得分为两部分说明:

    输出层的误差计算

    这个比较简单,参看程序即可,紧扣三部曲便知。主要是隐含层的计算

    在这里插入图片描述

    隐含层的误差计算

    这里要注意,因为要验证手写的1和9,所以我们前面说输出层要有两个输出值,而在利用这两个输出值计算隐含层的反向误差时就要分别计算每一个的误差值,然后将二者加和作为隐含层的误差。如下说明:
    在这里插入图片描述
    这个过程要结合前面的的程序说明,理解起来应该会更直观一些。搞清楚在误差的加和中,每一个加和项分别是由输出层中的哪个输出参数的误差与哪个权重的乘积。这个单看公式说明理解起来相对复杂,但是结合程序说明,理解起来就会好很多。

    权重更新

    这里要注意,在权重更新中,有很多优化的方向,紧扣前面的三部曲结合这里的程序说明,查看这里的momentum其实就是很多学者做的优化点。
    在这里插入图片描述

    效果验证

    在理解的过程中注意理解激活函数的使用位置以及对激活函数求导的位置。此外,之类求导可以类似的结合前面的线性分类器中的求导得方向的概念理解。
    在这里插入图片描述

    展开全文
  • # 简单粗暴tensorflow2.0合集 视频p7-p9 多层感知机(MLP)利用多层感知机MLP实现手写数字0-9的mnist数据集的识别 import tensorflow as tf import numpy as np # 数据的获取和预处理 class MNISTLoader(): def ...
    # 简单粗暴tensorflow2.0合集 视频p7-p9 多层感知机(MLP)利用多层感知机MLP实现手写数字0-9的mnist数据集的识别
    import tensorflow as tf
    import numpy as np
    
    # 数据的获取和预处理
    
    
    class MNISTLoader():
        def __init__(self):
            mnist = tf.keras.datasets.mnist
            (self.train_data, self.train_label), (self.test_data, self.test_label) = mnist.load_data()
            # 或者可以写成:
            # (self.train_data, self.train_label), (self.test_data, self.test_label) = tf.keras.datasets.mnist.load_data()
            # mnist数据集有四个文件,上行代码的意思是把数据集的四个文件导入到变量
            # self.train_data, self.train_label, self.test_data, self.test_label中
            # (self.train_data, self.train_label), (self.test_data, self.test_label) 是两个元组
            # MNIST中的图像默认为uint8(0-255的数字)。shape为3:[60000,28,28]
            # 以下代码将其归一化到0-1之间的浮点数,并在最后增加一维作为颜色通道数目
            self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)      # [60000, 28, 28, 1]
            self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)        # [10000, 28, 28, 1]
            self.train_label = self.train_label.astype(np.int32)
            # [60000] 将label转化为np.int32类型,print train_label为[7 2 1 ... 4 5 6]
            self.test_label = self.test_label.astype(np.int32)      # [10000]
            self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]
    
        def get_batch(self, batch_size):
            # 从60000个数据集中随机取出batch_size个元素并返回
            # 在训练时要计算损失,不能一张图片一张图片来计算损失,因为可能个别图片偏差太大,所以一组一组来计算损失
            index = np.random.randint(0, self.num_train_data, batch_size)  # 输出一个在0-self.num_train_data范围内的随机整形数列
            return self.train_data[index, :], self.train_label[index]
            # 表示取train_data第一维下标为index的所有值,其中index是一串数字
    
    
    class MLP(tf.keras.Model):
        def __init__(self):
            super().__init__()
            self.flatten = tf.keras.layers.Flatten()    # Flatten层将除第一维(batch_size)以外的维度展平 28x28=784
            # 相当于全连接层,这样的话,第一层有784个单元
    
            self.dense1 = tf.keras.layers.Dense(units=100, activation=tf.nn.relu)
            # 这一层有100个神经元
            # 每个神经元都有784个权重,以及一个bias
            # y1=x1*w1+x2*w2+x3*w3+.....+x784*w784 + bias1
            # y2=x1*w1+x2*w2+x3*w3+.....+x784*w784 + bias2
            # kernel = [w1,w2,w3....w784]
    
            self.dense2 = tf.keras.layers.Dense(units=10)
    
        def call(self, inputs):         # [batch_size, 28, 28, 1]
            x = self.flatten(inputs)    # [batch_size, 784]
            x = self.dense1(x)          # [batch_size, 100]
            x = self.dense2(x)          # [batch_size, 10]
            output = tf.nn.softmax(x)
            # softmax的输出是一个10维向量,例如[0,0.1,0,0.2,0.5,0.1,0.1,0,0,0],分别代表0-9十个数字预测的概率
            return output
    
    
    # 训练模型的搭建
    
    # 定义一些超参数
    num_epochs = 5          # 学习五轮
    batch_size = 50         # 每一批50个样本
    learning_rate = 0.001
    
    model = MLP()           # 创建类的实例
    data_loader = MNISTLoader()      # 创建类的实例
    
    optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)     # 使用Adam优化器
    # 当我们求出了loss以后,对loss求梯度,把kernel和bias的梯度(偏导数)函数交给optimizer
    
    num_batches = int(data_loader.num_train_data // batch_size * num_epochs)
    # 计算下面for循环的次数,data_loader.num_train_data是总共的训练图片数60000
    # 每一批50张,一共迭代五轮," / "就表示 浮点数除法,返回浮点结果;" // "表示整数除法
    # 所以需要循环data_loader.num_train_data // batch_size * num_epochs次
    
    # 开始训练
    for batch_index in range(num_batches):
        X, y = data_loader.get_batch(batch_size)     # X是图像,y是标签
        with tf.GradientTape() as tape:
            y_pred = model(X)                        # y_pred是一个50行,10列的向量
            loss = tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred)
            # 交叉熵损失函数,例如每个图片的y_pred是[0,0.1,0,0.2,0.5,0.1,0.1,0,0,0],y为[0,1,0,0,0,0,0,0,0,0],经过交叉熵损失函数使得输出为一个数
            # 因为是50张,所以输出为50维向量
    
            loss = tf.reduce_mean(loss)          # 对输出为50维的向量求平均
            print("batch %d: loss %f" % (batch_index, loss.numpy()))
        grads = tape.gradient(loss, model.variables)      # 对loss中每一个变量model.variables即kernel = [w1,w2,w3....w784]和bias求偏导
        # 对录像带的功能,我自己的理解是上面循环输出的loss是一个一个的浮点数,录像带让这些数变成函数
    
        optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))     # 梯度下降过程
    
    
    # 模型的测试
    sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()    # 定义一个测试对象
    num_batches = int(data_loader.num_test_data // batch_size)                    # 循环的次数
    for batch_index in range(num_batches):
        start_index, end_index = batch_index * batch_size, (batch_index + 1) * batch_size
        y_pred = model.predict(data_loader.test_data[start_index: end_index])     # 取50张图片进行预测
        sparse_categorical_accuracy.update_state(y_true=data_loader.test_label[start_index: end_index], y_pred=y_pred)
    print("test accuracy: %f" % sparse_categorical_accuracy.result())
    

      本文是通过自定义类来搭建网络的,没有使用TensorFlow内置的函数库api来搭建网络,灵活性更高。

     

    1.定义加载数据集的类

    1.1  第8-9行 

    class MNISTLoader():
        def __init__(self):

    def __init__(self)是构造函数,作用是数据集加载的初始化。在函数里需要加载数据集,数据集中像素值的归一化,增加色彩维度,以及其他一些备用张量的定义。当创建该类的实例时,构造函数将被自动执行。

    1.2 第19-20行

    self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)      # [60000, 28, 28, 1]
    self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)        # [10000, 28, 28, 1]

    数据集元素的初始化时除以255.0不是255

     

    2. 自定义模型的类的创建

    2.1  34行

    class MLP(tf.keras.Model): 表示自定义的MLP类继承了tf.keras.Model父类
    

    2.2 35行

    def __init__(self):
        super().__init__()

    在自定义Mlp模型类的初始化函数中,要把模型中所有用到的层以及各层的参数定义好,注意self代表实例

    2.3 49行

    call方法:在 Python 中,对类的实例 myClass 进行形如 myClass() 的调用等价于 myClass.__call__(),在call方法内进行模型的搭建。

    当定义类的实例: model = MLP(),等同于 model = MLP.__call__(),其括号内应该传入inputs

     

    3. 模型训练前需要定义一些超参数

    3.1  61行

    epoch是指正在数据集被循环迭代的次数,epoch = 5 代表数据集被循环训练了5轮

    3.2 71行

    num_batches = int(data_loader.num_train_data // batch_size * num_epochs)

     

    4. 开始训练

    注意自定义的类里的变量与类外的变量名称不能一样,否则会警告

    X 的shape为(50,28,28,1) y的shape为(50,10)

     

    展开全文
  • 1. 感知机(感知神经元) 一个感知机就是接受几个输入,并产生一个输出. 输入与那条边对应的权重的乘积求和就是我们用来计算输出的第一步. 我们通过比较这个和值与指定阈值的相对大小产生0和1不同的输出: 2...

    1. 感知机(感知神经元)

    一个感知机就是接受几个输入,并产生一个输出.

    输入与那条边对应的权重的乘积求和就是我们用来计算输出的第一步.

     我们通过比较这个和值与指定阈值的相对大小产生0和1不同的输出:

     

    2. 感知机的结构名词

     

     

    我们改写原有的分段函数,将阈值用-b代替:

    这里的b我们称作偏置.

     

    3. S型神经元

    S型神经元同样有很多输入,但是不仅限于0和1,它们可以是0和1之间任意值,比如0.618

    对于不同的输入,也具有对于的权值,还有一个偏置项b

    输出不是简单的0和1.而是一个S型函数(Sigmoid)的结果

    S形函数是这样的形式:

    我们先求和:

    加上偏置项:

    带入S形函数:

    S型曲线:

     

    4.神经网络架构

     

    作为输入的一层称为输入层

    作为输出的一层称为输出层

    中间其它层称为隐藏层

    tip:虽然神经网络一般选用s型神经元而不是感知神经元,但是往往称之为多层感知机(MLP)

     

    我们常用的神经网络往往是前一个神经元的输出作为后一个神经元的输入对待,这样的神经网络我们称之为前馈神经网络.

     

     

    展开全文
  • #!/usr/bin/env python #-*- coding: utf-8 -*- #code:myhaspl@qq.com #9-14.py import numpy as np import mlpy import cv2 print 'loading ...' ... '''返回数字特征'''
    #!/usr/bin/env python
    #-*- coding: utf-8 -*-
    #code:myhaspl@qq.com
    #9-14.py


    import numpy as np


    import mlpy
    import cv2




    print 'loading  ...'


    def getnumc(fn):
        '''返回数字特征'''
        fnimg = cv2.imread(fn)
        img=cv2.resize(fnimg,(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,3):
        for numj in xrange(1,5):
            fn='nums/'+str(numi)+'-'+str(numj)+'.png'
            x.append(getnumc(fn))
            y.append(numi)
        


    x=np.array(x)
    #以下分别为目标输出数字1-2
    d =np.array([0,0,0,0,1,1,1,1])
    y=np.array(y)
    a=0.1
    expect_e=0.0005
    maxtrycount=200


    def sgn(v):
            if v>0:
                    return 1
            else:
                    return 0
    def get_v(myw,myx):
            return sgn(np.dot(myw,myx.T))
    def neww(oldw,myd,myx,a):
            mye=get_e(oldw,myx,myd)
            return (oldw+2*a*mye*myx,mye)
    def get_e(myw,myx,myd):
            return myd-get_v(myw,myx.T)
     


    w=zeros((1,64),dtype=float64)
    mycount=0
    while True:
            mye=0
            i=0          
            for xn in x:
                    w,e=neww(w,d[i],xn,a)
                    i+=1
                    mye+=pow(e,2)  
            mye/=float(i)
            mycount+=1
            #print u"第 %d 次调整后的权值:"%mycount
            #print w
            print u"误差:%f"%mye        
            if mye<expect_e or mycount>maxtrycount:break 
                   
    for xn in x:
            print get_v(w,xn.T)


    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,3):
        testfn= 'nums/test/'+str(iii)+'-test.png'
        #testfn='nums/'+str(iii)+'-'+'2'+'.png'
        testx=[]
        testx.append(getnumc(testfn))
        
        print     
        print testfn+":",
        print svm.pred(testx)

        print get_v(w,np.array(testx))+1



    因为这里只用了一个神经元,所以只能产生一个判别边界,故只能对两个数字进行识别。每个数字都有4个样本,结果证明,用其它的测试样三进行测试,效果很好。程序中部分是参考别人写的或门程序,刚开始没有用sgn函数,发现对样本进行训练时,都能很快达到误差为0,但是用测试样本测试时,不是输出精确的-1或1的近似值,所以改就加了一个sgn函数程序中也带了SVM的代码,暂时我也没有看,没有学到那里去,好晚了突然好想睡觉,哈哈!!!


    展开全文
  • mnist手写数字数字集

    2019-12-11 14:15:19
    5000个mnist手写数字数字集,4500个训练集(Xtrain,ytrain),500个测试集(Xtest,ytest)。 每个样本X有400个特征,10种答案(1~10,10表示0)
  • #1手写数字识别案例 步骤: 收集数据 带有标签的训练数据集来源于trainingDigits文件夹里面所有的文件,接近2000个文件,每个文件中有32*32的二维数组,由01构成,文件名称就是该文件数据对应的标签类型(即...
  • android写的小程序,主要功能为 在屏幕上手写数字1-9,显示出手写的是数字几。然后显示手写所用时间
  • MNIST手写数字

    2019-04-12 15:09:58
    MNIST手写数字数据集,已经转换为png格式,分为训练集(6W)和测试集(1W),图片以序号命名,从零开始逐渐递增。压缩包里还有两个txt文档,分别对应每一张图片的标签。
  • 前面学习过SVM来识别手写数字,这次要从自己拍摄的照片来进行识别,这样就会增加了许多流程,比如怎么样把照片里的数字进行分割,怎么样进行调整大小,怎么样计算HOG等等。 现在就来实现把下面的图片进行拆分: ...
  • 手写数字识别

    2019-08-08 15:26:36
    手写数字识别 显示scikit-learn如何用于识别手写数字图像的示例。 Classification report for classifier SVC(gamma=0.001): precision recall f1-score support 0 1.00 0.99 0.99 ...
  • 最近在学习《百度架构师手把手带你零基础实践深度学习》,现在把课上学习的内容及代码记录下来。...1. 手写数字识别任务 手写数字识别是一个典型的图像分类问题,已经被广泛应用于汇款单号识别、手写邮政编码识别
  • 手写数字数据集:1~9

    2020-03-22 15:03:32
    数据集中包括1~9的手写数字图片,用于深度学习数据训练,可以进行诸如KNN等算法的验证、实现等,对于初学者十分友好
  • 通过用户进行手写数字输入,输出数字的结果。使用TensorFlow2.0深度学习框架和tkinter界面,使用mnist和digits数据集联合训练,识别准确率非常高!(包含训练源码和训练好的权重)
  • 基于人工神经网络的 MATLAB 手写数字识别系统 1函数 MouseDraw 实现手写识别系统 GUI 界面的建立和鼠标 手写的实现使用时保存为 MouseDraw.m) function MouseDraw(action) % MouseDraw 本例展示如何以Handle ...
  • 手写数字识别简介1.数据介绍2.代码库的引入导入数据数据初探绘制部分训练集图片训练准确率项目提交 简介 kaggle上发起的一个“Digit Recognizer”手写数字识别竞赛。链接:kaggle手写数字识别竞赛 1.数据介绍 数据...
  • 预处理手写数字函数: def shouxiefix(path_tu): #path_tu = 'D:\\002.png' img = cv2.imread(path_tu,0)# 蓝95 绿200 红147通道数(-1) 数组 高 宽 通道459 362 3 img = cv2.resize(img,(28,28)) """cv2.imshow...
  • matlab手写神经网络实现识别手写数字

    万次阅读 多人点赞 2018-05-27 22:49:32
    实验说明 ...实验数据:5000张手写数字图片(.jpg),图片命名为1.jpg,2.jpg…5000.jpg。还有一个放着标签的excel文件。 数据处理:前4000张作为训练样本,后1000张作为测试样本。 图片处理:用...
  • 使用机器学习的方法来识别手写数字,了解模型训练和用模型来进行预测的具体过程,在VS上配置好opencv便可直接运行。
  • 识别手写数字

    2019-10-02 16:49:47
    LeCun首次将反向传播算法应用于手写邮政编码识别,而后又将卷积神经网络应用于手写数字体识别,这便是CNN最初的模型–LeNet5。 LeNet5包含Input、卷积层1、池化层1、卷积层2、池化层2、全连接层、输出层。 层数...
  • 该演示生成一个手写数字,从 0 到 1 逐渐变化。 另外,其他编号(MNIST)也可用于生成。 官方文档标题为“Train Variational Autoencoder (VAE) to Generate Images” 被推荐用于此演示,如下所示。 ( ...
  • mnist手写数字体识别,算是计算机视觉、图像识别领域的入门级demo了。就好像你学习编程首先要打出一个’hello world’。 实现手写数字体识别有多种方式,可以用回归法,可以用CNN,可以用RNN,等等。代码简洁程度...
  • 手写1数字识别

    2008-05-09 18:45:06
    利用VC++编写能够实现简单手写数字识别。
  • 手写数字识别数据

    2017-09-13 11:12:11
    手写数字识别数据,数据以 0 1 的形式存储在 txt 文件中,大小为32*32。 可以用于机器学习中的分类算法的练习与神经网络的入门。
  • eg.1手写数字识别

    2018-07-16 15:46:55
    scikit-learn自带手写数字识别图片的数据,from sklearn import datasetsdigits = datasets.load_digits()#把图片显示出来images_and_labels= list(zip(digits.images,digits.target))plt.figure(figsize=(8,6),dpi=...

空空如也

空空如也

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

手写数字1