【图像识别】基于卷积神经⽹络（CNN）实现垃圾分类Matlab

【图像识别】基于卷积神经⽹络（CNN）实现垃圾分类Matlab

源码

⼀、垃圾分类

如何通过垃圾分类管理，最⼤限度地实现垃圾资源利⽤，减少垃圾处置量，改善⽣存环境质量，是当前世界各国共同关注的迫切问题之⼀。根据国家制定的统⼀标准，现在⽣活垃圾被⼴泛分为四类，分别是可回收物、餐厨垃圾、有害垃圾和其他垃圾。可回收物表⽰适宜回收和资源利⽤的垃圾，主要包括废纸、塑料、玻璃、⾦属和布料五⼤类，⽤蓝⾊垃圾容器收集，通过综合处理回收利⽤。餐厨垃圾包括剩菜剩饭、⾻头、菜根菜叶、果⽪等⾷品类废物，⽤绿⾊垃圾容器收集等等。但是随着深度学习技术的发展，为了简单⾼效地对⽣活垃圾进⾏识别分类,本篇⽂章将实现⼀种基于卷积神经⽹络的垃圾分类识别⽅法。该⽅法只需要对图像进⾏简单的预处理,CNN模型便能够⾃动提取图像特征且池化过程能够减少参数数量,降低计算的复杂度,实验结果表明卷积神经⽹络,能克服传统图像分类算法的诸多缺点，当然更为复杂的模型等待⼤家去实验研究。但是⽬前认为采⽤VGG或者global 池化⽅式可能效果更好⼀点。

⼆、卷积神经⽹络CNN

卷积神经⽹络（Convolutional Neural Networks / CNNs / ConvNets）与普通神经⽹络⾮常相似，它们都由具有可学习的权重和偏置常量(biases)的神经元组成。每个神经元都接收⼀些输⼊，并做⼀些点积计算，输出是每个分类的分数，普通神经⽹络⾥的⼀些计算技巧到这⾥依旧适⽤。

所以哪⾥不同呢？卷积神经⽹络默认输⼊是图像，可以让我们把特定的性质编码⼊⽹络结构，使是我们的前馈函数更加有效率，并减少了⼤量参数。

具有三维体积的神经元(3D volumes of neurons)

卷积神经⽹络利⽤输⼊是图⽚的特点，把神经元设计成三个维度 ： width, height, depth(注意这个depth不是神经⽹络的深度，⽽是⽤来描述神经元的) 。⽐如输⼊的图⽚⼤⼩是 32 × 32 × 3 (rgb)，那么输⼊神经元就也具有 32×32×3 的维度。下⾯是图解：

传统神经⽹络

卷积神经⽹络

⼀个卷积神经⽹络由很多层组成，它们的输⼊是三维的，输出也是三维的，有的层有参数，有的层不需要参数。

Layers used to build ConvNets

卷积神经⽹络通常包含以下⼏种层：

卷积层（Convolutional layer），卷积神经⽹路中每层卷积层由若⼲卷积单元组成，每个卷积单元的参数都是通过反向传播算法优化得到的。卷积运算的⽬的是提取输⼊的不同特征，第⼀层卷积层可能只能提取⼀些低级的特征如边缘、线条和⾓等层级，更多层的⽹络能从低级特征中迭代提取更复杂的特征。

线性整流层（Rectified Linear Units layer, ReLU layer），这⼀层神经的活性化函数（Activation function）使⽤线性整流（Rectified Linear Units, ReLU）。

池化层（Pooling layer），通常在卷积层之后会得到维度很⼤的特征，将特征切成⼏个区域，取其最⼤值或平均值，得到新的、维度较⼩的特征。

全连接层（ Fully-Connected layer）, 把所有局部特征结合变成全局特征，⽤来计算最后每⼀类的得分。

⼀个卷积神经⽹络各层应⽤：

卷积层（Convolutional layer）

局部感知（Local Connectivity）

