软件工程学习进度第七周暨暑期学习进度之第七周汇总

本周的学习重心依旧是深度学习，主要实践项目为基于TensorFlow深度学习框架的字母、数字组成的验证码识别。在上周进行了mnist手写数字识别之后，本以为验证码识别是一件很简单的事，但实践起来发现并不是那么回事，首先在训练量上，手写数字识别的识别类型只有0-9十个数字十种类型，且仅有一个手写数字参与识别，而验证码识别的识别类型有字母+数字共26+26+10=62种，且每次有四个字符参与识别，即，每次可能的结果有62的4次方 种。再然后就是数据集，手写数字有TensorFlow入门级的mnist数据集，网上有现成的可以直接下载使用，而验证码则没有一套专门的数据集，再加上验证码图片大小的不一致性，给数据集的处理又增加了难度。

训练神经网络的验证码数据集由代码生成，由于数量过多没有保存数据集文件，只保存了训练好的神经网络模型（本意是将识别准确率提高到98%以上，但实践中发现达到92%都很难，在训练时间达到十个小时的时候识别准确率在87%左右，在训练时间达到十九个小时的时候识别准确率仍在88%左右徘徊，并且很少出现90%+的情况，时间问题在准确率出现92.25%时停止了训练，共训练52000次，每次64个验证码数据被喂入）

 

由于网上没有验证码的数据集，所以参考了百度生成验证码图片的博文，几乎所有博文都用的相同方法生成数据集，在此不具体列出链接

另参考腾讯视频TensorFlow相关课程

 

程序源码如下：

import tensorflow as tf
from captcha.image import ImageCaptcha
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import os
import tkinter.filedialog
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+alphabet+ALPHABET, captcha_size=4):
# 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

# 生成验证码图片，返回图片转化后的numpy数组，以及验证码字符文本
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.convert('L')
    captcha_image = captcha_image.point(lambda i: 255 - i)
    # 将图片取反，黑色变为白色，白色变为黑色，这样模型收敛更块
    captcha_image = np.array(captcha_image)
    return captcha_text, captcha_image

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 vec2text(vec):
    char_pos = vec.nonzero()[0]
    text = []
    for i, c in enumerate(char_pos):
        char_at_pos = i  # c/63
        char_idx = c % CHAR_SET_LEN
        if char_idx < 10:
            char_code = char_idx + ord('0')
        elif char_idx < 36:
            char_code = char_idx - 10 + ord('A')
        elif char_idx < 62:
            char_code = char_idx - 36 + ord('a')
        elif char_idx == 62:
            char_code = ord('_')
        else:
            raise ValueError('error')
        text.append(chr(char_code))
    return "".join(text)

def get_next_batch(batch_size=64):
    batch_x = np.zeros([batch_size, IMAGE_HEIGHT * IMAGE_WIDTH])
    batch_y = np.zeros([batch_size, MAX_CAPTCHA * CHAR_SET_LEN])

    # 有时生成图像大小不是（60,160,3）
    def wrap_get_label_and_image():
        # 获取一张图，判断其是否符合（60,160,3）
        while True:
            text, image = gen_captcha_text_and_image()
            if image.shape == (60, 160, 3):
                return text, image

    for i in range(batch_size):
        text, image = gen_captcha_text_and_image()
        batch_x[i, :] = image.flatten()  # 将二维数组拉平为一维
        batch_y[i, :] = text2vec(text)

    return batch_x, batch_y

# 把彩色图像转为灰度图像（色彩对识别验证码没有什么用）
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

def crack_captcha_cnn(w_alpha=0.01, b_alpha=0.1):
    x = tf.reshape(X, shape=[-1, IMAGE_HEIGHT, IMAGE_WIDTH, 1])

    # 第一层卷积-池化
    w_c1 = tf.Variable(tf.random_normal([3, 3, 1, 32], stddev=w_alpha))
    b_c1 = tf.Variable(tf.random_normal([32], stddev=b_alpha))
    conv1 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, w_c1, strides=[1, 1, 1, 1], padding='SAME'), b_c1))
    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)

    # 第二层卷积-池化
    w_c2 = tf.Variable(tf.random_normal([3, 3, 32, 64], stddev=w_alpha))
    b_c2 = tf.Variable(tf.random_normal([64], stddev=b_alpha))
    conv2 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv1, w_c2, strides=[1, 1, 1, 1], padding='SAME'), b_c2))
    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)

    # 第三层卷积-池化
    w_c3 = tf.Variable(tf.random_normal([3, 3, 64, 64], stddev=w_alpha))
    b_c3 = tf.Variable(tf.random_normal([64], stddev=b_alpha))
    conv3 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv2, w_c3, strides=[1, 1, 1, 1], padding='SAME'), b_c3))
    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)

    # 全连层
    w_d = tf.Variable(tf.random_normal([8 * 32 * 40, 1024], stddev=w_alpha))
    b_d = tf.Variable(tf.random_normal([1024], stddev=b_alpha))
    dense = tf.reshape(conv3, [-1, w_d.get_shape().as_list()[0]])
    dense = tf.nn.relu(tf.add(tf.matmul(dense, w_d), b_d))
    dense = tf.nn.dropout(dense, keep_prob)

    # 输出层
    w_out = tf.Variable(tf.random_normal([1024, MAX_CAPTCHA * CHAR_SET_LEN], stddev=w_alpha))
    b_out = tf.Variable(tf.random_normal([MAX_CAPTCHA * CHAR_SET_LEN], stddev=b_alpha))
    out = tf.add(tf.matmul(dense, w_out), b_out)
    return out

