Matlab神经网络验证码识别

本文，将会简述如何利用Matlab的强大功能，调用神经网络处理验证码的识别问题。

预备知识，Matlab基础编程，神经网络基础。

可以先看下：

验证码识别原理

Matlab对图像读入处理，去掉噪声点和较浅的点，进行二值化，将图像转变为0/1矩阵，这样就完成了预处理。

然后要对图像进行切割，取到每个数字的小图片位置，将其缩放至等大小，方便神经网络进一步处理。

最后将图片转成神经网络能够识别的格式，例如BP网络，则将其转为行向量，深卷积网络，则将其转为矩阵即可。

识别预处理

Matlab对验证码的识别是基于神经网络的，但预处理工作还是占了整体工作的大半，将数据整理好并处理成对应可用的格式，问题就简单了很多。

Matlab的一大缺陷是不注重数据结构，其结构体无比难用，所以我们这里将尽可能使用矩阵进行处理，而参数较多时，我们也只是简单的将其放入到元胞数组中，不优雅之处，敬请见谅。

首先介绍一下matlab的图像基本处理函数：

img = imread('path') # 返回一个图像的矩阵，其每个元素的值，包含rgb三个通道的数据。

imshow(img) # 显示图像

imgGray = rgb2gray(img) # 转为灰度图像

thresh = graythresh(imgGray); % 自动确定二值化阀值

BW = 1 - im2bw(imgGray,thresh);   % 二值化，且取反，黑的部分是0，白的部分是1,

I2 = bwareaopen(BW, 8, 8);   % 去除连通分量中小于10的离散点
1
2
3
4
5
6

我们看看目标的图片：

有很多随机的像素点干扰，我们需要将这些像素点去除，然后进行图像切割。

切割图片实际上很简单，就是对图片中每行每列进行统计，然后将形成的波形进行扫描，每个从0上升又下降到0的区域，就是一个字符。

切割后的图片：

下面我们来写一个完整的函数分割器函数，为了检测正确性，我们这里提供了isshow标记，如果设置为true，将会打印中间的调试信息。



% 图片分割器

