深度学习－－手写数字识别＜三＞

最新推荐文章于 2024-07-17 22:00:05 发布
最新推荐文章于 2024-07-17 22:00:05 发布
阅读量1.4k 收藏 4
点赞数
分类专栏： 深度学习 文章标签： 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/akadiao/article/details/78273815
版权

DropOut

dropout过程：

(1)　开始删除随机选择的一半神经元;
(2)　利用SGD(随机梯度下降法)中抽取的一个样本集在更改过的神经网络上正向和反向更新weights和bases;
(3)　恢复之前删除过的神经元重新随机选择一半神经元删除，然后正向反向更新weights和bases，重复此过程;
(4)　由于之前学习出来的神经网络中的神经元都是在只有一半神经元的基础上学习的，当所有神经元被恢复后，把隐藏层的所有权重减半．

code3:

#!/usr/bin/python
# coding:utf-8

import cPickle
import gzip

import numpy as np
# 通过利用GPU获得与手工用C实现差不多的性能
import theano
# tensor是在numpy 基础上更加适用于神经网络的张量操作的库， tensor所有的操作都是基于符号的
import theano.tensor as T
from theano.tensor.nnet import conv
from theano.tensor.nnet import softmax
from theano.tensor import shared_randomstreams
# from theano.tensor.signal import downsample
import theano.tensor.signal.pool as downsample
from theano.tensor.nnet import sigmoid
from theano.tensor import tanh


GPU = True
if GPU:
    print "Trying to run under a GPU. If this is not desired, then modify "+"network3.py\nto set the GPU flag to False."
    try:
        theano.config.device = 'gpu'
    except:
        pass
    theano.config.floatX = 'float32'
else:
    print "Running with a CPU.  If this is not desired, then the modify "+"network3.py to set\nthe GPU flag to True."


# 加载MNIST数据
def load_data_shared(filename="../data/mnist.pkl.gz"):
    f = gzip.open(filename, 'rb')
    training_data, validation_data, test_data = cPickle.load(f)
    f.close()
    # 将数据放入共享变量中,允许theano复制数据到GPU
    def shared(data):
        shared_x = theano.shared(np.asarray(data[0], dtype=theano.config.floatX), borrow=True)
        shared_y = theano.shared(np.asarray(data[1], dtype=theano.config.floatX), borrow=True)
        return shared_x, T.cast(shared_y, "int32")
    return [shared(training_data), shared(validation_data), shared(test_data)]


# 神经元的激活函数
def linear(z):
    return z
# ReLU
def ReLU(z):
    return T.maximum(0.0, z)


class Network(object):

    def __init__(self, layers, mini_batch_size):
        self.layers = layers
        self.mini_batch_size = mini_batch_size
        self.params = [param for layer in self.layers for param in layer.params]
        self.x = T.matrix("x")
        self.y = T.ivector("y")
        init_layer = self.layers[0]
        init_layer.set_inpt(self.x, self.x, self.mini_batch_size)
        for j in xrange(1, len(self.layers)):
            prev_layer, layer  = self.layers[j-1], self.layers[j]
            layer.set_inpt(prev_layer.output, prev_layer.output_dropout, self.mini_batch_size)
        self.output = self.layers[-1].output
        self.output_dropout = self.layers[-1].output_dropout

    # 采用小批量随机梯度下降训练
    def SGD(self, training_data, epochs, mini_batch_size, eta, validation_data, test_data, lmbda=0.0):
        training_x, training_y = training_data
        validation_x, validation_y = validation_data
        test_x, test_y = test_data

        # 计算minibatches训练，验证和测试
        num_training_batches = size(training_data)/mini_batch_size
        num_validation_batches = size(validation_data)/mini_batch_size
        num_test_batches = size(test_data)/mini_batch_size

        # 定义（正则）的成本函数，象征性的梯度，并更新
        l2_norm_squared = sum([(layer.w**2).sum() for layer in self.layers])
        cost = self.layers[-1].cost(self)+0.5*lmbda*l2_norm_squared/num_training_batches
        grads = T.grad(cost, self.params)
        updates = [(param, param-eta*grad)for param, grad in zip(self.params, grads)]

        # 定义培训小批量的功能，并计算验证和测试小批量的准确性。
        # mini-batch index
        i = T.lscalar()
        # updates:可以迭代对,列表/元组/OrderedDict,根据这些表达式更新共享变量输入的值。
        train_mb = theano.function([i], cost, updates=updates,
        # givens：可变对象(Var1,Var2)的变量,列表,元组或字典,每对中的Var1和Var2必须具有相同的类型,在计算图中进行具体的替换(Var2替换Var1)
            givens={self.x:training_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size],
                    self.y:training_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size]})
        validate_mb_accuracy = theano.function([i], self.layers[-1].accuracy(self.y),
            givens={self.x:validation_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size],
                    self.y:validation_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size]})
        test_mb_accuracy = theano.function([i], self.layers[-1].accuracy(self.y),
            givens={self.x:test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size],
                    self.y:test_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size]})
        self.test_mb_predictions = theano.function([i], self.layers[-1].y_out,
            givens={self.x:test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size]})
        # 训练 cost_ij
        best_validation_accuracy = 0.0
        for epoch in xrange(epochs):
            for minibatch_index in xrange(num_training_batches):
                iteration = num_training_batches*epoch+minibatch_index
                if iteration % 1000 == 0:
                    print("Training mini-batch number {0}".format(iteration))
                cost_ij = train_mb(minibatch_index)
                if (iteration+1) % num_training_batches == 0:
                    validation_accuracy = np.mean([validate_mb_accuracy(j) for j in xrange(num_validation_batches)])
                    print("Epoch {0}: validation accuracy {1:.2%}".format(epoch, validation_accuracy))
                    if validation_accuracy >= best_validation_accuracy:
                        print("This is the best validation accuracy to date.")
                        best_validation_accuracy = validation_accuracy
                        best_iteration = iteration
                        if test_data:
                            test_accuracy = np.mean([test_mb_accuracy(j) for j in xrange(num_test_batches)])
                            print('The corresponding test accuracy is {0:.2%}'.format(test_accuracy))
        print("Finished training network.")
        print("Best validation accuracy of {0:.2%} obtained at iteration {1}".format(best_validation_accuracy, best_iteration))
        print("Corresponding test accuracy of {0:.2%}".format(test_accuracy))

