0x00 前言

某CMS的验证码是简单的计算验证码，都是一位数的加减乘除运算，之前尝试用分割的方法识别，但成功率较低。后来采用了pytorch训练后进行识别，可以达到98%以上的识别率，于是整理一下过程，水一篇文章。

0x01 验证码的获取

首先是验证码的获取，由于爬取验证码还要手工标注，比较麻烦，这里可以通过修改程序来批量生成标注好的样本。

主要代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
import com.google.code.kaptcha.Producer;

public class GenCalculateCaptcha {
    public static void main(String[] args) {
        Producer kaptcha = new CaptchaConfig().getKaptchaBeanMath();
        for(int i=0;i<100;i++){
            String capText = kaptcha.createText();
            String capStr = capText.substring(0, capText.lastIndexOf("@"));
            System.out.println(capStr);
        }
    }
}

执行结果：

1
2
3
4
5
6
7
8
9
10
6-1=?
9+1=?
0+5=?
8*6=?
6/1=?
5+7=?
9+3=?
0/5=?
1*2=?
...

通过执行的结果可以发现，生成的验证码中会出现*、/、?等字符，这些字符在作为文件名时不合法，所以需要进行替换。

例如将除号/替换为÷，乘号*替换为×，问号?替换为？。

同时为了避免生成的验证码重复，生成的文件名拼接了时间戳的md5，并用_连接。

替换的代码如下：

1
String newCapStr = capStr.replace("/","÷").replace("*","×").replace("?","？") + "_" + DigestUtils.md5Hex(""+System.currentTimeMillis())+".jpg";

再次执行结果如下：

1
2
3
4
5
6
7
8
9
10
11
8×4=？_b69426246067db177639de42b77082ab.jpg
3÷1=？_d0ad2c5c50b4d8db2736093bdf2c08e8.jpg
6÷3=？_d0a992ce88acf8a918f12646bef3a60d.jpg
3×8=？_d0a992ce88acf8a918f12646bef3a60d.jpg
9-3=？_d0a992ce88acf8a918f12646bef3a60d.jpg
2-0=？_d0a992ce88acf8a918f12646bef3a60d.jpg
0+9=？_3479d65864cdbbed02d5e9acb8e5fa37.jpg
4-1=？_3479d65864cdbbed02d5e9acb8e5fa37.jpg
6+2=？_3479d65864cdbbed02d5e9acb8e5fa37.jpg
7×2=？_3479d65864cdbbed02d5e9acb8e5fa37.jpg
...

然后就是验证码图片的保存。

主要代码如下：

1
2
3
BufferedImage bi = DefaultKaptcha.createImage(capStr);
String fileName = dir.getPath()+File.separator+capStr.replace("/","÷").replace("*","×").replace("?","？") + "_" + DigestUtils.md5Hex(""+System.currentTimeMillis())+".jpg";
ImageIO.write(bi, "jpg", new File(fileName));

生成的验证码如下：

2/1=?

3*5=?

到此获取标注好的验证码已经完成了，下面就开始进行验证码的识别。

0x02 验证码的识别

1.分割识别

最早是根据文章《自动识别验证码破解上学吧题目答案》中的方法来进行验证码的识别，但是由于验证码不太规则，导致识别效果较差，后面就放弃了。这里列出简要过程。

验证码图片为 60×160 像素的，两个数字的范围都是 0 到 9。对图片转成灰度图后并进行分割。

1
2
3
image = Image.open(path).convert("L")
cropped_image1 = image.crop((25, 13, 50, 44))  # 第一个数字的切图
cropped_image2 = image.crop((65, 13, 90, 44))  # 第二个数字的切图

可以自己找比较合适的分割位置。

分割的效果：

分割

然后进行二值化，遍历灰度图的像素点，这里以阈值66为界限，使得图片的像素点要么为纯黑 0，要么为纯白 255，下图是二值化之后的图片：

二值化

接着对验证码样本进行批量切图、转灰度图、二值化：

批量对图片进行分割，然后保存格式为数字_md5(时间戳).jpg

1
2
3
4
5
6
7
8
9
10
11
def corpImg(name):
    imgPath = "MathCodes/" + name
    fname = name[0:1]
    img = cv2.imread(imgPath, 0)  # 直接读为灰度图像
    img1 = img[13:44, 28:52] #分割
    cv2.imwrite(fname+"_"+getMd5()+".jpg", img1)

