使用深度學習來破解 captcha 驗證碼

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

本文會通過 Keras 搭建一個深度卷積神經網絡來識別 captcha 驗證碼，建議使用顯卡來運行該項目。

下面的可視化代碼都是在 jupyter notebook 中完成的，如果你希望寫成 python 腳本，稍加修改即可正常運行，當然也可以去掉這些可視化代碼。Keras 版本：1.2.2。

GitHub 地址：https://github.com/ypwhs/captcha_breakhttps://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張，估計可以拼過網速。至於深度學習到底能不能識別雙胞胎，相信各位已經有了答案。

參考鏈接：

• 快速開始泛型模型 - Keras中文文檔
• https://github.com/fchollet/keras/blob/master/examples/image_ocr.py
• http://cs231n.github.io/convol