验证码识别+自动登录学校网站

简介

前段时间打算用谷歌driver自动登录学校的网站，方便后面继续开发脚本，主要还是想着以后也许会用到爬虫爬取图像等数据用来训练。

这个项目从最开始使用 pytorch 搭模型、爬验证码数据、以及训练改进，到后来觉得登录学校网站不用手打验证码挺方便的，就不断优化程序最后完成了一个快速登录的可执行文件，下面是一个demo演示。

这里打算开个坑写写训练的过程和用谷歌driver登录网站的设计思路，以及最后的一些优化日志。

验证码数据集获取

解析验证码网址

我们打开网址的登录页面，检查页面源代码，定位到验证码的位置，可以看到一个验证码的网页。

打开这个网页，显示的就是验证码的图片，但这个验证码不是原来的验证码，说明验证码是动态加载的，尽管网址一样但是内容是不相同的。可以使用爬虫工具下载这个图片，为了观察这个网址以便批量下载，我们刷新登录页面，并再次打开一个新的验证码网址。可以看到唯一的变化就是网址后缀上的 uuid 变化了。uuid 是一种标识码，后端算法会根据这个 uuid 生成一个验证码。

所以可以先随机生成一个 uuid 标识，然后拼接成完整的验证码网址，通过爬虫下载图片。

批量下载验证码

使用python（环境：python3.7）提供一系列的操作：

• 生成uuid并拼接网址

  import uuid #该库用于生成uuid，有多种方式
  uuidx=str(uuid.uuid4())
  url = 'https://jaccount.sjtu.edu.cn/jaccount/captcha?uuid='+uuidx

• 通过爬虫下载验证码图片

  import requests
  origin_path='captcha-sjtu/origin.jpg'
  # 构造请求头
  headers={'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
                        'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 Edg/89.0.774.57'}
  # 发送请求
  res = requests.get(url=url,headers=headers)
  # 把获取的二进制写成图片
  with open(origin_path, 'wb') as f:
      f.write(res.content)

• 获得了一张图片后，我们需要将它命名为它的验证码识别结果，作为训练数据和测试数据的标签。但我们不可能人眼去识别和手动修改，这样工作量太大了，因此可以选择外接库来帮我们识别（本意不是识别出验证码，而是学习自己搭网络来训练，因此尽管有外接库，还是希望自己能完成一个网络）。这里选择ddddocr这个库，用法很简单

  import ddddocr
  import os
  ocr = ddddocr.DdddOcr(use_gpu=True)		#实例化一个识别器，使用gpu
  with open(origin_path, 'rb') as f:
      img_bytes = f.read()	#读入二进制数据
  try:	#可能上面的uuid拼接的url弄的不是一个验证码
      res = ocr.classification(img_bytes)		#识别的结果
  except:
      continue	#如果url不是验证码就跳过，无所谓。不用try语句的话会中断
  newname='captcha-sjtu/train/'+res+'.jpg'
  try:
      os.rename(origin_path, newname)	#可能已经有一个同名的了，为了不让程序中断，还是使用try
  except:
      continue

• 至此就处理完了一张图片，下面为批量处理的完整代码

  import requests
  import time
  import uuid
  import os
  import ddddocr
  ocr = ddddocr.DdddOcr(use_gpu=True)
  origin_path='captcha-sjtu/origin.jpg'
  for i in range(10000):
      # 每爬取500个，歇1秒，确保服务器不会受影响
      if i%500 == 0:
          print("-----",i/1000,'组-----------')
          time.sleep(1)
      # 生成随机数
      uuidx=str(uuid.uuid4())
      url = 'https://jaccount.sjtu.edu.cn/jaccount/captcha?uuid='+uuidx
      # 构造请求头
      headers={'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
                            'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 Edg/89.0.774.57'}
      # 发送请求
      res = requests.get(url=url,headers=headers)
      # 把获取的二进制写成图片
      with open(origin_path, 'wb') as f:
          f.write(res.content)
      # 再读取回来
      with open(origin_path, 'rb') as f:
          img_bytes = f.read()
      try:
          res = ocr.classification(img_bytes)#可能上面的uuid拼接的url弄的不是一个验证码
      except:
          continue
      newname='captcha-sjtu/train/'+res+'.jpg'
      try:
          os.rename(origin_path, newname)#可能已经有一个同名的了
      except:
          continue

