https://blog.csdn.net/c2a2o2/article/details/68490189

本文会通过 Keras 搭建一个深度卷积神经网络来识别 captcha 验证码，建议使用显卡来运行该项目。

下面的可视化代码都是在 jupyter notebook 中完成的，如果你希望写成 python 脚本，稍加修改即可正常运行，当然也可以去掉这些可视化代码。Keras 版本：1.2.2。

GitHub 地址：https://github.com/ypwhs/captcha_break

captcha 是用 python 写的生成验证码的库，它支持图片验证码和语音验证码，我们使用的是它生成图片验证码的功能。

首先我们设置我们的验证码格式为数字加大写字母，生成一串验证码试试看：

  1. from captcha.image import ImageCaptcha
  2. import matplotlib.pyplot as plt
  3. import numpy as np
  4. import random
  5.  
  6. %matplotlib inline
  7. %config InlineBackend.figure_format = \’retina\’
  8.  
  9. import string
  10. characters = string.digits + string.ascii_uppercase
  11. print(characters)
  12.  
  13. width, height, n_len, n_class = 170, 80, 4, len(characters)
  14.  
  15. generator = ImageCaptcha(width=width, height=height)
  16. random_str = \’\’.join([random.choice(characters) for j in range(4)])
  17. img = generator.generate_image(random_str)
  18.  
  19. plt.imshow(img)
  20. plt.title(random_str)

数据生成器

训练模型的时候，我们可以选择两种方式来生成我们的训练数据，一种是一次性生成几万张图，然后开始训练，一种是定义一个数据生成器，然后利用 fit_generator 函数来训练。

第一种方式的好处是训练的时候显卡利用率高，如果你需要经常调参，可以一次生成，多次使用；第二种方式的好处是你不需要生成大量数据，训练过程中可以利用 CPU 生成数据，而且还有一个好处是你可以无限生成数据。

我们的数据格式如下：

X

X 的形状是 (batch_size, height, width, 3)，比如一批生成32个样本，图片宽度为170，高度为80，那么形状就是 (32, 80, 170, 3)，取第一张图就是 X[0]。

y

y 的形状是四个 (batch_size, n_class)，如果转换成 numpy 的格式，则是 (n_len, batch_size, n_class)，比如一批生成32个样本，验证码的字符有36种，长度是4位，那么它的形状就是4个 (32, 36)，也可以说是 (4, 32, 36)，解码函数在下个代码块。

  1. def gen(batch_size=32):
  2. X = np.zeros((batch_size, height, width, 3), dtype=np.uint8)
  3. y = [np.zeros((batch_size, n_class), dtype=np.uint8) for i in range(n_len)]
  4. generator = ImageCaptcha(width=width, height=height)
  5. while True:
  6. for i in range(batch_size):
  7. random_str = \’\’.join([random.choice(characters) for j in range(4)])
  8. X[i] = generator.generate_image(random_str)
  9. for j, ch in enumerate(random_str):
  10. y[j][i, :] = 0
  11. y[j][i, characters.find(ch)] = 1
  12. yield X, y

上面就是一个可以无限生成数据的例子，我们将使用这个生成器来训练我们的模型。

使用生成器

生成器的使用方法很简单，只需要用 next 函数即可。下面是一个例子，生成32个数据，然后显示第一个数据。当然，在这里我们还对生成的 One-Hot 编码后的数据进行了解码，首先将它转为 numpy 数组，然后取36个字符中最大的数字的位置，因为神经网络会输出36个字符的概率，然后将概率最大的四个字符的编号转换为字符串。

  1. def decode(y):
  2. y = np.argmax(np.array(y), axis=2)[:,0]
  3. return \’\’.join([characters[x] for x in y])
  4.  
  5. X, y = next(gen(1))
  6. plt.imshow(X[0])
  7. plt.title(decode(y))

构建深度卷积神经网络

from keras.models import *
from keras.layers import *

