tensorflow 验证码识别

原文http://blog.topspeedsnail.com/archives/10858

gen_captcha.py 生成验证码图片及标签（源数据）

from captcha.image import ImageCaptcha  # pip install captcha
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']
# 验证码一般都无视大小写；验证码长度4个字符
def random_captcha_text(char_set=alphabet, captcha_size=5):
    captcha_text = []
    for i in range(captcha_size):
        c = random.choice(char_set)
        captcha_text.append(c)
    return captcha_text
 
# 生成字符对应的验证码
def gen_captcha_text_and_image():
    image = ImageCaptcha()
 
    captcha_text = random_captcha_text()
    captcha_text = ''.join(captcha_text)
 
    captcha = image.generate(captcha_text)
    # image.write(captcha_text, captcha_text + '.jpg')  # 写到文件

    captcha_image = Image.open(captcha)
    captcha_image=captcha_image.resize((120,40),Image.ANTIALIAS)
    # captcha_image.save(captcha_text+ '-2.jpg')
    captcha_image = np.array(captcha_image)  #[120,40,3]
    return captcha_text, captcha_image   #str,array([120,40,3])
 
if __name__ == '__main__':
    # 测试
    text, image = gen_captcha_text_and_image()
 
    plt.imshow(image)
    plt.title(text)
    plt.show()

　　train_captcha.py 定义辅助函数及模型，训练。

from gen_captcha import gen_captcha_text_and_image
from gen_captcha import number
from gen_captcha import alphabet
from gen_captcha import ALPHABET
 
import numpy as np
import tensorflow as tf
 
text, image = gen_captcha_text_and_image()
print("验证码图像channel:", image.shape)  # (60, 160, 3)
# 图像大小
IMAGE_HEIGHT = 40
IMAGE_WIDTH = 120
MAX_CAPTCHA = len(text)
print("验证码文本最长字符数", MAX_CAPTCHA)   # 验证码最长4字符; 我全部固定为4,可以不固定. 如果验证码长度小于4，用'_'补齐
 
# 把彩色图像转为灰度图像（色彩对识别验证码没有什么用）
def convert2gray(img):
    if len(img.shape) > 2:
        #对最后一维求平均值
        gray = np.mean(img, -1)
        # 上面的转法较快，正规转法如下
        # r, g, b = img[:,:,0], img[:,:,1], img[:,:,2]
        # gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
        return gray
    else:
        return img
 
"""
cnn在图像大小是2的倍数时性能最高, 如果你用的图像大小不是2的倍数，可以在图像边缘补无用像素。
np.pad(image,((2,3),(2,2)), 'constant', constant_values=(255,))  # 在图像上补2行，下补3行，左补2行，右补2行
"""
 
# 文本转向量
char_set =alphabet 
CHAR_SET_LEN = len(char_set) #26
def text2vec(text):
    text_len = len(text)
    if text_len > MAX_CAPTCHA:
        raise ValueError('验证码最长5个字符')
 
    vector = np.zeros(MAX_CAPTCHA*CHAR_SET_LEN)#5*26
    def char2pos(c):
        if c =='_':
            k = 62
            return k
        #ord() 返回 对应的 ASCII 数值，或者 Unicode 数值
        k = ord(c)-97
        return k
    for i, c in enumerate(text):
        idx = i * CHAR_SET_LEN + char2pos(c)
        vector[idx] = 1
    return vector #[5*26] 一维矩阵
# 向量转回文本
def vec2text(vec):
    #np.nonzero()返回矩阵中非零元素的 索引集
    char_pos = vec.nonzero()[0] #索引集 ，长度为5
    text=[]
    for i, c in enumerate(char_pos):
        char_at_pos = i #c/63
        char_idx = c % CHAR_SET_LEN
        char_code = char_idx + ord('a')
        
        text.append(chr(char_code))
    return "".join(text)
 
"""
#向量（大小MAX_CAPTCHA*CHAR_SET_LEN）用0,1编码 每63个编码一个字符，这样顺利有，字符也有

"""
 
