精华内容
下载资源
问答
  • 基于盲去卷积原理的图像复原程序代码, 露西-理查德森算法属于图像复原中的非线性算法,与维纳滤波这种较为直接的算法不同,该算法使用非线性迭代技术,在计算量、性能方面都有了一定提升。
  • 去卷积原理及在图像复原的应用

    万次阅读 热门讨论 2017-03-28 21:01:57
    去卷积原理及在图像复原的应用

    前言

           之前写过一篇维纳滤波在图像复原中的作用,讲述了图像退化模型以及维纳滤波的作用。维纳滤波使用的前提是知道信号和噪声的功率谱,但在实际应用中较难得到,只能根据先验知识进行估计。

           本文介绍盲去卷积复原算法,并在MATLAB中进行实验,和维纳滤波的复原效果进行一个对比。盲去卷积的方法有多种,本文主要介绍由fish提出的基于露西-理查德森(Richardson-Lucy)的盲去卷积算法。

    盲去卷积原理

         露西-理查德森算法属于图像复原中的非线性算法,与维纳滤波这种较为直接的算法不同,该算法使用非线性迭代技术,在计算量、性能方面都有了一定提升。

         露西-理查德森算法是由贝叶斯公式推导而来,因为使用了条件概率(即算法考虑了信号的固有波动,因此具有复原噪声图像的能力)。贝叶斯公式如下:

          结合图像退化/复原模型,可以得到迭代函数:

      

        其中 fi 就是第i轮迭代复原图像,对应贝叶斯公式中的p(x),g是退化函数,对应贝叶斯公式的p(y|x),c为退化图像(c(y)dy意为在退化图像上积分),如果满足等晕条件,即图像各区域的模糊函数相同,则迭代公式可化简如下:

         这就是路西-理查德森迭代公式,其中c是退化图像,g是退化函数,f是第k轮复原图像。如果系统的退化函数PSF(g(x))已知,只要有一个初始估计f就可以进行迭代求解了。在开始迭代后,由于算法的形式,估计值会与真实值的差距迅速减小,从而后续迭代过程f的更新速度会逐渐变慢,直至收敛。算法的另一优点就是初始值f>0,后续迭代值均会保持非负性,并且能量不会发散。

         盲去卷积需要两步进行复原,原因是我们既不知道原始图像f,也不知道退化函数g。求解过程示意图如下:

          即在第k轮迭代,我们假a设原始图像已知,即k-1轮得到的fk-1,再通过R-L公式求解gk,随后,再用gk求解fk,反复迭代,最后求得最终f和g。因此,在求解最初,我们需要同时假设一个复原图像f0和一个退化函数g0。迭代公式如下:

          此外,有人采用这种盲去卷积方法进行了相关实验,下图为实验原图:

    下图(a)左、右分别为附加标准差1.5%、10%泊松噪声的退化图像,图(b)左、右分别为1.5%的复原图像和PSF,图(c)为10%对应结果

         


    盲去卷积MATLAB实验

         将一幅原始图像,进行模糊处理(模拟大气湍流),分别使用维纳滤波(由于没加噪声,就是逆滤波)和盲去卷积进行复原,复原结果如下:


          下面是网上找到的有关盲去卷积的MATLAB程序,可以加深理解。
    %% Deblurring Images Using the Blind Deconvolution Algorithm 
    %%盲反卷积算法复原图像
    % The Blind Deconvolution Algorithm can be used effectively when no
    % information about the distortion (blurring and noise) is known. The
    % algorithm restores the image and the point-spread function (PSF)
    % simultaneously. The accelerated, damped Richardson-Lucy algorithm is used
    % in each iteration. Additional optical system (e.g. camera)
    % characteristics can be used as input parameters that could help to
    % improve the quality of the image restoration. PSF constraints can be
    % passed in through a user-specified function
    %在不知道图像失真信息(模糊和噪声)信息情况下,盲反卷积算法可以有效地加以利用。该算法
    %对图像和点扩展函数(PSF)的同时进行复原。每次迭代都使用加速收敛Richardson-Lucy 
    %算法。额外的光学系统(如照相机)的特性可作为输入参数,帮助改善图像复原质量。可以通
    %过用户指定的函数对PSF进行限制
    % Copyright 2004-2005 The MathWorks, Inc.
     
    %% Step 1: Read Image
    %%第一步:读取图像
    % The example reads in an intensity image. The |deconvblind| function can
    % handle arrays of any dimension.
    %该示例读取一个灰度图像。| deconvblind |函数可以处理任何维数组。
    I = imread('view.tif');
    figure;imshow(I);title('Original Image');
    %text(size(I,2),size(I,1)+15, ...
    %    'Image courtesy of Massachusetts Institute of Technology', ...
    %'FontSize',7,'HorizontalAlignment','right');  
       
    
     
    %% Step 2: Simulate a Blur
    %%第二步:模拟一个模糊
    % Simulate a real-life image that could be blurred (e.g., due to camera
    % motion or lack of focus). The example simulates the blur by convolving a
    % Gaussian filter with the true image (using |imfilter|). The Gaussian filter
    % then represents a point-spread function, |PSF|.
     %模拟一个现实中存在的模糊图像(例如,由于相机抖动或对焦不足)。这个例子通过对真实
    %图像进行高斯滤波器模拟图像模糊(使用|imfilter|)。高斯滤波器是一个点扩展函数,
    %|PSF|。
    PSF=fspecial('gaussian',7,10);
    Blurred=imfilter(I,PSF,'symmetric','conv');  %对图像I进行滤波处理;
    figure;imshow(Blurred);title('Blurred Image');  
    
       
    
     
    %% Step 3: Restore the Blurred Image Using PSFs of Various Sizes
    %%第三步:使用不同的点扩展函数复原模糊图像
    % To illustrate the importance of knowing the size of the true PSF, this
    % example performs three restorations. Each time the PSF reconstruction
    % starts from a uniform array--an array of ones.
    %为了说明知道真实PSF的大小的重要性,这个例子执行三个修复。PSF函数重建每次都是从统一
    %的全一数组开始。
    %%
    % The first restoration, |J1| and |P1|, uses an undersized array, |UNDERPSF|, for
    % an initial guess of the PSF. The size of the UNDERPSF array is 4 pixels
    % shorter in each dimension than the true PSF. 
    %第一次复原,|J1|和|P1|,使用一个较小数组,| UNDERPSF |,来对PSF的初步猜测。该
    %UNDERPSF数组每维比真实PSF少4个元素。
    UNDERPSF = ones(size(PSF)-4);
    [J1 P1] = deconvblind(Blurred,UNDERPSF);
    figure;imshow(J1);title('Deblurring with Undersized PSF'); 
    
       
    
    %%
    % The second restoration, |J2| and |P2|, uses an array of ones, |OVERPSF|, for an
    % initial PSF that is 4 pixels longer in each dimension than the true PSF.
    %第二次复原,|J2|和|P2|,使用一个元素全为1的数组,| OVERPSF|,初始PSF每维比真
    %实PSF多4个元素。
    OVERPSF = padarray(UNDERPSF,[4 4],'replicate','both');
    [J2 P2] = deconvblind(Blurred,OVERPSF);
    figure;imshow(J2);title('Deblurring with Oversized PSF');  
       
    
     
    %%
    % The third restoration, |J3| and |P3|, uses an array of ones, |INITPSF|, for an
    % initial PSF that is exactly of the same size as the true PSF.
    %第三次复原,|J3|和|P3|,使用一个全为一的数组| INITPSF |作为初次PSF,每维与真正
    %的PSF相同。
    INITPSF = padarray(UNDERPSF,[2 2],'replicate','both');
    [J3 P3] = deconvblind(Blurred,INITPSF);
    figure;imshow(J3);title('Deblurring with INITPSF');  
    
       
    
     
    %% Step 4: Analyzing the Restored PSF
    %%第四步:分析复原函数PSF
    % All three restorations also produce a PSF. The following pictures show
    % how the analysis of the reconstructed PSF might help in guessing the
    % right size for the initial PSF. In the true PSF, a Gaussian filter, the
    % maximum values are at the center (white) and diminish at the borders (black).
    %所有这三个复原也产生PSF。以下图片显示对PSF重建分析的如何可能有助于猜测最初PSF的大
    %小。在真正的PSF中,高斯滤波器的最高值在中心(白),到边界消失(黑)。
    figure;
    subplot(221);imshow(PSF,[],'InitialMagnification','fit');
    title('True PSF');
    subplot(222);imshow(P1,[],'InitialMagnification','fit');
    title('Reconstructed Undersized PSF');
    subplot(223);imshow(P2,[],'InitialMagnification','fit');
    title('Reconstructed Oversized PSF');
    subplot(224);imshow(P3,[],'InitialMagnification','fit');
    title('Reconstructed true PSF');  
    
       
    
     
    %% 
    % The PSF reconstructed in the first restoration, |P1|, obviously does not
    % fit into the constrained size. It has a strong signal variation at the
    % borders. The corresponding image, |J1|, does not show any improved clarity
    % vs. the blurred image,.
     %第一次复原的PSF,|P1|,显然不适合大小的限制。它在边界有一个强烈的变化信号。
    %相应的图片|J1|,与模糊图像|Blurred|比没有表现出清晰度提高。
    %%
    % The PSF reconstructed in the second restoration, |P2|, becomes very smooth
    % at the edges. This implies that the restoration can handle a PSF of a
    % smaller size. The corresponding image, |J2|, shows some deblurring but it
    % is strongly corrupted by the ringing.
     %第二次复原的PSF,|P2|,边缘变得非常平滑。这意味着复原可以处理一个更细致的
    %PSF。相应的图片|J2|,显得清晰了,但被一些“振铃”强烈破坏。
    %%
    % Finally, the PSF reconstructed in the third restoration, |P3|, is somewhat
    % intermediate between |P1| and |P2|. The array, |P3|, resembles the true PSF
    % very well. The corresponding image, |J3|, shows significant improvement;
    % however it is still corrupted by the ringing.
     %最后,第三次复原的PSF,|P3|,介于|P1|和|P2|之间。该阵列|P3|,非常接近真
    %正的PSF。相应的图片,|J3|,显示了显着改善,但它仍然被一些“振铃”破坏。
    
    
    %% Step 5: Improving the Restoration
    %%第五步:改善图像复原
    % The ringing in the restored image, |J3|, occurs along the areas of sharp
    % intensity contrast in the image and along the image borders. This example
    % shows how to reduce the ringing effect by specifying a weighting
    % function. The algorithm weights each pixel according to the |WEIGHT| array
    % while restoring the image and the PSF. In our example, we start by
    % finding the "sharp" pixels using the edge function. By trial and error,
    % we determine that a desirable threshold level is 0.3.
    %在复原图像|J3|内部灰度对比鲜明的地方和图像边界都出现了“振铃”。这个例子说明了如何
    %通过定义一个加权函数来减少图像中的“振铃”。该算法是在对图像和PSF进行复原时,对每个
    %像元根据|WEIGHT|数组进行加权计算。在我们的例子,我们从用边缘函数查找“鲜明”像元
    %开始。通过反复试验,我们确定理想的阈值为0.3。
    
    %WEIGHT = edge(I,'sobel',.3);  
     WEIGHT = edge(Blurred,'sobel',.3); 
    %%
    % To widen the area, we use |imdilate| and pass in a structuring element, |se|.
    %为了拓宽领域,我们使用|imdilate|并传递一个结构元素|se|。
    se = strel('disk',2);
    WEIGHT = 1-double(imdilate(WEIGHT,se));  
     
    %%
    % The pixels close to the borders are also assigned the value 0.
    %在边界附近像素的值也被分配为0。
    WEIGHT([1:3 end-[0:2]],:) = 0;
    WEIGHT(:,[1:3 end-[0:2]]) = 0;
    figure;imshow(WEIGHT);title('Weight array');  
    
       
    
     %%
    % The image is restored by calling deconvblind with the |WEIGHT| array and an
    % increased number of iterations (30). Almost all the ringing is suppressed.
    %该图像通过|WEIGHT|数组和增加重复次数(30)调用deconvblind函数来复原。几乎所
    %有的“振铃”被抑制。
    [J P] = deconvblind(Blurred,INITPSF,30,[],WEIGHT);
    figure;imshow(J);title('Deblurred Image');  
       
    
     
    %% Step 6: Using Additional Constraints on the PSF Restoration
    %第六步:使用附加约束对PSF复原
    % The example shows how you can specify additional constraints on the PSF.
    %这个例子说明了如何在PSF上指定额外的限制。
    % The function, |FUN|, below returns a modified PSF array which deconvblind
    % uses for the next iteration. 
    %函数|FUN|返还一个修改了的PSF数组,用作deconvblind函数的下一次重复。
    % In this example, |FUN| modifies the PSF by cropping it by |P1| and |P2| number
    % of pixels in each dimension, and then padding the array back to its
    % original size with zeros. This operation does not change the values in
    % the center of the PSF, but effectively reduces the PSF size by |2*P1| and
    % |2*P2| pixels. 
    %在这个例子中,通过对PSF数组各维数剪切|P1|和|P2|个值实现对PSF的修改,对数组填充
    %回零。此操作不会改变在PSF中心的值,而且有效地在各维减少了|2*P1|和| 2*P2|元
    %素。
     
    P1 = 2;
    P2 = 2;
    FUN = @(PSF) padarray(PSF(P1+1:end-P1,P2+1:end-P2),[P1 P2]);  
     
    %%
    % The anonymous function, |FUN|, is passed into |deconvblind| last.
    %该匿名函数|FUN|,最后传递给| deconvblind |。
    %%
    % In this example, the size of the initial PSF, |OVERPSF|, is 4 pixels larger
    % than the true PSF. Setting P1=2 and P2=2 as parameters in |FUN|
    % effectively makes the valuable space in |OVERPSF| the same size as the true
    % PSF. Therefore, the outcome, |JF| and |PF|, is similar to the result of
    % deconvolution with the right sized PSF and no |FUN| call, |J| and |P|, from
    % step 4.
    %在这个例子中,初始PSF,|OVERPSF|,每维比真正的PSF多4个像素,。设置P1=2和P2=2作
    %为|FUN|的参数,可有效地使|OVERPSF|与真正的PSF的大小相同。因此,得到的结果|JF|
    %和|PF|,与第四步不使用|FUN|而仅用正确尺寸PSF盲反卷积得到的结果|J|和|P|类似。
    [JF PF] = deconvblind(Blurred,OVERPSF,30,[],WEIGHT,FUN);
    figure;imshow(JF);title('Deblurred Image');  
    
       
    
     
    %%
    % If we had used the oversized initial PSF, |OVERPSF|, without the
    % constraining function, |FUN|, the resulting image would be similar to the
    % unsatisfactory result, |J2|, achieved in Step 3.
    %
    % Note, that any unspecified parameters before |FUN| can be omitted, such as
    % |DAMPAR| and |READOUT| in this example, without requiring a place holder,
    % ([]).
     %如果我们使用了没有约束的函数|FUN|的较大的初始PSF,| OVERPSF |,所得图像将类
    %似第3步得到的效果并不理想的|J2|。 
    %注意,任何在|FUN|之前未指定参数都可以省略,如|DAMPAR|和|READOUT|在这个例子中,而不需要指示他们的位置,([])。
     
    displayEndOfDemoMessage(mfilename) 
    


    展开全文
  • 卷积原理

    2013-09-13 22:26:25
    首先是相关函数 学习:突然明白学习的...这个知识是怎么来的,为什么这么来,到哪?有什么关系。还有学完知识要变成自己的思想,融入到自己的思想中。学习知识只是学习别人的思路。需要批判的接受。 线性相关 ...

    首先是相关函数

    学习:突然明白学习的真谛:世界上没有什么知识是学不会的。学到的知识分为固定知识,还有更重要的是思维。这个知识是怎么来的,为什么这么来,到哪去?有什么关系。还有学完知识要变成自己的思想,融入到自己的思想中。学习知识只是学习别人的思路。需要批判的接受。

    首先要明白线性相关,然后把序列反转,平移进行卷积计算。

    线性相关


    http://zlgc.seu.edu.cn/jpkc2/ipkc/signal/new/course/one/flash/juanji_swf.htm

    http://125.71.228.222/wlxt/ncourse/BMSP/web/wsjx/book/ch4.pdf




    展开全文
  • 图像卷积原理及运算方法

    万次阅读 多人点赞 2018-06-07 15:39:46
    用一个模板和另一个图片对比,进行卷积运算。目的是使目标与目标之间的差距变得更大。卷积在数字图像处理中最常见的应用为锐化和边缘提取。 如边缘提取,假如目标像素点和它周边的值(上下左右前后的临点,具体的...

    原理

    卷积,有时也叫算子。用一个模板去和另一个图片对比,进行卷积运算。目的是使目标与目标之间的差距变得更大。卷积在数字图像处理中最常见的应用为锐化和边缘提取。
    边缘提取,假如目标像素点和它周边的值(上下左右前后的临点,具体的比邻范围依赖于算子的大小,3*3的算子比邻范围为1,5*5的为2,以此类推)得有较大差异,那么就可以通过这个算子对原图矩阵中的这个位置进行卷积运算,得出的值和该像素点原来的灰度值会产生显著的差异。当这种前后差异超过我们预设的范围后,就将这个像素点标记为0(白色),其余点标记为255(黑色),这样就得到了一黑色为背景,白色线条作为边缘或形状的边缘提取效果图。
    锐化算子:通过卷积运算,可以增大矩阵每一个元素与周边元素的方差,轻则起到锐化作用,重则成了边缘提取。反之,则是去噪过程。这种矩阵运算 可以在空间域上,图像经过量化其实就是以矩阵的形式存在的。

    运算方法

    假设卷积核h为
    这里写图片描述
    待处理矩阵x为
    这里写图片描述
    求x*h

    1. 将卷积核旋转180°,即
      这里写图片描述

    2. 将卷积核h的中心对准x的第一个元素,然后h和x重叠的元素相乘,h中不与x重叠的地方x用0代替,再将相乘后h对应的元素相加,得到结果矩阵中Y的第一个元素。如:
      这里写图片描述
      所以结果矩阵中的第一个元素Y11 = -1 * 0 + -2 * 0 + -1 * 0 + 0 * 0 + 0 * 1 + 0 * 2 + 1 * 0 + 2 * 5 + 1 * 6 = 16

    3. x中的每一个元素都用这样的方法来计算,得到的卷积结果矩阵为
      这里写图片描述

    展开全文
  • 深刻理解卷积神经网络(CNN)工作原理前言基础介绍以及数据准备使用Keras建立CNN使用Tensorflow建立CNN 前言 对于我们半路出家的神经网络学习者,有些会是走捷径先学习如何实现项目,然后再回来学习各种基础。 ...

    深刻去理解卷积神经网络(CNN)工作原理

    前言

    对于我们半路出家的神经网络学习者,有些会是走捷径先学习如何实现项目,然后再回来学习各种基础。
    本文只适合于小白学习,大牛请打转向灯绕行。

    基础介绍以及数据准备

    卷积神经网络是通过以卷积计算为主,把前一层网络的数据计算生成这一层网络的一种网络结构。它最先使用在图像识别的领域,后来大家觉得它牛B,什么领域都想试试水。

    它的历史就不在这里说了,因为我们不是历史研究者。卷积公式这里也不作展示了,因为目前主流的深度学习框架都不用你去编写这个公式,自行去了解一下就好了。
    这次实验主要使用到的数据集是mnist,这个是经典的手写数字图像数据集。

    # import common
    import keras
    from keras.datasets import mnist
    from keras.utils import to_categorical
    import numpy as np
    

    准备一下数据。因为卷积计算图片通常包括通道信息。

    # data prepare
    X_train = None
    y_train = None
    X_test = None
    y_test = None
    def prepare_data():
        global X_train, y_train, X_test, y_test
        (X_train, y_train), (X_test, y_test) = mnist.load_data()
        X_train = np.expand_dims(X_train, 3)
        X_test = np.expand_dims(X_test, 3)
        # y_ data transform if need
        # y_train = to_categorical(y_train)
        # y_test = to_categorical(y_test)
    RANDOM_STATE = 2
    

    知识扩展:图像的通常格式
    通常图片都是由RGB三个颜色通道组成。用numpy的说法来讲,一张图片的shape是(x, y, channel),前两者是这个图像的尺寸,也可以叫分辨率,单位是pixel。最后一者就是这个图像的通道,即它由多少颜色通道组成,通常为3,就是我们见到的R红G绿B蓝图层。
    在这里插入图片描述

    使用Keras建立CNN

    这一部分应该常常使用到,使用LeNet网络,这里就不详细介绍原理了。可以参考(Keras添加网络层的N种方法
    在Tensorflow部分再作详细介绍CNN。
    导入会使用到的库

    # import common
    import keras
    from keras.layers import Conv2D, MaxPool2D, Activation, Flatten, Dense, Dropout
    from keras.losses import categorical_crossentropy
    from keras.models import Sequential
    from keras.optimizers import Adam
    from keras.utils import to_categorical
    from sklearn.model_selection import train_test_split
    

    预处理数据

    # import common
    import keras
    from keras.layers import Conv2D, MaxPool2D, Activation, Flatten, Dense, Dropout
    from keras.losses import categorical_crossentropy
    from keras.models import Sequential
    from keras.optimizers import Adam
    from keras.utils import to_categorical
    from sklearn.model_selection import train_test_split
    

    建立神经网络并训练。

    def net(input_shape, output_class, activation='tanh', is_compile=True):
        model = Sequential()
        model.add(Conv2D(20, (3, 3), input_shape=input_shape))
        model.add(MaxPool2D((2, 2)))
        model.add(Activation(activation))
        model.add(Conv2D(30, (3, 3)))
        model.add(MaxPool2D((2, 2)))
        model.add(Activation(activation))
        model.add(Dropout(0.5))
        model.add(Flatten())
        model.add(Dense(1024))
        model.add(Dropout(0.5))
        model.add(Dense(output_class))
        model.add(Activation('softmax'))
        model.compile(Adam(), categorical_crossentropy, ['accuracy'])
        return model
    
    def main():
        model = net(X_training.shape[1:], y_training.shape[1])
        model.fit(X_training, y_training, batch_size=1000, epochs=4, validation_data=(X_valing, y_valing))
    
    main()
    

    这里为什么使用Adam,请参考实验(关于Keras里常用各种优化器的实验
    结果:

    Train on 48000 samples, validate on 12000 samples
    Epoch 1/4
    48000/48000 [==============================] - 31s 638us/step - loss: 0.6272 - accuracy: 0.8065 - val_loss: 0.1858 - val_accuracy: 0.9439
    Epoch 2/4
    48000/48000 [==============================] - 34s 701us/step - loss: 0.2146 - accuracy: 0.9320 - val_loss: 0.1221 - val_accuracy: 0.9625
    Epoch 3/4
    48000/48000 [==============================] - 35s 724us/step - loss: 0.1638 - accuracy: 0.9484 - val_loss: 0.0994 - val_accuracy: 0.9700
    Epoch 4/4
    48000/48000 [==============================] - 32s 664us/step - loss: 0.1417 - accuracy: 0.9556 - val_loss: 0.0903 - val_accuracy: 0.9725
    
    

    使用Tensorflow建立CNN

    使用Keras可以很轻松简单搭建神经网络,但我们不知道里面到底做了什么事情,俗话说“纸上得来终觉浅,绝知此事要躬行”,所以我们就自己搭一个神经网络吧。
    以下的结构图片是引用自LeNet官方的图片。
    在这里插入图片描述
    LeNet网络结构可以总结为下面的话:

    1. 输入一张原始的图片,对原始图片进行滑动的卷积运算。
    2. 得出一张深度更深(原来是3层,后来可能变成20层)的图片层。
    3. 对图片按区域进行池化,就是相当于取平均,缩小图像。
    4. 得出一张尺寸小的点的图片,再进行滑动的卷积运算。
    5. 得出一张深度更深的图片层。
    6. 对图片按区域进行池化。
    7. 得出一张尺寸小的点的图片。
    8. 将所得到的图片全部拉成一条长排形状的神经元形式。
    9. 进行全连接前向传播
      10.最后以有多少类别的输出。
      以mnist为例,即28281的形式。
      在这里插入图片描述
      神经网络就是训练神经层之间转换的参数。所以在卷积神经网络里,卷积核是里面的值就是在tensorflow要训练的参数。
      在这里插入图片描述
      如下图,卷积核会滑动地计算每一个区域的卷积值。
      在这里插入图片描述

    代码如下:
    导入要使用到的库。

    # import common
    import tensorflow as tf
    from tensorflow.nn import conv2d, max_pool
    from tensorflow.nn import sparse_softmax_cross_entropy_with_logits
    from tensorflow.train import AdamOptimizer
    from keras.utils import to_categorical
    from sklearn.model_selection import train_test_split
    from input_data import DataSet
    from sklearn.metrics import accuracy_score
    

    处理数据

    # data process
    prepare_data()
    print(X_test.shape)
    y_train = to_categorical(y_train)
    y_test = to_categorical(y_test)
    
    X_training, X_valing, y_training, y_valing = train_test_split(X_train, y_train, test_size=0.2, random_state=RANDOM_STATE)
    
    train_data = DataSet(X_training, y_training)
    validation_data = DataSet(X_valing, y_valing)
    test_data = DataSet(X_test, y_test)
    INPUT_NODE = X_train.shape[:]
    IMAGE_SIZE = INPUT_NODE[1]
    IMAGE_CHANNEL = INPUT_NODE[3]
    print(INPUT_NODE, IMAGE_SIZE, IMAGE_CHANNEL)
    
    CONV1_SIZE = 3
    CONV1_DEEP = 20
    CONV2_SIZE = 3
    CONV2_DEEP = 30
    MAXPOOL1_SIZE = 2
    MAXPOOL2_SIZE = 2
    FC_SIZE = 1024
    
    OUTPUT_NODE = y_train.shape[1]
    

    神经网络构建并训练

    tf.reset_default_graph()
    def inference(input_tensor, is_train=False):
        conv1_weights = tf.get_variable(
            'conv1_weights', 
            shape=[CONV1_SIZE, CONV1_SIZE, IMAGE_CHANNEL, CONV1_DEEP],
            initializer=tf.truncated_normal_initializer(stddev=0.1)
        )
        conv1_biases = tf.get_variable(
            'conv1_biases',
            shape=[CONV1_DEEP],
            initializer=tf.constant_initializer(0.0)
        )
        layer_conv1 = conv2d(
            input_tensor, 
            conv1_weights, 
            strides=[1, 1, 1, 1], 
            padding='SAME'
        )
        layer_relu1 = tf.nn.relu(tf.nn.bias_add(layer_conv1, conv1_biases))
        layer_pool1 = max_pool(
            layer_relu1, 
            [1, MAXPOOL1_SIZE, MAXPOOL1_SIZE, 1],
            [1, 2, 2, 1],
            'SAME'
        )
        
        conv2_weights = tf.get_variable(
            'conv2_weights',
            shape=[CONV2_SIZE, CONV2_SIZE, CONV1_DEEP, CONV2_DEEP],
            initializer=tf.truncated_normal_initializer(stddev=0.1)
        )
        conv2_biases = tf.get_variable(
            'conv2_biases',
            shape=[CONV2_DEEP],
            initializer=tf.constant_initializer(0.1)
        )
        layer_conv2 = conv2d(
            layer_pool1, 
            conv2_weights, 
            strides=[1, 1, 1, 1], 
            padding='SAME'
        )
        layer_relu2 = tf.nn.relu(tf.nn.bias_add(layer_conv2, conv2_biases))
        layer_pool2 = max_pool(
            layer_relu2, 
            [1, MAXPOOL2_SIZE, MAXPOOL2_SIZE, 1],
            [1, 2, 2, 1],
            'SAME'
        )
        
        pool_shape = layer_pool2.get_shape().as_list()  # num * size * size * depth
        nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]
        layer_reshaped = tf.reshape(layer_pool2, [pool_shape[0], nodes])
        fc1_weights = tf.get_variable(
            'fc1_weights', 
            shape=[nodes, FC_SIZE], 
            initializer=tf.truncated_normal_initializer(stddev=0.1)
        )
        fc1_biases = tf.get_variable(
            'fc1_biases', 
            shape=[FC_SIZE],
            initializer=tf.constant_initializer(0.0)
        )
        layer_fc1 = tf.nn.relu(tf.matmul(layer_reshaped, fc1_weights) + fc1_biases)
        if is_train:
            layer_fc1 = tf.nn.dropout(layer_fc1, 0.5)
        fc2_weights = tf.get_variable(
            'fc2_weights', 
            shape=[FC_SIZE, OUTPUT_NODE],
            initializer=tf.truncated_normal_initializer(stddev=0.1)
        )
        fc2_biases = tf.get_variable(
            'fc2_biases', 
            shape=[OUTPUT_NODE],
            initializer=tf.constant_initializer(0.1)
        )
        layer_output = tf.matmul(layer_fc1, fc2_weights) + fc2_biases
        return layer_output
    
    TRAIN_TIMES = 500
    BATCH_SIZE = 1000
    def train():
        X_input = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, IMAGE_CHANNEL], name='X_input')
        y_output = tf.placeholder(tf.float32, shape=[None, OUTPUT_NODE], name='y_output')
        y_inference = inference(X_input, True)
        
        loss = tf.reduce_mean(sparse_softmax_cross_entropy_with_logits(labels=tf.argmax(y_output, 1), logits=y_inference))
        train_op = AdamOptimizer(0.001).minimize(loss)
        
        with tf.Session() as sess:
            tf.global_variables_initializer().run()
            for i in range(TRAIN_TIMES):
                x, y = train_data.next_batch(BATCH_SIZE)
                x = x.reshape(-1, IMAGE_SIZE, IMAGE_SIZE, IMAGE_CHANNEL)
                _, loss_end = sess.run([train_op, loss], feed_dict={X_input: x, y_output: y})
                if i % 100 == 0:
                    print('After {} training, loss is {}'.format(i, loss_end))
                    x_v, y_v = validation_data.next_batch(BATCH_SIZE)
                    x_v = x_v.reshape(-1, IMAGE_SIZE, IMAGE_SIZE, IMAGE_CHANNEL)
                    loss_val = sess.run(loss, feed_dict={X_input: x_v, y_output: y_v})
                    y_val_pred = sess.run(y_inference, feed_dict={X_input: x_v})
                    y_val_pred = np.argmax(y_val_pred, 1)
                    y_v = np.argmax(y_v, 1)
                    acc = accuracy_score(y_v, y_val_pred)
                    print('After {} training, validation loss is {}, accuracy is {}'.format(i, loss_val, acc))
            acc_mean = 0
            for i in range(test_data.num_examples // BATCH_SIZE):
                x_t, y_t = test_data.next_batch(BATCH_SIZE)
                x_t = x_t.reshape(-1, IMAGE_SIZE, IMAGE_SIZE, IMAGE_CHANNEL)
                y_test_pred = sess.run(y_inference, feed_dict={X_input: x_t})
                y_test_pred = np.argmax(y_test_pred, 1)
                y_t = np.argmax(y_t, 1)
                acc = accuracy_score(y_t, y_test_pred)
                acc_mean = acc_mean + (acc - acc_mean) / (i+1)
            print('End Accuracy {}'.format(acc_mean))
                
    train()
    

    结果如下。

    After 0 training, loss is 3.286005973815918
    After 0 training, validation loss is 3.2123682498931885, accuracy is 0.149
    After 100 training, loss is 0.1718430370092392
    After 100 training, validation loss is 0.17546264827251434, accuracy is 0.939
    After 200 training, loss is 0.11053168773651123
    After 200 training, validation loss is 0.07477676123380661, accuracy is 0.977
    After 300 training, loss is 0.0553237646818161
    After 300 training, validation loss is 0.07718825340270996, accuracy is 0.974
    After 400 training, loss is 0.062298230826854706
    After 400 training, validation loss is 0.0564616397023201, accuracy is 0.981
    End Accuracy 0.9853999999999999
    

    从上面得知,在卷积神经里的卷积层卷积核的值经过一定的优化寻找,可以使得该问题的loss最小。

    展开全文
  • 最近看到一个巨牛的人工智能教程,分享一下给大家。教程不仅是零基础,通俗易懂,而且非常风趣幽默,像看小说一样!...本文以通俗易懂的方式讲述卷积,并辅以图片解释,能快速理解卷积的实现原理。最后手写pyth...
  • 文章结构1.如何理解神经网络2....从前面对全连接网络的描述中,可以发现全连接网络试图描述整个有向图中所有元素之间的关系,因为每一个变量都会有自己的参数,这可能会导致参数量剧。在机器学习
  • 通过同轴数字全息显微系统采集一系列微球的全息图像,利用瑞利-索末菲传播原理对全息图进行三维重构,同时对重构光场进行去卷积运算,消除了散斑、离焦信号等噪音,并对微球球心纵向光场分布进行多项式拟合,提高了...
  • deconvolutiondeconv(反卷积、转置卷积) 起初是看FCN图像分割论文的时候,看到论文中用...所以就搜了相关资料,同时了解了空洞卷积-dilated conv的原理,在此博客记录一下。 deconv(反卷积、转置卷积) ...
  • 大家回顾一下,一个分类任务,我们在用机器学习算法来做时,首先要明确feature和label,然后把这个数据"灌"到算法里训练,最后保存模型,再来预测分类的准确性。但是这就有个问题,即我们需要实现确定好特征,每一...
  • Day03-卷积神经网络原理与使用 文章目录Day03-卷积神经网络原理与使用作业说明示例代码完成作业 作业说明 今天的实战项目是基于卷积神经网络 LeNet的“车牌识别”。 作业要求: 1、根据课上所学内容,构建 LeNet...
  • 卷积层是用一个固定大小的矩形区席卷原始数据,将原始数据分成一个个和卷积核大小相同的小块,然后将这些小块和卷积核相乘输出一个卷积值(注意这里是一个单独的值,不再是矩阵了)。 2.作用 特征提取 卷积的本质...
  • 卷积神经网络CNN原理详解(一)——基本原理 为什么要用神经网络? 特征提取的高效性。 大家可能会疑惑,对于同一个分类任务,我们可以用机器学习的算法来做,为什么要用神经网络呢?大家回顾一下,一个分类任务,我们...
  • 1、卷积神经网络 CNN是一种特殊的神经网络,一个标准的CNN由一系列的层组成,包括卷积层,池化层,全连接层等。(通常用来做影像处理) 工作原理: 1、一张图片(如下图,图片上写着字母),可通过CNN识别出...
  • 为了提高半导体光放大器(SOA)增益系数谱测量的准确性,减少光谱仪分辨率和系统噪声对测量结果的影响,提出了由传统的Hakki-Paoli(HP)方法改进得到的基于小波去噪和去卷积过程的Hakki-Paoli(HP-DD)方法,分析了其原理,并...
  • PCA 奇异值分解(SVD)原理与在降维中的应用 PCA 降维算法详解 以及代码示例 RPCA 核范数 RPCA ADMM DRPCA Wiener滤波器 BCCB卷积 LASSO
  • 简介:卷积操作是在图像中通过滑动窗口,逐像素进行矩阵计算,会消耗大量的计算资源寻址和修改内存数据,因此最终的卷积操作并不是可我们认为的滑动窗口执行卷积操作,而是采用转为矩阵的方式进行快速计算,矩阵...
  • 【深度学习】5:CNN卷积神经网络原理

    万次阅读 多人点赞 2018-01-29 10:58:16
    前言:先坦白的说,深度神经网络的学习...这篇CNN卷积神经网络的原理介绍,也是自己通过收集来的资料阅读、理解、操练后,有了一定的见解后才拙笔,里面的内容我会尽量详尽,不清楚明白的地方,望大家慧眼指出。 –—

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 328
精华内容 131
关键字:

去卷积原理