TensorFlow验证码识别

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

验证码

首先我们来看下验证码是怎样的,这里我们使用 Python 的 captcha 库来生成即可,这个库默认是没有安装的,所以这里我们需要先安装这个库,另外我们还需要安装 pillow 库,使用 pip3 即可:

pip3 install captcha pillow

安装好之后,我们就可以用如下代码来生成一个简单的图形验证码了:

from captcha.image import ImageCaptcha
from PIL import Image

text = '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 = 4
VOCAB_LENGTH = len(VOCAB)

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

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

from PIL import Image
from captcha.image import ImageCaptcha
import numpy as np

def 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 vector


def 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 random
from os.path import join, exists
import pickle
import numpy as np
from os import makedirs

DATA_LENGTH = 10000
DATA_PATH = 'data'

def get_random_text():
    text = ''
    for i in range(CAPTCHA_LENGTH):
        text += random.choice(VOCAB)
    return text

def 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_y

train_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 dataset
train_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 iterator
iterator = 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 Layer
with 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 layers
for _ 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 layers
y = 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 就好计算了:

# loss
cross_entropy = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits=y_reshape, labels=y_label_reshape))
# accuracy
max_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))

再接下来执行训练即可:

# train
train_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 0
Dev Accuracy 0.9472656 Step 2
Dev Accuracy 0.9501953 Step 4
Dev Accuracy 0.9658203 Step 6
Global Step 3243 Step 0 Train Loss 1.1920928e-06 Accuracy 1.0
Global Step 3245 Step 2 Train Loss 1.5497207e-06 Accuracy 1.0
Global Step 3247 Step 4 Train Loss 1.1920928e-06 Accuracy 1.0
Global Step 3249 Step 6 Train Loss 1.7881392e-06 Accuracy 1.0
...

验证集准确率 95% 以上。

测试

训练过程我们还可以每隔几个 Epoch 保存一下模型:

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

当然也可以取验证集上准确率最高的模型进行保存。

验证时我们可以重新 Reload 一下模型,然后进行验证:

# load model
ckpt = 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。

崔庆才

静觅博客博主

原文发布于微信公众号 - 进击的Coder(FightingCoder)

原文发表时间:2018-02-21

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Flutter入门

Android OpenGL ES(二)-正交投影

平移矩阵和单位矩阵和类似。但是向量[x,y,z,1]前乘这个平移矩阵后的结构就是平移矩阵中定义的偏移量。

41610
来自专栏恰童鞋骚年

数据结构基础温故-5.图(中):最小生成树算法

图的“多对多”特性使得图在结构设计和算法实现上较为困难,这时就需要根据具体应用将图转换为不同的树来简化问题的求解。

17520
来自专栏数据小魔方

机器学习笔记——哑变量处理

在机器学习的特征处理环节,免不了需要用到类别型特征,这类特征进入模型的方式与一般数值型变量有所不同。

82930
来自专栏技术专栏

Python3入门机器学习(三)- matplotlib基础与简单应用

34220
来自专栏数据结构与算法

迷 宫

Description Karles 和朋友到迷宫玩耍,没想到遇上了 10000000 年一次的大洪水,好在 Karles 是一个喜 欢思考的人,他发现迷宫的地...

27560
来自专栏专知

【论文推荐】最新7篇变分自编码器(VAE)相关论文—汉语诗歌、生成模型、跨模态、MR图像重建、机器翻译、推断、合成人脸

【导读】专知内容组整理了最近七篇变分自编码器(Variational Autoencoders)相关文章,为大家进行介绍,欢迎查看! 1. Generating...

75840
来自专栏机器之心

教程 | 如何使用TensorFlow中的高级API:Estimator、Experiment和Dataset

选自Medium 作者:Peter Roelants 机器之心编译 参与:李泽南、黄小天 近日,背景调查公司 Onfido 研究主管 Peter Roelant...

81070
来自专栏瓜大三哥

基于FPGA的Canny算子设计(一)

Canny算子计算流程: 高斯滤波和Sobel算子已经在前面讲过,所以这里主要讨论非最大值抑制和滞后分割电路设计。 非最大值一直电路设计 非最大值抑制主要是对...

32070
来自专栏数值分析与有限元编程

可视化 | Tecplot作三角形单元后处理工具

对于有限元分析的后处理,除了单的信息,还包括单元信息,比如一个单元由哪些结点组成。Tecplot可以处理的单元类型有三角形单元,四边形单元,四面体单元和六面体单...

41740
来自专栏小小挖掘机

Matplotlib基础全攻略

Matplotlib是Python中最流行的绘图库,它模仿MATLAB中的绘图风格,提供了一整套与MATLAB相似的绘图API,通过API,我们可以轻松地绘制出...

42650

扫码关注云+社区

领取腾讯云代金券