# 生成一个训练batch
def get_next_batch(batch_size=128):
    batch_x = np.zeros([batch_size, IMAGE_HEIGHT*IMAGE_WIDTH]) #[128,40*120]
    batch_y = np.zeros([batch_size, MAX_CAPTCHA*CHAR_SET_LEN]) #[128,5*26]
 
    # 有时生成图像大小不是(40, 120, 3)
    def wrap_gen_captcha_text_and_image():
        while True:
            text, image = gen_captcha_text_and_image()  #str,array([40,120,3])
            if image.shape == (40, 120, 3):
                return text, image
 
    for i in range(batch_size): #128
        text, image = wrap_gen_captcha_text_and_image() #str,array([40,120,3])
        image = convert2gray(image) #[40,120]
        #将数组展为 一维
        batch_x[i,:] = image.flatten() / 255 # (image.flatten()-128)/128  mean为0 ,[128,40*120]  [128,4800]
        batch_y[i,:] = text2vec(text)     #[130]                           #[128，5*26=130] ，【128，130】 
        # print("batch x,y :",batch_x.shape,batch_y.shape)
    return batch_x, batch_y
 
####################################################################
 
X = tf.placeholder(tf.float32, [None, IMAGE_HEIGHT*IMAGE_WIDTH]) #【？，40*120】  
Y = tf.placeholder(tf.float32, [None, MAX_CAPTCHA*CHAR_SET_LEN]) #【？，5*26】
keep_prob = tf.placeholder(tf.float32) # dropout
 
# 定义CNN
def crack_captcha_cnn(w_alpha=0.01, b_alpha=0.1):
    x = tf.reshape(X, shape=[-1, IMAGE_HEIGHT, IMAGE_WIDTH, 1])#【64，40，120，1】            【60*160】
    # 3 conv layer
    #tf.random_normal(shape),按正太分布生成随机值，构成shap数组（张量）
    w_c1 = tf.Variable(w_alpha*tf.random_normal([3, 3, 1, 32])) 
    b_c1 = tf.Variable(b_alpha*tf.random_normal([32]))
    #tf.nn.relu()将矩阵中的每行中非最大值置0， tf.nn.bias_add(value,bias)将一维向量bias，与矩阵value中的每一行对应分量相加
    #tf.nn.conv2d(value,filter,strides) value是待卷积的数据，filter是卷积核【height,width,in_channels,out_channels】,out_channels即映射通过的卷积核的个数，w_c1则表示会通过32次【3，3，1】的卷积核
    #SAME模式就是将滑动窗口与矩阵进行左对齐，然后向右滑动。一直滑到与矩阵最右边那一列不相交为止。
    conv1 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, w_c1, strides=[1, 1, 1, 1], padding='SAME'), b_c1))#【64,40，120,32】   【60，160，32】
    #tf.nn.max_pool(value,ksize,strides)池化与卷积的过程原理基本一样，ksize池化窗【batch,height,width,channels】,
    #只是卷积改变的是height,width,channels,池化通常改变的是height,width 
    conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') #[64,20,60,32]         【
    #tf.nn.dropout()用于在训练时，以某种概率暂不启用一部分神经元
    conv1 = tf.nn.dropout(conv1, keep_prob)
    #
    w_c2 = tf.Variable(w_alpha*tf.random_normal([3, 3, 32, 64]))
    b_c2 = tf.Variable(b_alpha*tf.random_normal([64]))
    conv2 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv1, w_c2, strides=[1, 1, 1, 1], padding='SAME'), b_c2)) #[64,20,60,64]
    conv2 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')#[64,10,30,64]
    conv2 = tf.nn.dropout(conv2, keep_prob)
 
    w_c3 = tf.Variable(w_alpha*tf.random_normal([3, 3, 64, 64]))
    b_c3 = tf.Variable(b_alpha*tf.random_normal([64]))
    conv3 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv2, w_c3, strides=[1, 1, 1, 1], padding='SAME'), b_c3))#[64,10,30,64]
    conv3 = tf.nn.max_pool(conv3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')#[64,5,15,64]
    conv3 = tf.nn.dropout(conv3, keep_prob)
 
    # Fully connected layer
    w_d = tf.Variable(w_alpha*tf.random_normal([40*120, 1024]))
    b_d = tf.Variable(b_alpha*tf.random_normal([1024]))
    #tensor.get_shape().as_list()返回这个tensor的形状以列表的形式, reshape()中的-1表示自动计算这个轴的元素个数
    dense = tf.reshape(conv3, [-1, w_d.get_shape().as_list()[0]])#【-1，10240】 [30,10240]
    #tf.matmul矩阵乘法，sum(行*列)作为结果矩阵的对应坐标的元素，tf.add()，矩阵每个元素加上对应值
    dense = tf.nn.relu(tf.add(tf.matmul(dense, w_d), b_d))#【30，1024】，

    dense = tf.nn.dropout(dense, keep_prob)
 
    w_out = tf.Variable(w_alpha*tf.random_normal([1024, MAX_CAPTCHA*CHAR_SET_LEN]))#【1024，5*26】
    b_out = tf.Variable(b_alpha*tf.random_normal([MAX_CAPTCHA*CHAR_SET_LEN]))#【5*26】
    out = tf.add(tf.matmul(dense, w_out), b_out)#【-1，5*26】 【30，130】
    #out = tf.nn.softmax(out)
    return out

# 训练
def train_crack_captcha_cnn():
    output = crack_captcha_cnn()
 
    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()
    # loss
    # print("output",output.shape,",Y",Y.shape)
    #loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=Y))
    loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=output, labels=Y))#output (?, 130) ,Y (64, 130)
    # print("loss:",loss,loss.shape)
    # 最后一层用来分类的softmax和sigmoid有什么不同？
    # optimizer 为了加快训练 learning_rate应该开始大，然后慢慢衰
    optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        # sess.run(tf.initialize_all_variables())
        step = 0
        while True:
            batch_x, batch_y = get_next_batch(64)
            # print("batch_x:",batch_x.shape,",batch_y:",batch_y.shape)

            _, loss_ = sess.run([optimizer, loss], feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.75})
            print(step, loss_)
            
            # 每100 step计算一次准确率
            if step % 100 == 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:",step, acc)
                # 如果准确率大于50%,保存模型,完成训练
                saver.save(sess, "e://code//python//test//package_test//model.ckpt", global_step=step)
                if acc > 0.5:
                    break
 
            step += 1