普通神经⽹络把输⼊层和隐含层进⾏“全连接(Full Connected)“的设计。从计算的⾓度来讲，相对较⼩的图像从整幅图像中计算特征是可⾏的。但是，如果是更⼤的图像（如 96x96 的图像），要通过这种全联通⽹络的这种⽅法来学习整幅图像上的特征，从计算⾓度⽽⾔，将变得⾮常耗时。你需要设计 10 的 4 次⽅（=10000）个输⼊单元，假设你要学习 100 个特征，那么就有 10 的 6 次⽅个参数需要去学习。与 28x28 的⼩块图像相⽐较， 96x96 的图像使⽤前向输送或者后向传导的计算⽅式，计算过程也会慢 10 的 2 次⽅（=100）倍。

卷积层解决这类问题的⼀种简单⽅法是对隐含单元和输⼊单元间的连接加以限制：每个隐含单元仅仅只能连接输⼊单元的⼀部分。例如，每个隐含单元仅仅连接输⼊图像的⼀⼩⽚相邻区域。（对于不同于图像输⼊的输⼊形式，也会有⼀些特别的连接到单隐含层的输⼊信号“连接区域”选择⽅式。如⾳频作为⼀种信号输⼊⽅式，⼀个隐含单元所需要连接的输⼊单元的⼦集，可能仅仅是⼀段⾳频输⼊所对应的某个时间段上的信号。)

每个隐含单元连接的输⼊区域⼤⼩叫r神经元的感受野(receptive field)。

由于卷积层的神经元也是三维的，所以也具有深度。卷积层的参数包含⼀系列过滤器（filter），每个过滤器训练⼀个深度，有⼏个过滤器输出单元就具有多少深度。

具体如下图所⽰，样例输⼊单元⼤⼩是32×32×3, 输出单元的深度是5, 对于输出单元不同深度的同⼀位置，与输⼊图⽚连接的区域是相同的，但是参数（过滤器）不同。

虽然每个输出单元只是连接输⼊的⼀部分，但是值的计算⽅法是没有变的，都是权重和输⼊的点积，然后加上偏置，这点与普通神经⽹络是⼀样的，如下图所⽰：

空间排列（Spatial arrangement）

⼀个输出单元的⼤⼩有以下三个量控制：depth, stride 和 zero-padding。

深度(depth) : 顾名思义，它控制输出单元的深度，也就是filter的个数，连接同⼀块区域的神经元个数。⼜名：depth column 步幅(stride)：它控制在同⼀深度的相邻两个隐含单元，与他们相连接的输⼊区域的距离。如果步幅很⼩（⽐如 stride = 1）的话，相邻隐含单元的输⼊区域的重叠部分会很多; 步幅很⼤则重叠区域变少。

补零(zero-padding) ： 我们可以通过在输⼊单元周围补零来改变输⼊单元整体⼤⼩，从⽽控制输出单元的空间⼤⼩。

我们先定义⼏个符号：

: 输⼊单元的⼤⼩（宽或⾼）

: 感受野(receptive field)

: 步幅（stride）

: 补零（zero-padding)的数量

: 深度，输出单元的深度

则可以⽤以下公式计算⼀个维度（宽或⾼）内⼀个输出单元⾥可以有⼏个隐藏单元：

如果计算结果不是⼀个整数，则说明现有参数不能正好适合输⼊，步幅（stride）设置的不合适，或者需要补零，证明略，下⾯⽤⼀个例⼦来说明⼀下。

这是⼀个⼀维的例⼦，左边模型输⼊单元有5个，即, 边界各补了⼀个零，即，步幅是1， 即，感受野是3，因为每个输出隐藏单元连接3个输⼊单元，即，根据上⾯公式可以计算出输出隐藏单元的个数是：，与图⽰吻合。右边那个模型是把步幅变为2，其余不变，可以算出输出⼤⼩为：，也与图⽰吻合。若把步幅改为3，则公式不能整除，说明步幅为3不能恰好吻合输⼊单元⼤⼩。

另外，⽹络的权重在图的右上⾓，计算⽅法和普通神经⽹路⼀样。

参数共享(Parameter Sharing)

应⽤参数共享可以⼤量减少参数数量，参数共享基于⼀个假设：如果图像中的⼀点（x1, y1）包含的特征很重要，那么它应该和图像中的另⼀点（x2, y2）⼀样重要。换种说法，我们把同⼀深度的平⾯叫做深度切⽚(depth slice)（(e.g. a volume of size [55x55x96] has 96 depth slices, each of size [55x55])），那么同⼀个切⽚应该共享同⼀组权重和偏置。我们仍然可以使⽤梯度下降的⽅法来学习这些权值，只需要对原始算法做⼀些⼩的改动， 这⾥共享权值的梯度是所有共享参数的梯度的总和。