pytorch 模型搭建

构建 Dataset

将数据集分成9:1，并预留一些数据用于验证。首先定义一些参数设置，写在setting.py内。通过观察验证码，可以得到图片的宽度和高度，以及内容和长度。这里验证码的内容都是小写字母，因此我们只需要小写字母的字母表；而验证码长度是4或者5，对于CNN网络来说，需要接受一个固定大小的输入，然后输出一个固定大小的标签等等。

因此我们没办法同时识别长度为4和长度为5的验证码，但根据观察发现这两种长度的验证码出现的频率几乎是1：1的，那么在登录验证时只需要不断 try 尝试即可，而且并不会造成很多的时间浪费。以下为setting的内容。

#  setting.py 
width_sjtu=100	#图片尺寸
height_sjtu=40
alphabet_sjtu='abcdefghijklmnopqrstuvwxyz'#全是小写字母
#验证码长度
numchar=4
#train:
#  遍历数据集训练的次数
max_epoch=100
#  批处理数量
batch_size=128
#  学习率
base_lr=0.0003

#  训练数据存放路径
train_data_path_sjtu='./captcha-sjtu/train'
#  测试数据存放路径
test_data_path_sjtu= './captcha-sjtu/test'
#  预测数据
samples_path_sjtu = './captcha-sjtu/predict'
#  是否使用gpu
use_gpu= True
#  gpu并行处理进程数
num_workers= 0
#  训练后的模型输出的路径
model_path='./weights'

随后，我们要重写Dataset，大部分工作在重写_getitem_()方法，返回处理后的图像和标签，于是我们需要先考虑这个标签的形式。我们似乎可以使用一个字母表大小（里面也可以包括数字等等）的一维向量，比如全是小写字母那么我的向量长度就为26，然后将验证码图片出现的字母映射在向量对应的索引处：如果字母出现则为1，不出现则为0。但这种方法，一方面没办法表示验证码的顺序，一方面没办法识别有重复字母的验证码。

因此考虑对每个字母都建立一个长度为26的向量进行映射，因此向量的总长度就是验证码长度×字母表长度。

对于一个图片，前面使用了它的名称作为验证码结果，因为我们下载的时候并没有区别长度，因此这里长度不一致的数据要剔除，执行一次continue即可。然后，我们把验证码字符串的每一个字符都映射到一个向量上，在python中可以使用str.find()，这里的str即为我们的字母表。然后我们把这些向量都拼接起来，就构成了label。

make_dataset()函数会返回图片路径、图片label，最后我们Dataset中使用它重写_getitem_()方法。对应的dataset.py文件如下。

# datasets.py
import os
from PIL import Image
import torch
from torch.utils.data import Dataset

def img_loader(img_path):
    img = Image.open(img_path)
    # 将图像转换为 RGB
    return img.convert('RGB')

# 处理数据集所在文件夹下的数据
def make_dataset(data_path, alphabet, num_class, num_char):
    # 获取数据集所在文件夹的所有文件名
    img_names = os.listdir(data_path)
    samples = []
    for img_name in img_names:
        # 拼接每个图像数据集的路径
        img_path = os.path.join(data_path, img_name)
        # 找出该图像的label
        target_str = img_name.split('.')[0]
        # 判断lable和结果的长度是否一致
        if len(target_str) != num_char:
            continue

        target = []
        # 创建每个数据的target数组 4 * alphabet，这里使用one hot
        for char in target_str:
            #------如果只看小写要映射成小写-------------------
            # if ord(char)>=65 or ord(char)<=90:
            #     char=chr(ord(char)+32)
            #---------------------------------

            vec = [0] * num_class
            vec[alphabet.find(char)] = 1
            target += vec#要四个数组，如果写在一个数组内，重复的表示不出来

        # 加入数据集
        samples.append((img_path, target))
    # 返回数据集
    return samples


