精华内容
下载资源
问答
  • 卷积神经网络代码

    热门讨论 2012-04-19 09:19:00
    卷积神经网络的源代码 ConvNet - C++ Convolutional Neural Network Library Description of the contents: compile.sh script that compiles the ConvNet library CMakeLists.txt main file describing build ...
  • 硬件加速卷积神经网络代码HLS 完整注释
  • 卷积神经网络代码的学习,运用mnist数据集
  • 卷积神经网络代码 Matlab deep-learning-test 深度学习导论课上的matlab实现卷积神经网络的代码,最后会有一个手写数字识别作业!
  • 卷积神经网络代码.zip

    2021-06-03 16:27:07
    卷积神经网络
  • C#卷积神经网络代码

    2018-11-04 00:28:19
    用c#实现卷积神经网络,可以训练识别图片,代码按照卷积神经网络算法思路撰写,准确率
  • 卷积神经网络matlab代码 不需要配置,直接将工作目录设为这个压缩包的解压完的目录下就行,matlab直接运行
  • MNIST卷积神经网络代码实现(三) 0. 引言 前两篇博客总结了感知机和全连接网络实现MNIST手写数字的识别,本篇博客对卷积神经网络的代码实现进行总结。卷积神经网络(CNN)较全连接神经网络而言,其优势在于权值...

    MNIST卷积神经网络代码实现(三)

    0. 引言

    前两篇博客总结了感知机和全连接网络实现MNIST手写数字的识别,本篇博客对卷积神经网络的代码实现进行总结。卷积神经网络(CNN)较全连接神经网络而言,其优势在于权值共享和抗形变性,重要的步骤在于卷积和池化两个操作的应用,较全连接神经网络而言,这两种操作能极大的减少网络参数,降低网络的复杂性。
    注:以下代码有不清楚的请看博主前面博客,由于相似的太多,故不做累述,敬请见谅!

    1. 构建模型之前的准备(导入包)

    导入相关包并创建默认的session,进行代码的运行

    from tensorflow.examples.tutorials.mnist import input_data // 加载TensorFlow提供的mnist数据集
    import tensorflow as tf // 导入TensorFlow模块
    
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    sess = tf.InteractiveSession()
    

    2. 构建模型

    2.1 定义反复用到的操作

    // weight_variable()方法用于初始化权重,以便之后调用,这里用截断正太分布进行初始化,随机加入噪声。
    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.1)
        return tf.Variable(initial)
    // bias_variable()用于初始化偏置,初始化为常量0.1    
    def bias_variable(shape):
        initial = tf.constant(0.1, shape=shape)
        return tf.Variable(initial)
    // 定义卷积操作,步长为1×1,padding='SAME'会在输入矩阵上下各加几个值为0的行,在左右各加个几个值为0的列,以提取边缘特征,意味着卷积后图像的大小为原尺寸/步长,显然横向除以横向,纵向除以纵向。
    def conv2d(x, W):
        return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') 
    // 定义池化操作,这里定义最大池化,即在区域里提取最显著的特征。池化核的大小为2×2。池化后图像的大小为原尺寸/步长。
    def max_pool_2x2(x):
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')    
    

    2.2 定义输入、输出及真实输出

    x = tf.placeholder(tf.float32, [None, 784])// x是特征,即输入的数据,是一个长度为784的数组,None代表行数不确定
    x_image = tf.reshape(x, [-1, 28, 28, 1])// reshape()将读入的x输入变成图像的格式,即28*28,以便之后处理,-1None相对应,即图片的数量不确定,1代表灰度图像。即输入为28*28*1的x_image。
    y_ = tf.placeholder(tf.float32, [None, 10])// y_是真实的输出label,是一个长度为10的数组
    

    2.1 网络结构

    2.2.1 卷积层1+池化层1

    W_conv1 = weight_variable([5, 5, 1, 32])// 卷积核的为5*5,单通道的灰度图像,一共32个不同的卷积核,输出32个特征图
    b_conv1 = bias_variable([32])// 每个卷积对应一个偏置,共32个偏置
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1)+b_conv1)// 先进行卷积操作,后用relu激活函数处理,得到处理后的输出28*28*32。
    h_pool1 = max_pool_2x2(h_conv1)// 进行最大池化,28*28*32变成了14*14*32
    

    2.2.2 卷积层2+池化层2

    W_conv2 = weight_variable([5, 5, 32, 64])// 卷积核尺寸为5*5,32个通道,因为上面得到的是32层,第二个卷积层有64个不同的卷积核
    b_conv2 = bias_variable([64])//64个偏置
    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2)+b_conv2)// 第一层卷积和池化后的输出h_pool1作为第二层卷积层的输入,由于步长strides为1,填充边界padding为1,故结果为14*14*64
    h_pool2 = max_pool_2x2(h_conv2)// 由于步长为2,padding='SAME',故最大池化后为7*7*64
    

    2.2.3 全连接层1

    W_fc1 = weight_variable([7*7*64, 1024])// 第一个全连接层的权重矩阵,输入是上层的节点数,上层是7*7*64个结点,输出是1024个结点,1024是自己定义的。
    b_fc1 = bias_variable([1024])
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])// 为方便全连接层计算,把上一层传过来的结果reshape,从三维的变成一维的。
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+b_fc1)// 得到一个长度为1024的输出
    

    2.2.4 全连接层2

    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)// 使用softmax作为激活函数,softmax是一个多分类器。一般配合交叉熵损失函数使用
    

    2.2 学习规则及评价指标

    2.2.1 学习规则

    cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv), reduction_indices=[1]))
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) // 优化器使用Adam,学习率用一个较小的1e-4
    

    2.2.2 评价指标

    correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    

    3. 构建模型后的工作(训练模型、测试模型)

    tf.global_variables_initializer().run()
    
    for i in range(2000):
        batch = mnist.train.next_batch(50)// 获取50条数据作为一个batch,这里可以叫做mini-batch
       
        train_step.run({x: batch[0], y_: batch[1], keep_prob: 0.5})//训练
        
        //100个batch的训练做一个预测
        if i % 100 == 0
            print("step:", str(i), "测试准确率:",  accuracy.eval({x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))// eval()是tf.Tensor的Session.run()的另一种写法,但是eval()只能用于tf.Tensor类对象,即必须是有输出的operation,对于没有输出的operation,可以用run()或Session.run()即可。
    

    注:本代码借鉴黄文坚、唐源的《TensorFlow 实战》一书。

    展开全文
  • Deep Learning论文笔记之(五)CNN卷积神经网络代码理解zouxy09@qq.comhttp://blog.csdn.net/zouxy09 自己平时看了一些论文,但老感觉看完过后就会慢慢的淡忘,某一天重新拾起来的时候又好像没有看过一样。...

    Deep Learning论文笔记之(五)CNN卷积神经网络代码理解

    zouxy09@qq.com

    http://blog.csdn.net/zouxy09

     

             自己平时看了一些论文,但老感觉看完过后就会慢慢的淡忘,某一天重新拾起来的时候又好像没有看过一样。所以想习惯地把一些感觉有用的论文中的知识点总结整理一下,一方面在整理过程中,自己的理解也会更深,另一方面也方便未来自己的勘察。更好的还可以放到博客上面与大家交流。因为基础有限,所以对论文的一些理解可能不太正确,还望大家不吝指正交流,谢谢。

     

           本文的代码来自githupDeep Learningtoolbox,(在这里,先感谢该toolbox的作者)里面包含了很多Deep Learning方法的代码。是用Matlab编写的(另外,有人翻译成了C++python的版本了)。本文中我们主要解读下CNN的代码。详细的注释见代码。

           在读代码之前,最好先阅读下我的上一个博文:

             Deep Learning论文笔记之(四)CNN卷积神经网络推导和实现

                http://blog.csdn.net/zouxy09/article/details/9993371

           里面包含的是我对一个作者的CNN笔记的翻译性的理解,对CNN的推导和实现做了详细的介绍,看明白这个笔记对代码的理解非常重要,所以强烈建议先看懂上面这篇文章。

     

             下面是自己对代码的注释:

    cnnexamples.m

    clear all; close all; clc;
    addpath('../data');
    addpath('../util');
    load mnist_uint8;
    
    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');
    
    %% ex1 
    %will run 1 epoch in about 200 second and get around 11% error. 
    %With 100 epochs you'll get around 1.2% error
    
    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
    };
    
    % 这里把cnn的设置给cnnsetup,它会据此构建一个完整的CNN网络,并返回
    cnn = cnnsetup(cnn, train_x, train_y);
    
    % 学习率
    opts.alpha = 1;
    % 每次挑出一个batchsize的batch来训练,也就是每用batchsize个样本就调整一次权值,而不是
    % 把所有样本都输入了,计算所有样本的误差了才调整一次权值
    opts.batchsize = 50; 
    % 训练次数,用同样的样本集。我训练的时候:
    % 1的时候 11.41% error
    % 5的时候 4.2% error
    % 10的时候 2.73% error
    opts.numepochs = 10;
    
    % 然后开始把训练样本给它,开始训练这个CNN网络
    cnn = cnntrain(cnn, train_x, train_y, opts);
    
    % 然后就用测试样本来测试
    [er, bad] = cnntest(cnn, test_x, test_y);
    
    %plot mean squared error
    plot(cnn.rL);
    %show test error
    disp([num2str(er*100) '% error']);
    


    cnnsetup.m

    function net = cnnsetup(net, x, y)
        inputmaps = 1;
    	% B=squeeze(A) 返回和矩阵A相同元素但所有单一维都移除的矩阵B,单一维是满足size(A,dim)=1的维。
    	% train_x中图像的存放方式是三维的reshape(train_x',28,28,60000),前面两维表示图像的行与列,
    	% 第三维就表示有多少个图像。这样squeeze(x(:, :, 1))就相当于取第一个图像样本后,再把第三维
    	% 移除,就变成了28x28的矩阵,也就是得到一幅图像,再size一下就得到了训练样本图像的行数与列数了
        mapsize = size(squeeze(x(:, :, 1)));
    
    	% 下面通过传入net这个结构体来逐层构建CNN网络
    	% n = numel(A)返回数组A中元素个数
    	% net.layers中有五个struct类型的元素,实际上就表示CNN共有五层,这里范围的是5
        for l = 1 : numel(net.layers)   %  layer
            if strcmp(net.layers{l}.type, 's') % 如果这层是 子采样层
                % subsampling层的mapsize,最开始mapsize是每张图的大小28*28
    			% 这里除以scale=2,就是pooling之后图的大小,pooling域之间没有重叠,所以pooling后的图像为14*14
    			% 注意这里的右边的mapsize保存的都是上一层每张特征map的大小,它会随着循环进行不断更新
    			mapsize = floor(mapsize / net.layers{l}.scale);
                for j = 1 : inputmaps % inputmap就是上一层有多少张特征图
                    net.layers{l}.b{j} = 0; % 将偏置初始化为0
                end
            end
            if strcmp(net.layers{l}.type, 'c') % 如果这层是 卷积层
                % 旧的mapsize保存的是上一层的特征map的大小,那么如果卷积核的移动步长是1,那用
    			% kernelsize*kernelsize大小的卷积核卷积上一层的特征map后,得到的新的map的大小就是下面这样
    			mapsize = mapsize - net.layers{l}.kernelsize + 1;
    			% 该层需要学习的参数个数。每张特征map是一个(后层特征图数量)*(用来卷积的patch图的大小)
    			% 因为是通过用一个核窗口在上一个特征map层中移动(核窗口每次移动1个像素),遍历上一个特征map
    			% 层的每个神经元。核窗口由kernelsize*kernelsize个元素组成,每个元素是一个独立的权值,所以
    			% 就有kernelsize*kernelsize个需要学习的权值,再加一个偏置值。另外,由于是权值共享,也就是
    			% 说同一个特征map层是用同一个具有相同权值元素的kernelsize*kernelsize的核窗口去感受输入上一
    			% 个特征map层的每个神经元得到的,所以同一个特征map,它的权值是一样的,共享的,权值只取决于
    			% 核窗口。然后,不同的特征map提取输入上一个特征map层不同的特征,所以采用的核窗口不一样,也
    			% 就是权值不一样,所以outputmaps个特征map就有(kernelsize*kernelsize+1)* outputmaps那么多的权值了
    			% 但这里fan_out只保存卷积核的权值W,偏置b在下面独立保存
                fan_out = net.layers{l}.outputmaps * net.layers{l}.kernelsize ^ 2;
                for j = 1 : net.layers{l}.outputmaps  %  output map
                    % fan_out保存的是对于上一层的一张特征map,我在这一层需要对这一张特征map提取outputmaps种特征,
    				% 提取每种特征用到的卷积核不同,所以fan_out保存的是这一层输出新的特征需要学习的参数个数
    				% 而,fan_in保存的是,我在这一层,要连接到上一层中所有的特征map,然后用fan_out保存的提取特征
    				% 的权值来提取他们的特征。也即是对于每一个当前层特征图,有多少个参数链到前层
    				fan_in = inputmaps * net.layers{l}.kernelsize ^ 2;
                    for i = 1 : inputmaps  %  input map
    					% 随机初始化权值,也就是共有outputmaps个卷积核,对上层的每个特征map,都需要用这么多个卷积核
    					% 去卷积提取特征。
    					% rand(n)是产生n×n的 0-1之间均匀取值的数值的矩阵,再减去0.5就相当于产生-0.5到0.5之间的随机数
    					% 再 *2 就放大到 [-1, 1]。然后再乘以后面那一数,why?
    					% 反正就是将卷积核每个元素初始化为[-sqrt(6 / (fan_in + fan_out)), sqrt(6 / (fan_in + fan_out))]
    					% 之间的随机数。因为这里是权值共享的,也就是对于一张特征map,所有感受野位置的卷积核都是一样的
    					% 所以只需要保存的是 inputmaps * outputmaps 个卷积核。
                        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; % 将偏置初始化为0
                end
    			% 只有在卷积层的时候才会改变特征map的个数,pooling的时候不会改变个数。这层输出的特征map个数就是
    			% 输入到下一层的特征map个数
                inputmaps = net.layers{l}.outputmaps; 
            end
        end
    	
    	% fvnum 是输出层的前面一层的神经元个数。
    	% 这一层的上一层是经过pooling后的层,包含有inputmaps个特征map。每个特征map的大小是mapsize。
    	% 所以,该层的神经元个数是 inputmaps * (每个特征map的大小)
    	% prod: Product of elements.
    	% For vectors, prod(X) is the product of the elements of X
    	% 在这里 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
    


    cnntrain.m

    function net = cnntrain(net, x, y, opts)
        m = size(x, 3); % m 保存的是 训练样本个数
        numbatches = m / opts.batchsize;
    	% rem: Remainder after division. rem(x,y) is x - n.*y 相当于求余
    	% rem(numbatches, 1) 就相当于取其小数部分,如果为0,就是整数
        if rem(numbatches, 1) ~= 0
            error('numbatches not integer');
        end
    	
        net.rL = [];
        for i = 1 : opts.numepochs
    		% disp(X) 打印数组元素。如果X是个字符串,那就打印这个字符串
            disp(['epoch ' num2str(i) '/' num2str(opts.numepochs)]);
            % tic 和 toc 是用来计时的,计算这两条语句之间所耗的时间
    		tic;
    		% P = randperm(N) 返回[1, N]之间所有整数的一个随机的序列,例如
    		% randperm(6) 可能会返回 [2 4 5 6 1 3]
    		% 这样就相当于把原来的样本排列打乱,再挑出一些样本来训练
            kk = randperm(m);
            for l = 1 : numbatches
    			% 取出打乱顺序后的batchsize个样本和对应的标签
                batch_x = x(:, :, kk((l - 1) * opts.batchsize + 1 : l * opts.batchsize));
                batch_y = y(:,    kk((l - 1) * opts.batchsize + 1 : l * opts.batchsize));
    
    			% 在当前的网络权值和网络输入下计算网络的输出
                net = cnnff(net, batch_x); % Feedforward
    			% 得到上面的网络输出后,通过对应的样本标签用bp算法来得到误差对网络权值
    			%(也就是那些卷积核的元素)的导数
                net = cnnbp(net, batch_y); % Backpropagation
    			% 得到误差对权值的导数后,就通过权值更新方法去更新权值
                net = cnnapplygrads(net, opts);
                if isempty(net.rL)
                    net.rL(1) = net.L; % 代价函数值,也就是误差值
                end
                net.rL(end + 1) = 0.99 * net.rL(end) + 0.01 * net.L; % 保存历史的误差值,以便画图分析
            end
            toc;
        end
        
    end
    


    cnnff.m

    function net = cnnff(net, x)
        n = numel(net.layers); % 层数
        net.layers{1}.a{1} = x; % 网络的第一层就是输入,但这里的输入包含了多个训练图像
        inputmaps = 1; % 输入层只有一个特征map,也就是原始的输入图像
    
        for l = 2 : n   %  for each layer
            if strcmp(net.layers{l}.type, 'c') % 卷积层
                %  !!below can probably be handled by insane matrix operations
    			% 对每一个输入map,或者说我们需要用outputmaps个不同的卷积核去卷积图像
                for j = 1 : net.layers{l}.outputmaps   %  for each output map
                    %  create temp output map
    				% 对上一层的每一张特征map,卷积后的特征map的大小就是 
    				% (输入map宽 - 卷积核的宽 + 1)* (输入map高 - 卷积核高 + 1)
    				% 对于这里的层,因为每层都包含多张特征map,对应的索引保存在每层map的第三维
    				% 所以,这里的z保存的就是该层中所有的特征map了
                    z = zeros(size(net.layers{l - 1}.a{1}) - [net.layers{l}.kernelsize - 1 net.layers{l}.kernelsize - 1 0]);
                    for i = 1 : inputmaps   %  for each input map
                        %  convolve with corresponding kernel and add to temp output map
    					% 将上一层的每一个特征map(也就是这层的输入map)与该层的卷积核进行卷积
    					% 然后将对上一层特征map的所有结果加起来。也就是说,当前层的一张特征map,是
    					% 用一种卷积核去卷积上一层中所有的特征map,然后所有特征map对应位置的卷积值的和
    					% 另外,有些论文或者实际应用中,并不是与全部的特征map链接的,有可能只与其中的某几个连接
                        z = z + convn(net.layers{l - 1}.a{i}, net.layers{l}.k{i}{j}, 'valid');
                    end
                    %  add bias, pass through nonlinearity
    				% 加上对应位置的基b,然后再用sigmoid函数算出特征map中每个位置的激活值,作为该层输出特征map
                    net.layers{l}.a{j} = sigm(z + net.layers{l}.b{j});
                end
                %  set number of input maps to this layers number of outputmaps
                inputmaps = net.layers{l}.outputmaps;
            elseif strcmp(net.layers{l}.type, 's') % 下采样层
                %  downsample
                for j = 1 : inputmaps
                    %  !! replace with variable
    				% 例如我们要在scale=2的域上面执行mean pooling,那么可以卷积大小为2*2,每个元素都是1/4的卷积核
    				z = convn(net.layers{l - 1}.a{j}, ones(net.layers{l}.scale) / (net.layers{l}.scale ^ 2), 'valid'); 
    				% 因为convn函数的默认卷积步长为1,而pooling操作的域是没有重叠的,所以对于上面的卷积结果
    				% 最终pooling的结果需要从上面得到的卷积结果中以scale=2为步长,跳着把mean pooling的值读出来
                    net.layers{l}.a{j} = z(1 : net.layers{l}.scale : end, 1 : net.layers{l}.scale : end, :);
                end
            end
        end
    
        %  concatenate all end layer feature maps into vector
    	% 把最后一层得到的特征map拉成一条向量,作为最终提取到的特征向量
        net.fv = [];
        for j = 1 : numel(net.layers{n}.a) % 最后一层的特征map的个数
            sa = size(net.layers{n}.a{j}); % 第j个特征map的大小
    		% 将所有的特征map拉成一条列向量。还有一维就是对应的样本索引。每个样本一列,每列为对应的特征向量
            net.fv = [net.fv; reshape(net.layers{n}.a{j}, sa(1) * sa(2), sa(3))];
        end
        %  feedforward into output perceptrons
    	% 计算网络的最终输出值。sigmoid(W*X + b),注意是同时计算了batchsize个样本的输出值
        net.o = sigm(net.ffW * net.fv + repmat(net.ffb, 1, size(net.fv, 2)));
    
    end
    


    cnnbp.m

    function net = cnnbp(net, y)
        n = numel(net.layers); % 网络层数
    
        %  error
        net.e = net.o - y; 
        %  loss function
    	% 代价函数是 均方误差
        net.L = 1/2* sum(net.e(:) .^ 2) / size(net.e, 2);
    
        %%  backprop deltas
    	% 这里可以参考 UFLDL 的 反向传导算法 的说明
    	% 输出层的 灵敏度 或者 残差
        net.od = net.e .* (net.o .* (1 - net.o));   %  output delta
    	% 残差 反向传播回 前一层
        net.fvd = (net.ffW' * net.od);              %  feature vector delta
        if strcmp(net.layers{n}.type, 'c')         %  only conv layers has sigm function
            net.fvd = net.fvd .* (net.fv .* (1 - net.fv));
        end
    
        %  reshape feature vector deltas into output map style
        sa = size(net.layers{n}.a{1}); % 最后一层特征map的大小。这里的最后一层都是指输出层的前一层
        fvnum = sa(1) * sa(2); % 因为是将最后一层特征map拉成一条向量,所以对于一个样本来说,特征维数是这样
        for j = 1 : numel(net.layers{n}.a) % 最后一层的特征map的个数
    		% 在fvd里面保存的是所有样本的特征向量(在cnnff.m函数中用特征map拉成的),所以这里需要重新
    		% 变换回来特征map的形式。d 保存的是 delta,也就是 灵敏度 或者 残差
            net.layers{n}.d{j} = reshape(net.fvd(((j - 1) * fvnum + 1) : j * fvnum, :), sa(1), sa(2), sa(3));
        end
    
    	% 对于 输出层前面的层(与输出层计算残差的方式不同)
        for l = (n - 1) : -1 : 1
            if strcmp(net.layers{l}.type, 'c')
                for j = 1 : numel(net.layers{l}.a) % 该层特征map的个数
                    % net.layers{l}.d{j} 保存的是 第l层 的 第j个 map 的 灵敏度map。 也就是每个神经元节点的delta的值
    				% expand的操作相当于对l+1层的灵敏度map进行上采样。然后前面的操作相当于对该层的输入a进行sigmoid求导
    				% 这条公式请参考 Notes on Convolutional Neural Networks
    				% for k = 1:size(net.layers{l + 1}.d{j}, 3)
    					% net.layers{l}.d{j}(:,:,k) = net.layers{l}.a{j}(:,:,k) .* (1 - net.layers{l}.a{j}(:,:,k)) .*  kron(net.layers{l + 1}.d{j}(:,:,k), ones(net.layers{l + 1}.scale)) / net.layers{l + 1}.scale ^ 2;
    				% end
    				net.layers{l}.d{j} = net.layers{l}.a{j} .* (1 - net.layers{l}.a{j}) .* (expand(net.layers{l + 1}.d{j}, [net.layers{l + 1}.scale net.layers{l + 1}.scale 1]) / net.layers{l + 1}.scale ^ 2);
                end
            elseif strcmp(net.layers{l}.type, 's')
                for i = 1 : numel(net.layers{l}.a) % 第l层特征map的个数
                    z = zeros(size(net.layers{l}.a{1}));
                    for j = 1 : numel(net.layers{l + 1}.a) % 第l+1层特征map的个数
                         z = z + convn(net.layers{l + 1}.d{j}, rot180(net.layers{l + 1}.k{i}{j}), 'full');
                    end
                    net.layers{l}.d{i} = z;
                end
            end
        end
    
        %%  calc gradients
    	% 这里与 Notes on Convolutional Neural Networks 中不同,这里的 子采样 层没有参数,也没有
    	% 激活函数,所以在子采样层是没有需要求解的参数的
        for l = 2 : n
            if strcmp(net.layers{l}.type, 'c')
                for j = 1 : numel(net.layers{l}.a)
                    for i = 1 : numel(net.layers{l - 1}.a)
    					% dk 保存的是 误差对卷积核 的导数
                        net.layers{l}.dk{i}{j} = convn(flipall(net.layers{l - 1}.a{i}), net.layers{l}.d{j}, 'valid') / size(net.layers{l}.d{j}, 3);
                    end
    				% db 保存的是 误差对于bias基 的导数
                    net.layers{l}.db{j} = sum(net.layers{l}.d{j}(:)) / size(net.layers{l}.d{j}, 3);
                end
            end
        end
    	% 最后一层perceptron的gradient的计算
        net.dffW = net.od * (net.fv)' / size(net.od, 2);
        net.dffb = mean(net.od, 2);
    
        function X = rot180(X)
            X = flipdim(flipdim(X, 1), 2);
        end
    end
    


    cnnapplygrads.m

    function net = cnnapplygrads(net, opts)
        for l = 2 : numel(net.layers)
            if strcmp(net.layers{l}.type, 'c')
                for j = 1 : numel(net.layers{l}.a)
                    for ii = 1 : numel(net.layers{l - 1}.a)
    					% 这里没什么好说的,就是普通的权值更新的公式:W_new = W_old - alpha * de/dW(误差对权值导数)
                        net.layers{l}.k{ii}{j} = net.layers{l}.k{ii}{j} - opts.alpha * net.layers{l}.dk{ii}{j};
                    end
                end
                net.layers{l}.b{j} = net.layers{l}.b{j} - opts.alpha * net.layers{l}.db{j};
            end
        end
    
        net.ffW = net.ffW - opts.alpha * net.dffW;
        net.ffb = net.ffb - opts.alpha * net.dffb;
    end
    


    cnntest.m

    function [er, bad] = cnntest(net, x, y)
        %  feedforward
        net = cnnff(net, x); % 前向传播得到输出
    	% [Y,I] = max(X) returns the indices of the maximum values in vector I
        [~, h] = max(net.o); % 找到最大的输出对应的标签
        [~, a] = max(y); 	 % 找到最大的期望输出对应的索引
        bad = find(h ~= a);  % 找到他们不相同的个数,也就是错误的次数
    
        er = numel(bad) / size(y, 2); % 计算错误率
    end
    


    展开全文
  • 卷积神经网络在图像识别应用,此压缩包包括代码
  • 一个简单的卷积神经网络,包括一个卷积层,ReLU层,池化层,全连接层。适合初学者一步一步的看,对卷积神经网络有一个深入的了解。
  • 卷积神经网络代码Matlab 人工神经网络 使用空间光谱深度残差卷积神经网络(HSID-CNN)的用于高光谱图像降噪的Matlab演示代码,IEEE TGRS,2019。 By Qiang Zhang (whuqzhang@gmail.com) Wuhan University, China. ...
  • 关于一些初步卷积神经网络的HLS代码及约束。通过这部分可以了解卷积神经网络在HLS上面的实现。具有一些借鉴意义,想要真正的了解还请参加Xilinx每年的暑期计划。
  • 详情参考https://github.com/LianHaiMiao/pytorch-lesson-zh/,这个老师讲的特别详细,或者参考https://blog.csdn.net/a1103688841/article/details/89222614
  • 卷积神经网络代码 Matlab ML here will show some code about machine learning by using python. 个人博客: 欢迎来访和留言 文件说明 matlab 吴恩达机器学习教程个人代码总结和学习记录 模型实现 cross_validate :...
  • CNN卷积神经网络训练模型,python语言编程,粗略训练,入门难度。
  • 手写数字识别MNIST数据集,内含t10k-images-idx3-ubyte.gz等四个压缩文件以及卷积神经网络识别代码
  • 本资料属于MATLAB运行程序,直接下载,直接使用,具有详细的代码解释,初学者即可看懂
  • 卷积神经网络代码实现

    千次阅读 2018-03-18 20:05:03
    #构建卷积神经网络 #第一层卷积 conv1 = tf.layers.conv2d(inputs=images, filters=6, kernel_size=[5,5], strides=1, padding='same', activation=tf.nn.relu )#输入的形状是32*32(图片外围加入了两行0),...
    # -*- coding=utf-8 -*-
    import numpy as np
    import tensorflow as tf
    #下载并载入MNIST手写数字库(55000*28*28)55000张训练图像
    from tensorflow .examples.tutorials.mnist import input_data
    
    #one_hot独热码的编码(encoding)形式
    #0,1,2到9的10个数字
    # 0 表示为0 : 1000000000
    # 1 表示为1 : 0100000000
    # 2 表示为2 : 0010000000等以此类推
    mnist = input_data.read_data_sets('MNIST_data',one_hot=True)
    
    #输入图片为28*28
    #None表示张量(Tensor)的第一个维度可以是任何长度
    input_x = tf.placeholder(tf.float32,[None,28*28])
    
    #输出为10个数字
    output_y = tf.placeholder(tf.int32,[None,10])
    
    #改变矩阵维度,-1表示根据实际情况而定 1表示图片深度,改变形状之后的输入
    images = tf.reshape(input_x,[-1,28,28,1])
    
    #从Test数据集里选取3000个手写数字的图片和对应标签
    test_x = mnist.test.images[:3000]#测试图片
    test_y = mnist.test.labels[:3000]#测试标签
    
    
    #构建卷积神经网络
    #第一层卷积
    conv1 = tf.layers.conv2d(inputs=images,
                             filters=6,
                             kernel_size=[5,5],
                             strides=1,
                             padding='same',
                             activation=tf.nn.relu
                             )#输入的形状是32*32(图片外围加入了两行0),输出的形状是28*28
    
    #第一层池化
    pool1 = tf.layers.max_pooling2d(inputs=conv1,
                                    pool_size=[2,2],
                                    strides=2
                                    )#形状变为[14*14,32]
    
    #第二层卷积
    conv2 = tf.layers.conv2d(inputs=pool1,
                             filters=16,
                             kernel_size=[5,5],
                             strides=1,
                             activation=tf.nn.relu)#形状变为[10*10,6]
    
    #第二层池化
    pool2 = tf.layers.max_pooling2d(inputs=conv2,
                                    pool_size=[2,2],
                                    strides=2
                                    )#形状变为[5*5,6]
    conv3 = tf.layers.conv2d(inputs=pool2,
                             filters=120,
                             kernel_size=[5,5],
                             strides=1,
                             activation=tf.nn.relu)
    
    #平坦化
    flat = tf.reshape(conv3,[-1,1*1*120])
    
    #经过全连接层
    dense = tf.layers.dense(inputs=flat,
                            units=1024,
                            activation=tf.nn.relu)
    
    #dropout 丢弃50%
    dropout = tf.layers.dropout(inputs=dense,rate=0.5)
    
    #10个神经元的全连接层,不用激励函数来做非线性化
    logits = tf.layers.dense(inputs=dropout,units=10)
    
    #计算误差,再用softmax计算百分比概率
    loss = tf.losses.softmax_cross_entropy(onehot_labels=output_y,
                                           logits=logits)
    
    #用一个Adam优化器来最小化误差,学习率设为0.001
    #train_op = tf.train.AdamOptimizer(learning_rate=0.001.minimize(loss))
    train_op = tf.train.AdamOptimizer(0.001).minimize(loss)
    
    #计算与测试值和实际值的匹配程度
    #返回(accuracy,update_op),会创建两个局部变量
    accuracy = tf.metrics.accuracy(labels=tf.argmax(output_y,axis=1),
                                   predictions=tf.argmax(logits,axis=1),)[1]
    
    #创建会话
    sess = tf.Session()
    
    #初始化变量,全局和局部
    init = tf.group(tf.global_variables_initializer(),tf.local_variables_initializer())
    
    sess.run(init)
    
    for x in range(2000):
        batch = mnist.train.next_batch(50) #从train数据集里去下一个50个样本
        train_loss,train_op_ = sess.run([loss,train_op],{input_x:batch[0],output_y:batch[1]})
        if x % 100 == 0:#每100轮输出一次
            test_accuracy = sess.run(accuracy,{input_x:test_x,output_y:test_y})
            print("step=%d,train loss = %.4f,test accuracy = %.2f" % (x,train_loss,test_accuracy))
    
    
    #测试,打印20个测试值和真实值的对
    test_output = sess.run(logits,{input_x:test_x[:20]})
    inferenced_y = np.argmax(test_output,1)
    print(inferenced_y,'inferenced numbers')#推测的数字
    print(np.argmax(test_y[:20],1),'real numbers')#真实的数字
    
    
    
    
    
    
    
    
    
    
    

    展开全文
  • """---------------------cnn卷积神经网络---------------------""" import torch from torch import nn, optim import torch.nn.functional as F from torch.autograd import Variable from torch.utils.data ...
    """---------------------cnn卷积神经网络---------------------"""
    import torch
    from torch import nn, optim
    import torch.nn.functional as F
    from torch.autograd import Variable
    from torch.utils.data import DataLoader
    from torchvision import transforms
    from torchvision import datasets
    from log1 import Logged
    
    # 定义超参数
    batch_size = 128
    learning_rate = 1e-2
    num_epoches = 20
    
    """04-Convolutional Neural Network"""
    def to_np(x):
        return x.cpu().data.numpy()
    
    
    # 下载训练集 MNIST 手写数字训练集
    train_dataset = datasets.MNIST(
        root='F:/PycharmProjects/pytorch-beginner-master/02-Logistic Regression/data', train=False, transform=transforms.ToTensor(), download=True)
    
    test_dataset = datasets.MNIST(
        root='F:/PycharmProjects/pytorch-beginner-master/02-Logistic Regression/data', train=False, transform=transforms.ToTensor())
    
    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
    
    
    #定义 Convolution Network 模型
    #nn.Sequential:这个表示将一个有序的模块写在一起,也就相当于将神经网络的层按顺序放在一起,这样可以方便结构显示
    class Cnn(nn.Module):
        def __init__(self, in_dim, n_class):
            super(Cnn, self).__init__()
            self.conv = nn.Sequential(
                # 开始输入[batch_size=128, in_dim=1, 28,28]经过第一层Conv2d后,用公式W2 = ((input-kernel_size+2padding)/stride) + 1计算输出为:[128,6,28,28]
                nn.Conv2d(in_channels=in_dim, out_channels=6, kernel_size=3, stride=1, padding=1),
                # 修正线性单元,是神经元的激活函数 默认设置为False,表示新创建一个对象对其修改,也可以设置为True,表示直接对这个对象进行修改
                nn.ReLU(True),#输入[128,6,28,28],输出为:[128,6,28,28]
                # 池化层可以非常有效地缩小矩阵的尺寸。从而减少最后全连接层中的参数
                nn.MaxPool2d(2, 2),#输入:[128,6,28,28]输出:[128,6,14,14]
                nn.Conv2d(6, 16, kernel_size=5, stride=1, padding=0),#输入:[128,6,14,14]输出:[128,16,10,10]
                nn.ReLU(True), #
            nn.MaxPool2d(kernel_size=2, stride=2))#输入:[128,16,10,10]输出:[128,16,5,5]
    
        self.fc = nn.Sequential(
            nn.Linear(400, 120), #输入为:[128,400],输出为:[128,120]
            nn.Linear(120, 84), #输入为:[128,120],输出为:[128,84]
            nn.Linear(84, n_class))#输入为:[128,84],输出为:[128,10]
    
    def forward(self, x):
        out = self.conv(x)#输入x=[128,1,28,28],上面__init__一步步说明了out=[128,16,5,5]的由来
        #返回一个有相同数据但大小不同的tensor,-1就代表这个位置由其他位置的数字来推断
        out = out.view(out.size(0), -1)#out变为[128,x] x=128*16*5*5/128,所以x值为400,out为[128,400]
        out = self.fc(out)#进入这个函数看,输出为[128,10]
        return out
    
    
    model = Cnn(in_dim=1, n_class=10)  # 图片大小是28x28
    use_gpu = torch.cuda.is_available()  # 判断是否有GPU加速
    if use_gpu:
        model = model.cuda()
    # 定义loss和optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=learning_rate)
    #logger = Logged('F:/PycharmProjects/pytorch-beginner-master/04-Convolutional Neural Network/logs')
    #开始训练
    for epoch in range(num_epoches):
        print('epoch {}'.format(epoch + 1))
        print('*' * 10)
        for i, data in enumerate(train_loader, 1):
            img, label = data
            if use_gpu:
                img = img.cuda()
                label = label.cuda()
            img = Variable(img)
            label = Variable(label)
            # 向前传播
    
        # 开始输入为[batch_size=128, in_dim=1, 28,28] 其分别代表:batch_size组数据,通道数为1,
        # 高度为28,宽为28,输出为[batch_size=128,n_class=10],详情进model函数看
        out = model(img)
        loss = criterion(out, label)
    
        # 向后传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
        if i % 20 == 0:
            print("loss: ", loss.data.item())
    
    
    model.eval()
    for data in test_loader:
        img, label = data
        if use_gpu:
            with torch.no_grad():
                img = Variable(img).cuda()
                label = Variable(label).cuda()
        else:
            with torch.no_grad():
                img = Variable(img)
                label = Variable(label)
        out = model(img)
        loss = criterion(out, label)
    print("test loss: ", loss.data.item())
    
    # 保存模型
    torch.save(model.state_dict(), 'F:/PycharmProjects/pytorch-beginner-master/04-Convolutional Neural Network/cnn.pth')
    
    展开全文
  • image_dataset_... 使您的图像数据集类似于深度学习网站上给出的卷积神经网络代码的 MNIST 数据集。 代码必须分别运行 3 次以进行训练、测试和验证。 从每个部分生成的三个元组必须在 zip 文件中进行腌制。
  • 卷积神经网络-Codealong 介绍 在此代码中,我们将重新研究以前的圣诞老人图像分类示例。 为此,我们将审查从嵌套目录结构中加载数据集并构建基线模型。 从那里,我们将构建一个CNN并演示其在图像识别任务上的改进...
  • 该存储库提供“ CA-Net:可解释医学图像分割的综合注意力卷积神经网络”的代码。 现在可以在上我们的工作。 接受了我们的工作。 图1. CA-Net的结构。 图2.皮肤病变分割。 图3.胎盘和胎脑分割。 要求条件 一些重要...
  • Python CNN卷积神经网络代码实现

    千次阅读 2018-11-22 18:33:00
     数据集为55000条,抽取训练集为100000,一层16个卷积核,二层32个卷积核,全连接层512,10分类:    2.训练集数据不变,增大卷积核数:  数据集为55000条,抽取训练集为1000,一层32个卷积核,二层64个...
  • CNN 卷积神经网络 代码实例+图

    千次阅读 2016-07-04 15:30:34
    conv1_weights是[5,5,1,32] conv2_weights是[5,5,32,64]
  • Matlab deep learning toolbox CNN 卷积神经网络代码改进

    千次阅读 热门讨论 2015-05-01 13:30:05
    Matlab Deep learning toolbox CNN部分改进版本代码我已经放在了github里,看这个代码学习深度学习将会非常的有效率,地址: https://github.com/PierreHao/Deep-Learning-ToolBox-CNN 对原有的matlab toolbox cnn...
  • 卷积神经网络经典代码代码,可以直接运行。卷积神经网络MATLAB代码
  • 卷积神经网络Matlab实现,卷积神经网络matlab代码,matlab源码
  • 卷积神经网络的matlab代码,直接可运行卷积神经网络的matlab代码,直接可运行卷积神经网络的matlab代码,直接可运行卷积神经网络的matlab代码,直接可运行
  • 卷积神经网络 python代码 代码代码 代码。。。。。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,739
精华内容 23,495
关键字:

卷积神经网络代码