我们不禁会问为什么要权重共享呢？⼀⽅⾯，重复单元能够对特征进⾏识别，⽽不考虑它在可视域中的位置。另⼀⽅⾯，权值共享使得我们能更有效的进⾏特征抽取，因为它极⼤的减少了需要学习的⾃由变量的个数。通过控制模型的规模，卷积⽹络对视觉问题可以具有很好的泛化能⼒。

卷积（Convolution）

如果应⽤参数共享的话，实际上每⼀层计算的操作就是输⼊层和权重的卷积！这也就是卷积神经⽹络名字的由来。

先抛开卷积这个概念不管。为简便起见，考虑⼀个⼤⼩为5×5的图像，和⼀个3×3的卷积核。这⾥的卷积核共有9个参数，就记为 吧。这种情况下，卷积核实际上有9个神经元，他们的输出⼜组成⼀个3×3的矩阵，称为特征图。第⼀个神经元连接到图像的第⼀个3×3的局部，第⼆个神经元则连接到第⼆个局部（注意，有重叠！就跟你的⽬光扫视时也是连续扫视⼀样）。具体如下图所⽰。

图的上⽅是第⼀个神经元的输出，下⽅是第⼆个神经元的输出。每个神经元的运算依旧是

需要注意的是，平时我们在运算时，习惯使⽤ 这种写法，但事实上，我们这⾥使⽤的是 。

现在我们回忆⼀下离散卷积运算。假设有⼆维离散函数 , ， 那么它们的卷积定义为

现在发现了吧！上⾯例⼦中的9个神经元均完成输出后，实际上等价于图像和卷积核的卷积操作！

Numpy examples

下⾯⽤numpy的代码具体的说明⼀下上⾯的概念和公式等。

假设输⼊存储在⼀个numpy array X⾥，那么：

* 位于 (x, y) 的 depth column 是 X[x, y, :]

* 深度为 d 的 depth slice 是 X[:, :, d]

假设X的⼤⼩是X.shape: (11,11,4)，并且不⽤补零（P ＝ 0），过滤器（感受野）⼤⼩F ＝ 5，步幅为2（S＝ 2）。那么输出单元的空间⼤⼩应该为 (11 - 5) / 2 + 1 = 4，即宽和⾼都为4 。假设输出存储在 V 中，那么它的计算⽅式应该为：

V[0,0,0] = np.sum(X[:5,:5,:] * W0) + b0

V[1,0,0] = np.sum(X[2:7,:5,:] * W0) + b0

V[2,0,0] = np.sum(X[4:9,:5,:] * W0) + b0

V[3,0,0] = np.sum(X[6:11,:5,:] * W0) + b0

V[0,0,1] = np.sum(X[:5,:5,:] * W1) + b1

V[1,0,1] = np.sum(X[2:7,:5,:] * W1) + b1

V[2,0,1] = np.sum(X[4:9,:5,:] * W1) + b1

V[3,0,1] = np.sum(X[6:11,:5,:] * W1) + b1

V[0,1,1] = np.sum(X[:5,2:7,:] * W1) + b1

V[2,3,1] = np.sum(X[4:9,6:11,:] * W1) + b1

注意在numpy中 * 表⽰两个数组对应元素相乘。

卷积层总结(Summary)

接收三维输⼊

需要给出4个参数（hyperparameters）：

Number of filters ,

their spatial extent ,

the stride ,

the amount of zero padding .

输出⼀个三维单元 ，其中：

应⽤权值共享，每个filter会产⽣ 个权重，总共 个权重和 个偏置。

在输出单元，第d个深度切⽚的结果是由第d个filter 和输⼊单元做卷积运算，然后再加上偏置⽽来。

池化层(Pooling Layer)

池化（pool）即下采样（downsamples），⽬的是为了减少特征图。池化操作对每个深度切⽚独⽴，规模⼀般为 2＊2，相对于卷积层进⾏卷积运算，池化层进⾏的运算⼀般有以下⼏种：