def tarin_again():
    output = crack_captcha_cnn()
    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))
    loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=output, labels=Y))#output (?, 130) ,Y (64, 130)
    optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
  #saver = tf.train.Saver()
    with tf.Session() as sess:
        new_saver=tf.train.import_meta_graph('checkout\\model.ckpt-3500.meta')
        new_saver.restore(sess,"E://Code//python//test//package_test//checkout//./model.ckpt-3500")
        sess.run(tf.global_variables_initializer())
        step = 0
        while True:
            batch_x, batch_y = get_next_batch(64)
            _, loss_ = sess.run([optimizer, loss], feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.75})
            print(step, loss_)
            
            # 每100 step计算一次准确率
            if step % 200 == 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:",step, acc)
                # 如果准确率大于50%,保存模型,完成训练
                new_saver.save(sess, "e://code//python//test//package_test//checkout/model.ckpt", global_step=step)
                if acc > 0.95:
                    print("step:",step, acc)
                    if acc>0.98
                        print("step:",step, acc)
                        break
     
            step += 1


if __name__=='__main__':
    # train_crack_captcha_cnn()
　　tarin_again()

　　

test_captcha.py 使用模型识别验证码

from train_captcha import crack_captcha_cnn,convert2gray,gen_captcha_text_and_image,X,keep_prob,vec2text
import tensorflow as tf
import numpy as np 
def crack_captcha(captcha_image):
    output = crack_captcha_cnn()
 
  #saver = tf.train.Saver()
    with tf.Session() as sess:
        new_saver=tf.train.import_meta_graph('checkout\\model.ckpt-3500.meta')
        new_saver.restore(sess,"E://Code//python//test//package_test//checkout//./model.ckpt-3500")
        sess.run(tf.global_variables_initializer())
        predict = tf.argmax(tf.reshape(output, [-1, 5, 26]), 2)

        text_list = sess.run(predict, feed_dict={X: [captcha_image], keep_prob: 1})

        text = text_list[0].tolist()
        vector = np.zeros(5*26)
        i = 0
        for n in text:
              vector[i*26 + n] = 1
              i += 1
        return vec2text(vector)

if __name__=='__main__':
    # train_crack_captcha_cnn()
    for i in range(100):
        text, image = gen_captcha_text_and_image()
        image = convert2gray(image)
        image = image.flatten() / 255
        predict_text = crack_captcha(image)
        if text==predict_text:
            print("{} 正确: {}  预测: {}".format(i,text, predict_text))