教你使用TensorFlow2对识别验证码

 验证码是根据随机字符生成一幅图片，然后在图片中加入干扰象素，用户必须手动填入，防止有人利用机器人自动批量注册、灌水、发垃圾广告等等 。

创新互联主营邯山网站建设的网络公司,主营网站建设方案,成都App制作,邯山h5小程序设计搭建,邯山网站营销推广欢迎邯山等地区企业咨询

数据集来源：https://www.kaggle.com/fournierp/captcha-version-2-images

图片是5个字母的单词，可以包含数字。这些图像应用了噪声(模糊和一条线)。它们是200 x 50 PNG。我们的任务是尝试制作光学字符识别算法的模型。

在数据集中存在的验证码png图片，对应的标签就是图片的名字。

 
 
 
 
    
  
  
  
  
  1. import os
    2. 
  
  
  
  
  2. import numpy as np
    3. 
  
  
  
  
  3. import pandas as pd
    4. 
  
  
  
  
  4. import cv2
    5. 
  
  
  
  
  5. import matplotlib.pyplot as plt
    6. 
  
  
  
  
  6. import seaborn as sns
    7. 
  
  
  
  
  7. # imgaug 图片数据增强
    8. 
  
  
  
  
  8. import imgaug.augmenters as iaa
    9. 
  
  
  
  
  9. import tensorflow as tf
    10. 
  
  
  
  
  10. # Conv2D MaxPooling2D Dropout Flatten Dense BN  GAP
    11. 
  
  
  
  
  11. from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense, Layer, BatchNormalization, GlobalAveragePooling2D 
    12. 
  
  
  
  
  12. from tensorflow.keras.optimizers import Adam
    13. 
  
  
  
  
  13. from tensorflow.keras import Model, Input 
    14. 
  
  
  
  
  14. from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
    15. 
  
  
  
  
  15. # 图片处理器
    16. 
  
  
  
  
  16. from tensorflow.keras.preprocessing.image import ImageDataGenerator
    17. 
  
  
  
  
  17. import plotly.express as px
    18. 
  
  
  
  
  18. import plotly.graph_objects as go
    19. 
  
  
  
  
  19. import plotly.offline as pyo
    20. 
  
  
  
  
  20. pyo.init_notebook_mode()
    21.

对数据进行一个简单的分析，统计图像中大约出现了什么样的符号。

 
 
 
 
    
  
  
  
  
  1. # 数据路径
    2. 
  
  
  
  
  2. DIR = '../input/captcha-version-2-images/samples/samples'
    3. 
  
  
  
  
  3. # 存储验证码的标签
    4. 
  
  
  
  
  4. captcha_list = []
    5. 
  
  
  
  
  5. characters = {}
    6. 
  
  
  
  
  6. for captcha in os.listdir(DIR):
    7. 
  
  
  
  
  7.     captcha_list.append(captcha)
    8. 
  
  
  
  
  8.     # 每张验证码的captcha_code
    9. 
  
  
  
  
  9.     captcha_code = captcha.split(".")[0]
    10. 
  
  
  
  
  10.     for i in captcha_code:
    11. 
  
  
  
  
  11.         # 遍历captcha_code 
    12. 
  
  
  
  
  12.         characters[i] = characters.get(i, 0) +1
    13. 
  
  
  
  
  13. symbols = list(characters.keys())
    14. 
  
  
  
  
  14. len_symbols = len(symbols)
    15. 
  
  
  
  
  15. print(f'图像中只使用了{len_symbols}符号')
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. plt.bar(*zip(*characters.items()))
    18. 
  
  
  
  
  18. plt.title('Frequency of symbols')
    19. 
  
  
  
  
  19. plt.show()
    20.