class CaptchaData(Dataset):
    def __init__(self, data_path, num_class=62, num_char=4, transform=None, target_transform=None,
                 alphabet="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"):
        super(Dataset, self).__init__();
        self.data_path = data_path
        self.num_class = num_class
        self.num_char = num_char
        self.transform = transform
        self.target_transform = target_transform
        self.alphabet = alphabet
        self.samples = make_dataset(self.data_path, self.alphabet,
                                    self.num_class, self.num_char)

    def __len__(self):
        return len(self.samples)

    def __getitem__(self, index):
        img_path, target = self.samples[index]
        img = img_loader(img_path)
        # 如果有传入预处理函数，就预处理数据集
        if self.transform is not None:
            img = self.transform(img)
        if self.target_transform is not None:
            target = self.target_transform(target)

        return img, torch.Tensor(target)

构建CNN model

接着，我们搭建一个CNN网络，这个网络不能太大，因为我们的标签向量本身很大，如果只是用自己机器训练的话，gpu内存可能不够用（全连接层的参数尤其多）。要查看gpu的占用，可以在任务管理器–性能–GPU1处实时监控专用GPU内存利用率（GPU0一般是处理器的而非显卡），如下图

我最后选择了一个可以训练的模型，使用四层卷积和两层全连接层，每次卷积后使用一个2×2的最大池化，接着批归一化，最后使用ReLU激活函数。因为学校网址的验证码本身不是很复杂，训练后可以针对长度4和长度5的验证码都可以达到96%的准确率。

实际上，并不需要多高的准确率，因为try一次的时间甚至不到1秒钟（当然调整网络结构优化识别性能是一件很有趣的事情）。model.py的代码如下。

