精华内容
下载资源
问答
  • CNN卷积神经网络实现手写数字识别Matlab+minist数据集都有,在matlab上可直接运行,新手友好,亲测可用。
  • 卷积神经网络CNN手写数字图像识别
  • CNN识别手写数字,很好的机器学习初心者学习资料,里面包含了MATLAB代码和详细的注释,可以直接运行
  • MNIST手写Matlab程序,包含BP和CNN程序。不依赖任何库,包含MNIST数据,BP网络可达到98.3%的识别率,CNN可达到99%的识别率。CNN比较耗时,关于CNN的程序介绍:...
  • 卷积神经网络CNN手写数字识别,有详细的代码注释和讲解,以及流程介绍,有利于初学者理解,能完整运行,且准确率当10各epochs时为0.985
  • 实战+原理--手写数字识别--CNN卷积神经网络--matlab

    万次阅读 多人点赞 2019-04-13 23:27:09
    实战+原理–手写数字识别–卷积神经网络–matlab Marshal Zheng 2019-04-13 文章目录实战+原理--手写数字识别--卷积神经网络--matlabTargetDatasetDataset-converted into bmpTrainTestResultTheory about CNN ...

    实战+原理–手写数字识别–卷积神经网络–matlab

    Marshal Zheng
    2019-04-13

    Target

    使用卷积神经网络进行手写数字识别–进一步理解CNN实现,便于拓展

    Dataset

    不可能让我们自己手写吧……绝望脸……

    总有一些经典的数据库!

    Therefore,使用谷歌实验室的手写数字数据库THE MINIST DATABASE

    在这里[MINIST DATABASE],界面如此简单……看来追求的是内涵!

    Dataset-converted into bmp

    数据集的格式让人绝望-(-ubyte),怎么读嘛……赶紧去找这种图像格式……

    训练集图像格式(train-images.idx3-ubyte)
    offset——–type————–value———- description
    0000 —32 bit integer——0x00000803—–magic number
    0004—32 bit integer——–60000——number of images
    0008—32 bit integer———-28———–number of rows
    0012—32 bit integer———-28——–number of columns
    0016—unsigned byte ——–??——————pixel
    0017—unsigned byte ——–??——————pixel

    ……

    训练集标签格式(train-labels.idx1-ubyte)
    offset——–type—————-value———- description
    0000 —32 bit integer——0x00000803—–magic number
    0004—32 bit integer——–60000——number of images
    0008—unsigned byte ———??——————number
    0009—unsigned byte ———??——————number

    ……

    然后将其转换成bmp图像

    function tobmp
    fid_image=fopen('train-images.idx3-ubyte','r');
    fid_label=fopen('train-labels.idx1-ubyte','r');
    % Read the first 16 Bytes
    magicnumber=fread(fid_image,4);
    size=fread(fid_image,4);
    row=fread(fid_image,4);
    col=fread(fid_image,4);
    % Read the first 8 Bytes
    extra=fread(fid_label,8);
    % Read labels related to images
    imageIndex=fread(fid_label);
    Num=length(imageIndex);
    % Count repeat times of 0 to 9
    cnt=zeros(1,10);
    for k=1:Num
        image=fread(fid_image,[max(row),max(col)]);     % Get image data
        val=imageIndex(k);      % Get value of image
        for i=0:9
            if val==i
                cnt(val+1)=cnt(val+1)+1;
            end
        end
        if cnt(val+1)<10
            str=[num2str(val),'_',num2str(cnt(val+1)),'.bmp'];
        elseif cnt(val+1)<100
            str=[num2str(val),'_',num2str(cnt(val+1)),'.bmp'];
        elseif cnt(val+1)<1000
            str=[num2str(val),'_',num2str(cnt(val+1)),'.bmp'];
        else
            str=[num2str(val),'_',num2str(cnt(val+1)),'.bmp'];
        end
        imwrite(image',str);
    end
    fclose(fid_image);
    fclos
    

    转换完:

    img

    Train

    使用一定的样本去训练卷积神经网络(不要用全部,如果电脑性能不够~会疯掉的)

    for iter=1:20
    for n=1:20
        for m=0:9
            %读取样本
            train_data=imread(strcat(num2str(m),'_',num2str(n),'.bmp'));
            train_data=double(train_data);
            % 去均值
    %       train_data=wipe_off_average(train_data);
            %前向传递,进入卷积层1
            for k=1:layer_c1_num
                state_c1(:,:,k)=convolution(train_data,kernel_c1(:,:,k));
                %进入激励函数
                state_c1(:,:,k)=tanh(state_c1(:,:,k)+bias_c1(1,k));
                %进入pooling1
                state_s1(:,:,k)=pooling(state_c1(:,:,k),pooling_a);
            end
            %进入f1层
            [state_f1_pre,state_f1_temp]=convolution_f1(state_s1,kernel_f1,weight_f1);
            %进入激励函数
            for nn=1:layer_f1_num
                state_f1(1,nn)=tanh(state_f1_pre(:,:,nn)+bias_f1(1,nn));
            end
            %进入softmax层
            for nn=1:layer_output_num
                output(1,nn)=exp(state_f1*weight_output(:,nn))/sum(exp(state_f1*weight_output));
            end
           %% 误差计算部分
            Error_cost=-output(1,m+1);
    %         if (Error_cost<-0.98)
    %             break;
    %         end
            %% 参数调整部分
            [kernel_c1,kernel_f1,weight_f1,weight_output,bias_c1,bias_f1]=CNN_upweight(yita,Error_cost,m,train_data,...
                                                                                                    state_c1,state_s1,...
                                                                                                    state_f1,state_f1_temp,...
                                                                                                    output,...
                                                                                                    kernel_c1,kernel_f1,weight_f1,weight_output,bias_c1,bias_f1);
            
        end    
    end
    end
    
    Test
    for n=1:20
        for m=0:9
            %读取样本
            train_data=imread(strcat(num2str(m),'_',num2str(n),'.bmp'));
            train_data=double(train_data);
            % 去均值
    %       train_data=wipe_off_average(train_data);
            %前向传递,进入卷积层1
            for k=1:layer_c1_num
                state_c1(:,:,k)=convolution(train_data,kernel_c1(:,:,k));
                %进入激励函数
                state_c1(:,:,k)=tanh(state_c1(:,:,k)+bias_c1(1,k));
                %进入pooling1
                state_s1(:,:,k)=pooling(state_c1(:,:,k),pooling_a);
            end
            %进入f1层
            [state_f1_pre,state_f1_temp]=convolution_f1(state_s1,kernel_f1,weight_f1);
            %进入激励函数
            for nn=1:layer_f1_num
                state_f1(1,nn)=tanh(state_f1_pre(:,:,nn)+bias_f1(1,nn));
            end
            %进入softmax层
            for nn=1:layer_output_num
                output(1,nn)=exp(state_f1*weight_output(:,nn))/sum(exp(state_f1*weight_output));
            end
            [p,classify]=max(output);
            if (classify==m+1)
                count=count+1;
            end
            fprintf('真实数字为%d  网络标记为%d  概率值为%d \n',m,classify-1,p);
        end
    end
    
    Result

    真实数字为0 网络标记为0 概率值为9.972138e-01
    真实数字为1 网络标记为1 概率值为9.193176e-01
    真实数字为2 网络标记为2 概率值为9.896526e-01
    真实数字为3 网络标记为3 概率值为9.371080e-01
    真实数字为4 网络标记为4 概率值为9.952712e-01
    真实数字为5 网络标记为5 概率值为9.003822e-01
    真实数字为6 网络标记为6 概率值为9.212196e-01
    真实数字为7 网络标记为7 概率值为9.913647e-01
    真实数字为8 网络标记为8 概率值为9.930044e-01
    真实数字为9 网络标记为9 概率值为9.595271e-01

    效果不错嘛……

    Theory about CNN (Convolutional Neural Networks)

    这里我的另一篇笔记:花书《Deep learning》的学习–CNN卷积神经网络–+个人理解

    展开全文
  • 一、CNN简介 ...而机器识图的方式正好和绣十字绣的方式相反,现在有了一幅图片,机器通过识别图片中每个格子(像素点)上的颜色,将每个格子里的颜色都用数字类型存储,得到一张很大的数字矩阵,图片信息也就

    一、CNN简介

    1 机器如何识图
    先给大家出个脑筋急转弯:在白纸上画出一个大熊猫,一共需要几种颜色的画笔?——大家应该都知道,只需要一种黑色的画笔,只需要将大熊猫黑色的地方涂上黑色,一个大熊猫的图像就可以展现出来。

    我们画大熊猫的方式,其实和妈妈们的十字绣很接近——在给定的格子里,绣上不同的颜色,最后就可以展现出一幅特定的“图片”。而机器识图的方式正好和绣十字绣的方式相反,现在有了一幅图片,机器通过识别图片中每个格子(像素点)上的颜色,将每个格子里的颜色都用数字类型存储,得到一张很大的数字矩阵,图片信息也就存储在这张数字矩阵中。
    在这里插入图片描述
    上图中每一个格子代表一个像素点,像素点里的数字代表颜色码,颜色码范围是[0,255],(各式各样的颜色都是由红、绿、蓝三色组成,每个颜色都是0~255之间数字)

    我们在得到的一张大数字矩阵的基础上开展卷积神经网络识别工作:
    机器识图的过程:机器识别图像并不是一下子将一个复杂的图片完整识别出来,而是将一个完整的图片分割成许多个小部分,把每个小部分里具有的特征提取出来(也就是识别每个小部分),再将这些小部分具有的特征汇总到一起,就可以完成机器识别图像的过程了

    2 卷积神经网络原理介绍
    用CNN卷积神经网络识别图片,一般需要的步骤有:
    (1)卷积层初步提取特征
    (2)池化层提取主要特征
    (3)全连接层将各部分特征汇总
    (4)产生分类器,进行预测识别

    2.1 卷积层工作原理
    卷积层的作用:就是提取图片每个小部分里具有的特征
    假定我们有一个尺寸为66 的图像,每一个像素点里都存储着图像的信息。我们再定义一个卷积核(相当于权重),用来从图像中提取一定的特征。卷积核与数字矩阵对应位相乘再相加,得到卷积层输出结果。
    在这里插入图片描述
    (429 = 18
    1+540+511+550+1211+750+351+240+2041)
    卷积核的取值在没有以往学习的经验下,可由函数随机生成,再逐步训练调整
    当所有的像素点都至少被覆盖一次后,就可以产生一个卷积层的输出(下图的步长为1)
    在这里插入图片描述
    机器一开始并不知道要识别的部分具有哪些特征,是通过与不同的卷积核相作用得到的输出值,相互比较来判断哪一个卷积核最能表现该图片的特征——比如我们要识别图像中的某种特征(比如曲线),也就是说,这个卷积核要对这种曲线有很高的输出值,对其他形状(比如三角形)则输出较低。卷积层输出值越高,就说明匹配程度越高,越能表现该图片的特征。

    卷积层具体工作过程:
    比如我们设计的一个卷积核如下左,想要识别出来的曲线如下右:
    在这里插入图片描述
    现在我们用上面的卷积核,来识别这个简化版的图片——一只漫画老鼠
    在这里插入图片描述
    当机器识别到老鼠的屁股的时候,卷积核与真实区域数字矩阵作用后,输出较大:6600
    在这里插入图片描述
    而用同一个卷积核,来识别老鼠的耳朵的时候,输出则很小:0
    在这里插入图片描述
    我们就可以认为:现有的这个卷积核保存着曲线的特征,匹配识别出来了老鼠的屁股是曲线的。我们则还需要其他特征的卷积核,来匹配识别出来老鼠的其他部分。卷积层的作用其实就是通过不断的改变卷积核,来确定能初步表征图片特征的有用的卷积核是哪些,再得到与相应的卷积核相乘后的输出矩阵

    2.2 池化层工作原理
    池化层的输入就是卷积层输出的原数据与相应的卷积核相乘后的输出矩阵
    池化层的目的:
    为了减少训练参数的数量,降低卷积层输出的特征向量的维度
    减小过拟合现象,只保留最有用的图片信息,减少噪声的传递
    最常见的两种池化层的形式:
    最大池化:max-pooling——选取指定区域内最大的一个数来代表整片区域
    均值池化:mean-pooling——选取指定区域内数值的平均值来代表整片区域
    举例说明两种池化方式:(池化步长为2,选取过的区域,下一次就不再选取)
    在这里插入图片描述
    在44的数字矩阵里,以步长22选取区域,比如上左将区域[1,2,3,4]中最大的值4池化输出;上右将区域[1,2,3,4]中平均值5/2池化输出

    2.3 全连接层工作原理
    卷积层和池化层的工作就是提取特征,并减少原始图像带来的参数。然而,为了生成最终的输出,我们需要应用全连接层来生成一个等于我们需要的类的数量的分类器。
    全连接层的工作原理和之前的神经网络学习很类似,我们需要把池化层输出的张量重新切割成一些向量,乘上权重矩阵,加上偏置值,然后对其使用ReLU激活函数,用梯度下降法优化参数既可。

    二、部分源代码

    %% 准备工作空间
    clc
    clear all
    close all
    %% 导入数据
    digitDatasetPath = fullfile('./', '/HandWrittenDataset/');
    imds = imageDatastore(digitDatasetPath, ...
        'IncludeSubfolders',true,'LabelSource','foldernames');% 采用文件夹名称作为数据标记
    %,'ReadFcn',@mineRF
    
    % 数据集图片个数
    countEachLabel(imds)
    
    numTrainFiles = 17;% 每一个数字有22个样本,取17个样本作为训练数据
    [imdsTrain,imdsValidation] = splitEachLabel(imds,numTrainFiles,'randomize');
    % 查看图片的大小
    img=readimage(imds,1);
    size(img)
    
    %% 定义卷积神经网络的结构
    layers = [
    % 输入层
    imageInputLayer([28 28 1])
    % 卷积层
    convolution2dLayer(5,6,'Padding',2)
    batchNormalizationLayer
    reluLayer
    
    maxPooling2dLayer(2,'stride',2)
    
    convolution2dLayer(5, 16)
    batchNormalizationLayer
    reluLayer
    
    maxPooling2dLayer(2,'stride',2)
    
    convolution2dLayer(5, 120)
    batchNormalizationLayer
    reluLayer
    % 最终层
    fullyConnectedLayer(10)
    softmaxLayer
    classificationLayer];
    
    %% 训练神经网络
    % 设置训练参数
    options = trainingOptions('sgdm',...
        'maxEpochs', 50, ...
        'ValidationData', imdsValidation, ...
        'ValidationFrequency',5,...
        'Verbose',false,...
        'Plots','training-progress');% 显示训练进度
    
    % 训练神经网络,保存网络
    net = trainNetwork(imdsTrain, layers ,options);
    save 'CSNet.mat' net
    
    %% 标记数据(文件名称方式,自行构造)
    cifar10Data = tempdir;
     
    url = 'https://www.cs.toronto.edu/~kriz/cifar-10-matlab.tar.gz';
     
    helperCIFAR10Data.download(url,cifar10Data);
    
    [trainingImages,trainingLabels,testImages,testLabels] = helperCIFAR10Data.load('cifar10Data');
    size(trainingImages)
    numImageCategories = 10;
    categories(trainingLabels)
    % Create the image input layer for 32x32x3 CIFAR-10 images
    [height, width, numChannels, ~] = size(trainingImages);
    imageSize = [height width numChannels];
    inputLayer = imageInputLayer(imageSize);
    
    
    % Convolutional layer parameters filter size
    filterSize = [5 5];
    numFilters = 32;
    middleLayers = [   
    % The first convolutional layer has a bank of 32 5x5x3 filters. A
    % symmetric padding of 2 pixels is added to ensure that image borders
    % are included in the processing. This is important to avoid
    % information at the borders being washed away too early in the
    % network.
    convolution2dLayer(filterSize, numFilters, 'Padding', 2)  %(n+2p-f)/s+1
     
    % Note that the third dimension of the filter can be omitted because it
    % is automatically deduced based on the connectivity of the network. In
    % this case because this layer follows the image layer, the third
    % dimension must be 3 to match the number of channels in the input
    % image.
     
    % Next add the ReLU layer:
    reluLayer()
     
    % Follow it with a max pooling layer that has a 3x3 spatial pooling area
    % and a stride of 2 pixels. This down-samples the data dimensions from
    % 32x32 to 15x15.
    maxPooling2dLayer(3, 'Stride', 2)
     
    % Repeat the 3 core layers to complete the middle of the network.
    convolution2dLayer(filterSize, numFilters, 'Padding', 2)
    reluLayer()
    maxPooling2dLayer(3, 'Stride',2)
     
    convolution2dLayer(filterSize, 2 * numFilters, 'Padding', 2)
    reluLayer()
    maxPooling2dLayer(3, 'Stride',2)
    
    ];
    
    
    finalLayers = [
    % Add a fully connected layer with 64 output neurons. The output size of
    % this layer will be an array with a length of 64.
    fullyConnectedLayer(64)
     
    % Add an ReLU non-linearity.
    reluLayer
     
    % Add the last fully connected layer. At this point, the network must
    % produce 10 signals that can be used to measure whether the input image
    % belongs to one category or another. This measurement is made using the
    % subsequent loss layers.
    fullyConnectedLayer(numImageCategories)
     
    % Add the softmax loss layer and classification layer. The final layers use
    % the output of the fully connected layer to compute the categorical
    % probability distribution over the image classes. During the training
    % process, all the network weights are tuned to minimize the loss over this
    % categorical distribution.
    softmaxLayer
    classificationLayer
    ];
    
    
    layers = [
        inputLayer
        middleLayers
        finalLayers
        ];
    
    layers(2).Weights = 0.0001 * randn([filterSize numChannels numFilters]);
    
    % Set the network training options
    opts = trainingOptions('sgdm', ...
        'Momentum', 0.9, ...
        'InitialLearnRate', 0.001, ...
        'LearnRateSchedule', 'piecewise', ...
        '
    
    % A trained network is loaded from disk to save time when running the
    % example. Set this flag to true to train the network.
    doTraining = false;
     
    if doTraining    
        % Train a network.
        cifar10Net = trainNetwork(trainingImages, trainingLabels, layers, opts);
    else
        % Load pre-trained detector for the example.
        load('rcnnStopSigns.mat','cifar10Net')       
    end
    
    % Extract the first convolutional layer weights
    w = cifar10Net.Layers(2).Weights;
     
    % rescale the weights to the range [0, 1] for better visualization
    w = rescale(w);
     
    figure
    montage(w)
    
    % Run the network on the test set.
    YTest = classify(cifar10Net, testImages);
     
    % Calculate the accuracy.
    accuracy = sum(YTest == testLabels)/numel(testLabels)
    
    
    %% 使用网络进行分类并计算准确性
    % 手写数据
    YPred = classify(net,mineSet);
    YValidation =mineSet.Labels;
    % 计算正确率
    accuracy = sum(YPred ==YValidation)/numel(YValidation);
    
      
    
    end
    
    % 伸缩+反色
    % function data =mineRF(filename)
    % img= imread(filename);
    % data=uint8(255-rgb2gray(imresize(img,[28 28])));
    % 
    % end
    
    % 二值化 
    % function data =mineRF(filename)
    % img= imread(filename);
    % data=imbinarize(img);
    % 
    % end
    
    

    三、运行结果

    在这里插入图片描述

    四、matlab版本及参考文献

    1 matlab版本
    2014a

    2 参考文献
    [1] 蔡利梅.MATLAB图像处理——理论、算法与实例分析[M].清华大学出版社,2020.
    [2]杨丹,赵海滨,龙哲.MATLAB图像处理实例详解[M].清华大学出版社,2013.
    [3]周品.MATLAB图像处理与图形用户界面设计[M].清华大学出版社,2013.
    [4]刘成龙.精通MATLAB图像处理[M].清华大学出版社,2015.

    展开全文
  • 利用matlab CNN网络进行手写体的数字识别分类
  • 手写数字识别matlab实现,源代码附上。用到机器学习的方法
  • %CNN 手写数字识别程序 %$2021/8/6 Zhigang Zhou$% %查阅MATLAB trainNetwork()帮助文档 %参阅网址: %https://blog.csdn.net/weixin_43935696/article/details/109372278 %...

    文章目录

    • 前言
    • 使用步骤
    • 识别结果


    前言


    利用MATLAB实践MNIST手写数字识别,下载手写数据集的准备工作有些麻烦。MATLAB 2021版可以直接调用MNIST部分数据进行CNN手写数字识别实践。直接上程序。

    一、使用步骤

    1.训练、测试及保存网络

    代码如下(示例):

    %CNN 手写数字识别程序
    %$2021/8/6 GAVIN$%
    %查阅MATLAB trainNetwork()帮助文档
    %参阅网址:
    %https://blog.csdn.net/weixin_43935696/article/details/109372278
    %https://blog.csdn.net/qq_40166660/article/details/111992192
    
    
    %%读取MATLAB自带数字图像数据集,数据集有10000幅0-9图像,各数字有1000幅图像
    digitDatasetPath = fullfile(matlabroot,'toolbox','nnet', ...
        'nndemos','nndatasets','DigitDataset');
    imds=imageDatastore(digitDatasetPath, 'FileExtensions',...
    {'.png','.jpg','.tif'},'IncludeSubfolders',true,... 
    'LabelSource','foldernames');
    %countEachLabel(imds)%显示标签文件夹及其中的文件数,10*2 table
    %a=readimage(imds,1);%读数据集中的第一幅图像
    %whos a %查看图像数据结构及数据类型:28x28,uint8
    figure
    numImages = 10000;
    perm = randperm(numImages,20);%随机选取20个数,perm是1*20double数组
    for i = 1:20  %此循环是MATLAB自带示例
        subplot(4,5,i);
        imshow(imds.Files{perm(i)});%显示随机选取的20幅图像
        drawnow;
    end
    numTrainingFiles = 750;%每个数字图像文件夹中1000幅图像中的750幅用于训练
    [imdsTrain,imdsTest] = splitEachLabel(imds,numTrainingFiles,'randomize');
    %%将每个标签文件夹中的文件随机拆分为两组,750个为imdsTrain,其余为imdsTest
    
    %%一般的CNN网络
    layers = [
        imageInputLayer([28 28 1],'Name','imageinput')
        
        convolution2dLayer(3,8,'Name','conv1','Padding','same')
        batchNormalizationLayer('Name','bn1')
        reluLayer('Name','relu1')  
        
        maxPooling2dLayer(2,'Stride',2,'Name','pool1')
        
        convolution2dLayer(3,16,'Padding','same','Name','conv2')
        batchNormalizationLayer('Name','bn2')
        reluLayer('Name','relu2')     
        
        maxPooling2dLayer(2,'Stride',2,'Name','pool2')
        
        convolution2dLayer(3,32,'Padding','same','Name','conv3')
        batchNormalizationLayer('Name','bn3')
        reluLayer('Name','relu3')  
        
        fullyConnectedLayer(10,'Name','fullc' )
        softmaxLayer('Name','soft')  
        classificationLayer('Name','classoutput')];
    
    %%改进的LeNet-5 网络
    % layers = [...        
    %     imageInputLayer([28 28 1],"Name","imageinput")
    % 
    %     convolution2dLayer([5 5],6,"Name","conv1","Padding","same")
    %     tanhLayer("Name","tanh1")
    % 
    %     maxPooling2dLayer([2 2],"Name","maxpool1","Stride",[2 2])
    % 
    %     convolution2dLayer([5 5],16,"Name","conv2")
    %     tanhLayer("Name","tanh2")
    % 
    %     maxPooling2dLayer([2 2],"Name","maxpool","Stride",[2 2])
    % 
    %     fullyConnectedLayer(120,"Name","fc1")
    %     fullyConnectedLayer(84,"Name","fc2")
    %     fullyConnectedLayer(10,"Name","fc")
    %     softmaxLayer("Name","softmax")
    %     classificationLayer("Name","classoutput")];
    
    figure;plot(layerGraph(layers))%显示网络结构图
    
    options = trainingOptions('sgdm', ...         %MATLAB示例优化器
        'LearnRateSchedule','piecewise', ...      %学习率
        'LearnRateDropFactor',0.2, ...             
        'LearnRateDropPeriod',5, ...
        'MaxEpochs',20, ...           %最大学习整个数据集的次数
        'MiniBatchSize',128, ...  %一个batch有128个样本,训练一轮样本需要迭代7500/128次
        'Plots','training-progress',... %画出整个训练过程
        'Verbose',0);%不在命令窗显示训练过程信息             
    
    net = trainNetwork(imdsTrain,layers,options);
    %save Minist_LeNet5 net 
    save zzg_cnn_1 net 
    
    YPred = classify(net,imdsTest);%在测试集上输出网络预测结果
    YTest = imdsTest.Labels;
    accuracy=sum(YPred == YTest)/numel(YTest);%网络在测试集的精度
    disp(accuracy);%0.9936,训练耗时10'54"
    %LeNet-5:精度0.9820,训练耗时7'40"

    2.手写数字识别

    代码如下(示例):

    %测试自己在画图板上写的数字
    %load Minist_LeNet5 net;   %导入训练好的LeNet5网络
    load zzg_cnn_1 net %导入训练好的CNN网络
    imds_zzg=imageDatastore('F:\2021MATLAB\shouxieshibie\zixieshuzi',...
    'FileExtensions',{'.jpg','.png','.bmp'},'IncludeSubfolders',false,... 
    'LabelSource','foldernames');
    len=numel(imds_zzg.Files);%读取imds_zzg中文件个数
    %len=length(readall(imds_zzg));%读取imds_zzg中文件个数
    
    figure('Name','CNN手写数字识别,版权所有:周志刚','NumberTitle','off');
    for i = 1:len 
        test_image =readimage(imds_zzg,i); %导入手写体数字图片
        subplot(8,5,i);
        imshow(imds_zzg.Files{i});
        pause(1)
        %drawnow;
        shape = size(test_image);
        dimension=numel(shape);
        if dimension > 2
        test_image = rgb2gray(test_image);      %灰度化
        end
        test_image = imresize(test_image, [28,28]); %保证输入为28*28
        test_image = imcomplement(test_image);%反转,使得输入网络时一定要保证图片 背景是黑色,数字部分是白色
        result = classify(net, test_image);  
        disp(result);%在命令窗显示识别结果
        title(['CNN识别结果:' char(result)])%在手写数字图像标题显示识别结果
    end
    

    二 识别结果

    展开全文
  • CNN 用于手写识别 matlab 代码理解

    千次阅读 2018-10-22 21:10:16
    1. 加载数据集并划分训练数据与测试数据 ...%含有70000个手写数字样本其中60000作为训练样本,10000作为测试样本,把数据转成相应的格式,并归一化。 train_x = double(reshape(train_x',28,28,60000))/2...

    1. 加载数据集并划分训练数据与测试数据

    % function test_example_CNN
    load mnist_uint8;
    %该模型采用的数据为mnist_uint8.mat
    %含有70000个手写数字样本其中60000作为训练样本,10000作为测试样本,把数据转成相应的格式,并归一化。
    train_x = double(reshape(train_x',28,28,60000))/255;
    test_x = double(reshape(test_x',28,28,10000))/255;
    train_y = double(train_y');
    test_y = double(test_y');
    

    2. 设置网络结构及训练参数

    %设置网络结构及训练参数
    rand('state',0)
    
    cnn.layers = {
        struct('type', 'i') %input layer
        struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer
        struct('type', 's', 'scale', 2) %sub sampling layer
        struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer
        struct('type', 's', 'scale', 2) %subsampling layer
    };
    %训练选项,alpha学习率(不用),batchsize批训练中样本的数量,numepochs迭代次数。
    opts.alpha = 1;
    opts.batchsize = 50;
    opts.numepochs = 5;
    
    

    3. 初始化网络

    cnn = cnnsetup(cnn, train_x, train_y);
    
    %初始化网络
    function net = cnnsetup(net, x, y)
       % assert(~isOctave() || compare_versions(OCTAVE_VERSION, '3.8.0', '>='), ['Octave 3.8.0 or greater is required for CNNs as there is a bug in convolution in previous versions. See http://savannah.gnu.org/bugs/?39314. Your version is ' myOctaveVersion]);
        inputmaps = 1;%输入图片数量
        mapsize = size(squeeze(x(:, :, 1)));%获取训练图像的大小
    
         % 下面通过传入net这个结构体来逐层构建CNN网络  
        for l = 1 : numel(net.layers)
            if strcmp(net.layers{l}.type, 's')
                % 如果这层是下采样层  
                mapsize = mapsize / net.layers{l}.scale;
               % assert(all(floor(mapsize)==mapsize), ['Layer ' num2str(l) ' size must be integer. Actual: ' num2str(mapsize)]);
                for j = 1 : inputmaps
                    net.layers{l}.b{j} = 0; %将偏置初始化为0
                end
            end
            if strcmp(net.layers{l}.type, 'c')
                % 如果这层是卷积层,且步长为 1 
                mapsize = mapsize - net.layers{l}.kernelsize + 1;
                %outputmaps表示卷积核的个数,fan_out表示卷积层需要的总参数个数
                fan_out = net.layers{l}.outputmaps * net.layers{l}.kernelsize ^ 2;
                %遍历每个卷积核
                for j = 1 : net.layers{l}.outputmaps  
                    %所有输入图片每个卷积核需要的参数个数
                    fan_in = inputmaps * net.layers{l}.kernelsize ^ 2;
                    for i = 1 : inputmaps
                        %为每张图片的每个卷积核随机初始化权值,
                        %每个卷积核的权值是一个kernelsize*kernelsize的矩阵
                        % rand(n)是产生n×n的 0-1之间均匀取值的数值的矩阵,再减去0.5就相当于产生-0.5到0.5之间的随机数  
                        % 再 *2 就放大到 [-1, 1] 
                        % 反正就是将卷积核每个元素初始化为[-sqrt(6 / (fan_in + fan_out)), sqrt(6 / (fan_in + fan_out))]  
                        net.layers{l}.k{i}{j} = (rand(net.layers{l}.kernelsize) - 0.5) * 2 * sqrt(6 / (fan_in + fan_out));
                    end
                    %初始化每个卷积核的偏置
                    net.layers{l}.b{j} = 0;
                end
                 % 只有在卷积层的时候才会改变特征map的个数,pooling的时候不会改变个数。这层输出的特征map个数就是  
                % 输入到下一层的特征map个数 
                inputmaps = net.layers{l}.outputmaps;
            end
        end
       % fvnum 是输出层的前面一层的神经元个数。  
        % 这一层的上一层是经过pooling后的层,包含有inputmaps个特征map。每个特征map的大小是mapsize。  
        % 所以,该层的神经元个数是 inputmaps * (每个特征map的大小)  
        % 在这里 mapsize = [特征map的行数 特征map的列数],所以prod后就是 特征map的行*列  
        fvnum = prod(mapsize) * inputmaps;
        % onum 是标签的个数,也就是输出层神经元的个数。你要分多少个类,自然就有多少个输出神经元 
        onum = size(y, 1);
    
        % 这里是最后一层神经网络的设定,即全连接层
        % ffb 是输出层每个神经元对应的基biases 
        net.ffb = zeros(onum, 1);
        % ffW 输出层前一层 与 输出层 连接的权值,这两层之间是全连接的
        net.ffW = (rand(onum, fvnum) - 0.5) * 2 * sqrt(6 / (onum + fvnum));
    end
    

    4. 根据初始化的参数对数据进行训练

    cnn = cnntrain(cnn, train_x, train_y, opts);
    
    • 对输入图片分批次
    • 迭代开始,抽取每个批次的训练样本
    • 计算每个批次的网络输出
    • 根据上面的网络输出,根据真实标签用bp算法计算误差对网络权值(卷积核参数)的导数
    • 根据导数对网络参数进行更新
    • 计算误差
    展开全文
  • 一、CNN卷积神经网络 模型参考这里。 二、部分代码 %% 准备工作空间 clc clear all close all %% 导入数据 digitDatasetPath = fullfile('./', '/HandWrittenDataset/'); imds = imageDatastore...
  • 一个简单的CNN程序,实现对十种手写数字识别
  • cnn 手写字体识别matlab代码概括

    千次阅读 2017-05-12 11:57:30
     cnn 层 结构  cnnsetup 设置权重和偏向进行初始化  cnntrain  cnntest  2、cnnsetup.m  下采样层和卷积层参数设置 3、cnntrain.m  对数据进行处理  训练过程包括:前向传递和反向传播,根据损失...
  • 手写数字识别】基于卷积神经网络CNN实现手写数字识别分类matlab源码
  • 基于深度学习的手写数字识别Matlab实现

    千次阅读 多人点赞 2019-05-08 19:48:31
    基于深度学习的手写数字识别1.网络设计2. 训练方法3.实验结果4.实验结果分析5.结论 1.网络设计 1.1 CNN(特征提取网络+分类网络) 随着深度学习的迅猛发展,其应用也越来越广泛,特别是在视觉识别、语音识别和自然...
  • 本文代码用于对手写体进行识别,里面有数据也有代码,能够对图片进行预处理、特征提取、智能识别
  • 1、Mnist_cnn.py 该脚本文件 用TensorFlow框架 实现CNN卷积神经网络处理Mnist手写数字识别数据集,准确率达到99.21%; 2、Mnist_cnn_tensorboard.py 该脚本文件在Mnist_cnn.py的基础上实现可视化。
  • CNN 手写数字识别.zip

    2020-05-05 13:29:54
    利用CNN来进行手写识别,通过卷积神经网络来识别数据集中的手写数字,可以很好的得到识别结果。实现平台为matlab,易于上手,很基础的代码来实现
  • CNN——卷积神经网络类数字识别matlab实现代码,原因是现在而与Matlab c++ / CUDA库前端比一个Matlab库。这个项目提供了matlab类卷积神经网络的实现。勒存这网络是由Yann和已经成功地使用在许多实际应用,如手写数字...
  • 用卷积神经网络识别手写数字图像,使用部分MINST数据集,MATLAB编程,包含一个卷积层,一个池化层,一个全连接层,一个隐藏层。
  • 由于CNN模型训练效果与实际测试之间存在较大的差距,为提高自由手写数字识别率,尝试使用TensorFlow搭构CNN网络模型,在完成MNIST数据集训练的基础上实现对自由手写数字识别,并根据两种样本状态的差别和识别结果...
  • 在朋友的强烈建议下,写一篇关于利用CNN卷积神经网络实现基于MATLAB手写数字识别系统的设计的博客。 一、关于卷积神经网络 关于卷积神经网络我写过一篇文章单独介绍,可以参考:手写数字识别问题(3)——详解卷积...
  • CNN手写数字识别ReLU版

    2016-12-05 20:40:13
    本科毕设论文,CNN实现的手写数字集,改自Matlab的深度学习工具箱,有较详细的中文注释!代码等见论文
  • 基于CNN手写数字识别算法内容介绍算法原理实验环境实验步骤实验结果 内容介绍 卷积神经网络(Convolutional Neural Network,CNN) 卷积神经网络相较于传统的图像处理算法的优点之一在于避免了对图像复杂的前期...
  • matlab——简单CNN网络的数字识别

    千次阅读 2019-09-09 10:10:55
    digitDatasetPath = fullfile(matlabroot,'toolbox','nnet', ... 'nndemos','nndatasets','DigitDataset'); imds = imageDatastore(digitDatasetPath, ... 'IncludeSubfolders',true, ... 'LabelSource'...
  • 利用卷积神经网络方法编写的简单的CNN-MNIST手写识别程序
  • 运用matlab读取手写数字识别数据集,对其分别进行传统机器学习建模和迁移学习建模。对比分析两者性能差异。 工作计划: 准备数据集,进行前期的数据清洗工作,使其转化成机器学习算法能够输入的数据结构。 用传统...
  • matlab手写神经网络实现识别手写数字

    万次阅读 多人点赞 2018-05-27 22:49:32
    一直想自己写一个神经网络来实现手写数字识别,而不是套用别人的框架。恰巧前几天,有幸从同学那拿到5000张已经贴好标签的手写数字图片,于是我就尝试用matlab写一个网络。 实验数据:5000张手写数字图片(.jpg)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 992
精华内容 396
关键字:

cnn手写数字识别matlab

matlab 订阅