如何提取图像的数据建立X，y??

 
 
 
 
    
  
  
  
  
  1. # 如何提取图像 建立 model  X 的shape  1070 * 50 * 200 * 1 
    2. 
  
  
  
  
  2. # y的shape 5 * 1070 * 19
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. for i, captcha in enumerate(captcha_list):
    5. 
  
  
  
  
  5.     captcha_code = captcha.split('.')[0]
    6. 
  
  
  
  
  6.     # cv2.IMREAD_GRAYSCALE 灰度图
    7. 
  
  
  
  
  7.     captcha_cv2 = cv2.imread(os.path.join(DIR, captcha),cv2.IMREAD_GRAYSCALE)
    8. 
  
  
  
  
  8.     # 缩放
    9. 
  
  
  
  
  9.     captcha_cv2 = captcha_cv2 / 255.0
    10. 
  
  
  
  
  10.     # print(captcha_cv2.shape) (50, 200) 
    11. 
  
  
  
  
  11.     # 将captcha_cv2的(50, 200) 切换成(50, 200, 1)
    12. 
  
  
  
  
  12.     captcha_cv2 = np.reshape(captcha_cv2, img_shape)
    13. 
  
  
  
  
  13.     # (5,19)
    14. 
  
  
  
  
  14.     targs = np.zeros((len_captcha, len_symbols))
    15. 
  
  
  
  
  15.     
    16. 
  
  
  
  
  16.     for a, b in enumerate(captcha_code):
    17. 
  
  
  
  
  17.         targs[a, symbols.index(b)] = 1
    18. 
  
  
  
  
  18.     X[i] = captcha_cv2
    19. 
  
  
  
  
  19.     y[:, i] = targs
    20. 
  
  
  
  
  20. 
  
  
  
  
  21. print("shape of X:", X.shape)
    22. 
  
  
  
  
  22. print("shape of y:", y.shape)
    23.

输出如下

 
 
 
 
    
  
  
  
  
  1. print("shape of X:", X.shape)
    2. 
  
  
  
  
  2. print("shape of y:", y.shape)
    3.

通过Numpy中random 随机选择数据，划分训练集和测试集

 
 
 
 
    
  
  
  
  
  1. # 生成随机数
    2. 
  
  
  
  
  2. from numpy.random import default_rng
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. rng = default_rng(seed=1)
    5. 
  
  
  
  
  5. test_numbers = rng.choice(1070, size=int(1070*0.3), replace=False)
    6. 
  
  
  
  
  6. X_test = X[test_numbers]
    7. 
  
  
  
  
  7. X_full = np.delete(X, test_numbers,0)
    8. 
  
  
  
  
  8. y_test = y[:,test_numbers]
    9. 
  
  
  
  
  9. y_full = np.delete(y, test_numbers,1)
    10. 
  
  
  
  
  10. 
  
  
  
  
  11. val_numbers = rng.choice(int(1070*0.7), size=int(1070*0.3), replace=False)
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. X_val = X_full[val_numbers]
    14. 
  
  
  
  
  14. X_train = np.delete(X_full, val_numbers,0)
    15. 
  
  
  
  
  15. y_val = y_full[:,val_numbers]
    16. 
  
  
  
  
  16. y_train = np.delete(y_full, val_numbers,1)
    17.

在此验证码数据中，容易出现过拟合的现象，你可能会想到添加更多的新数据、 添加正则项等， 但这里使用数据增强的方法，特别是对于机器视觉的任务，数据增强技术尤为重要。

常用的数据增强操作：imgaug库。imgaug是提供了各种图像增强操作的python库 https://github.com/aleju/imgaug。

imgaug几乎包含了所有主流的数据增强的图像处理操作， 增强方法详见github

 
 
 
 
    
  
  
  
  
  1. # Sequential(C, R)  尺寸增加了5倍，
    2. 
  
  
  
  
  2. # 选取一系列子增强器C作用于每张图片的位置,第二个参数表示是否对每个batch的图片应用不同顺序的Augmenter list     # rotate=(-8, 8)  旋转
    3. 
  
  
  
  
  3. # iaa.CropAndPad  截取(crop)或者填充(pad),填充时,被填充区域为黑色。
    4. 
  
  
  
  
  4. # px: 想要crop(negative values)的或者pad(positive values)的像素点。
    5. 
  
  
  
  
  5. # (top, right, bottom, left)
    6. 
  
  
  
  
  6. # 当pad_mode=constant的时候选择填充的值
    7. 
  
  
  
  
  7. aug =iaa.Sequential([iaa.CropAndPad(
    8. 
  
  
  
  
  8.     px=((0, 10), (0, 35), (0, 10), (0, 35)),
    9. 
  
  
  
  
  9.     pad_mode=['edge'],
    10. 
  
  
  
  
  10.     pad_cval=1
    11. 
  
  
  
  
  11. ),iaa.Rotate(rotate=(-8,8))])
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. X_aug_train = None
    14. 
  
  
  
  
  14. y_aug_train = y_train
    15. 
  
  
  
  
  15. for i in range(40):
    16. 
  
  
  
  
  16.     X_aug = aug(images = X_train)
    17. 
  
  
  
  
  17.     if X_aug_train is not None:
    18. 
  
  
  
  
  18.         X_aug_train = np.concatenate([X_aug_train, X_aug], axis = 0)
    19. 
  
  
  
  
  19.         y_aug_train = np.concatenate([y_aug_train, y_train], axis = 1)
    20. 
  
  
  
  
  20.     else:
    21. 
  
  
  
  
  21.         X_aug_train = X_aug
    22.