#  model.py
import torch.nn as nn
class CNN_sjtu(nn.Module):#4长度和5长度准确率都在96%左右，验证都是正确的
    def __init__(self, num_class=36, num_char=4, width=100, height=40):
        super(CNN_sjtu, self).__init__()
        self.num_class = num_class
        self.num_char = num_char
        # 卷积层后，全连接层的一维数组输入长度
        # 512是卷积处理后图片的通道数，长度和宽度各除以16是因为图像经过了四次2*2池化层（MaxPool2d）
        self.line_size = int(512 * (width // 2 // 2 // 2 // 2) * (height // 2 // 2 // 2 // 2))
        self.conv1 = nn.Sequential(
            # 输入的是RGB图像，所以是3通道。
            # 这里设置该层有16个卷积核，所以输出是16通道
            # padding（1，1）表示在图像上下左右各加1行、1列，保证在卷积后图像大小不变
            nn.Conv2d(3, 16, 3, padding=(1, 1)),
            # 池化层，保留图像每2*2片段像素的最大值
            nn.MaxPool2d(2, 2),
            # 对每个通道的图像都归一化，防止梯度爆炸
            nn.BatchNorm2d(16),
            # 激活函数
            nn.ReLU()
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 64, 3, padding=(1, 1)),
            nn.MaxPool2d(2, 2),
            nn.BatchNorm2d(64),
            nn.ReLU()
        )
        self.conv3 = nn.Sequential(
            nn.Conv2d(64, 512, 3, padding=(1, 1)),
            nn.MaxPool2d(2, 2),
            nn.BatchNorm2d(512),
            nn.ReLU()
        )
        self.conv4 = nn.Sequential(
            nn.Conv2d(512, 512, 3, padding=(1, 1)),
            nn.MaxPool2d(2, 2),
            nn.BatchNorm2d(512),
            nn.ReLU()
        )
        # 全连接层
        self.fc = nn.Sequential(
            nn.Linear(self.line_size, self.line_size),
            # nn.Identity(),
            # 输出应为 验证码长度*字符的分类数
            nn.Linear(self.line_size, self.num_char * self.num_class)
        )

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = self.conv4(x)
        # resize输入数组的尺寸，相当于flatten
        x = x.view(-1, self.line_size)
        x = self.fc(x)

        return x
    

训练模型

训练代码如下，每一轮迭代都会保存模型参数到给定文件夹。最终观察表现最好的参数模型，手动删除其他不好的，并可以修改一下命名，以防之后重新训练覆盖了这个参数模型。

#train.py
import torch
from model import *
from datasets import CaptchaData
from torch.utils.data import DataLoader
from torchvision.transforms import Compose, ToTensor, Resize,Normalize
import time
import os
from setting import *

#导入设定参数
alphabet=alphabet_sjtu
width=width_sjtu
height=height_sjtu

#  训练数据存放路径
train_data_path=train_data_path_sjtu
#  测试数据存放路径
test_data_path=test_data_path_sjtu
#  预测数据
samples_path=samples_path_sjtu

if not os.path.exists(model_path):
    os.makedirs(model_path)

device =torch.device("cuda")#设置gpu

# 计算准确度
def calculat_acc(output, target):
    output, target = output.view(-1, len(alphabet)), target.view(-1, len(alphabet)) #字母有26个就是26列
    output = nn.functional.softmax(output, dim=1) #缩放到0-1区间，所有元素和为1
    output = torch.argmax(output, dim=1)    #返回每一列得分最高的索引值，说明预测的是这个位置的字母
    target = torch.argmax(target, dim=1)    #然后dim=1这个维度会消失
    output, target = output.view(-1, int(numchar)), target.view(-1, int(numchar))
    correct_list = []
    for i, j in zip(target, output):
        if torch.equal(i, j):   #如果两个列表相等（相同大小和元素）
            correct_list.append(1)
        else:
            correct_list.append(0)
    acc = sum(correct_list) / len(correct_list)
    return acc


def train():
    # 数据shape的预处理，缩放、转tensor，以及图像处理基本都要使用归一化
    transforms = Compose([Resize((height, width)), ToTensor(),Normalize(0, 1)])
    # 创建训练数据集对象
    train_dataset = CaptchaData(train_data_path, num_class=len(alphabet), num_char=int(numchar), transform=transforms, alphabet=alphabet)
    # 初始化DataLoader，之后训练的数据由它按照我们的要求如batch_size等提供
    train_data_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers,
                                   shuffle=True, drop_last=False)
    # 创建测试数据集对象
    test_dataset = CaptchaData(test_data_path, num_class=len(alphabet), num_char=int(numchar), transform=transforms, alphabet=alphabet)
    test_data_loader = DataLoader(test_dataset, batch_size=batch_size,
                                  num_workers=num_workers,drop_last=False)

    print("训练数据量：",train_dataset.__len__(),'\t测试数据量：',test_dataset.__len__())

    # 初始化模型
    cnn = CNN_sjtu(num_class=len(alphabet), num_char=int(numchar), width=width, height=height)
    if use_gpu:
        cnn=cnn.to(device)
  
    #----------------损失函数及优化方法---------------------
    # 使用Adam优化方法
    optimizer = torch.optim.Adam(cnn.parameters(), lr=base_lr)
    # 使用多标签分类的损失函数
    criterion = nn.MultiLabelSoftMarginLoss()
    
    #----------------开始迭代训练-------------------------
    # 训练我们指定的epoch次
    print("开始训练...")
    for epoch in range(max_epoch):
        start_ = time.time()
        loss_history = []
        acc_history = []
        # 切换到训练模式
        cnn.train()
        for img, target in train_data_loader:
            if use_gpu:
                img = img.to(device)
                target = target.to(device)
            # 获取神经网络的输出
            output = cnn(img)
            # 计算损失函数
            loss = criterion(output, target)
            # 初始化梯度
            optimizer.zero_grad()
            # 反向传播计算梯度
            loss.backward()
            # 优化参数
            optimizer.step()
            # 计算准确度
            acc = calculat_acc(output, target)
            acc_history.append(float(acc))
            loss_history.append(float(loss))
        print('epoch:{},train_loss: {:.4}|train_acc: {:.4}'.format(
            epoch,
            torch.mean(torch.Tensor(loss_history)),
            torch.mean(torch.Tensor(acc_history)),
        ))

        with torch.no_grad():
            loss_history = []
            acc_history = []
            # 切换到测试模式
            cnn.eval()
            for img, target in test_data_loader:
                if torch.cuda.is_available():
                    img = img.to(device)
                    target = target.to(device)
                output = cnn(img)

                acc = calculat_acc(output, target)
                acc_history.append(float(acc))
            print('test_loss: {:.4}|test_acc: {:.4}'.format(
                torch.mean(torch.Tensor(loss_history)),
                torch.mean(torch.Tensor(acc_history)),
            ))
        print('epoch: {}|time: {:.4f}'.format(epoch, time.time() - start_))
        torch.save(cnn.state_dict(), os.path.join(model_path, "model_{}.path".format(epoch)))#每个epoch保存一次参数