* 最⼤池化（Max Pooling）。取4个点的最⼤值。这是最常⽤的池化⽅法。

* 均值池化（Mean Pooling）。取4个点的均值。

* ⾼斯池化。借鉴⾼斯模糊的⽅法。不常⽤。

* 可训练池化。训练函数 ff ，接受4个点为输⼊，出⼊1个点。不常⽤。

最常见的池化层是规模为2*2， 步幅为2，对输⼊的每个深度切⽚进⾏下采样。每个MAX操作对四个数进⾏，如下图所⽰：

池化操作将保存深度⼤⼩不变。

如果池化层的输⼊单元⼤⼩不是⼆的整数倍，⼀般采取边缘补零（zero-padding）的⽅式补成2的倍数，然后再池化。

池化层总结(Summary)

接收单元⼤⼩为：

需要两个参数（hyperparameters）：

their spatial extent ,

the stride ,

输出⼤⼩：，其中：

不需要引⼊新权重

全连接层（Fully-connected layer）

全连接层和卷积层可以相互转换：

* 对于任意⼀个卷积层，要把它变成全连接层只需要把权重变成⼀个巨⼤的矩阵，其中⼤部分都是0 除了⼀些特定区块（因为局部感知），⽽且好多区块的权值还相同（由于权重共享）。

* 相反地，对于任何⼀个全连接层也可以变为卷积层。⽐如，⼀个 的全连接层，输⼊层⼤⼩为 ，它可以等效为⼀个 的卷积层。换⾔之，我们把 filter size 正好设置为整个输⼊层⼤⼩。

卷积神经⽹络架构

Layer Patterns

常见的卷积神经⽹络架构是这样的：

INPUT -> [[CONV -> RELU]*N -> POOL?]*M -> [FC -> RELU]*K -> FC

1

堆叠⼏个卷积和整流层，再加⼀个池化层，重复这个模式知道图⽚已经被合并得⽐较⼩了，然后再⽤全连接层控制输出。

上述表达式中 ? 意味着0次或1次，通常情况下：N >= 0 && N <= 3, M >= 0, K >= 0 && K < 3。

⽐如你可以组合出以下⼏种模式：

* INPUT -> FC, 实现了⼀个线性分类器， 这⾥ N = M = K = 0

* INPUT -> CONV -> RELU -> FC

* INPUT -> [CONV -> RELU -> POOL]*2 -> FC -> RELU -> FC. Here we see that there is a single CONV layer between

every POOL layer.

* INPUT -> [CONV -> RELU -> CONV -> RELU -> POOL]*3 -> [FC -> RELU]*2 -> FC Here we see two CONV layers stacked before every POOL layer. This is generally a good idea for larger and deeper networks, because multiple stacked CONV layers can develop more complex features of the input volume before the destructive pooling operation.

Layer Sizing Patterns

Input layer : 应该是2的整数次幂。⽐如32，64， 128等。

Conv Layer : 使⽤⼩的过滤器（filter），, 步幅 ，如果不能恰好拟合输⼊层，还要边缘补零。如果使⽤ ，那么输出⼤⼩将与输⼊⼀样。如果⽤更⼤的过滤器（⽐如7*7），⼀般只会在紧挨着原始输⼊图⽚的卷积层才会看到。

Pool Layer :

三、部分代码

function varargout = cnnMain(varargin)

gui_Singleton = 1;

gui_State = struct('gui_Name',       mfilename, ...

'gui_Singleton',  gui_Singleton, ...

'gui_OpeningFcn', @cnnMain_OpeningFcn, ...

'gui_OutputFcn',  @cnnMain_OutputFcn, ...

'gui_LayoutFcn',  [] , ...

'gui_Callback',   []);

if nargin && ischar(varargin{1})

gui_State.gui_Callback = str2func(varargin{1});

end

if nargout

[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});

else

gui_mainfcn(gui_State, varargin{:});

end

function cnnMain_OpeningFcn(hObject, eventdata, handles, varargin)

handles.output = hObject;

guidata(hObject, handles);

movegui(hObject,'center');

function varargout = cnnMain_OutputFcn(hObject, eventdata, handles)

varargout{1} = handles.output;

function LPBut_Callback(hObject, eventdata, handles)