# 定义层类型
# 用于创建一个组合的卷积和最大混合层
class ConvPoolLayer(object):
    def __init__(self, filter_shape, image_shape, poolsize=(2, 2), activation_fn=sigmoid):
        """
        filter_shape是一个长度为4的元组，其作品数量的过滤器，输入特征图的数量，过滤器和过滤器的高度，宽度。
        image_shape是一个长度为4的元组，其作品都是小批量，输入特征的数字地图，图像的高度，和图像的宽度。
        ` poolsize `是一个元组的长度为2，X和Y的条目池的大小。
        """
        self.filter_shape = filter_shape
        self.image_shape = image_shape
        self.poolsize = poolsize
        self.activation_fn=activation_fn
        # 初始化:weights/biases
        n_out = (filter_shape[0]*np.prod(filter_shape[2:])/np.prod(poolsize))
        self.w = theano.shared(np.asarray(np.random.normal(loc=0, scale=np.sqrt(1.0/n_out), size=filter_shape),
                dtype=theano.config.floatX), borrow=True)
        self.b = theano.shared(np.asarray(np.random.normal(loc=0, scale=1.0, size=(filter_shape[0],)),
                dtype=theano.config.floatX), borrow=True)
        self.params = [self.w, self.b]

    def set_inpt(self, inpt, inpt_dropout, mini_batch_size):
        self.inpt = inpt.reshape(self.image_shape)
        conv_out = conv.conv2d(input=self.inpt, filters=self.w, filter_shape=self.filter_shape,image_shape=self.image_shape)
        # pooled_out = downsample.max_pool_2d(input=conv_out, ds=self.poolsize, ignore_border=True)
        pooled_out = downsample.pool_2d(input=conv_out, ds=self.poolsize, mode='max', ignore_border=True)
        self.output = self.activation_fn(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))
        # 卷积层中没有dropout
        self.output_dropout = self.output

# 全链接层
class FullyConnectedLayer(object):
    def __init__(self, n_in, n_out, activation_fn=sigmoid, p_dropout=0.0):
        self.n_in = n_in
        self.n_out = n_out
        self.activation_fn = activation_fn
        self.p_dropout = p_dropout
        # 初始化权重和偏差
        self.w = theano.shared(np.asarray(np.random.normal(loc=0.0, scale=np.sqrt(1.0/n_out), size=(n_in, n_out)),
                dtype=theano.config.floatX),name='w', borrow=True)
        self.b = theano.shared(np.asarray(np.random.normal(loc=0.0, scale=1.0, size=(n_out,)),
                dtype=theano.config.floatX),name='b', borrow=True)
        self.params = [self.w, self.b]

    def set_inpt(self, inpt, inpt_dropout, mini_batch_size):
        self.inpt = inpt.reshape((mini_batch_size, self.n_in))
        self.output = self.activation_fn((1-self.p_dropout)*T.dot(self.inpt, self.w) + self.b)
        self.y_out = T.argmax(self.output, axis=1)
        self.inpt_dropout = dropout_layer(inpt_dropout.reshape((mini_batch_size, self.n_in)), self.p_dropout)
        self.output_dropout = self.activation_fn(T.dot(self.inpt_dropout, self.w) + self.b)

    # 返回小批量的准确性
    def accuracy(self, y):
        return T.mean(T.eq(y, self.y_out))

