精华内容
下载资源
问答
  • 人工神经网络 基于CNN卷积神经网络 基于Python 实现图片验证码识别
  • 项目封装了比较通用的校验、训练、验证、识别、API模块,极大的减少了识别字符型验证码花费的时间和精力。
  • “基于深度网络的网站验证码识别研究与实现”:主要是利用卷积神经网络,基于TensorFlow平台,构建了三层卷积两层全联接模型,训练出的一个准确率为91.3%的识别模型。再基于Django构建登陆系统,使用selenium实现...

    开发环境: Pycharm + Python3.7 + Django2.2 + sqlite数据库 + TensorFlow深度学习框架 + selenium自动化测试

    “基于深度网络的网站验证码识别研究与实现”:主要是利用卷积神经网络,基于TensorFlow平台,构建了三层卷积两层全联接模型,训练出的一个准确率为91.3%的识别模型。再基于Django构建登陆系统,使用selenium实现自动测试,完成验证码从识别到自动登录的全过程。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • captcha_input.py(读取验证码图片文件以及目标标签并保存到tfrecords文件中,图片与目标标签要一一对应): import tensorflow as tf import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 设置警告级别 # ...

     

    captcha_input.py(读取验证码图片文件以及目标标签并保存到tfrecords文件中,图片与目标标签要一一对应):

    import tensorflow as tf
    import os
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # 设置警告级别
    
    # 读取验证码图片以及目标标签数据,并存放到tfrecords文件中(图片验证码与目标标签一一对应)
    
    # 自定义命令行参数
    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):
    	# [b'NZPP', b'WKHK', b'WPSJ', ...] ---> [[13, 25, 15, 15], [22, 10, 7, 10], [22, 15, 18, 9], ...]
        
        # 构建字符索引 {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', ...]
        for string in label_str:
    
            letter_list = []  # [13, 25, 15, 15]
    
            # 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])  # 图片尺寸 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():
        """
        读取验证码图片标签数据(CSV)
        :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)
    
        # [b'NZPP' b'WKHK' b'WPSJ' ..., b'FVQJ' b'BQYA' b'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:[[13, 25, 15, 15], [22, 10, 7, 10], [22, 15, 18, 9], ...]
        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):  # 构建一个有序的文件名列表。 os.listdir()构建的文件名列表是无序的。
            # 取出第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()
    
        # 获取验证码文件当中的标签数据
        labels = get_captcha_label()
    
        print(image_batch, labels)
    
        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(labels)
    
            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)
    
            

    captcha_train.py(神经网络训练验证码):

    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, "每个样本的目标值数量")  # 验证码4位
    tf.app.flags.DEFINE_integer("letter_num", 26, "每个目标值取的字母的可能个数")  # 只有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()
    
        # 读取内容
        key, value = reader.read(file_queue)
    
        # tfrecords格式example,需要解析
        features = tf.parse_single_example(value, features={
            "image": tf.FixedLenFeature([], tf.string),
            "label": tf.FixedLenFeature([], tf.string)
        })
    
        # 解码内容,字符串内容
        # 1、先解析图片的特征值
        image = tf.decode_raw(features["image"], tf.uint8)
        # 2、再解析图片的目标值
        label = tf.decode_raw(features["label"], tf.uint8)
    
        # print(image, label)
    
        # 改变形状
        image_reshape = tf.reshape(image, [20, 80, 3])
    
        label_reshape = tf.reshape(label, [4])
    
        print(image_reshape, label_reshape)
    
        # 进行批处理,每批次读取的样本数 100, 也就是每次训练时候的样本
        image_batch, label_batch = tf.train.batch([image_reshape, label_reshape], batch_size=FLAGS.batch_size, num_threads=1, capacity=FLAGS.batch_size)
    
        print(image_batch, label_batch)
        return image_batch, label_batch
    
    
    def fc_model(image):
        """
        进行预测结果
        :param image: 100张图片特征值 [100, 20, 80, 3]
        :return: y_predict预测值 [100, 4 * 26]
        """
        with tf.variable_scope("model"):
            # 将图片数据形状转换成二维的形状
            image_reshape = tf.reshape(image, [-1, 20 * 80 * 3])
    
            # 1、随机初始化权重偏置
            # matrix[100, 20 * 80 * 3] * [20 * 80 * 3, 4 * 26] + [104] = [100, 4 * 26]
            weights = weight_variables([20 * 80 * 3, 4 * 26])
            bias = bias_variables([4 * 26])
    
            # 进行全连接层计算 [100, 4 * 26]
            y_predict = tf.matmul(tf.cast(image_reshape, tf.float32), weights) + bias
    
        return y_predict
    
    
    def predict_to_onehot(label):
        """
        将读取文件当中的目标值转换成one-hot编码
        :param label:  [[13, 25, 15, 15], [19, 23, 20, 16]......]
        :return: one-hot   [-1, 4, 26]
        """
        # 进行one_hot编码转换,提供给交叉熵损失计算,准确率计算[100, 4, 26]
        label_onehot = tf.one_hot(label, depth=FLAGS.letter_num, on_value=1.0, axis=2)
    
        print(label_onehot)
    
        return label_onehot
    
    
    def captcharec():
        """
        验证码识别程序
        :return:
        """
        # 1、读取验证码的数据文件 label_batch [100 ,4]
        image_batch, label_batch = read_and_decode()
    
        # 2、通过输入图片特征数据,建立模型,得出预测结果
        # 一层,全连接神经网络进行预测
        # matrix [100, 20 * 80 * 3] * [20 * 80 * 3, 4 * 26] + [104] = [100, 4 * 26]
        y_predict = fc_model(image_batch)
    
        #  [100, 4 * 26]
        print(y_predict)
    
        # 3、把真实目标值转换成one-hot编码  [100 ,4] --> [100, 4, 26]
        y_true = predict_to_onehot(label_batch)
    
        # 4、softmax计算, 交叉熵损失计算
        with tf.variable_scope("soft_cross"):
            # 求平均交叉熵损失 ,y_true [100, 4, 26]--->[100, 4*26]
            loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
                labels=tf.reshape(y_true, [FLAGS.batch_size, 4 * 26]),
                logits=y_predict))
    
        # 5、梯度下降优化损失
        with tf.variable_scope("optimizer"):
            train_op = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
    
        # 6、求出样本的每批次预测的准确率是多少 三维比较
        with tf.variable_scope("acc"):
    
            # 比较每个预测值和目标值是否下标位置一样(每个样本有4个位置,位置下标的列表)  y_predict [100, 4 * 26]---->[100, 4, 26]
            equal_list = tf.equal(tf.argmax(y_true, 2), tf.argmax(tf.reshape(y_predict, [FLAGS.batch_size, 4, 26]), 2))
    
            # equal_list  100个样本   [1, 0, 1, 0, 1, 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)
    
        return None
    
    
    if __name__ == "__main__":
        captcharec()
    
        

     

     

    展开全文
  • CNN卷积神经网络实现验证码识别(准确率达99%)

    万次阅读 多人点赞 2017-12-11 23:17:30
    基于python生成验证码,并用CNN进行训练识别验证码四位,如果由数字,小写字母,大写字母组成,那么cpu要跑很久很久,所以这里的验证码只包含了四位数字,一共有10*10*10*10个可能的数据。通过卷积神经模型,准确...

    CNN卷积神经网络实现验证码识别(准确率达99%)

     基于python生成验证码,并用CNN进行训练识别,验证码四位,如果由数字,小写字母,大写字母组成,那么cpu要跑很久很久,所以这里的验证码只包含了四位数字,一共有10*10*10*10个可能的数据。通过卷积神经模型,准确率达到了99%,大约迭代1200次左右,运行时间不算太长!!下面附上代码和效果图!!!!具体的细节就不介绍了,最近有点忙~~~,有问题可以评论!!!我会解答!!
    另外附上我另一个博客地址,我会尽力经常更新,因为楼主还在上学,如果比较忙的话,可能更新会慢点!点击打开链接





    import tensorflow as tf
    from captcha.image import  ImageCaptcha
    import numpy as np
    import matplotlib.pyplot as plt
    from PIL import  Image
    import random
    
    number=['0','1','2','3','4','5','6','7','8','9']
    #alphabet = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
    #ALPHABET = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
    
    def random_captcha_text(char_set=number,captcha_size=4):
        captcha_text=[]
        for i in range(captcha_size):
            c=random.choice(char_set)
            captcha_text.append(c)
        return captcha_text
    
    def gen_captcha_text_image():
        image=ImageCaptcha()
        captcha_text=random_captcha_text()
        captcha_text=''.join(captcha_text)
        captcha=image.generate(captcha_text)
        captcha_image=Image.open(captcha)
        captcha_image=np.array(captcha_image)
        return captcha_text,captcha_image
    
    
    def convert2gray(img):
        if len(img.shape)>2:
            r, g, b = img[:, :, 0], img[:, :, 1], img[:, :, 2]
            gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
            return gray
        else:
            return img
    
    
    def text2vec(text):
        text_len = len(text)
        if text_len > max_captcha:
            raise ValueError('验证码最长4个字符')
    
        vector = np.zeros(max_captcha * char_set_len)
    
        def char2pos(c):
            if c == '_':
                k = 62
                return k
            k = ord(c) - 48
            if k > 9:
                k = ord(c) - 55
                if k > 35:
                    k = ord(c) - 61
                    if k > 61:
                        raise ValueError('No Map')
            return k
    
        for i, c in enumerate(text):
            idx = i * char_set_len + char2pos(c)
            vector[idx] = 1
        return vector
    
    
    def get_next_batch(batch_size=128):
        batch_x=np.zeros([batch_size,image_height*image_width])
        batch_y=np.zeros([batch_size,max_captcha*char_set_len])
    
        def wrap_gen_captcha_text_and_image():
            while True:
                text, image = gen_captcha_text_image()
                if image.shape == (60, 160, 3):
                    return text, image
    
        for i in range(batch_size):
            text, image = wrap_gen_captcha_text_and_image()
            image = convert2gray(image)
    
            batch_x[i, :] = image.flatten() / 255
            batch_y[i, :] = text2vec(text)
    
        return batch_x, batch_y
    
    def cnn_structure(w_alpha=0.01, b_alpha=0.1):
        x = tf.reshape(X, shape=[-1, image_height, image_width, 1])
    
    
        wc1=tf.get_variable(name='wc1',shape=[3,3,1,32],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
        #wc1 = tf.Variable(w_alpha * tf.random_normal([3, 3, 1, 32]))
        bc1 = tf.Variable(b_alpha * tf.random_normal([32]))
        conv1 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, wc1, strides=[1, 1, 1, 1], padding='SAME'), bc1))
        conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
        conv1 = tf.nn.dropout(conv1, keep_prob)
    
        wc2=tf.get_variable(name='wc2',shape=[3,3,32,64],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
       # wc2 = tf.Variable(w_alpha * tf.random_normal([3, 3, 32, 64]))
        bc2 = tf.Variable(b_alpha * tf.random_normal([64]))
        conv2 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv1, wc2, strides=[1, 1, 1, 1], padding='SAME'), bc2))
        conv2 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
        conv2 = tf.nn.dropout(conv2, keep_prob)
    
        wc3=tf.get_variable(name='wc3',shape=[3,3,64,128],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
        #wc3 = tf.Variable(w_alpha * tf.random_normal([3, 3, 64, 128]))
        bc3 = tf.Variable(b_alpha * tf.random_normal([128]))
        conv3 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv2, wc3, strides=[1, 1, 1, 1], padding='SAME'), bc3))
        conv3 = tf.nn.max_pool(conv3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
        conv3 = tf.nn.dropout(conv3, keep_prob)
    
    
        wd1=tf.get_variable(name='wd1',shape=[8*20*128,1024],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
        #wd1 = tf.Variable(w_alpha * tf.random_normal([7*20*128,1024]))
        bd1 = tf.Variable(b_alpha * tf.random_normal([1024]))
        dense = tf.reshape(conv3, [-1, wd1.get_shape().as_list()[0]])
        dense = tf.nn.relu(tf.add(tf.matmul(dense, wd1), bd1))
        dense = tf.nn.dropout(dense, keep_prob)
    
        wout=tf.get_variable('name',shape=[1024,max_captcha * char_set_len],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
        #wout = tf.Variable(w_alpha * tf.random_normal([1024, max_captcha * char_set_len]))
        bout = tf.Variable(b_alpha * tf.random_normal([max_captcha * char_set_len]))
        out = tf.add(tf.matmul(dense, wout), bout)
        return out
    
    def train_cnn():
        output=cnn_structure()
        cost=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=output,labels=Y))
        optimizer=tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)
        predict=tf.reshape(output,[-1,max_captcha,char_set_len])
        max_idx_p = tf.argmax(predict, 2)
        max_idx_l = tf.argmax(tf.reshape(Y, [-1, max_captcha, char_set_len]), 2)
        correct_pred = tf.equal(max_idx_p, max_idx_l)
        accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
    
        saver=tf.train.Saver()
    
        with tf.Session() as sess:
            init = tf.global_variables_initializer()
            sess.run(init)
            step = 0
            while True:
                batch_x, batch_y = get_next_batch(100)
                _, cost_= sess.run([optimizer, cost], feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.75})
                print(step, cost_)
                if step % 10 == 0:
                    batch_x_test, batch_y_test = get_next_batch(100)
                    acc = sess.run(accuracy, feed_dict={X: batch_x_test, Y: batch_y_test, keep_prob: 1.})
                    print(step, acc)
                    if acc > 0.99:
                        saver.save(sess, "./model/crack_capcha.model", global_step=step)
                        break
                step += 1
    
    
    def crack_captcha(captcha_image):
        output = cnn_structure()
    
        saver = tf.train.Saver()
        with tf.Session() as sess:
            saver.restore(sess, "./model/crack_capcha.model-1200")
    
            predict = tf.argmax(tf.reshape(output, [-1, max_captcha, char_set_len]), 2)
            text_list = sess.run(predict, feed_dict={X: [captcha_image], keep_prob: 1.})
            text = text_list[0].tolist()
            return text
    
    if __name__=='__main__':
        train=1
        if train==0:
            text,image=gen_captcha_text_image()
            print("验证码大小:",image.shape)#(60,160,3)
    
            image_height=60
            image_width=160
            max_captcha=len(text)
            print("验证码文本最长字符数",max_captcha)
            char_set=number
            char_set_len=len(char_set)
    
            X = tf.placeholder(tf.float32, [None, image_height * image_width])
            Y = tf.placeholder(tf.float32, [None, max_captcha * char_set_len])
            keep_prob = tf.placeholder(tf.float32)
            train_cnn()
    
        if train == 1:
            image_height = 60
            image_width = 160
            char_set = number
            char_set_len = len(char_set)
    
            text, image = gen_captcha_text_image()
    
            f = plt.figure()
            ax = f.add_subplot(111)
            ax.text(0.1, 0.9, text, ha='center', va='center', transform=ax.transAxes)
            plt.imshow(image)
    
           # plt.show()
    
            max_captcha = len(text)
            image = convert2gray(image)
            image = image.flatten() / 255
    
            X = tf.placeholder(tf.float32, [None, image_height * image_width])
            Y = tf.placeholder(tf.float32, [None, max_captcha * char_set_len])
            keep_prob = tf.placeholder(tf.float32)
    
            predict_text = crack_captcha(image)
            print("正确: {}  预测: {}".format(text, predict_text))
    
    
            plt.show()
    


    以上就是代码加上效果图,如果有好的建议可以在下面评论 !!!
    展开全文
  • 首先进行文字预测,需要把文字部分从整个验证码图片中截取下来,截取函数在前面的文章中已介绍过,可以把截取函数保存为一个python文件,在这里直接导入即可,代码如下。 import json import numpy as np import ...

    模型训练好之后,就可以应用于新图片的预测了。比如现在有下面这么一张12306的验证码,预测工作也分为两部分:上半部分的文字预测、下半部分的图片预测,将两部分划分开之后分别加载各自的模型进行预测。
    在这里插入图片描述
    文字预测:需要把文字部分从整个验证码图片中截取下来,截取函数在前面的文章中已介绍过,可以把截取函数保存为一个python文件,在这里直接导入即可。
    图片预测:先把8个小图片分别截取保存下来,这些数据可以用作新模型训练的数据来源噢。用当前的模型对新数据预测并分类存储,然后利用新数据去改善旧数据的质量和数量,这样也可以提高模型的精度。
    代码如下

    import os
    import json
    import numpy as np
    from PIL import Image
    import tensorflow as tf
    from collections import defaultdict
    from tensorflow.keras import models
    from collections import defaultdict
    from split_text import judge_image_bk, split_image_text	#文本截取
    
    #在训练的时候对数据做了一些处理工作,所以在测试的时候也需要做相应的处理
    def transform_test(imgpath, flag):
        feature = tf.io.read_file(imgpath)
        feature = tf.image.decode_jpeg(feature,channels=3)
        feature = tf.image.resize(feature, [64, 64])
        feature = tf.divide(feature, 255.)
        if flag == 1:   #训练时,只对文字部分做了标准化处理
            feature = tf.image.per_image_standardization(feature)
        mean = tf.convert_to_tensor([0.485, 0.456, 0.406])
        std = tf.convert_to_tensor([0.229, 0.224, 0.225])
        feature = tf.divide(tf.subtract(feature, mean), std)
        return feature
    
    #划分下面8张小验证码图片
    def split_image(raw_image, image_shape, count, save_dir):
        crop_area = [(5, 41, 71, 107), (77, 41, 143, 107), (149, 41, 215, 107), (221, 41, 287, 107),
                     (5, 113, 71, 179), (77, 113, 143, 179), (149, 113, 215, 179), (221, 113, 287, 179)]
        if isinstance(raw_image, str):
            try:
                raw_image = Image.open(raw_image)
                lst = [raw_image.crop(region).resize(image_shape) for region in crop_area]
            except Exception as e:
                print('图片文件错误:', e.args)
                return False
        for i in range(8):
            lst[i].save(os.path.join(os.getcwd(), save_dir, 'z'+str(count+i)+'.jpg'))
        return True
    
    #第一次运行此函数会创建新文件夹,保存截取下来的图片
    def mk_dir(save_dir):
        try:
            os.mkdir(os.path.join(os.getcwd(), save_dir))
        except FileExistsError:
            pass
    
    def model_load(model_path):	#加载模型
        return models.load_model(model_path)
    
    def text_predict(captcha_path, text_save_dir):	#文本预测
        mode = judge_image_bk(captcha_path)
        name = ['a'] if mode == 1 else ['a', 'b']
        split_image_text(captcha_path, (64, 64), name, text_save_dir, mode)
        res_text = []
        for each in name:
            index = np.argmax(text_model.predict(np.expand_dims(transform_test(each + '.jpg', 1), 0))[0])
            res_text.append(dic[labels[index]])
        print('文字识别结果:', ' '.join(res_text))
        return res_text
    
    def pic_predict(captcha_path, pic_save_dir):	#图片预测
        if split_image(captcha_path, (64, 64), 1, pic_save_dir):
            res_dic = defaultdict(list)
            for j in range(1, 9):
                path = 'z' + str(j) + '.jpg'
                index = np.argmax(model_pic.predict(np.expand_dims(transform_test(path, 2), 0))[0])
                tmp = dic[labels[index]]
                res_dic[tmp].append(j)
    
            res_dic = dict(res_dic)
            print('图片识别结果:', res_dic)
            return res_dic
        return
    
    def captcha_pos(res_text, res_pic):	#获得最终的验证码位置
        res = []
        for each in res_text:
            try:
                res.extend(res_pic.get(each))
            except KeyError:
                print(each + '无匹配图片!')
        print('验证码位置:', res)
        return res
    

    以上是预测时,所需要的函数定义部分。
    下面就可以定义相关参数,然后识别验证码。

    if __name__ == '__main__':
        text_save_dir = 'text_prediction'	#保存文本图片的文件夹
        pic_save_dir = 'pic_prediction'		#保存8张小验证码图片的文件夹
        #分别创建两个文件夹
        mk_dir(text_save_dir)
        mk_dir(pic_save_dir)
    	#加载两个模型
        text_model = model_load('text_model.h5')
        model_pic = model_load('pic_model.h5')
    
        labels = ['Ants', 'Bandaid', 'Banner', 'Basketball', 'Beer', 'Boots', 'Bottleopener', 'Buscard', 'Candlestick', 'Cherry', 'Chineseknot', 'Coral', 'Cottonswab', 'Dashboard', 'DragonBoat', 'Earplugs', 'Electronicscale', 'Embroidery', 'Exhaustfan', 'Filebag', 'Flyswatter', 'Frenchfries', 'Gong', 'Jujube', 'MemorialGateway', 'Mop', 'Mungbean', 'Palmprint', 'Pyramid', 'Redbean', 'Refrigerator', 'Seagull', 'Seaweed', 'Spatula', 'Tapemeasure', 'Teacup', 'Tennisracket', 'Treadmill', 'Wallclock', 'Windchime', 'Wool', 'Wristband', 'aircraftcarrier', 'apill', 'blackboard', 'calendar', 'candle', 'chilipatse', 'clocksandwatches', 'doublefacedadhesivetape', 'firecrackers', 'funnel', 'honeybee', 'hot-waterbag', 'lion', 'lizard', 'notebook', 'palette', 'paper-cut', 'pencil-box', 'pineapple', 'plate', 'poster', 'preservedplum', 'pressurecooker', 'redwine', 'ricecooker', 'safetyhat', 'salad', 'sandbag', 'seal', 'smallbell', 'stapler', 'steamer', 'streetlamp', 'teatable', 'tiger', 'typewriter', 'whistling', 'wire']
    
        with open('en2ch.json', 'r') as f:	#加载英译中文件
            dic = json.load(f)
    
        captcha_path = 'D:/captcha/15689.jpg'	#原始验证码图片保存的路径
        #文字识别
        res_text = text_predict(captcha_path, text_save_dir)
        #图像识别
        res_pic = pic_predict(captcha_path, pic_save_dir)
    
        res = captcha_pos(res_text, res_pic)
    

    通过两部分的预测结果输出验证码的正确位置。第一排4张图片标号:1、2、3、4;第二排4张图片标号:5、6、7、8。

    最终结果如下
    在这里插入图片描述

    这样一来就可以使用自己的模型去处理12306登录时的验证码。

    展开全文
  • 这是一个基于 编写的卷积神经网络模型,简单实现的验证码识别功能。 是一款 社区中流行的验证码生成库, 项目模型的训练集以及在线测试所用到的验证码均采用该库生成。 运行环境 Ubuntu16.04 python3.5.2 virtualenv...
  • 今天我们就要用这个数据集来训练神经网络了。 学习数据集 我们拿到任何一个数据集都要先进行观察。一是我们自己要学会分辨,这样才能更有针对性的指导神经网络来分类;二是要看我们要处理的问题的复杂度,这样也是...
  • Keras 识别验证码

    2019-10-02 18:41:10
    本项目会通过 Keras 搭建一个深度卷积神经网络识别 captcha 验证码,建议使用显卡来运行该项目。 下面的可视化代码都是在 jupyter notebook 中完成的,如果你希望写成 python 脚本,稍加修改即可正常运行,当然也...
  • 用自己训练的数据跑tesseract识别验证码,最后附上正确率 1、使用现成的工具jTessBoxEditor,和tesseract,都是已经写好的工具,不需要再造轮子(尤其是从头学深度学习让你造一个神经网络写完就已经半年后了,还不...
  • 验证码图片的识别,不论是使用传统的ORC技术,还是使用统计机器学习或者是使用深度学习神经网络,都少不了从网络上采集大量相关的验证码图片做数据集样本来进行训练。 采集验证码图片,可以直接使用Python进行批量...
  • 验证码图片的识别,不论是使用传统的ORC技术,还是使用统计机器学习或者是使用深度学习神经网络,都少不了从网络上采集大量相关的验证码图片做数据集样本来进行训练。 采集验证码图片,可以直接使用Python进行...
  • 在本次项目中,使用 Tensorflow 框架将卷积神经网络应用于验证码的特征提取及识别上,利用 Python 中的 Captcha 库随机生成具有"数字"、"大写英文字母"及"小写英文字母"的多字符类型验证码样本,用于卷积神经网络...
  • 近年来,机器学习变得愈加火热,中国选手柯洁与AlphaGo的人机大战更是引起热议。目前,在图像识别和视觉分析研究中,卷积...最近我也在自学Tensorflow,想通过卷积神经网络快速识别整块验证码(不分割字符)。期间...
  • 最近新冠肺炎肆虐,已在家办公三周左右,闲来无聊,来写一篇最近用到的卷积神经网络训练模型来识别图片验证码的blog。 最近在做一个网络爬虫的项目,爬取官方网站上的信息,需要输入查询内容及图片验证码上边的1-9及...
  • 识别验证码现在网上有大量的案例,因为python可以使用 from captcha.image import ImageCaptcha 来生成验证码。 生成的验证码样例如下: 验证码的噪声简单且训练集可以无限次生成的情况下,识别验证码就非常容易...
  • 【前言】几天研究验证码解决方案有三种吧。第一、手工输入,即保存图片后然后我们手工输入;...目标是得到去噪后的二值图片,然后使用深度学习神经网络方法进行识别。  2、第一次尝试了用谷歌的开源t...
  • pytorch识别验证码.zip

    2020-02-08 21:52:24
    使用pytorch识别验证码中的数字,验证码为python自带库ImageCaptcha生成的数字验证码。使用LeNeT-5多层神经网络,尝试了学习率退火、激活函数Sigmoid改为ReLU、BN算法归一化等策略,识别精确度大约稳定在90%左右。
  • 随着人工智能的兴起,在计算机视觉(CV)领域上也有重大的突破进展...基于神经网络识别图像中的字母,从而去自动识别验证码。在PycharmIDE,用Python进行数据采集、数据处理、图像识别,并运用网络迭代计算来破解验证码。
  • @shugelee 同学突然来了兴致搞验证码识别,问到我的时候我记起自己做过一点点东西,特发上来给他参考,并趁机补充了一下《Python也可以》系列。 图像预处理 使用下图(后方称为 SAMPLE_BMP)作为训练和测试
  • 数据集是神经网络训练的必要准备。 一个好的数据集,比一个好的网络更为重要。 本文为生成验证码识别网络数据集 代码下载地址: https://download.csdn.net/download/weixin_44754046/11200446 (运行环境: python3...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 文章目录freetype库使用介绍使用freetype库生成不定长验证码使用LSTM神经网络+CTC loss识别freetype库生成的不定长验证码 freetype库使用介绍 freetype为字体字库提供了一套解决方案,支持文字字体渲染等操作,...
  •  TensorFlow是Google开发的一款神经网络Python外部的结构包, 也是一个采用数据流图来进行数值计算的开源软件库.TensorFlow 让我们可以先绘制计算结构图, 也可以称是一系列可人机交互的计算操作, 然后把编辑好的...
  • 最近一段时间刚忙完上线,好不容易闲下来就继上篇《基于Windows10 x64+visual Studio2013+Python2.7.12环境下的Caffe配置学习》文章,记录下利用caffe进行中文验证码图片识别的开发过程。由于这里主要介绍开发和实现...

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

python神经网络识别验证码

python 订阅