【24】SE 验证码识别

目标

在爬取瑞典专利和注册局(PRV,代码 SE)的专利数据库数据的时候,存在输入验证码的步骤,需要编写程序来识别。以下是几张示例:

captcha-example-1

captcha-example-2

captcha-example-3

难点

这次要识别的验证码的特点:

  1. 背景特别干净,没有任何噪声
  2. 字符本身的扭曲变形非常厉害
  3. 存在多种字体,包括多种衬线和非衬线字体
  4. 所有英文字母都是小写
  5. 字符旋转的角度不会超过 ±90°

没有噪声是好事,这意味着不需要做任何降噪相关的处理。但是字符的变形扭曲要远远比一般见到的验证码厉害得多,甚至有的例子中人眼也难以分辨到底是什么字母。

扭曲的特别厉害的一张:

captcha-example-bad

容易看出,这一批验证码的生成规则都是把对应的文字从左到右排列,然后按照一个随机的曲线和宽度进行扭曲。在曲线曲率较大的地方,字符就容易出现非常大的扭曲变形,从而难以辨认。因此,如何进行形态矫正是一个非常大的考验。

多种字体也是一个挑战。在一些衬线字体中,1l 的样子完全一致,仅仅是有微小的高度差别,这为识别造成了很大的麻烦。幸亏只有小写,不然会有更多容易混淆的情况。

另外,还有一个隐藏的特点。仔细看的话,你会发现之前第一张示例图片和这一张示例图片其实是同一个验证码,都是 t3st1n。写爬虫的小哥告诉我,同一个 IP 貌似返回的是同样的验证码文字,也就是说验证码文字的生成不是完全随机,而是包含 IP 的某种哈希。反向推导这个生成算法可能不太现实,但是至少可以通过多张同样内容的验证码一起识别交叉验证,提高准确性。可惜的是爬虫使用的是代理池,IP 会不受控制的变化,因此这条路就难以进行下去,只能尽量一发入魂了。

传统方法

首先,试一试传统的数字图像处理方法。能够想到的方法,无非就是先对每个字符的图像进行校准,然后去试着识别是哪个字符,最后再拼起来。以下是我想要采取的流程:

  1. 把排列成曲线的字符矫正回直线
  2. 提取字符,做必要的矫正和处理
  3. 匹配内容

曲线矫正

首先尝试做曲线矫正。这一步我在实际开发的时候并没有做,原因在于难以对字符扭曲形成的曲线进行建模并矫正。项目结束以后我才想到,其实可以试试用 numpy 或者 scipy 去做曲线拟合,获得曲线方程以后大概就可以生成变换矩阵矫正形变了。不过项目已经结束了,以后如果有类似的需求可以再试一试。

字符提取

于是我上来就直接对单个字符进行提取了。下面我用于在一张图片中提取字符的函数,参数列表:img 是 cv2.imread() 返回的图片对象;reverse_color 是一个布尔值,代表是否反转颜色;iter 是一个整数(默认为 2),代表第一次膨胀的迭代次数。

 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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import cv2
import numpy as np


