TensorFlow验证码识别

本节咱们来用 TensorFlow 来实现一个深度学习模型，用来实现验证码识别的过程，这里咱们识别的验证码是图形验证码，首先咱们会用标注好的数据来训练一个模型，而后再用模型来实现这个验证码的识别。

验证码

首先咱们来看下验证码是怎样的，这里咱们使用 Python 的 captcha 库来生成便可，这个库默认是没有安装的，因此这里咱们须要先安装这个库，另外咱们还须要安装 pillow 库，使用 pip3 便可：

pip3 install captcha pillow

安装好以后，咱们就能够用以下代码来生成一个简单的图形验证码了：

from captcha.image import ImageCaptchafrom PIL import Imagetext = '1234'image = ImageCaptcha()captcha = image.generate(text)captcha_image = Image.open(captcha)captcha_image.show()

运行以后便会弹出一张图片，结果以下：

能够看到图中的文字正是咱们所定义的 text 内容，这样咱们就能够获得一张图片和其对应的真实文本，这样咱们就能够用它来生成一批训练数据和测试数据了。

预处理

在训练以前确定是要进行数据预处理了，如今咱们首先定义好了要生成的验证码文本内容，这就至关于已经有了 label 了，而后咱们再用它来生成验证码，就能够获得输入数据 x 了，在这里咱们首先定义好咱们的输入词表，因为大小写字母加数字的词表比较庞大，设想咱们用含有大小写字母和数字的验证码，一个验证码四个字符，那么一共可能的组合是 (26 + 26 + 10) ^ 4 = 14776336 种组合，这个数量训练起来有点大，因此这里咱们精简一下，只使用纯数字的验证码来训练，这样其组合个数就变为 10 ^ 4 = 10000 种，显然少了不少。

因此在这里咱们先定义一个词表和其长度变量：

VOCAB = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']CAPTCHA_LENGTH = 4VOCAB_LENGTH = len(VOCAB)

这里 VOCAB 就是词表的内容，即 0 到 9 这 10 个数字，验证码的字符个数即 CAPTCHA_LENGTH 是 4，词表长度是 VOCAB 的长度，即 10。

接下来咱们定义一个生成验证码数据的方法，流程相似上文，只不过这里咱们将返回的数据转为了 Numpy 形式的数组：

from PIL import Imagefrom captcha.image import ImageCaptchaimport numpy as npdef generate_captcha(captcha_text):    """    get captcha text and np array    :param captcha_text: source text    :return: captcha image and array    """    image = ImageCaptcha()    captcha = image.generate(captcha_text)    captcha_image = Image.open(captcha)    captcha_array = np.array(captcha_image)    return captcha_array

这样调用此方法，咱们就能够获得一个 Numpy 数组了，这个实际上是把验证码转化成了每一个像素的 RGB，咱们调用一下这个方法试试：

captcha = generate_captcha('1234')print(captcha, captcha.shape)

内容以下：

[[[239 244 244]  [239 244 244]  [239 244 244]  ...,   ...,   [239 244 244]  [239 244 244]  [239 244 244]]] (60, 160, 3)

能够看到它的 shape 是 (60, 160, 3)，这其实表明验证码图片的高度是 60，宽度是 160，是 60 x 160 像素的验证码，每一个像素都有 RGB 值，因此最后一维即为像素的 RGB 值。

接下来咱们须要定义 label，因为咱们须要使用深度学习模型进行训练，因此这里咱们的 label 数据最好使用 One-Hot 编码，即若是验证码文本是 1234，那么应该词表索引位置置 1，总共的长度是 40，咱们用程序实现一下 One-Hot 编码和文本的互相转换：

def text2vec(text):    """    text to one-hot vector    :param text: source text    :return: np array    """    if len(text) > CAPTCHA_LENGTH:        return False    vector = np.zeros(CAPTCHA_LENGTH * VOCAB_LENGTH)    for i, c in enumerate(text):        index = i * VOCAB_LENGTH + VOCAB.index(c)        vector[index] = 1    return vectordef vec2text(vector):    """    vector to captcha text    :param vector: np array    :return: text    """    if not isinstance(vector, np.ndarray):        vector = np.asarray(vector)    vector = np.reshape(vector, [CAPTCHA_LENGTH, -1])    text = ''    for item in vector:        text += VOCAB[np.argmax(item)]    return text

