验证码识别原理分析

案例数据如下所示：

分为验证码图片数据[20, 80, 3]和目标结果csv文件

 验证码图片数据有很多张，名字例如1.jpg、2.jpg；一份目标结果csv文件，有两列数据，第一列为序列号（从0开始），第二列是目标字母，如NZPP。

数据处理分析步骤：

步骤一：把验证码图片数据和目标csv数据存储成tfrecords文件

步骤二：识别验证码

1、从tfrecords读取，每一张图片有image，label。[100, 20, 80, 3]

2、建立模型，直接读取数据输入到模型中。这里我们就定义一个全连接层。

x=[100, 20*80*3]     w=[20*80*3, 26*4]     bias=[26*4]     y_predict=[100, 26*4]

3、建立损失，softmax，交叉熵

先把[100, 4]的目标值转换成one-hot编码[100, 26*4]

4、梯度下降优化

4个标签（一张图有四个字母）的交叉熵如何建立？

y_true=[None, 4*26]      y_predict=[None, 4*26]

重点注意：

求准确性的时候用到的函数tf.argmax(data值，维度)，函数表示求给定数据中的最大值的位置。那么参数中的维度值怎么给定？

在此案例中，求准确性是要用三维计算（一个样本中的四个值都为1，结果才为1），预测值和目标值的范围是[100, 4, 26]（三个值对应的维度数是0，1，2），我们肯定是需要求出每个图片的每个字母的准确性，所以是从26个值中找最大值，因此维度值=2。

完整代码

步骤一

把特征数据和目标数据存储成tfrecords文件

#! /usr/bin/env python 
# -*- coding:utf-8 -*-
"""
读取图片验证码源数据和目标csv文件，存储为tfrecords文件
验证码特征数据保存形状[6000,20,80,3]
目标数据保存形状[6000, 4]  例如：[[13,25,15,15], [22,10,7,10], [22,15,18,9],...]
"""
import tensorflow as tf

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'   # 设置告警级别

FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("tfrecords_dir", "./tfrecords/captcha.tfrecords", "验证码图片和标签的TFRecords文件路径")
tf.app.flags.DEFINE_string("captcha_dir", "../data/Genpics/", "验证码图片路径")
tf.app.flags.DEFINE_string("letter", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "验证码字符的种类")


def dealwithlabel(label_str):
    # 构建字符索引  {0:'A', 1:'B', ...}
    num_letter = dict(enumerate(list(FLAGS.letter)))

    # 键值对反转    {'A':0, 'B':1, ...}
    letter_num = dict(zip(num_letter.values(), num_letter.keys()))
    print(letter_num)

    # 构建标签的列表
    array = []

    # 给标签数据进行处理    label_str  [b'NZPP' b'WKHK' b'WPSJ' ... b'FVQJ' b'BQYA' b'BCHR']
    for string in label_str:
        letter_list = []

        # 修改编码，b'FVQJ'到字符串，并且循环找到每张验证码的字符对应的数字标记
        for letter in string.decode('utf-8'):
            letter_list.append(letter_num[letter])

        array.append(letter_list)

    # [[13,25,15,15], [22,10,7,10], [22,15,18,9],...]
    print(array)

    # 将array转换成tensor类型
    label = tf.constant(array)

    return label



def get_captcha_image():
    """
    获取验证码图片数据
    :return: image
    """
    # 构造文件名
    filename = []

    for i in range(6000):
        string = str(i) + ".jpg"
        filename.append(string)

    # 构造路径+文件
    file_list = [os.path.join(FLAGS.captcha_dir, file) for file in filename]

    # 构造文件队列    shuffle指定是否顺序和乱序
    file_queue = tf.train.string_input_producer(file_list, shuffle=False)

    # 构造阅读器
    reader = tf.WholeFileReader()

    # 读取图片数据内容
    key, value = reader.read(file_queue)

    # 解码图片数据
    image = tf.image.decode_jpeg(value)

    # 设置形状，之前的形状是[？,？,？]
    image.set_shape([20, 80, 3])

    # 批处理数据  [6000, 20, 80, 3]
    image_batch = tf.train.batch([image], batch_size=6000, num_threads=1, capacity=6000)

    return image_batch