function y = cutting(img, isshow)

    if nargin < 2; isshow = false; end

    if isshow;

        imshow(img); % 显示彩色图像

    end

    imgGray = rgb2gray(img); % 转为灰度图像

    thresh = graythresh(imgGray); % 自动确定二值化阀值 （这个不太好，有时会整体删除一个字）

    BW = 1 - im2bw(imgGray,thresh);   % 二值化

    I2 = bwareaopen(BW, 8, 8);   % 去除连通分量中小于10的离散点

    varray = sum(I2);

    imgsize = size(I2);

    if isshow

        figure; % 打开一个新的窗口显示灰度图像

        imshow(imgGray); % 显示转化后的灰度图像

        harray = sum(I2');

        x1 = 1 : imgsize(1, 1);

        x2 = 1 : imgsize(1, 2);

        figure; % 打开一个新的窗口显示分割图

        plot(x1, harray, 'r+-', x2, varray, 'y*-');

        figure; % 打开一个新的窗口显示灰度图像

        imshow(I2); % 显示转化后的灰度图像

    end

    va = mean(varray);    % 计算平均值

    harray = sum(I2');

    vb = mean(harray);

    %% matlab 设计的实在太烂！真是我有史以来见过的最烂的语言

    %% 函数只有搅成一坨的情况下才能正确运行

    %% 他们根部不知道如何用闭包，以及合理的封装对象

    isanum = false;

    sumy = 0;

    for i = 1 : imgsize(1, 1)

        if harray(i) > vb;

            if isanum == false;

                isanum = true;

                cvb = i;

            end

        else

            if isanum;

                isanum = false;

                cve = i;

                sumy = sumy + 1;

                if isshow;

                    hold on;

                    plot([0 imgsize(1,2)], [cvb cvb],'r--');

                    plot([0 imgsize(1,2)], [cve cve], 'r--');

                end

            end

        end

    end

    y = {}

    sumy = 0;

    for i = 1 : imgsize(1, 2);

        if varray(i) > va;

            if isanum == false;

                isanum = true;

                ctb = i;

            end

        else

            if isanum;

                isanum = false;

                cte = i;

                sumy = sumy + 1;

                if isshow;

                    hold on;

                    plot([ctb ctb], [0 imgsize(1,1)],'r--');

                    plot([cte cte], [0 imgsize(1,1)],'r--');

                end

                t = I2(cvb:cve, ctb:cte);

                y{sumy} = t;

            end

        end

    end

end


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

我们这个函数实现了对图片的预处理工作，成功的将大部分图片分割成了小图片，放到返回的元胞数组中，但这还有一个重要的问题，就是切割后的图片并不等大小。

并且，我们为了让这些图片能够方便的进行训练，希望将他们归好类别，方便标记。将图像等大小十分简单，只需要将图像的最大的长和宽找到，然后对矩阵进行扩展，多余的位置补0即可。

%% 将数字分类放置

for i = 1 : length(imgs_name)

    img_name = imgs_name{i};

    imgs = cutting(imread(['train/',img_name,'.jpg']), false);

    if (length(imgs) == length(img_name))

        imgs_num_size = length(img_name);

        for j = 1 : imgs_num_size

            tmp_num = str2num(img_name(j)) + 1;

            imgs_sample_num(tmp_num) = imgs_sample_num(tmp_num) + 1;

            imgs_sample{tmp_num, imgs_sample_num(tmp_num)} = imgs{j};

            tmp_size = size(imgs{j});

        end

    end

end

max_size = [16 16];

%% 归一化所有样本，使其等大小

for i = 1 : 10

    for j = 1 : imgs_sample_num(i)

        temp = zeros(max_size);

        imgs_size = size(imgs_sample{i, j});

        temp(1:imgs_size(1,1), 1:imgs_size(1,2)) = imgs_sample{i, j};

        imgs_sample{i, j} = temp;

        % figure;

        % imshow(temp);

    end

end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

分别用BP网络和深卷积网络来进行图像识别

BP网络结构

由于已经做好了充足的预处理工作，那么接下来的识别就十分简单了，BP网络和深卷积网络都有对应的库支持操作，所以我们只需要编写配置代码就可以了。

BP网络就是简单的三层结构，由于层数太大可能带来误差残差太小等问题，造成训练困难，我们这里使用足够多的隐层节点保障BP网络的精度就可以了。

输入就是整个图像转为1维向量，输出则是可能属于的类别的概率，是一个10维的向量，要确定分类结果，就将其中最大的数字找到即可。

BP网络的训练及识别

那么，我们就可以开始组织训练数据了。



% 创建数据集

%% buildtrainset: 用来创建神经网络适合的训练集

function [inputs outputs] = buildtrainset(imgs, number)

    i = 1;

    for k = 1 : 10

        for j = 1 : number(k)

            input = imgs{k, j};

            input_size = numel(input);

            inputs(i, :) = reshape(input', input_size, 1);

            outputs(i, :) = zeros(10, 1);

            outputs(i, k) = 1;

            i = i + 1;

        end

    end

end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

然后训练并比较正确与否：

function y = runbp(imgs_sample, imgs_sample_num, max_size)

    % bp 网络训练

    [a, b] = buildtrainset(imgs_sample, imgs_sample_num);

    net = bpann(a', b');

    % bp 测试

    image_dir=dir('image/*.jpg');

    for i = 1: length(image_dir)

        str_name = image_dir(i).name;

        imgs_test{i} = str_name(1:4);

    end

    rightnum = 0;

    sumnum = 0;

    for i = 1 : length(imgs_test)

        img_name = imgs_test{i};

        imgs = cutting(imread(['image/',img_name,'.jpg']), false);

        if (length(imgs) == length(img_name))

            for j = 1 : length(img_name)

                tmp_num = str2num(img_name(j)) + 1;

                %% 等大小化

                temp = zeros(max_size);

                imgs_size = size(imgs{j});

                temp(1:imgs_size(1,1), 1:imgs_size(1,2)) = imgs{j};

                imgs{j} = temp;

                input_size = numel(temp);

                testInput(j, :) = reshape(temp', input_size, 1);

            end

            size(testInput)

            Y = sim( net , testInput' );

            mans = [1:4];

            for j = 1 : length(img_name)

                ymax = 0;

                yans = NaN;

                for k = 1 : 10

                    if (ymax < Y(k, j))

                        ymax = Y(k, j);

                        yans = k;

                    end

                end

                mans(j) = yans-1;

                sumnum = sumnum + 1;

                if (mans(j) == str2num(img_name(j)))

                    rightnum = rightnum + 1;

                end

            end

            img_name

            mans

        end

    end

    rightdata = [rightnum, sumnum-rightnum]

    pie(rightdata, {'right', 'wrong'});

end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

经过1500次左右的迭代，收敛精度基本达到了要求：

识别结果：

1830

mans =

     1     8     3     0

2940

mans =

     2     9     4     0

3742

mans =

     3     7     4     2

5980

mans =

     5     9     8     0

6739

mans =

     6     7     3     9

8240

mans =

     8     2     4     0

8324

mans =

     8     3     2     4


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

但遗憾的是，识别正确率并不是100%，而是70%，由于有3组数据在预处理时失败了，并没有被正确的二值化，造成了无法识别，但可以看出，神经网络的识别正确率还是相当高的。

深度卷积网络的图像识别

我们这里使用了一个流行的深度学习工具包DeepLearnToolbox，这个工具包可以在github上被找到。

将其下载下来，然后添加两个path路径，将其引用：

path(path, 'DeepLearnToolbox-master/CNN/')

path(path, 'DeepLearnToolbox-master/util/')
1
2

然后我们构建一个卷积网络的结构struct，并利用类似BP的方式，将数据集构造好：

    % 网络训练集构造

    [a, b] = buildtrainset_cnn(imgs_sample, imgs_sample_num);

    % 16×16的原图片

    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) %sub sampling layer

    };

    cnn = cnnsetup(cnn, a, b);
1
2
3
4
5
6
7
8
9
10
11
12
13

而卷积网络的配置如下：

    % 学习率

    opts.alpha = 2;

    % 每次挑出一个batchsize的batch来训练，也就是每用batchsize个样本就调整一次权值，而不是

    % 把所有样本都输入了，计算所有样本的误差了才调整一次权值

    opts.batchsize = size(a, 3);

    % 训练次数，用同样的样本集。我训练的时候：

    % 1的时候 11.41% error

    % 5的时候 4.2% error

    % 10的时候 2.73% error

    opts.numepochs = 2000;

    % cnn = cnntrain(cnn, a, b, opts);  % 如果是还未训练

    load cnn_save cnn;  %如果已经训练过，载入保存的网络就可以了
1
2
3
4
5
6
7
8
9
10
11
12
13

这样我们来观察一下网络的结构，这是一个复杂的网络，input是一个16×16的图片，而每次卷积的核都是5×5的，还会有两个降维层。

然后我们会进行测试，和BP网络几乎一样

% 测试

    image_dir=dir('image/*.jpg');

    for i = 1: length(image_dir)

        str_name = image_dir(i).name;

        imgs_test{i} = str_name(1:4);

    end

    rightnum = 0;

    sumnum = 0;

    for i = 1 : length(imgs_test)

        img_name = imgs_test{i};

        imgs = cutting(imread(['image/',img_name,'.jpg']), false);

        if (length(imgs) == length(img_name))

            for j = 1 : length(img_name)

                tmp_num = str2num(img_name(j)) + 1;

                %% 等大小化

                temp = zeros(max_size);

                imgs_size = size(imgs{j});

                temp(1:imgs_size(1,1), 1:imgs_size(1,2)) = imgs{j};

                imgs{j} = temp;

                input_size = size(temp);

                testInput(:, :, j) = reshape(temp', input_size(1,1), input_size(1,2));

            end

            % 然后就用测试样本来测试  

            cnn = cnnff(cnn, testInput);

            cnn.o

            [~, mans] = max(cnn.o);

            img_name

            mans = mans-1

            % [~, a] = max(y);

            % bad = find(mans ~= a);

        end

    end

    %plot mean squared error

    plot(cnn.rL);  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

附: 源码仓库

https://github.com/sunxfancy/ANN2