def train_crack_captcha_cnn():
    output = crack_captcha_cnn()
    # loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(output, Y))
    loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=output, labels=Y))
    # 最后一层用来分类的softmax和sigmoid，可以自己选择
    # optimizer 为了加快训练 learning_rate应该开始大，然后慢慢衰
    optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

    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:
        sess.run(tf.global_variables_initializer())

        step = 0
        while True:
            batch_x, batch_y = get_next_batch(64)
            sess.run(optimizer, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
            # 每10 step计算一次准确率
            if step % 10 == 0:
                batch_x_test, batch_y_test = get_next_batch(100)
                acc, loss_ = sess.run([accuracy, loss], feed_dict={X: batch_x_test, Y: batch_y_test, keep_prob: 0.8})
                print("step=%d, loss=%g, acc=%g"%(step, loss_, acc))
                saver.save(sess, "./model/crack_capcha1.model", global_step=step)
                # 如果准确率大于98%,保存模型,完成训练
                if acc > 0.9:
                    saver.save(sess, "./model/crack_capcha.model", global_step=step)
                    break
            step += 1



def crack_captcha(captcha_image):
   output = crack_captcha_cnn()

   saver = tf.train.Saver()
   with tf.Session() as sess:
      saver.restore(sess, r"F:pyProgramverification_codemodelcrack_capcha1.model-52000")

      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_list = sess.run(predict, feed_dict={X: [captcha_image]})

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

if __name__ == '__main__':
    # 图像大小
    IMAGE_HEIGHT = 60
    IMAGE_WIDTH = 160
    MAX_CAPTCHA = 4
    print("验证码文本字符数", MAX_CAPTCHA)
    char_set = number + alphabet + ALPHABET
    # 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)  # dropout

    # train_crack_captcha_cnn()
    root = tkinter.Tk()
    root.withdraw()
    default_dir = r"C:UsersanimatorDesktop"
    file_path = tkinter.filedialog.askopenfilename(title=u'选择文件', initialdir=(os.path.expanduser(default_dir)))
    image = Image.open(file_path)
    plt.imshow(image)
    image = np.array(image)
    image = convert2gray(image)
    image = image.flatten() / 255
    print("预测结果："+crack_captcha(image))
    plt.show()

为了防止错过最佳训练模型，对每个训练模型都进行了保存，后来在出现92.25%的训练结果后手动结束了程序，训练过程如下：

可见第52000次训练结果0.9225

删掉多余的训练模型后剩余

测试结果（图片位于桌面，百度随机下载的一张验证码图片）

图片中验证码为1TjV，但是识别结果为1TJY，大小写识别和部分易混淆字母识别不准确

解决思路：由于神经网络训练模型单个数字或字母的识别率很高，且模型训练较容易，可以增加图片的分割操作将所有字符一个一个的分开识别，这样的好处一是提高识别精度，二是避免验证码字符个数限制，可以识别任意个字符组成的验证码

目前只有思路，时间问题还未具体实践

java的学生管理系统样卷内容和小学期进行的学生管理系统差别不大，用Java代码实现起来也非常简单，这里不再列出其代码

除此之外，还实验了支持下载队列的多线程网络爬虫，代码如下：

from urllib import request
import re
from bs4 import BeautifulSoup
from time import ctime,sleep
import os,sys,io
import threading
# 在当前目录创建一个urls子目录，用于保存下载的HTML文件
os.makedirs('urls',exist_ok=True)
# 下载队列，入口点的URL会作为下载队列的第一个元素，这里以“极客教程”网站为例
insertURL = ["https://geekori.com"]
# 已经处理完的URL会添加到这个队列中
delURL = []
# 负责下载和分析的HTML代码的函数，该函数会在多个线程中执行
def getURL():
    while(1):
        global insertURL
        global delURL
        try:
            if len(insertURL)>0:
                # 从队列头取一个URL
                html = request.urlopen(insertURL[0]).read()
                soup = BeautifulSoup(html,'lxml')
                # 开始分析HTML代码
                title = soup.find(name='title').get_text().replace('
','')
                fp = open("./urls/"+str(title)+".html","w",encoding='utf-8')
                # 将HTML代码保存到相应的文件中
                fp.write(str(html.decode('utf-8')))
                fp.close()
                # 开始查找所有的a标签
                href_ = soup.find_all(name='a')
                # 对所有的a标签进行迭代
                for each in href_:
                    urlStr = each.get('href')
                    if str(urlStr)[:4]=='http' and urlStr not in insertURL:
                        # 添加所有以http开头并且没有处理过的URL
                        insertURL.append(urlStr)
                        print(urlStr)
                # 将处理完的URL添加到delURL队列中
                delURL.append(insertURL[0])
                # 删除inserURL中处理完的URL
                del insertURL[0]
        except:
            delURL.append(insertURL[0])
            del insertURL[0]
            continue
        sleep(2)
# 下面的代码启动了三个线程运行getURL函数
threads = []
t1 = threading.Thread(target=getURL)
threads.append(t1)
t2 = threading.Thread(target=getURL)
threads.append(t2)
t3 = threading.Thread(target=getURL)
threads.append(t3)

if __name__=='__main__':
    for t in threads:
        t.setDaemon(True)
        t.start()
    for tt in threads:
        tt.join()

运行效果如图：

urls目录下以下载的文件如图：

OK，以上就是本周所有内容了，往后几周将会复习巩固暑假的进度，准备开学的考核，加油！