def extract_char(img, reverse_color, iter=2):
    # Binary, dilation
    if reverse_color:
        _, binary = cv2.threshold(img, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY_INV)
    else:
        _, binary = cv2.threshold(img, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY)
    kernel = np.ones((3, 3), np.uint8)
    dilation = cv2.dilate(binary, kernel, iterations=iter)
    
    # Find contours, sort them
    contours, hierarchy = cv2.findContours(dilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    contours = sorted(contours, key=(lambda x: (x[0][0][0], x[0][0][1])))
    
    chars = list()
    
    for cnt in contours:
        # Contour approximation
        rect = None
        for i in range(100):
            epsilon = (0.01 + 0.01 * i) * cv2.arcLength(cnt, True)
            box = cv2.approxPolyDP(cnt, epsilon, True)
            box = np.float32(box)
            if len(box) <= 4:
                break
        if len(box) != 4:
            print("NOOOOOO! Fall Back!")
            rect = cv2.minAreaRect(cnt)
            box = cv2.boxPoints(rect)
            box = np.float32(box)
        
        # Transform to a single image
        points = np.float32([[25, 25], [25, 125], [125, 125]])
        M = cv2.getAffineTransform(box[0:3], points)
        processed = cv2.warpAffine(binary, M, (150, 150))
        if rect and rect[2] <= -80.0:
            processed = np.rot90(processed, 1)
        
        # Refind countour
        kernel = np.ones((11, 11), np.uint8)
        _dilation = cv2.dilate(processed, kernel, iterations=5)
        _contours, _hierarchy = cv2.findContours(_dilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        if len(_contours) > 1:
            print("HELPPPPP More Than ONE Contours")
            print(_contours)
        
        cnt = _contours[0]
        
        # Find rectangle
        rect = cv2.minAreaRect(cnt)
        box = cv2.boxPoints(rect)
        box = np.float32(box)
        
        # Transform to a single image
        points = np.float32([[0, 100], [0, 0], [100, 0]])
        M = cv2.getAffineTransform(box[0:3], points)
        processed = cv2.warpAffine(processed, M, (100, 100))
        if rect[2] <= -80.0:
            processed = np.rot90(processed, 1)
        
        chars.append(processed)
    
    return chars

该函数按顺序做了这些事情:

  1. 将原图做二值化,并转化为黑底白字的形式。

  2. 对字符做膨胀,让字符分离的部分(例如 i, j 的点)连接便于寻找轮廓。

  3. 使用 cv2.findContours() 查找所有的轮廓。

  4. 遍历所有的轮廓:

    a. 使用 cv2.approxPolyDP() 对当前轮廓做四边形近似。

    b. 如果无法取得四边形的近似,则更改方案使用 cv2.minAreaRect() 获取最小外接矩形。

    c. 使用 cv2.warpAffine() 将获得的四边形轮廓映射成一个 150 × 150 的正方形图片。如 minAreaRect 返回的旋转角小于 -80°,则对图片做逆时针旋转 90°。

    d. 对这张正方形图片做膨胀,让字符连接。

    e. 再次使用 cv2.findContours() 查找轮廓,如果有多于一个轮廓则报错。无论如何选择列表中的 0 号轮廓。

    f. 使用 cv2.minAreaRect() 获取最小外接矩形。

    g. 使用 cv2.warpAffine() 将这个矩形映射为最终的 100 × 100 大小的一张正方形图片。如 minAreaRect 返回的旋转角小于 -80°,则对图片做逆时针旋转 90°。

最终函数返回一个列表,包含了每个字符矫正后的独立图像。提取出来的字符大概是下面这种诡异画风:

traditional-extract-example

生成模板

提取出了字符,下面就要做匹配了。我准备采用简单粗暴的模板匹配,也就是 cv2.matchTemplate()。做模板匹配,首先需要生成模板。这里借鉴了 Python PIL创建文字图片 这篇博客的代码,魔改成了我的模板生成代码。

 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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# Learn from: https://www.cnblogs.com/mmhx/p/3819776.html
from PIL import Image,ImageDraw,ImageFont,ImageOps


class LetterImage():
    def __init__(self, fontFile='', imgSize=(0, 0), imgMode='RGB', bg_color=(0, 0, 0), fg_color=(255, 255, 255), fontsize=20):
        self.imgSize = imgSize
        self.imgMode = imgMode
        self.fontsize = fontsize
        self.bg_color = bg_color
        self.fg_color = fg_color
        if '' == fontFile:
            self.font = ImageFont.truetype('times.ttf', fontsize)
        else:
            self.font = ImageFont.truetype(fontFile, fontsize)

    def GenLetterImage(self, letters):
        # Generate the Image of letters
        self.letters = letters
        self.letterWidth, self.letterHeight = self.font.getsize(letters)
        if self.imgSize == (0, 0):
            self.imgSize = (self.letterWidth + 2, self.letterHeight + 2)
        self.imgWidth, self.imgHeight = self.imgSize
        self.img = Image.new(self.imgMode, self.imgSize, self.bg_color)
        self.drawBrush = ImageDraw.Draw(self.img)
        textY0 = (self.imgHeight - self.letterHeight + 1) / 2
        textY0 = int(textY0)
        textX0 = int((self.imgWidth - self.letterWidth + 1) / 2)
        print('text location:',(textX0, textY0))
        print('text size (width,height):', self.letterWidth, self.letterHeight)
        print('img size(width,height):', self.imgSize)
        self.drawBrush.text((textX0, textY0), self.letters, fill=self.fg_color, font=self.font)
    
    def SaveImg(self, saveName=''):
        if '' == saveName.strip():
            saveName = str(self.letters.encode('utf8')) + '.png'
        fileName, file_format = saveName.split('.')
        # fileName += '_' + str(self.fontsize) + '.' + file_format
        print(fileName, file_format)
        self.img.save(saveName, file_format)
    
    def Show(self):
        self.img.show()


def generate(fontFile, font_type):
    letterList = LetterImage(fontFile=fontFile, imgSize=(100, 100), bg_color=(0, 0, 0), fontsize=50)
    for i in range(10):
        letter = chr(ord('0') + i)
        letterList.GenLetterImage(letter)
        letterList.SaveImg(f"template/{font_type}_{letter}.png")
    for i in range(26):
        letter = chr(ord('a') + i)
        letterList.GenLetterImage(letter)
        letterList.SaveImg(f"template/{font_type}_{letter}.png")
    # for i in range(26):
    #     letter = chr(ord('A') + i)
    #     letterList.GenLetterImage(letter)
    #     letterList.SaveImg(f"template/{font_type}_{letter}_cap.png")


if __name__=='__main__':
    generate("times.ttf", "serif")
    generate("msyh.ttc", "sans-serif")

生成出来的字符模板是这样子的:

template-example

模板匹配

提取好字符,生成好模板,下面就可以开心的做匹配了!

但是又遇到这么几个问题:

  1. 这个模板和提取的字符长得完全不像啊!
  2. cv2.matchTemplate() 做模板匹配的时候,并不会做任何大小的改变,也就是说我需要尽量保证大小一致,但是这个大小怎么控制呢?
  3. 旋转也是要考虑的问题,大部分字符都会存在一定的旋转角,这个怎么解决?

对于这几个问题,我采取的解决方法是:

  1. 匹配之前,模板图片也使用同样的 extract_char() 函数进行一遍处理。由于分辨率原因,第一次膨胀需要采用和字符提取时不同的参数。这个需要摸索一下找到最佳参数,尽量使得处理后的模板和处理后的字符大小相近。
  2. 自适应大小。从缩小 12% 到放大 12%,以 1.5% 为间隔进行缩放,分别匹配。
  3. 自适应旋转角度。从 -100° 到 100° 以 20° 为间隔进行旋转,分别匹配。

这里的旋转角和缩放大小都可以看情况调节。需要权衡的是:旋转角度和缩放大小的数量更多能保证更精确的匹配,但是一味的增加角度和大小的数量又会导致性能下降。

下面是用于模板匹配的代码。

 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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
import cv2
import numpy as np
import glob
from extract_char import extract_char


def rotate(img, angle):
    # Rotation helper function
    h, w = img.shape
    M = cv2.getRotationMatrix2D((w / 2, h / 2), angle, 1)
    return cv2.warpAffine(img, M, (w, h))


def tempTrans(raw_img):
    # Do rotation and extract_char to templates
    ret = list()
    for i in range(-100, 100, 20):
        if i < 0:
            i += 360
        img = rotate(raw_img.copy(), i)
        ret.append(extract_char(img, False, 7)[0])
    return ret


def translate(name):
    # Get the corresponding character based on filename
    parts = name.split("_")
    return parts[-1]


def match(img, templates):
    anslist = dict()
    # Iter throught templates
    for template in templates:
        # Rotate templates
        for rot_template in tempTrans(template[0]):
            h, w = rot_template.shape
            for i in range(-8, 8):
                # Change template size
                temp = cv2.resize(rot_template.copy(), (int(h*(1 - 0.015*i)), int(w*(1 - 0.015*i))))
                
                # Match it
                result = cv2.matchTemplate(img, temp, cv2.TM_CCOEFF_NORMED)
                
                # Find numbers above threshold
                threshold = 0.65
                loc = np.where(result >= threshold)
                ans = translate(template[1])
                if ans in anslist.keys():
                    anslist[ans] += loc[0].size
                else:
                    anslist[ans] = loc[0].size
    anslist = sorted(anslist.items(), key=lambda x: x[1], reverse=True)
    return anslist[0][0]


def recognize(imgList):
    # Prepare templates
    template_paths = glob.glob("./template/*.png")
    templates = list()
    for path in template_paths:
        templates.append((cv2.imread(path, 0), path.split("\\")[-1].split(".")[0]))
    
    # Recognize captchas
    ansList = list()
    for img, path in imgList:
        print(path)
        chars = extract_char(img, True)
        
        ansStr = str()
        for char in chars:
            ans = match(char, templates)
            ansStr += ans
        ansList.append(ansStr)
        
    return ansList


if __name__ == "__main__":
    # Get captcha images
    imgList = list()
    imgPaths = glob.glob("./captcha/*.jpg")
    for path in imgPaths:
        imgList.append((cv2.imread(path, 0), path))
    
    # Recognize them
    ans = recognize(imgList)
    print(ans)

结果

由于模板匹配的粗糙特性,这种方法的效果非常差劲。存在几个问题:

  1. 有些字符因为难以矫正的巨大扭曲,而完全无法与模板匹配上。
  2. 有很多字符会与其他字符匹配度更高。例如非常讨厌的 l (Lima),凡是中间会有一竖条的字符,识别结果里常常会有它,而且极可能名列榜首。其实我拿到的数据集中并不存在 l 这个字符,但是光靠一个很小的数据集我没法确定到底有没有它,无法直接排除 l
  3. 有些字符旋转以后会和别的字符完全一致。这里要点名批评 qb69un。一旦旋转矫正出现问题,他们就会直接变成另一个字符。而由于原图中每个字符都有不同的变形和旋转,我现有的程序难以辨认一个字符的正确朝向并予以矫正。
  4. 矫正过程中的拉伸会导致一些字符无法区分。0o17 在拉伸变换到正方形后,会变得完全一致无法区分。部分情况下,hn 也会同样难以区分。
  5. 性能差劲。由于自适应匹配需要进行大量的尝试,因此会消耗大量的时间。
  6. 几乎每一张验证码都会至少有那么一两个字符扭曲非常厉害。而验证码这种东西,要么全对,要么一个字符错就算全错。这导致单字符的识别准确率提升并没有什么大作用,全图识别的准确率几乎为 0。对某些参数的精细调整也许可以强行使一张特定的图片识别准确,但是对其他图片将仍然难以识别全对。

由于这一系列难以解决的问题,模板匹配这条路宣告失败。

机器学习

既然 9102 年了,在这个炼丹当道的世代,当然是要试试机器学习的。

思路

用机器学习做验证码有两种思路:

  1. 直接把整张图扔进去,输出一整串结果向量。
  2. 分别抠出字符,然后做字符的分类识别。

如果验证码是属于那种有干扰噪声,但是字符本身较为规整变形不多的情况,可以考虑采用第一种情况。然而现在我这个情况实属变形得可怕,在数据集不足的情况下我决定还是走第二条路。毕竟抠字的代码现成可用,所以并不用费什么功夫。

数据集

不过需要做一点小魔改。之前 extract_char() 函数里,我在第一次四边形变换矫正的时候,用的是四边形近似的方法。这个方法非常激进,在一些情况下(近似的四边形接触到字符的像素的时候)会造成字符矫正过度反而难以辨认,但是在总体上能够提升模板匹配的准确率。既然现在换成神经网络,那就不需要这么过度的矫正了,第一步的四边形变换就可以换成简单的最小外接矩形。下面是修改后的函数。

 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
45
46
47
48
49
50
51
52
53
54
def extract_char(img, reverse_color, iter=2):
    # Binary, dilation
    if reverse_color:
        _, binary = cv2.threshold(img, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY_INV)
    else:
        _, binary = cv2.threshold(img, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY)
    kernel = np.ones((3, 3), np.uint8)
    dilation = cv2.dilate(binary, kernel, iterations=iter)
    
    # Find contours, sort them
    contours, hierarchy = cv2.findContours(dilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    contours = sorted(contours, key=(lambda x: (x[0][0][0], x[0][0][1])))
    
    chars = list()
    
    for cnt in contours:
        # Find rectangle
        rect = cv2.minAreaRect(cnt)
        box = cv2.boxPoints(rect)
        box = np.float32(box)
        
        # Transform to a single image
        points = np.float32([[25, 125], [25, 25], [125, 25]])
        M = cv2.getAffineTransform(box[0:3], points)
        processed = cv2.warpAffine(binary, M, (150, 150))
        if rect[2] <= -80.0:
            processed = np.rot90(processed, 1)
        
        # Refind countour
        kernel = np.ones((11, 11), np.uint8)
        _dilation = cv2.dilate(processed, kernel, iterations=5)
        _contours, _hierarchy = cv2.findContours(_dilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        if len(_contours) > 1:
            print("HELPPPPP More Than ONE Contours")
            print(_contours)
        
        cnt = _contours[0]
        
        # Find rectangle
        rect = cv2.minAreaRect(cnt)
        box = cv2.boxPoints(rect)
        box = np.float32(box)
        
        # Transform to a single image
        points = np.float32([[0, 100], [0, 0], [100, 0]])
        M = cv2.getAffineTransform(box[0:3], points)
        processed = cv2.warpAffine(processed, M, (100, 100))
        if rect[2] <= -80.0:
            processed = np.rot90(processed, 1)
        
        chars.append(processed)
    
    return chars

最后生成的字符是这个样子:

train-example

前期我把拿到的所有验证码图片都先做了标注,然后用一个脚本批量把每个字符归类放到各自的文件夹里,于是获得了这样的画风:

train-1

train-3

train-t

(没错,就是 t3st1n 最多)

用一个简单脚本可以计算数据集均值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
import cv2
import glob


def calculate_mean(path: str) -> float:
    means = list()
    imglist = glob.glob(path)
    
    for path in imglist:
        # Only for gray images
        img = cv2.imread(path, 0)
        img_mean = np.mean(img)
        means.append(img_mean)
    
    return np.mean(means) / 255


if __name__ == "__main__":
    print(calculate_mean("./dataset/*/*.png"))

计算得出,该数据集的均值 mean 为 0.13。

于是,数据集就准备完毕了。

模型

 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
class View(nn.Module):
    def __init__(self):
        super(View, self).__init__()

    def forward(self, x):
        return x.view(x.size(0), -1)

model = nn.Sequential(
    nn.Conv2d(1, 69, kernel_size=3, stride=1, padding=1, dilation=1),
    nn.BatchNorm2d(69),
    nn.ReLU(),
    nn.Conv2d(69, 69, kernel_size=3, stride=1, padding=2, dilation=2),
    nn.AvgPool2d(2),
    nn.BatchNorm2d(69),
    nn.ReLU(),
    nn.Conv2d(69, 69, kernel_size=3, stride=1, padding=4, dilation=4),
    nn.AvgPool2d(2),
    nn.BatchNorm2d(69),
    nn.ReLU(),
    nn.Conv2d(69, 69, kernel_size=3, stride=1, padding=8, dilation=8),
    nn.AvgPool2d(2),
    nn.BatchNorm2d(69),
    nn.ReLU(),
    nn.Conv2d(69, 50, kernel_size=3, stride=1, padding=1, dilation=1),
    nn.BatchNorm2d(50),
    nn.ReLU(),
    nn.Conv2d(50, 34, kernel_size=3, stride=1, padding=1, dilation=1),
    nn.BatchNorm2d(34),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),
    View(),
)

依然是 Good old 全卷积 + 空洞卷积 + 全局池化。优点分析可以参见上一篇博客【23】基于全卷积网络的图像分类

需要特别说明的是最后一层输出的是 34 类而非 36 类,原因是数据集里缺失了 6l 这两个字符… 如果数据集包含了完整的 36 个字符,则需要把最后一个卷积层的深度改为 36,全局池化层的输出也需要改为 36。

结果

使用 0.1 的学习率,128 的 Batch size,在 40 - 50 个 epoch 后收敛。

训练集 acc 约为 96.2%,验证集 acc 约为 93.3%。

在实际的验证码图片测试中,整体准确率上升到 80%。其中,t3st1n 这一条验证码的识别准确率为 99%(毕竟好几百条这哥们儿),其余验证码的准确率约 50%。由于其他验证码数据中,有部分字符十分稀缺,所以识别准确率不出意外的比较差。

因此可以看出,只要拥有足够的数据量(每个字符 100 张以上),神经网络可以获得相当优秀的识别准确率。

尾声

在花费了一个礼拜的功夫之后,这网站把验证码系统换成了 reCAPTCHA项目终结。😕


关于验证码的一些思考

验证码,即 CAPTCHA,全称 Completely Automated Public Turing test to tell Computers and Humans Apart(全自动区分计算机和人类的图灵测试)。

顾名思义,验证码的初衷在于区分人和机器人,需要使用人能够简单完成,但是程序难以完成的任务。最初的传统验证码使用加入噪声或者扭曲的文字图像,人能够轻易辨认,程序难以识别。但是随着计算机视觉和深度学习的发展,现在的机器人已经有能力解决 99% 的文字验证码了。为了抵抗机器人,验证码的字符越来越扭曲,噪声越来越多,人越来越难以看清,反而是机器人依旧能够很准确的识别。就看我正在解决的这个验证码,一个普普通通的学生都可以随便做到很高的识别率,反而是人眼不一定能轻松辨认出是什么字符。从这个角度来说,这个验证码不就是本末倒置了么。

厂商们都清楚这个问题。为了解决这个问题,新一代的验证码开始流行于市场上。我常常见到的有这么几种:

  1. 在文字图片上点击指定的文字
  2. 拖动一个滑块,完成拼图 / 旋转图片到指定角度
  3. 在几张图片中选中指定内容的图片

更为高级的,就是谷歌的 reCAPTCHA。从第二代 reCAPTCHA 开始,谷歌就会综合各种数据给每个用户打分,低于某个阈值的就可以认为是机器人。到第三代,甚至在前端完全不提供任何用户界面,只在网站后台提供打分系统。

但是这些验证码都不可破解吗?显然不是。上面我提到的这三种形式里的前两个无非都只是需要鼠标操作,写一个控制鼠标操作的脚本何其容易,剩下的判定利用神经网络解决也不会是难事。至于第三个,如果是 12306 那种物体类别判断,想想我们现在连 ImageNet 的 1000 类都可以训练下来,破解下这个不就是小儿科;如果是谷歌那种一整张图切成九宫格选物体的类型,大不了也就是上个语义分割网络,再或者也可以选择走提供给视障患者的语音挑战来绕过这个。

就连用机器学习去判断用户的谷歌 reCAPTCHA,也不是不能破解。这篇论文:Hacking Google reCAPTCHA v3 using Reinforcement Learning 就介绍了一种用强化学习绕过 reCAPTCHA v3 的方法。

扯了这么多有的没的,我想表达的观点很简单。道高一尺魔高一丈,研发验证码的人不断创造出新的验证码把机器人挡在外面,而开发爬虫的人又不断更新自己的程序来绕过限制,这不就是妥妥的零和博弈么。生成式对抗网络里生成器和判别器的博弈训练过程和这样的螺旋上升过程不就是完全一回事吗。如此精妙,不得不赞叹隐藏在世界表面下的奇妙社会规律,也不得不赞叹 Goodfellow 强大的洞察和想象力。(GAN 吹是我了)

那把眼光放长放科幻,这个运行在世界上的大型 GAN 最后能给我们带来什么样的结果呢?会是人类一败涂地还是机器大获胜利?Let’s see.


本文阅读量
本站访客量