这里 text2vec() 方法就是将真实文本转化为 One-Hot 编码，vec2text() 方法就是将 One-Hot 编码转回真实文本。

例如这里调用一下这两个方法，咱们将 1234 文本转换为 One-Hot 编码，而后在将其转回来：

vector = text2vec('1234')text = vec2text(vector)print(vector, text)

运行结果以下：

[ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  1.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  1.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  1.  0.  0.  0.  0.  0.]1234

这样咱们就能够实现文本到 One-Hot 编码的互转了。

接下来咱们就能够构造一批数据了，x 数据就是验证码的 Numpy 数组，y 数据就是验证码的文本的 One-Hot 编码，生成内容以下：

import randomfrom os.path import join, existsimport pickleimport numpy as npfrom os import makedirsDATA_LENGTH = 10000DATA_PATH = 'data'def get_random_text():    text = ''    for i in range(CAPTCHA_LENGTH):        text += random.choice(VOCAB)    return textdef generate_data():    print('Generating Data...')    data_x, data_y = [], []    # generate data x and y    for i in range(DATA_LENGTH):        text = get_random_text()        # get captcha array        captcha_array = generate_captcha(text)        # get vector        vector = text2vec(text)        data_x.append(captcha_array)        data_y.append(vector)    # write data to pickle    if not exists(DATA_PATH):        makedirs(DATA_PATH)    x = np.asarray(data_x, np.float32)    y = np.asarray(data_y, np.float32)    with open(join(DATA_PATH, 'data.pkl'), 'wb') as f:        pickle.dump(x, f)        pickle.dump(y, f)

这里咱们定义了一个 getrandomtext() 方法，能够随机生成验证码文本，而后接下来再利用这个随机生成的文原本产生对应的 x、y 数据，而后咱们再将数据写入到 pickle 文件里，这样就完成了预处理的操做。

构建模型

有了数据以后，咱们就开始构建模型吧，这里咱们仍是利用 traintestsplit() 方法将数据分为三部分，训练集、开发集、验证集：

with open('data.pkl', 'rb') as f:    data_x = pickle.load(f)    data_y = pickle.load(f)    return standardize(data_x), data_ytrain_x, test_x, train_y, test_y = train_test_split(data_x, data_y, test_size=0.4, random_state=40)dev_x, test_x, dev_y, test_y, = train_test_split(test_x, test_y, test_size=0.5, random_state=40)

接下来咱们使用者三个数据集构建三个 Dataset 对象：

# train and dev datasettrain_dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y)).shuffle(10000)train_dataset = train_dataset.batch(FLAGS.train_batch_size)dev_dataset = tf.data.Dataset.from_tensor_slices((dev_x, dev_y))dev_dataset = dev_dataset.batch(FLAGS.dev_batch_size)test_dataset = tf.data.Dataset.from_tensor_slices((test_x, test_y))test_dataset = test_dataset.batch(FLAGS.test_batch_size)

而后初始化一个迭代器，并绑定到这个数据集上：

# a reinitializable iteratoriterator = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)train_initializer = iterator.make_initializer(train_dataset)dev_initializer = iterator.make_initializer(dev_dataset)test_initializer = iterator.make_initializer(test_dataset)

接下来就是关键的部分了，在这里咱们使用三层卷积和两层全链接网络进行构造，在这里为了简化写法，直接使用 TensorFlow 的 layers 模块：

# input Layerwith tf.variable_scope('inputs'):    # x.shape = [-1, 60, 160, 3]    x, y_label = iterator.get_next()keep_prob = tf.placeholder(tf.float32, [])y = tf.cast(x, tf.float32)# 3 CNN layersfor _ in range(3):    y = tf.layers.conv2d(y, filters=32, kernel_size=3, padding='same', activation=tf.nn.relu)    y = tf.layers.max_pooling2d(y, pool_size=2, strides=2, padding='same')    # y = tf.layers.dropout(y, rate=keep_prob)# 2 dense layersy = tf.layers.flatten(y)y = tf.layers.dense(y, 1024, activation=tf.nn.relu)y = tf.layers.dropout(y, rate=keep_prob)y = tf.layers.dense(y, VOCAB_LENGTH)

这里卷积核大小为 3，padding 使用 SAME 模式，激活函数使用 relu。