if __name__ == "__main__":
    train()

模型效果测试

最后我们可以看看我们模型的效果，下面是一些预测的示例。

预测部分的代码如下，至此，整个模型训练部分就完成了，登录网站的部分见下一篇博客。

#predict.py
import torch
from PIL import Image
from model import *
from torchvision.transforms import Compose, ToTensor, Resize,Normalize
import matplotlib.pyplot as plt
import os
import random
from setting import *

#----------参数设定-------------
model_net = CNN_sjtu()
alphabet=alphabet_sjtu
width=width_sjtu
height=height_sjtu
samples_path=samples_path_sjtu+'/4'
numchar=4

# 获取模型
def load_net():
    global model_net
    # 初始化模型
    model_net = CNN_sjtu(num_class=len(alphabet), num_char=int(numchar), width=width, height=height)
    # 读取参数模型
    if use_gpu:
        model_net = model_net.cuda()
        model_net.eval()
        model_net.load_state_dict(torch.load('./weights/model_sjtu_4.path'))    #加载参数模型
    else:
        model_net.eval()
        model_net.load_state_dict(torch.load(model_path, map_location='cpu'))

# 预测验证码
def predict_image(img):
    global model_net
    with torch.no_grad():
        img = img.convert('RGB')
        transforms = Compose([Resize((height, width)), ToTensor(),Normalize(0, 1)]) #图像变换
        img = transforms(img)

        if use_gpu:
            img = img.view(1, 3, height, width).cuda()
        else:
            img = img.view(1, 3, height, width)
        output = model_net(img) #推理

        output = output.view(-1, len(alphabet))
        output = nn.functional.softmax(output, dim=1)
        output = torch.argmax(output, dim=1)
        output = output.view(-1, numchar)[0]
        return ''.join([alphabet[i] for i in output.cpu().detach().numpy()])  #转换成numpy类型需要先从gpu加载到cpu，然后可以获得字母表的索引


if __name__ == "__main__":
    load_net()
    # 枚举数据所在文件夹
    img_names = os.listdir(samples_path)
    random.shuffle(img_names)
    samples = []
    for img_name in img_names:
        # 拼接每个数据的路径
        img_path = os.path.join(samples_path, img_name)
        img = Image.open(img_path)
        v_code = predict_image(img)
        plt.figure()
        plt.title("{}".format(v_code))
        plt.imshow(img)
        plt.show()