# Softmax输出
class SoftmaxLayer(object):
    def __init__(self, n_in, n_out, p_dropout=0.0):
        self.n_in = n_in
        self.n_out = n_out
        self.p_dropout = p_dropout
        # 初始化权重和偏差
        self.w = theano.shared(np.zeros((n_in, n_out), dtype=theano.config.floatX), name='w', borrow=True)
        self.b = theano.shared(np.zeros((n_out,), dtype=theano.config.floatX), name='b', borrow=True)
        self.params = [self.w, self.b]

    def set_inpt(self, inpt, inpt_dropout, mini_batch_size):
        self.inpt = inpt.reshape((mini_batch_size, self.n_in))
        self.output = softmax((1-self.p_dropout)*T.dot(self.inpt, self.w) + self.b)
        self.y_out = T.argmax(self.output, axis=1)
        self.inpt_dropout = dropout_layer(inpt_dropout.reshape((mini_batch_size, self.n_in)), self.p_dropout)
        self.output_dropout = softmax(T.dot(self.inpt_dropout, self.w) + self.b)

    # log-likelihood cost函数
    def cost(self, net):
        return -T.mean(T.log(self.output_dropout)[T.arange(net.y.shape[0]), net.y])
    # mini-batch cost
    def accuracy(self, y):
        return T.mean(T.eq(y, self.y_out))


# dropout层
# 随机地删除网络中的一半的隐藏神经元,同时让输入层和输出层的神经元保持不变
def dropout_layer(layer, p_dropout):
    # np.random.RandomState(0).randint(999999)产生一个小于999999的任意整数
    # RandomStreams获取随机数
    srng = shared_randomstreams.RandomStreams(np.random.RandomState(0).randint(999999))
    # RandomStreams.binomial()产生二项分布
    # 要随机地从n个数中以概率p对其进行选择，可以先生成一个掩膜（mask = np.random.binomial(1, p, n)）
    mask = srng.binomial(n=1, p=1-p_dropout, size=layer.shape)
    # cast(x, dtype):象征性地投X到张量型D
    # theano.config.floatX = 'float32'
    # 屏蔽神经网络的部分节点
    return layer*T.cast(mask, theano.config.floatX)


# 返回数据集data的大小
def size(data):
    return data[0].get_value(borrow=True).shape[0]