通过全链接网络变换以后，y 的 shape 就变成了 [batchsize, nclasses]，咱们的 label 是 CAPTCHALENGTH 个 One-Hot 向量拼合而成的，在这里咱们想使用交叉熵来计算，可是交叉熵计算的时候，label 参数向量最后一维各个元素之和必须为 1，否则计算梯度的时候会出现问题。详情参见 TensorFlow 的官方文档：https://www.tensorflow.org/apidocs/python/tf/nn/softmaxcrossentropywithlogits：

NOTE: While the classes are mutually exclusive, their probabilities need not be. All that is required is that each row of labels is a valid probability distribution. If they are not, the computation of the gradient will be incorrect.

可是如今的 label 参数是 CAPTCHALENGTH 个 One-Hot 向量拼合而成，因此这里各个元素之和为 CAPTCHALENGTH，因此咱们须要从新 reshape 一下，确保最后一维各个元素之和为 1：

y_reshape = tf.reshape(y, [-1, VOCAB_LENGTH])y_label_reshape = tf.reshape(y_label, [-1, VOCAB_LENGTH])

这样咱们就能够确保最后一维是 VOCAB_LENGTH 长度，而它就是一个 One-Hot 向量，因此各元素之和一定为 1。

而后 Loss 和 Accuracy 就好计算了：

# losscross_entropy = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits=y_reshape, labels=y_label_reshape))# accuracymax_index_predict = tf.argmax(y_reshape, axis=-1)max_index_label = tf.argmax(y_label_reshape, axis=-1)correct_predict = tf.equal(max_index_predict, max_index_label)accuracy = tf.reduce_mean(tf.cast(correct_predict, tf.float32))

再接下来执行训练便可：

# traintrain_op = tf.train.RMSPropOptimizer(FLAGS.learning_rate).minimize(cross_entropy, global_step=global_step)for epoch in range(FLAGS.epoch_num):    tf.train.global_step(sess, global_step_tensor=global_step)    # train    sess.run(train_initializer)    for step in range(int(train_steps)):        loss, acc, gstep, _ = sess.run([cross_entropy, accuracy, global_step, train_op],                                       feed_dict={keep_prob: FLAGS.keep_prob})        # print log        if step % FLAGS.steps_per_print == 0:            print('Global Step', gstep, 'Step', step, 'Train Loss', loss, 'Accuracy', acc)    if epoch % FLAGS.epochs_per_dev == 0:        # dev        sess.run(dev_initializer)        for step in range(int(dev_steps)):            if step % FLAGS.steps_per_print == 0:                print('Dev Accuracy', sess.run(accuracy, feed_dict={keep_prob: 1}), 'Step', step)

在这里咱们首先初始化 traininitializer，将 iterator 绑定到 Train Dataset 上，而后执行 trainop，得到 loss、acc、gstep 等结果并输出。

训练

运行训练过程，结果相似以下：

...Dev Accuracy 0.9580078 Step 0Dev Accuracy 0.9472656 Step 2Dev Accuracy 0.9501953 Step 4Dev Accuracy 0.9658203 Step 6Global Step 3243 Step 0 Train Loss 1.1920928e-06 Accuracy 1.0Global Step 3245 Step 2 Train Loss 1.5497207e-06 Accuracy 1.0Global Step 3247 Step 4 Train Loss 1.1920928e-06 Accuracy 1.0Global Step 3249 Step 6 Train Loss 1.7881392e-06 Accuracy 1.0...

验证集准确率 95% 以上。

测试

训练过程咱们还能够每隔几个 Epoch 保存一下模型：

# save modelif epoch % FLAGS.epochs_per_save == 0:    saver.save(sess, FLAGS.checkpoint_dir, global_step=gstep)

固然也能够取验证集上准确率最高的模型进行保存。

验证时咱们能够从新 Reload 一下模型，而后进行验证：

# load modelckpt = tf.train.get_checkpoint_state('ckpt')if ckpt:    saver.restore(sess, ckpt.model_checkpoint_path)    print('Restore from', ckpt.model_checkpoint_path)    sess.run(test_initializer)    for step in range(int(test_steps)):        if step % FLAGS.steps_per_print == 0:            print('Test Accuracy', sess.run(accuracy, feed_dict={keep_prob: 1}), 'Step', step)else:    print('No Model Found')

验证以后其准确率基本是差很少的。

若是要进行新的 Inference 的话，能够替换下 test_x 便可。

代码

以上即是使用 TensorFlow 进行验证码识别的过程，代码见：https://github.com/AIDeepLearning/CrackCaptcha。