• (第三章)TF框架之实现验证码识别


    这里实现一个用神经网络(卷积神经网络也可以)实现验证码识别的小案例,主要记录本人做这个案例的流程,不会像之前那么详细,主要用作个人记录用。。。

      • 这里是验证码的四个字母,被one-hot编码后形成的四个一维数组,[1, 26] * 4 ----> 可以转变成[4, 26] ----> [1, 104]
      • 第一个位置:[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]

      • 第二个位置:[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]

      • 第三个位置:[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]

      • 第四个位置:[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]

    • 字母验证码识别设计:

      • 这两个(真实值和预测值)104的一阶张量进行交叉熵损失计算,得出损失大小。会提高四个位置的概率,使得4组中每组26个目标值中为1的位置对应的预测概率值越来越大,在预测的四组当中概率值最大。这样得出预测中每组的字母位置。所有104个概率相加为1

    • 流程设计

      • 1、把图片的特征值和目标值,-----> 转换成tfrecords格式,方便数据特征值、目标值统一读取

        • [b'NZPP' b'WKHK' b'WPSJ' ..., b'FVQJ' b'BQYA' b'BCHR'] -----> [[13, 25, 15, 15], [22, 10, 7, 10], [22, 15, 18, 9], [16, 6, 13, 10]]

        • "ABCD……Z" —>"0, 1, …, 25"

      • 2、训练验证码、准确率的计算

    将原来的图片数据(特征)和csv数据(标签)------> 转变为tfrecords格式的数据,注意example协议(序列化后)

    代码如下:

    import tensorflow as tf
    import os
    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 = []
    
        # 给标签数据进行处理[[b"NZPP"], ......]
        for string in label_str:
    
            letter_list = []# [1,2,3,4]
    
            # 修改编码,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], [16, 6, 13, 10], [1, 0, 8, 17], [0, 9, 24, 14].....]
        print(array)
    
        # 将array转换成tensor类型
        label = tf.constant(array)
    
        return label
    
    
    def get_captcha_image():
        """
        获取验证码图片数据
        :param file_list: 路径+文件名列表
        :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]
    
        # 构造文件队列
        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)
    
        records = [[1], ["None"]]
    
        number, label = tf.decode_csv(value, record_defaults=records)
    
        # [["NZPP"], ["WKHK"], ["ASDY"]]
        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)
    
        print(label_batch)
    
        # 建立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(features=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()
    
        return None
    
    
    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)
    • 训练验证码,得到准确率的代码
    import tensorflow as tf
    
    
    class CaptchaIdentification(object):
        """
        验证码的读取数据、网络训练
        """
        def __init__(self):
    
            # 验证码图片的属性
            self.height = 20
            self.width = 80
            self.channel = 3
            # 每个验证码的目标值个数(4个字符)
            self.label_num = 4
            self.feature_num = 26
    
            # 每批次训练样本个数
            self.train_batch = 100
    
        @staticmethod
        def weight_variables(shape):
            w = tf.Variable(tf.random_normal(shape=shape, mean=0.0, stddev=0.1))
            return w
    
        @staticmethod
        def bias_variables(shape):
            b = tf.Variable(tf.random_normal(shape=shape, mean=0.0, stddev=0.1))
            return b
    
        def read_captcha_tfrecords(self):
            """
            读取验证码特征值和目标值数据
            :return:
            """
            # 1、构造文件的队列
            file_queue = tf.train.string_input_producer(["./tfrecords/captcha.tfrecords"])
    
            # 2、tf.TFRecordReader 读取TFRecords数据
            reader = tf.TFRecordReader()
    
            # 单个样本数据
            key, value = reader.read(file_queue)
    
            # 3、解析example协议
            feature = tf.parse_single_example(value, features={
                "image": tf.FixedLenFeature([], tf.string),
                "label": tf.FixedLenFeature([], tf.string)
            })
    
            # 4、解码操作、数据类型、形状
            image = tf.decode_raw(feature["image"], tf.uint8)
            label = tf.decode_raw(feature["label"], tf.uint8)
    
            # 确定类型和形状
            # 图片形状 [20, 80, 3]
            # 目标值 [4]
            image_reshape = tf.reshape(image, [self.height, self.width, self.channel])
            label_reshape = tf.reshape(label, [self.label_num])
    
            # 类型
            image_type = tf.cast(image_reshape, tf.float32)
            label_type = tf.cast(label_reshape, tf.int32)
    
            # 5、 批处理
            # print(image_type, label_type)
            # 提供每批次多少样本去进行训练
            image_batch, label_batch = tf.train.batch([image_type, label_type],
                                                       batch_size=self.train_batch,
                                                       num_threads=1,
                                                       capacity=self.train_batch)
            print(image_batch, label_batch)
            return image_batch, label_batch
    
        def captcha_model(self, image_batch):
            """
            建立全连接层网络
            :param image_batch: 验证码图片特征值
            :return: 预测结果
            """
            # 全连接层
            # [100, 20, 80, 3] --->[100, 20 * 80 * 3]
            # [100, 20 * 80 * 3] * [20 * 80 * 3, 104] + [104] = [None, 104] 104 = 4*26
            with tf.variable_scope("captcha_fc_model"):
                # 初始化权重和偏置参数
                self.weight = self.weight_variables([20 * 80 * 3, 104])
    
                self.bias = self.bias_variables([104])
    
                # 4维---->2维做矩阵运算
                x_reshape = tf.reshape(image_batch, [self.train_batch, 20 * 80 * 3])
    
                # [self.train_batch, 104]
                y_predict = tf.matmul(x_reshape, self.weight) + self.bias
    
            return y_predict
    
        def loss(self, y_true, y_predict):
            """
            建立验证码4个目标值的损失
            :param y_true: 真实值
            :param y_predict: 预测值
            :return: loss
            """
            with tf.variable_scope("loss"):
                # 先进行网络输出的值的概率计算softmax,在进行交叉熵损失计算
                # y_true:[100, 4, 26]------>[None, 104]
                # y_predict:[100, 104]
                y_reshape = tf.reshape(y_true,
                                       [self.train_batch, self.label_num * self.feature_num])
    
                all_loss = tf.nn.softmax_cross_entropy_with_logits(labels=y_reshape,
                                                                   logits=y_predict,
                                                                   name="compute_loss")
                # 求出平均损失
                loss = tf.reduce_mean(all_loss)
    
            return loss
    
        def turn_to_onehot(self, label_batch):
            """
            目标值转换成one_hot编码
            :param label_batch: 目标值 [None, 4]
            :return:
            """
            with tf.variable_scope("one_hot"):
    
                # [None, 4]--->[None, 4, 26]
                y_true = tf.one_hot(label_batch,
                                    depth=self.feature_num,
                                    on_value=1.0)
            return y_true
    
        def sgd(self, loss):
            """
            梯度下降优化损失
            :param loss:
            :return: train_op
            """
            with tf.variable_scope("sgd"):
    
                train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    
            return train_op
    
        def acc(self, y_true, y_predict):
            """
            计算准确率
            :param y_true: 真实值
            :param y_predict: 预测值
            :return: accuracy
            """
            with tf.variable_scope("acc"):
    
                # y_true:[None, 4, 26]
                # y_predict:[None, 104]
                y_predict_reshape = tf.reshape(y_predict, [self.train_batch, self.label_num, self.feature_num])
    
                # 先对最大值的位置去求解  这里的2指的是维度
                euqal_list = tf.equal(tf.argmax(y_true, 2), tf.argmax(y_predict_reshape, 2))
    
                # 需要对每个样本进行判断  这里的1指的是维度
                #  x = tf.constant([[True,  True], [False, False]])
                #  tf.reduce_all(x, 1)  # [True, False]
                accuracy = tf.reduce_mean(tf.cast(tf.reduce_all(euqal_list, 1), tf.float32))
    
            return accuracy
    
        def train(self):
            """
            模型训练逻辑
            :return:
            """
            # 1、通过接口获取特征值和目标值
            # image_batch:[100, 20, 80, 3]
            # label_batch: [100, 4]
            # [[13, 25, 15, 15], [22, 10, 7, 10]]
            image_batch, label_batch = self.read_captcha_tfrecords()
    
            # 2、建立验证码识别的模型
            # 全连接层神经网络
            # y_predict [100, 104]
            y_predict = self.captcha_model(image_batch)
    
            # 转换label_batch 到one_hot编码
            # y_true:[None, 4, 26]
            y_true = self.turn_to_onehot(label_batch)
    
            # 3、利用真实值和目标值建立损失
            loss = self.loss(y_true, y_predict)
    
            # 4、对损失进行梯度下降优化
            train_op = self.sgd(loss)
    
            # 5、计算准确率
            accuracy = self.acc(y_true, y_predict)
    
            # 会话训练
            with tf.Session() as sess:
    
                sess.run(tf.global_variables_initializer())
    
                # 生成线程的管理
                coord = tf.train.Coordinator()
    
                # 指定开启子线程去读取数据
                threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    
                # 循环训练打印结果
                for i in range(1000):
    
                    _, acc_run = sess.run([train_op, accuracy])
    
                    print("第 %d 次训练的准确率为:%f " % (i, acc_run))
    
                # 回收线程
                coord.request_stop()
    
                coord.join(threads)
    
            return None
    
    
    if __name__ == '__main__':
        ci = CaptchaIdentification()
        ci.train()
  • 相关阅读:
    JavaScript闭包基本概念
    JavaScript函数
    JavaScript类型比较
    Java思维导图之Class对象
    Python进阶之装饰器
    Java IO学习要点导图
    sl003完全平方数
    sl002个税计算
    sl001数字拼接
    装饰器
  • 原文地址:https://www.cnblogs.com/kongweisi/p/11067782.html
Copyright © 2020-2023  润新知