[img_lp,PL]=LPLocation(handles.img_rgb);

axes(handles.axes1); hold on;

row = PL.row;

col = PL.col

plot([col(1) col(2)], [row(1) row(1)], 'g-', 'LineWidth', 3);

plot([col(1) col(2)], [row(2) row(2)], 'g-', 'LineWidth', 3);

plot([col(1) col(1)], [row(1) row(2)], 'g-', 'LineWidth', 3);

plot([col(2) col(2)], [row(1) row(2)], 'g-', 'LineWidth', 3);

hold off;

axes(handles.axes2);

imshow(img_lp);

title('定位图', 'FontWeight', 'Bold');

handles.img_lp=img_lp;

guidata(hObject, handles);

% --------------------------------------------------------------------

function openFile_Callback(hObject, eventdata, handles)

[uuu,vvv]=uigetfile({'*.jpg;*.tif;*.png;*.gif;*.BMP;*.JPEG','All Image Files'} ,'MultiSelect', 'on');%获取⼀张车牌照⽚path=strcat(vvv,uuu);%拼接图⽚路径

img_rgb=imread(path);

img_rgb=imresize(img_rgb,[240,320]);

axes(handles.axes1);

im = imread(path);

imshow(img_rgb);

title('原图像', 'FontWeight', 'Bold');

handles.img_rgb=img_rgb;

guidata(hObject, handles);

function FGBut_Callback(hObject, eventdata, handles)

functionPath=pwd;      %储存现有路径

dataPath=strcat(functionPath,'\CNN\data');   %储存data路径

cnnToolPath=strcat(functionPath,'\CNN\DeepLearnToolbox_CNN_lzbV3.0');

addpath(functionPath)

addpath(dataPath)

addpath(cnnToolPath)

[LP_word]=LPWordDivide(handles.img_lp);

figure

for i=1:7

subplot(1,7,i)

imshow(LP_word(:,:,i));

end

guidata(hObject, handles);

% --- Executes on button press in CNNbut.

function CNNbut_Callback(hObject, eventdata, handles)

functionPath=pwd;      %储存现有路径

dataPath=strcat(functionPath,'\CNN\data');   %储存data路径

cnnToolPath=strcat(functionPath,'\CNN\DeepLearnToolbox_CNN_lzbV3.0');

addpath(functionPath)

addpath(dataPath)

addpath(cnnToolPath)

if(~exist('trainData.mat','file')||~exist('testData.mat','file')) %检查是否有trainData、testData

%数据⾃动保存在/data⽂件夹

[train_x,train_y,test_x,test_y]=dataSet();   %⽣成数据

else

load trainData

load testData

end

if(~exist('Net.mat','file'))    %检查是否有NET

%如果想要重新⽣成NET，框⿊下⼀句按F9(运⾏约20分钟)

%⽹络⾃动保存在/data⽂件夹

cd(functionPath)

[net,err,bad]=LPNetTrain(train_x,train_y,test_x,test_y);   %训练⽹络

else

load Net5_3_1.mat

cd(functionPath)

end

lp=cnnff(net,handles.LP_word);    %获得车牌字符的神经⽹络结果

lplabel=lp.Y;             %获得字符的标签

[word,position]=label2word(lplabel);     %转换为str,word为字符结果，position为对照标签位置set(handles.AA,'String', word);

% --- Executes on button press in pushbutton4.

function pushbutton4_Callback(hObject, eventdata, handles)

img_gray = rgb2gray(handles.img_lp);

axes(handles.axes4);

imshow(img_gray);

title('灰度图像', 'FontWeight', 'Bold');

function pushbutton5_Callback(hObject, eventdata, handles)

se=[1 1];

img_bimr = imerode(handles.img_rgb, se);

se = strel('rectangle',[1,5]);

axes(handles.axes5);

imshow(img_bimr2);

title('腐蚀与膨胀', 'FontWeight', 'Bold');

四、运⾏结果

五、参考⽂献

[1][J]. 汪洋,王⼩妮,王育新,刘畅,熊继伟,韩定良.  .

[2][J]. 吴碧程,邓祥恩,张⼦憧,唐⼩煜.  .

[3][J]. 吴健,陈豪,⽅武.  .