def main():
    names = os.listdir("MathCodes")
    for name in names:
        corpImg(name)

切图

从中挑选出噪点去除效果最好图片的作为模板，0 到 9 这 10 个数字各一个。

模板

分别遍历这几个模板图片的像素点并存为 0-1 矩阵：首先创建一个 24列 31 行的二维数组（所有元素都为 0），遇到黑色像素点就将 0 变成 1，此处需要注意二维数组中坐标与像素点坐标是相反的。

1
2
3
4
5
6
7
8
num_info = [([0] * 24) for i in range(31)]  # 创建一个宽度为24，高度为31的二维数组
pixdata = img.load()
for y in range(31):
    for x in range(24):
        if pixdata[x, y] == 0:
            # print(x, y)
            num_info[y][x] = 1  # 注意二维数组中坐标是相反的
num_info_list.append(num_info)

接下来就是识别了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
num_info_list = []  # 这个数组用以存储全部数字的 0-1 矩阵

for i in range(10):
    filename = 'temp/'+str(i) + '.png'
    img = Image.open(filename)

    num_info = [([0] * 24) for i in range(31)]  # 创建一个宽度为24，高度为31的二维数组
    pixdata = img.load()
    for y in range(31):
        for x in range(24):
            if pixdata[x, y] == 0:
                # print(x, y)
                num_info[y][x] = 1  # 注意二维数组中坐标是相反的
    num_info_list.append(num_info)
img = Image.open('temp/067_1.jpg')
img = binarizing(img,66)
img.save("temp/01111.png")
count_list = [] # 记录当前图片像素信息与每一个 0-1 序列的匹配程度

pixdata = img.load()
for i in range(10):
    count = 0
    for y in range(31):
        for x in range(24):
            if pixdata[x, y] == 0 and num_info_list[i][y][x] == 1: # 图片中黑色像素点出现的位置对应的矩阵点也是 1
                count = count + 1
    count_list.append(count)

print(count_list)
print('当前图片的识别结果：' + str(count_list.index(max(count_list)))) # 找到匹配数最大的那个元素的序号，而序号和数字是相同的。

分割识别

从上面来看识别效果不是太好，所以后面就放弃了这种方法。

也可以先分割验证码，之后用ddddocr进行识别，中间的运算符可以采用上述的方法进行识别。这里就说一个思路，不具体实现了。一来比较麻烦，二来是运算符处理的效果也不会太好，但最终的结果会比直接分割识别这种方法好。

这是ddddocr识别效果，有一个没识别出来，不过准确率还挺高。

ddddocr识别

接下来就使用pytorch进行训练。

2.pytorch识别

pytorch训练验证码的过程都差不多，这里从网上找了一套修改了一下。

样本已经有了，首先对验证码进行分析。验证码字符一共有16种，分别为：

1
0123456789+-×÷=？

验证码长度为5

1
2
captcha_array = list("0123456789+-×÷=？")
captcha_size = 5

接下来就是Datasets数据加载。

pytorch有非常方便高效的数据加载模块Dataset和DataLoader。
Dataset是数据样本的封装，可以很方便的读取数据。

实现一个Dataset的子类，需要重写__len__和__getitem__方法，__len__需要返回整个数据集的大小，__getitem__提供一个整数索引参数，返回一个样本数据（一个图片张量和一个标签张量）。主要代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class MyDataset(Dataset):
    def __init__(self, root_dir):
        super(MyDataset, self).__init__()
        self.image_path = [os.path.join(root_dir, image_name) for image_name in os.listdir(root_dir)]
        self.transforms = transforms.Compose(
            [
                transforms.ToTensor(),
                transforms.Resize((60, 160)),
                transforms.Grayscale()  # 灰色
            ]
        )

    def __len__(self):
        return self.image_path.__len__()

    def __getitem__(self, index):
        image_path = self.image_path[index]
        # print(image_path)
        image = self.transforms(Image.open(image_path))
        ll = image_path.split("/")[-1]
        ll = ll.split("_")[0] #验证码文本
        label_tensor = one_hot.text2Vec(ll)  # [5,16]
        label_tensor = label_tensor.view(1, -1)[0]  # [5*16]
        # print(label)
        return image, label_tensor

其中text2Vec是将验证码进行onehot编码，这里是变成一个5*16的数组。

主要代码:

1
2
3
4
5
def text2Vec(text):
    vec = torch.zeros(common.captcha_size, len(common.captcha_array))
    for i in range(len(text)):
        vec[i, common.captcha_array.index(text[i])] = 1
    return vec

比如说0×4=？转换的结果就如下：

1
2
3
4
5
tensor([[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., 1., 0., 0., 0.], # ×
        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # 4
        [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., 1.]]) # ？

对应的还原方法:

1
2
3
4
5
6
def vec2Text(vec):
    vec = torch.argmax(vec, dim=1)  # 取最大值，不是0的取出来
    text = ''
    for i in vec:
        text += common.captcha_array[i]
    return text

DataLoader是Dataset的进一步封装，Dataset每次通过__getitem__方法取到的是一个样本，经过DataLoader封装为dataloader后，每次取的是一个batch大小的样本批次。

主要代码：

1
2
3
4
5
6
transform = transforms.Compose([transforms.ToTensor()])  # 不做数据增强和标准化了
train_dataset = CaptchaData('./datasets/train/', transform=transform)
train_data_loader = DataLoader(train_dataset, batch_size=32, num_workers=0, shuffle=True, drop_last=True)

test_data = CaptchaData('./datasets/test/', transform=transform)
test_data_loader = DataLoader(test_data, batch_size=128, num_workers=0, shuffle=True, drop_last=True)

transforms是数据预处理操作，一般数据增强就通过transform实现，可以随机亮度，随机翻转，随机缩放等等。此处只使用了ToTensor()，将PIL.Image对象转换成Tensor。

训练采用了CNN神经网络，CNN主要由卷积层，池化层，激活函数组成，再加上一个BatchNorm，BatchNorm叫做批规范化，可以加速模型的收敛速度。

模型的主要代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 第一层神经网络
        # nn.Sequential: 将里面的模块依次加入到神经网络中
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),  # 3通道变成16通道，图片：60*160
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        # 第2层神经网络
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 64, kernel_size=3),  # 16通道变成64通道，图片：30*80
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        # 第3层神经网络
        self.layer3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3),  # 64通道变成128通道，图片：14*39
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        # 第4层神经网络
        self.fc1 = nn.Sequential(
            nn.Linear(13824, 1024),
            nn.Dropout(0.2),  # drop 20% of the neuron
            nn.ReLU()
        )
        # 第5层神经网络
        self.fc2 = nn.Linear(1024, common.captcha_size * common.captcha_array.__len__())  # 5:验证码的长度， 16: 字母列表的长度

    # 前向传播
    def forward(self, x):
        x = x.to(device)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        x = self.fc2(x)
        return x

nn.Sequential()可以看作模块的有序容器，可以方便快捷的搭建神经网络。
网络的输入是一个shape为[batch, 3, 60, 180]的张量，batch代表的是一个批次图片数量，3代表输入的图片是3通道的，即RGB，180和60则分别代表图片的宽和高。

经过上结构的卷积后，得到一个shape为[batch, 128, 6, 18]的张量，x.view(x.size(0), -1)将改变张量的shape为[batch, 128*6*18]，再用一个[1024, 16*5]的全连接层映射为一个[batch, 16*5]张量，这个就是模型的输出，其中16代表字符的种类数量，5代表一张验证码图片含有的字符数量。

接下来就是验证码的训练了：

训练

这里使用的是CPU进行训练的，训练样本生成了2000张，测试样本200张，刚开始训练准确率就可以到100%，而且速度不是太慢。

验证码生成的脚本：https://github.com/fupinglee/Calculate_Captcha

如果是在GPU下训练，在CPU下使用模型时，需要进行转换：

torch.load(model_path, map_location=torch.device('cpu'))

训练后测试的结果（200张测试准确率是100%，又另外生成了2000张验证码进行测试）：

预测

经过测试，使用pytorch训练的准确率可以达到99%。

完整代码：https://github.com/fupinglee/CalculateCaptcha_Recognition

0x03 总结

本文通过2种方法来对计算验证码进行识别。第一种方法使用简单，但识别率较低，可以针对一些比较简单的验证码（比如验证码未进行扭曲、干扰等）。第二种方法使用简单，但识别率比较依赖样本的数量，前期验证码标注是一件麻烦事，但对于本文这种简单的验证码，少量的样本准确率也会很高。

0x04 参考

1.自动识别验证码破解上学吧题目答案

2.pyTorch – 图形验证码识别

3.验证码代码

4.pytorch识别验证码代码