让我们看看一些数据增强的训练图像。

 
 
 
 
    
  
  
  
  
  1. fig, ax = plt.subplots(nrows=2, ncols =5, figsize = (16,16))
    2. 
  
  
  
  
  2. for i in range(10):
    3. 
  
  
  
  
  3.     index = np.random.randint(X_aug_train.shape[0])
    4. 
  
  
  
  
  4.     ax[i//5][i%5].imshow(X_aug_train[index],cmap='gray')
    5.

这次使用函数式API创建模型，函数式API是创建模型的另一种方式，它具有更多的灵活性，包括创建更为复杂的模型。

需要定义inputs和outputs

 
 
 
 
    
  
  
  
  
  1. #函数式API模型创建
    2. 
  
  
  
  
  2. captcha = Input(shape=(50,200,channels))
    3. 
  
  
  
  
  3. x = Conv2D(32, (5,5),padding='valid',activation='relu')(captcha)
    4. 
  
  
  
  
  4. x = MaxPooling2D((2,2),padding='same')(x)
    5. 
  
  
  
  
  5. x = Conv2D(64, (3,3),padding='same',activation='relu')(x)
    6. 
  
  
  
  
  6. x = MaxPooling2D((2,2),padding='same')(x)
    7. 
  
  
  
  
  7. x = Conv2D(128, (3,3),padding='same',activation='relu')(x)
    8. 
  
  
  
  
  8. maxpool = MaxPooling2D((2,2),padding='same')(x)
    9. 
  
  
  
  
  9. outputs = []
    10. 
  
  
  
  
  10. for i in range(5):
    11. 
  
  
  
  
  11.     x = Conv2D(256, (3,3),padding='same',activation='relu')(maxpool)
    12. 
  
  
  
  
  12.     x = MaxPooling2D((2,2),padding='same')(x)
    13. 
  
  
  
  
  13.     x = Flatten()(x)
    14. 
  
  
  
  
  14.     x = Dropout(0.5)(x)
    15. 
  
  
  
  
  15.     x = BatchNormalization()(x)
    16. 
  
  
  
  
  16.     x = Dense(64, activation='relu')(x)
    17. 
  
  
  
  
  17.     x = Dropout(0.5)(x)
    18. 
  
  
  
  
  18.     x = BatchNormalization()(x)
    19. 
  
  
  
  
  19.     x = Dense(len_symbols , activation='softmax' , name=f'char_{i+1}')(x)
    20. 
  
  
  
  
  20.     outputs.append(x)
    21. 
  
  
  
  
  21.     
    22. 
  
  
  
  
  22. model = Model(inputs = captcha , outputs=outputs)
    23. 
  
  
  
  
  23. # ReduceLROnPlateau更新学习率
    24. 
  
  
  
  
  24. reduce_lr = ReduceLROnPlateau(patience =3, factor = 0.5,verbose = 1)
    25. 
  
  
  
  
  25. model.compile(loss='categorical_crossentropy', optimizer=Adam(learning_rate=0.0005), metrics=["accuracy"])
    26. 
  
  
  
  
  26. # EarlyStopping用于提前停止训练的callbacks。具体地,可以达到当训练集上的loss不在减小
    27. 
  
  
  
  
  27. earlystopping = EarlyStopping(monitor ="val_loss",  
    28. 
  
  
  
  
  28.                              mode ="min", patience = 10,
    29. 
  
  
  
  
  29.                               min_delta = 1e-4,
    30. 
  
  
  
  
  30.                              restore_best_weights = True) 
    31. 
  
  
  
  
  31. 
  
  
  
  
  32. history = model.fit(X_train, [y_train[i] for i in range(5)], batch_size=32, epochs=30, verbose=1, validation_data = (X_val, [y_val[i] for i in range(5)]), callbacks =[earlystopping,reduce_lr])
    33.

下面对model进行一个测试和评估。

 
 
 
 
    
  
  
  
  
  1. score = model.evaluate(X_test,[y_test[0], y_test[1], y_test[2], y_test[3], y_test[4]],verbose=1)
    2. 
  
  
  
  
  2. metrics = ['loss','char_1_loss', 'char_2_loss', 'char_3_loss', 'char_4_loss', 'char_5_loss', 'char_1_acc', 'char_2_acc', 'char_3_acc', 'char_4_acc', 'char_5_acc']
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. for i,j in zip(metrics, score):
    5. 
  
  
  
  
  5.     print(f'{i}: {j}')
    6.

具体输出如下：

 
 
 
 
    
  
  
  
  
  1. 11/11 [==============================] - 0s 11ms/step - loss: 0.7246 - char_1_loss: 0.0682 - char_2_loss: 0.1066 - char_3_loss: 0.2730 - char_4_loss: 0.2636 - char_5_loss: 0.0132 - char_1_accuracy: 0.9844 - char_2_accuracy: 0.9657 - char_3_accuracy: 0.9408 - char_4_accuracy: 0.9626 - char_5_accuracy: 0.9938
    2. 
  
  
  
  
  2. loss: 0.7246273756027222
    3. 
  
  
  
  
  3. char_1_loss: 0.06818050146102905
    4. 
  
  
  
  
  4. char_2_loss: 0.10664034634828568
    5. 
  
  
  
  
  5. char_3_loss: 0.27299806475639343
    6. 
  
  
  
  
  6. char_4_loss: 0.26359987258911133
    7. 
  
  
  
  
  7. char_5_loss: 0.013208594173192978
    8. 
  
  
  
  
  8. char_1_acc: 0.9844236969947815
    9. 
  
  
  
  
  9. char_2_acc: 0.9657320976257324
    10. 
  
  
  
  
  10. char_3_acc: 0.940809965133667
    11. 
  
  
  
  
  11. char_4_acc: 0.9626168012619019
    12. 
  
  
  
  
  12. char_5_acc: 0.9937694668769836
    13.

字母1到字母5的精确值都大于

绘制loss和score

 
 
 
 
    
  
  
  
  
  1. metrics_df = pd.DataFrame(history.history)
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. columns = [col for col in metrics_df.columns if 'loss' in col and len(col)>8]
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. fig = px.line(metrics_df, y = columns)
    6. 
  
  
  
  
  6. fig.show()
    7. 
 
 
 
 

 
 
 
 
    
  
  
  
  
  1. plt.figure(figsize=(15,8))
    2. 
  
  
  
  
  2. plt.plot(history.history['loss'])
    3. 
  
  
  
  
  3. plt.plot(history.history['val_loss'])
    4. 
  
  
  
  
  4. plt.title('model loss')
    5. 
  
  
  
  
  5. plt.ylabel('loss')
    6. 
  
  
  
  
  6. plt.xlabel('epoch')
    7. 
  
  
  
  
  7. plt.legend(['train', 'val'], loc='upper right',prop={'size': 10})
    8. 
  
  
  
  
  8. plt.show()
    9. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. # 预测数据
    2. 
  
  
  
  
  2. def predict(captcha):
    3. 
  
  
  
  
  3.     captcha = np.reshape(captcha , (1, 50,200,channels))
    4. 
  
  
  
  
  4.     result = model.predict(captcha)
    5. 
  
  
  
  
  5.     result = np.reshape(result ,(5,len_symbols))
    6. 
  
  
  
  
  6.     # 取出最大预测中的输出
    7. 
  
  
  
  
  7.     label = ''.join([symbols[np.argmax(i)] for i in result])
    8. 
  
  
  
  
  8.     return label
    9. 
  
  
  
  
  9.     
    10. 
  
  
  
  
  10. predict(X_test[2])
    11. 
  
  
  
  
  11. # 25277
    12.

下面预测所有的数据

 
 
 
 
    
  
  
  
  
  1. actual_pred = []
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. for i in range(X_test.shape[0]):
    4. 
  
  
  
  
  4.     actual = ''.join([symbols[i] for i in (np.argmax(y_test[:, i],axis=1))])
    5. 
  
  
  
  
  5.     pred =  predict(X_test[i])
    6. 
  
  
  
  
  6.     actual_pred.append((actual, pred))
    7. 
  
  
  
  
  7. print(actal_pred[:10])
    8.

输出如下：

 
 
 
 
    
  
  
  
  
  1. [('n4b4m', 'n4b4m'), ('42nxy', '42nxy'), ('25257', '25277'), ('cewnm', 'cewnm'), ('w46ep', 'w46ep'), ('cdcb3', 'edcb3'), ('8gf7n', '8gf7n'), ('nny5e', 'nny5e'), ('gm2c2', 'gm2c2'), ('g7fmc', 'g7fmc')]
    2. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. sameCount = 0
    2. 
  
  
  
  
  2. diffCount = 0
    3. 
  
  
  
  
  3. letterDiff = {i:0 for i in range(5)}
    4. 
  
  
  
  
  4. incorrectness = {i:0 for i in range(1,6)}
    5. 
  
  
  
  
  5. for real, pred in actual_pred:
    6. 
  
  
  
  
  6.     # 预测和输出相同
    7. 
  
  
  
  
  7.     if real == pred:
    8. 
  
  
  
  
  8.         sameCount += 1
    9. 
  
  
  
  
  9.     else:
    10. 
  
  
  
  
  10.         # 失败
    11. 
  
  
  
  
  11.         diffCount += 1
    12. 
  
  
  
  
  12.         # 遍历
    13. 
  
  
  
  
  13.         incorrectnessPoint = 0
    14. 
  
  
  
  
  14.         for i in range(5):
    15. 
  
  
  
  
  15.             if real[i] != pred[i]:
    16. 
  
  
  
  
  16.                 letterDiff[i] += 1
    17. 
  
  
  
  
  17.                 incorrectnessPoint += 1
    18. 
  
  
  
  
  18.         incorrectness[incorrectnessPoint] += 1
    19. 
  
  
  
  
  19. 
  
  
  
  
  20. 
  
  
  
  
  21. x = ['True predicted', 'False predicted']
    22. 
  
  
  
  
  22. y = [sameCount, diffCount]
    23. 
  
  
  
  
  23. 
  
  
  
  
  24. fig = go.Figure(data=[go.Bar(x = x, y = y)])
    25. 
  
  
  
  
  25. fig.show()
    26.

在预测数据中，一共有287个数据预测正确。

在这里，我们可以看到出现错误到底是哪一个index。

 
 
 
 
    
  
  
  
  
  1. x1 = ["Character " + str(x) for x in range(1, 6)]
    2. 
  
  
  
  
  2.     
    3. 
  
  
  
  
  3. fig = go.Figure(data=[go.Bar(x = x1, y = list(letterDiff.values()))])
    4. 
  
  
  
  
  4. fig.show()
    5.

为了计算每个单词的错误数，绘制相关的条形图。

 
 
 
 
    
  
  
  
  
  1. x2 = [str(x) + " incorrect" for x in incorrectness.keys()]
    2. 
  
  
  
  
  2. y2 = list(incorrectness.values())
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. fig = go.Figure(data=[go.Bar(x = x2, y = y2)])
    5. 
  
  
  
  
  5. fig.show()
    6.

下面绘制错误的验证码图像，并标准正确和错误的区别。

 
 
 
 
    
  
  
  
  
  1. fig, ax = plt.subplots(nrows = 8, ncols=4,figsize = (16,20))
    2. 
  
  
  
  
  2. count = 0
    3. 
  
  
  
  
  3. for i, (actual , pred) in enumerate(actual_pred):
    4. 
  
  
  
  
  4.     if actual != pred:
    5. 
  
  
  
  
  5.         img = X_test[i]
    6. 
  
  
  
  
  6.         try:
    7. 
  
  
  
  
  7.             ax[count//4][count%4].imshow(img, cmap = 'gray')
    8. 
  
  
  
  
  8.             ax[count//4][count%4].title.set_text(pred + ' - ' + actual)
    9. 
  
  
  
  
  9.             count += 1
    10. 
  
  
  
  
  10.         except:
    11. 
  
  
  
  
  11.             pass
    12.

分享标题：教你使用TensorFlow2对识别验证码
网页网址：http://www.shufengxianlan.com/qtweb/news13/533463.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站维护知识

同城分类信息

乐山网站建设　　 　云主机　　 　重庆电信五里店机房　　 　成都微商城开发　　 　宣传册设计　　 　LED网站设计方案　　 　瑞杰管理　　 　重庆手机网站建设　　 　全网品牌营销　　 　成都网页设计　　 　棕树数据中心　　 　西云主机托管　　 　成都网站制作公司　　 　成都包装设计公司　　 　微信公众号开发　　 　高端网站建设　　 　免备案空间腾讯云　　 　成都网络营销公司　　 　成都logo设计公司　　 　做网站设计