if __name__ == '__main__':
    training_data, validation_data, test_data = load_data_shared()
    mini_batch_size = 10
    # CNN
    net = Network([FullyConnectedLayer(n_in=784, n_out=100), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
    net.SGD(training_data, 10, mini_batch_size, 0.1, validation_data, test_data)

输出：

Trying to run under a GPU.  If this is not desired, then modify network3.py
to set the GPU flag to False.
Training mini-batch number 0
Training mini-batch number 1000
Training mini-batch number 2000
Training mini-batch number 3000
Training mini-batch number 4000
Epoch 0: validation accuracy 92.78%
This is the best validation accuracy to date.
The corresponding test accuracy is 92.11%
Training mini-batch number 5000
Training mini-batch number 6000
Training mini-batch number 7000
Training mini-batch number 8000
Training mini-batch number 9000
Epoch 1: validation accuracy 94.91%
This is the best validation accuracy to date.
The corresponding test accuracy is 94.36%
Training mini-batch number 10000
Training mini-batch number 11000
Training mini-batch number 12000
Training mini-batch number 13000
Training mini-batch number 14000
Epoch 2: validation accuracy 95.86%
This is the best validation accuracy to date.
The corresponding test accuracy is 95.31%
Training mini-batch number 15000
Training mini-batch number 16000
Training mini-batch number 17000
Training mini-batch number 18000
Training mini-batch number 19000
......
Epoch 56: validation accuracy 97.77%
This is the best validation accuracy to date.
The corresponding test accuracy is 97.65%
Training mini-batch number 285000
Training mini-batch number 286000
Training mini-batch number 287000
Training mini-batch number 288000
Training mini-batch number 289000
Epoch 57: validation accuracy 97.77%
This is the best validation accuracy to date.
The corresponding test accuracy is 97.65%
Training mini-batch number 290000
Training mini-batch number 291000
Training mini-batch number 292000
Training mini-batch number 293000
Training mini-batch number 294000
Epoch 58: validation accuracy 97.76%
Training mini-batch number 295000
Training mini-batch number 296000
Training mini-batch number 297000
Training mini-batch number 298000
Training mini-batch number 299000
Epoch 59: validation accuracy 97.77%
This is the best validation accuracy to date.
The corresponding test accuracy is 97.65%
Finished training network.
Best validation accuracy of 97.77% obtained at iteration 299999
Corresponding test accuracy of 97.65%

参考：Neural Networks and Deep Learning

阿卡蒂奥
关注
专栏目录
深度学习/CV 学习笔记（一）：手写数字识别（tensorflow1.0+2.0实现）
weixin_46343121的博客
09-07 592
目录 1. MNIST数据集 2.使用tensorflow1.0实现 2.1 环境配置 2.2 获取数据 2.3 定义变量、模型构建函数 2.4 CNN模型构建 2.5 定义损失函数及优化器 2.6 创建输入占位符 2.7 定义准确率计算函数 2.8 开始训练 2.9 训练结果 3.使用tensorflow2.0(Keras)实现 3.1环境配置 3.2 获取数据 3.3 构建模型 3.4 编译模型 3.5 使用Tensorboard进行可视化 3.6 训练模型 3..
字符型图片数字验证码识别完整过程及Python实现（深度学习学习、实现数字、字符模型训练）
04-11
字符型图片数字验证码识别完整过程及Python实现（深度学习学习、实现数字、字符模型训练），欢迎大家获取，有什么问题，留言咨询，多多交流。
手写数字识别（三）
lzh的博客
07-18 3486
手写数字识别（三） 数字分割、识别 1. 数字分割 一个比较简单的方法是通过统计图像的灰度进行划分。先统计每一行的灰度值，对于遇到的空白区间作为划分行，然后以同样方法划分列，以此确定分区。但是很显然这样的方法对于数字密集或者是轻微的倾斜都会有问题。 我写的是通过bfs来划分，首先是通过膨胀处理，然后对于所有未标记的黑点走一次bfs，把同一个联通块看做是一个数字，并且在bfs的同时打上标记，...
使用深度学习进行手写数字识别
最新发布
2301_80222318的博客
07-17 652
相较于上一篇代码，这篇使用的 FishionMint 数据 集是 MNIST 的一个替代品，图像内容是时尚商品，而不是手写数字，且每个类别的图像 数量更平均，这使得它在某些方面比 MNIST 更具挑战性， 模型一般在经过 40epoch 时损失函数就可以及其接近 0 了，在训练集上高达 100 之百的准确率，在测试集上的准确率高达百分之 99.3，实现 了测试集准确率超百分之 90。由于残差学习框架的引入，ResNet可以构建非常深的网络结构（例如，100层或更深），而不会遭受传统深层网络中的退化问题。
基于深度学习字符型图片数字验证码识别完整过程及Python实现（深度学习学习、实现数字、字符模型训练、详细介绍附源码）
04-11
基于深度学习字符型图片数字验证码识别完整过程及Python实现（深度学习学习、实现数字、字符模型训练、详细介绍附源码）
《深度学习入门》第3章实战：手写数字识别
rellvera的博客
11-18 1384
笔者最近阅读了《深度学习入门——基于Python的理论与实现》这本书的第三章，章节最后刚好有个手写数字识别的实战内容，于是就照着书本内容写了程序跑了一下，在此做个记录。
【深度学习-TensorFlow】手写数字识别
08-04
手写数字_基础版
c#深度学习-PaddleOCRSharp数字识别demo
09-22
PaddleOCRSharp的例子，直接运行识别数字，注释详细，用于自学深度学习。PaddleOCRSharp是基于PaddleOCR的C++代码修改并封装的.NET工具类库，支持文本识别、文本检测、基于文本检测结果的统计分析的表格识别功能。 ...
中国科学院大学深度学习课程实验作业——手写数字识别（代码+实验报告）
01-14
手写数字识别是机器学习的经典任务之一，本文设计了一种简单的卷积神经网络(CNN)来完成手写数字识别任务，并采用pytorch框架搭建，其准确率在测试集高达99%，取得了不错的效果。
深度学习作业-基于pytorch框架python实现手写数字识别完整源码+代码注释+实验报告.zip
12-14
深度学习作业_基于pytorch框架python实现手写数字识别完整源码+代码注释+实验报告.zip 使用MNIST手写数字体数据集进行训练和预测，实现测试集准确率达到98%及以上。本实验的目的： 掌握卷积神经网络基本原理，以...
基于KNN的手写数字识别
zj572459439的专栏
06-14 1061
实现了基于KNN的手写数字识别
基于ResNet实现手写体数字识别实验
m0_62581697的博客
11-27 1322
1、transforms.Compose([transforms.Resize(32),transforms.ToTensor(),transforms.Normalize(mean=[0.5], std=[0.5])])：这个语句创建了一个预处理管道，它首先调整图像大小为32x32，然后将图像转换为torch.Tensor，并归一化这个Tensor2、ResNet18的基本含义是，网络的基本架构是ResNet，网络的深度是18层。但是这里的网络深度指的是网络的权重层，也就是包括池化，激活，线性层。
WIN10 anaconda 安装 tensorflow-gpu不出错的最佳解决办法（不在系统安装CUDA）
star2523的专栏
12-01 1万+
来源：https://www.pugetsystems.com/labs/hpc/The-Best-Way-to-Install-TensorFlow-with-GPU-Support-on-Windows-10-Without-Installing-CUDA-1187/ 由于使用根据百度出来的WIN10下面使用anaconda和CUDA安装tensorflow-gpu的解决办法，总会报如下错误...
《神经网络与深度学习》编程笔记
XingLiu's Blog
12-25 1241
小白学习神经网络的一些笔记，参考书上的代码实现的。原理在附件的pdf中，注释就不写了。纯手打，调试ok
Python实现手写数字的识别
janestan的博客
09-29 9544
输入层(input layer)是由训练集的实例特征向量传入，经过连接结点的权重(weight)传入下一层，一层的输出是下一层的输入，隐藏层的个数可以是任意的，输入层有一层，输出层有一层，每个单元(unit)也可以被称作神经结点,根据生物学来源定义，一层中加权的求和，然后根据非线性方程转化输出。多层向前神经网络由以下部分组成：输入层(input layer),隐藏层(hidden layers),输入层(output layers)，每层由单元(units)组成。（1）通过迭代性的来处理训练集中的实例。
[分享] Python实现的基于深度学习的手写数字识别算法
qq_38474647的博客
11-28 1419
本文将采用深度学习中的卷积神经网络来训练手写数字识别模型。使用卷积神经网络建立合理的模型结构，利用卷积层中设定一定数目的卷积核（即滤波器），通过训练数据使模型学习到能够反映出十个不同手写提数字特征的卷积核权值，最后通过全连接层使用softmax函数给出预测数字图对应每种数字可能性的概率多少。 本文以学习基于深度学习的手写数字识别算法的过程为线索，由简入深，...
【深度学习】python实现简单神经网络以及手写数字识别案例
Daycym的博客
10-29 1万+
前言 \quad\quad为了能够解决感知机人工设定权重的工作，即确定合适的、能符合预期的输入与输出的权重，神经网络便出现了，神经网络的一个重要的性质是它可以自动地从数据中学习得到合适的权重参数。 神经网络 \quad\quad如上图，我们把最左边的一列称为输入层，最右边的称为输出层，中间的称为中间层（也可称为隐藏层），一般情况下，我们通常将输入层、隐藏层、输出层的总数减去1后的数量来表示神经网...
二项分布的实现（np.random.binomial）
热门推荐
12-04 3万+
二项分布（binomial distribution）： P(N)=(nN)pN(1−p)n−N P(N)=\begin{pmatrix}n\\N \end{pmatrix}p^N(1-p)^{n-N} numpy给出的api是：numpy.random.RandomState.binomial(n, p, size=None)表示对一个二项分布进行采样（size表示采样的次数，draw sa
基于python手写深度学习网络系列（6）误差反向传播实现手写数字识别网络
大白的博客
04-07 991
基于python手写深度学习网络系列（6） 误差反向传播实现手写数字识别网络 通过计算图进行了解： 计算图就是将计算过程用图形表示出来，图形指的是数据结构图，通过多个节点和边表示。 从左向右传播是正向传播，反过来就是反向传播。 局部计算：无论全局发生了什么，都能只根据与自己相关的信息输出接下来的结果。 计算图的优点：通过局部计算，简化各个节点的计算； 计算图可以将中间的计算结果全部保...
深度学习驱动的手写数字识别与多数字检测
该论文中的研究者通过构建一个相对简单的深度学习网络，实现了高达99.3%的准确率，这一成绩证实了深度学习在手写数字识别任务中的优越性。 此外，作者并未止步于单一的数字分类，而是进一步探索了深度网络在处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值