def get_captcha_label():
    """
    读取验证码图片的标签数据
    :return: label
    """
    file_queue = tf.train.string_input_producer(["../data/Genpics/labels.csv"], shuffle=False)

    reader = tf.TextLineReader()

    key, value = reader.read(file_queue)

    # record_defaults：指定每一个样本的每一列的类型，指定默认值
    # 第一列为int，第二列为字符串
    records = [[1], ["None"]]

    number, label = tf.decode_csv(value, record_defaults=records)

    # ['NZPP' 'WKHK' 'WPSJ' ... 'FVQJ' 'BQYA' 'BCHR']
    label_batch = tf.train.batch([label], batch_size=6000, num_threads=1, capacity=6000)

    return label_batch


def write_to_tfrecords(image_batch, label_batch):
    """
    将图片内容和标签写入到tfrecords文件当中
    :param image_batch: 特征值
    :param label_batch: 目标值
    :return: None
    """
    # 转换类型
    label_batch = tf.cast(label_batch, tf.uint8)

    # 建立TFRecords存储器
    writer = tf.python_io.TFRecordWriter(FLAGS.tfrecords_dir)

    # 循环将每一个图片上的数据构造example协议块，序列化后写入
    for i in range(6000):
        # 取出第i个图片数据，转换相应类型，图片的特征值要转换成字符串形式
        image_string = image_batch[i].eval().toString()

        # 标签值，转换成整型
        label_string = label_batch[i].eval().tostring()

        # 构造协议块
        example = tf.train.Example(feature=tf.train.Features(feature={
            "image": tf.train.Feature(bytes_list=tf.train.BytesList(value=[image_string])),
            "label": tf.train.Feature(bytes_list=tf.train.BytesList(value=[label_string]))
        }))

        writer.write(example.SerializeToString())

    # 关闭文件
    writer.close()



if __name__ == '__main__':

    # 获取验证码文件当中的图片
    image_batch = get_captcha_image()

    # 获取验证码文件当中的标签
    label = get_captcha_label()

    print(image_batch, label)

    with tf.Session() as sess:

        coord = tf.train.Coordinator()

        threads = tf.train.start_queue_runners(sess=sess, coord=coord)

        # [b'NZPP' b'WKHK' b'WPSJ' ... b'FVQJ' b'BQYA' b'BCHR']
        label_str = sess.run(label)

        print(label_str)

        # 处理字符串标签到数字标签
        label_batch = dealwithlabel(label_str)
        print(label_batch)

        # 将图片数据和标签写入到tfrecords文件当中
        write_to_tfrecords(image_batch, label_batch)

        coord.request_stop()

        coord.join(threads)

步骤二

识别验证码

#! /usr/bin/env python 
# -*- coding:utf-8 -*-

import tensorflow as tf

FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("captcha_dir", "./tfrecords/captcha.tfrecords", "验证码数据的路径")
tf.app.flags.DEFINE_integer("batch_size", 100, "每批次训练的样本数")
tf.app.flags.DEFINE_integer("label_num", 4, "每个样本的目标值数量")
tf.app.flags.DEFINE_integer("letter_num", 26, "每个目标值取的字母的可能个数")

# 定义一个初始化权重的函数
def weight_variables(shape):
    w = tf.Variable(tf.random_normal(shape=shape, mean=0.0, stddev=1.0))
    return w

# 定义一个初始化偏置的函数
def bias_variables(shape):
    b = tf.Variable(tf.constant(0.0, shape=shape))
    return b