input_tensor = Input((height, width, 3))
x = input_tensor
for i in range(4):
    x = Convolution2D(32*2**i, 3, 3, activation=\'relu\')(x)
    x = Convolution2D(32*2**i, 3, 3, activation=\'relu\')(x)
    x = MaxPooling2D((2, 2))(x)

x = Flatten()(x)
x = Dropout(0.25)(x)
x = [Dense(n_class, activation=\'softmax\', name=\'c%d\'%(i+1))(x) for i in range(4)]
model = Model(input=input_tensor, output=x)

model.compile(loss=\'categorical_crossentropy\',
              optimizer=\'adadelta\',
              metrics=[\'accuracy\'])

模型结构很简单，特征提取部分使用的是两个卷积，一个池化的结构，这个结构是学的 VGG16 的结构。之后我们将它 Flatten，然后添加 Dropout ，尽量避免过拟合问题，最后连接四个分类器，每个分类器是36个神经元，输出36个字符的概率。

模型可视化

得益于 Keras 自带的可视化，我们可以使用几句代码来可视化模型的结构：

  1. from keras.utils.visualize_util import plot
  2. from IPython.display import Image
  3.  
  4. plot(model, to_file=“model.png”, show_shapes=True)
  5. Image(\’model.png\’)

这里需要使用 pydot 这个库，以及 graphviz 这个库，在 macOS 系统上安装方法如下：

  1. brew install graphviz
  2. pip install pydot-ng

我们可以看到最后一层卷积层输出的形状是 (1, 6, 256)，已经不能再加卷积层了。

训练模型

训练模型反而是所有步骤里面最简单的一个，直接使用 model.fit_generator 即可，这里的验证集使用了同样的生成器，由于数据是通过生成器随机生成的，所以我们不用考虑数据是否会重复。注意，这段代码在笔记本上可能要耗费一下午时间。如果你想让模型预测得更准确，可以将 nb_epoch改为 10 或者 20，但它也将耗费成倍的时间。注意我们这里使用了一个小技巧，添加 nb_worker=2 参数让 Keras 自动实现多进程生成数据，摆脱 python 单线程效率低的缺点。如果不添加，耗时120秒，添加则只需80秒。

  1. model.fit_generator(gen(), samples_per_epoch=51200, nb_epoch=5,
  2. nb_worker=2, pickle_safe=True,
  3. validation_data=gen(), nb_val_samples=1280)

测试模型

当我们训练完成以后，可以识别一个验证码试试看：

  1. X, y = next(gen(1))
  2. y_pred = model.predict(X)
  3. plt.title(\’real: %s\npred:%s\’%(decode(y), decode(y_pred)))
  4. plt.imshow(X[0], cmap=\’gray\’)

计算模型总体准确率

模型在训练的时候只会显示第几个字符的准确率，为了统计模型的总体准确率，我们可以写下面的函数：

  1. from tqdm import tqdm
  2. def evaluate(model, batch_num=20):
  3. batch_acc = 0
  4. generator = gen()
  5. for i in tqdm(range(batch_num)):
  6. X, y = next(generator)
  7. y_pred = model.predict(X)
  8. y_pred = np.argmax(y_pred, axis=2).T
  9. y_true = np.argmax(y, axis=2).T
  10. batch_acc += np.mean(map(np.array_equal, y_true, y_pred))
  11. return batch_acc / batch_num
  12.  
  13. evaluate(model)

这里用到了一个库叫做 tqdm，它是一个进度条的库，为的是能够实时反馈进度。然后我们通过一些 numpy 计算去统计我们的准确率，这里计算规则是只要有一个错，那么就不算它对。经过计算，我们的模型的总体准确率在经过五代训练就可以达到 90%，继续训练还可以达到更高的准确率。

模型总结

模型的大小是16MB，在我的笔记本上跑1000张验证码需要用20秒，当然，显卡会更快。对于验证码识别的问题来说，哪怕是10%的准确率也已经称得上破解，毕竟假设100%识别率破解要一个小时，那么10%的识别率也只用十个小时，还算等得起，而我们的识别率有90%，已经可以称得上完全破解了这类验证码。

改进

对于这种按顺序书写的文字，我们还有一种方法可以使用，那就是循环神经网络来识别序列。下面我们来了解一下如何使用循环神经网络来识别这类验证码。

CTC Loss

这个 loss 是一个特别神奇的 loss，它可以在只知道序列的顺序，不知道具体位置的情况下，让模型收敛。在这方面百度似乎做得很不错，利用它来识别音频信号。（warp-ctc）

那么在 Keras 里面，CTC Loss 已经内置了，我们直接定义这样一个函数，即可实现 CTC Loss，由于我们使用的是循环神经网络，所以默认丢掉前面两个输出，因为它们通常无意义，且会影响模型的输出。

  • y_pred 是模型的输出，是按顺序输出的37个字符的概率，因为我们这里用到了循环神经网络，所以需要一个空白字符的概念；
  • labels 是验证码，是四个数字；
  • input_length 表示 y_pred 的长度，我们这里是15；
  • label_length 表示 labels 的长度，我们这里是4。
  1. from keras import backend as K
  2.  
  3. def ctc_lambda_func(args):
  4. y_pred, labels, input_length, label_length = args
  5. y_pred = y_pred[:, 2:, :]
  6. return K.ctc_batch_cost(labels, y_pred, input_length, label_length)

模型结构

我们的模型结构是这样设计的，首先通过卷积神经网络去识别特征，然后经过一个全连接降维，再按水平顺序输入到一种特殊的循环神经网络，叫 GRU，它具有一些特殊的性质，为什么用 GRU 而不用 LSTM 呢？总的来说就是它的效果比 LSTM 好，所以我们用它。

  1. from keras.models import *
  2. from keras.layers import *
  3. rnn_size = 128
  4.  
  5. input_tensor = Input((width, height, 3))
  6. x = input_tensor
  7. for i in range(3):
  8. x = Convolution2D(32, 3, 3, activation=\’relu\’)(x)
  9. x = Convolution2D(32, 3, 3, activation=\’relu\’)(x)
  10. x = MaxPooling2D(pool_size=(2, 2))(x)
  11.  
  12. conv_shape = x.get_shape()
  13. x = Reshape(target_shape=(int(conv_shape[1]), int(conv_shape[2]*conv_shape[3])))(x)
  14.  
  15. x = Dense(32, activation=\’relu\’)(x)
  16.  
  17. gru_1 = GRU(rnn_size, return_sequences=True, init=\’he_normal\’, name=\’gru1\’)(x)
  18. gru_1b = GRU(rnn_size, return_sequences=True, go_backwards=True,
  19. init=\’he_normal\’, name=\’gru1_b\’)(x)
  20. gru1_merged = merge([gru_1, gru_1b], mode=\’sum\’)
  21.  
  22. gru_2 = GRU(rnn_size, return_sequences=True, init=\’he_normal\’, name=\’gru2\’)(gru1_merged)
  23. gru_2b = GRU(rnn_size, return_sequences=True, go_backwards=True,
  24. init=\’he_normal\’, name=\’gru2_b\’)(gru1_merged)
  25. x = merge([gru_2, gru_2b], mode=\’concat\’)
  26. x = Dropout(0.25)(x)
  27. x = Dense(n_class, init=\’he_normal\’, activation=\’softmax\’)(x)
  28. base_model = Model(input=input_tensor, output=x)
  29.  
  30. labels = Input(name=\’the_labels\’, shape=[n_len], dtype=\’float32\’)
  31. input_length = Input(name=\’input_length\’, shape=[1], dtype=\’int64\’)
  32. label_length = Input(name=\’label_length\’, shape=[1], dtype=\’int64\’)
  33. loss_out = Lambda(ctc_lambda_func, output_shape=(1,),
  34. name=\’ctc\’)([x, labels, input_length, label_length])
  35.  
  36. model = Model(input=[input_tensor, labels, input_length, label_length], output=[loss_out])
  37. model.compile(loss={\’ctc\’: lambda y_true, y_pred: y_pred}, optimizer=\’adadelta\’)

模型可视化

可视化的代码同上，这里只贴图。

可以看到模型比上一个模型复杂了许多，但实际上只是因为输入比较多，所以它显得很大。还有一个值得注意的地方，我们的图片在输入的时候是经过了旋转的，这是因为我们希望以水平方向输入，而图片在 numpy 里默认是这样的形状：(height, width, 3)，因此我们使用了 transpose 函数将图片转为了(width, height, 3)的格式，然后经过各种卷积和降维，变成了 (17, 32)，这里的每个长度为32的向量都代表一个竖条的图片的特征，从左到右，一共有17条。然后我们兵分两路，一路从左到右输入到 GRU，一路从右到左输入到 GRU，然后将他们输出的结果加起来。再兵分两路，还是一路正方向，一路反方向，只不过第二次我们直接将它们的输出连起来，然后经过一个全连接，输出每个字符的概率。

数据生成器

  1. def gen(batch_size=128):
  2. X = np.zeros((batch_size, width, height, 3), dtype=np.uint8)
  3. y = np.zeros((batch_size, n_len), dtype=np.uint8)
  4. while True:
  5. generator = ImageCaptcha(width=width, height=height)
  6. for i in range(batch_size):
  7. random_str = \’\’.join([random.choice(characters) for j in range(4)])
  8. X[i] = np.array(generator.generate_image(random_str)).transpose(1, 0, 2)
  9. y[i] = [characters.find(x) for x in random_str]
  10. yield [X, y, np.ones(batch_size)*int(conv_shape[1]–2),
  11. np.ones(batch_size)*n_len], np.ones(batch_size)

评估模型

  1. def evaluate(model, batch_num=10):
  2. batch_acc = 0
  3. generator = gen()
  4. for i in range(batch_num):
  5. [X_test, y_test, _, _], _ = next(generator)
  6. y_pred = base_model.predict(X_test)
  7. shape = y_pred[:,2:,:].shape
  8. ctc_decode = K.ctc_decode(y_pred[:,2:,:],
  9. input_length=np.ones(shape[0])*shape[1])[0][0]
  10. out = K.get_value(ctc_decode)[:, :4]
  11. if out.shape[1] == 4:
  12. batch_acc += ((y_test == out).sum(axis=1) == 4).mean()
  13. return batch_acc / batch_num

我们会通过这个函数来评估我们的模型，和上面的评估标准一样，只有全部正确，我们才算预测正确，中间有个坑，就是模型最开始训练的时候，并不一定会输出四个字符，所以我们如果遇到所有的字符都不到四个的时候，就不计算了，相当于加0，遇到多于4个字符的时候，只取前四个。

评估回调

因为 Keras 没有针对这种输出计算准确率的选项，因此我们需要自定义一个回调函数，它会在每一代训练完成的时候计算模型的准确率。

  1. from keras.callbacks import *
  2. class Evaluate(Callback):
  3. def __init__(self):
  4. self.accs = []
  5.  
  6. def on_epoch_end(self, epoch, logs=None):
  7. acc = evaluate(base_model)*100
  8. self.accs.append(acc)
  9. print
  10. print \’acc: %f%%\’%acc
  11. evaluator = Evaluate()

训练模型

由于 CTC Loss 收敛很慢，所以我们需要设置比较大的代数，这里我们设置了100代，然后添加了一个早期停止的回调和我们上面定义的回调，但是第一次训练只训练37代就停了，测试准确率才95%，我又在这个基础上继续训练了一次，停在了25代，得到了98%的准确率，所以一共训练了62代。

model.fit_generator(gen(), samples_per_epoch=51200, nb_epoch=100, 
                    callbacks=[evaluator], 
                    nb_worker=2, pickle_safe=True)

测试模型

  1. characters2 = characters + \’ \’
  2. [X_test, y_test, _, _], _ = next(gen(1))
  3. y_pred = base_model.predict(X_test)
  4. y_pred = y_pred[:,2:,:]
  5. out = K.get_value(K.ctc_decode(y_pred, input_length=np.ones(y_pred.shape[0])*y_pred.shape[1], )[0][0])[:, :4]
  6. out = \’\’.join([characters[x] for x in out[0]])
  7. y_true = \’\’.join([characters[x] for x in y_test[0]])
  8.  
  9. plt.imshow(X_test[0].transpose(1, 0, 2))
  10. plt.title(\’pred:\’ + str(out) + \’\ntrue: \’ + str(y_true))
  11.  
  12. argmax = np.argmax(y_pred, axis=2)[0]
  13. list(zip(argmax, \’\’.join([characters2[x] for x in argmax])))

这次随机出来的验证码很厉害，是O0OP，不过更厉害的是模型认出来了。

有趣的问题

我又用之前的模型做了个测试，对于 O0O0 这样丧心病狂的验证码，模型偶尔也能正确识别，这让我非常惊讶，它是真的能识别 O 与 0 的差别呢，还是猜出来的呢？这很难说。

  1. generator = ImageCaptcha(width=width, height=height)
  2. random_str = \’O0O0\’
  3. X = generator.generate_image(random_str)
  4. X = np.expand_dims(X, 0)
  5.  
  6. y_pred = model.predict(X)
  7. plt.title(\’real: %s\npred:%s\’%(random_str, decode(y_pred)))
  8. plt.imshow(X[0], cmap=\’gray\’)

总结

模型的大小是4.7MB，在我的笔记本上跑1000张验证码需要用14秒，平均一秒识别71张，估计可以拼过网速。至于深度学习到底能不能识别双胞胎，相信各位已经有了答案。

参考链接：

版权声明：本文为davidwang456原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/davidwang456/articles/9348548.html