def read_and_decode():
    """
    读取验证码数据tfrecords文件
    :return: image_batch, label_batch
    """
    # 1、构建文件队列
    file_queue = tf.train.string_input_producer([FLAGS.captcha_dir])
    # 2、构建读取阅读器，默认一个样本
    reader = tf.TFRecordReader()
    # 3、读取内容
    key, value = reader.read(file_queue)
    # 4、tfrecords格式example，需要解析
    features = tf.parse_single_example(value, features={
        "image": tf.FixedLenFeature([], tf.string),
        "label": tf.FixedLenFeature([], tf.string)
    })
    # 5、解码内容，字符串内容
    image = tf.decode_raw(features["image"], tf.uint8)
    label = tf.decode_raw(features["label"], tf.uint8)

    # 6、改变形状（批处理需要固定形状）
    image_reshape = tf.reshape(image, [20, 80, 3])
    label_reshape = tf.reshape(label, [4])

    # 7、进行批处理
    image_batch, label_batch = tf.train.batch([image_reshape, label_reshape], batch_size=FLAGS.batch_size, num_threads=1, capacity=FLAGS.batch_size)

    return image_batch, label_batch


def fc_model(image):
    """
    进行预测结果
    :param image: 100个图片的特征值
    :return: y_predict预测值[100, 4*26]
    """
    with tf.variable_scope("model"):
        # 随机初始化权重和偏置
        # matrix [100,20*80*3] * [20*80*3, 4*26] + [104] = [100, 104]
        weights = weight_variables([20*80*3, 4*26])
        bias = bias_variables([4*26])

        # 将图片数据形状转换成二维形状
        image_reshape = tf.reshape(image, [-1, 20*80*3])

        # 进行全连接层计算
        y_predict = tf.matmul(tf.cast(image_reshape, tf.float32), weights) + bias

    return y_predict


def predict_to_onehot(label):
    """
    将文件中的目标值label转换成one-hot编码
    :param label: [100, 4]    [[13,25,15,15], [22,10,7,10], [22,15,18,9],...]
    :return:
    """
    # 进行one-hot编码转换，提供给交叉熵损失计算和准确率计算  [100,4]->[100,4,26]
    label_onehot = tf.one_hot(label, depth=FLAGS.letter_num, on_value=1.0, axis=2)

    return label_onehot



def captcharec():
    """
    验证码识别
    :return:
    """
    # 1、读取验证码数据tfrecords文件
    image_batch, label_batch = read_and_decode()

    # 2、通过输入图片特征数据，建立模型，得出预测结果
    # 方案：用一层全连接神经网络进行预测
    # matrix [100,20*80*3] * [20*80*3, 4*26] + [104] = [100, 104]
    y_predict = fc_model(image_batch)   # shape=[100, 104]

    # 3、先把目标值转换成one-hot编码   [100, 4, 26]
    y_true = predict_to_onehot(label_batch)

    # 4、softmax计算，交叉熵损失计算
    with tf.variable_scope("soft_cross"):
        # 求平均交叉熵损失  y_true格式转换 [100, 4, 26] -> [100, 104]
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
            labels=tf.reshape(y_true, [FLAGS.batch_size, FLAGS.label_num * FLAGS.letter_num]),
            logits=y_predict))

    # 5、梯度下降优化损失
    with tf.variable_scope("optimizer"):
        train_op = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

    # 6、求出样本的每批次预测的准确率是多少?  三维比较
    with tf.variable_scope("acc"):
        # 比较预测值和目标值的最大值位置是否一样。每个样本有四个值需要比较
        equal_list = tf.equal(tf.argmax(y_true, 2),
                              tf.argmax(tf.reshape(y_predict, [FLAGS.batch_size, FLAGS.label_num, FLAGS.letter_num]), 2))

        # 100个样本  [1,0,0,1,...]
        accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))

    # 定义一个初始化变量的op
    init_op = tf.global_variables_initializer()

    # 开启会话训练
    with tf.Session as sess:
        sess.run(init_op)

        # 定义线程协调器和开启线程（有数据在文件当中，需要读取提供给模型）
        coord = tf.train.Coordinator()
        # 开启线程去运行读取文件
        threads = tf.train.start_queue_runners(sess, coord=coord)

        # 训练识别模型
        for i in range(5000):
            sess.run(train_op)
            print("第%d批次的准确率为：%f" % (i, accuracy.eval()))

        # 回收线程
        coord.request_stop()
        coord.join(threads)



if __name__ == '__main__':
    captcharec()