深度学习之卷积神经网络识别图片验证码实战案例(十)

案例背景:程序自动化的爬虫而无需人工介入是我们的最终目标。自动化爬虫避免不了自动登录的问题,在爬取XX数据的过程中,遇到登录图形验证码的识别的问题,那我们该如何攻破这种验证码呢?

字符验证码图片如下:
深度学习之卷积神经网络识别图片验证码实战案例(十)_第1张图片
在这个案例中,我会通过案例一步一步攻破这种验证码。

现有能力调研

深度学习之卷积神经网络识别图片验证码实战案例(十)_第2张图片

  1. pytesseract 是一款开源的免费的OCR识别工具,它能识别一些很基础、很简单的验证码,但是面对稍微复杂一点的验证码识别准确率就很低了。
  2. 超级鹰等云打码平台,能够识别复杂的验证码,识别准确率较好,但是其是收费的,费用标准大约几百每年。在平台上注册后会送一些免费的使用次数,大家感兴趣的可以尝试一下。

靠人不如靠己!不就是个简单的验证码识别吗?弄他!

验证码分析

我们先分析一下,我们这个验证码相较于市面上常见的验证码,有何区别?

深度学习之卷积神经网络识别图片验证码实战案例(十)_第3张图片
这个验证码主要有2个问题影响识别:

  1. 干扰元素较多
  2. 字符倾斜,严重的字符展示不全。

如何让机器像人一样准确地识别出图片上的验证码字符呢?下面我们一起用机器学习搞定这个实战案例!开始之前,我们再来回顾一下六步法实战!

深度学习之卷积神经网络识别图片验证码实战案例(十)_第4张图片

1、数据收集

首先,我们要搞定训练数据收集的问题,也就是收集一些验证码图片的数据。数据从何而来呢?在六步法实战中,我们介绍了获取数据的几种常用手段。显然,这个数据集需要我们自己去手动搞定他了!怎么搞?答案就是爬虫!

爬虫分析实现

  1. XX平台获取验证码的接口是动态的,也就是同样的请求会随机返回一张二维码。接口的URL是:http://xxxxx
  2. 获取的图片的数据后,我们将数据保存下来。
  3. 重复1、2步骤…

20行代码实现爬取图片数据

import requests
import time

headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
                         "Chrome/88.0.4324.182 Safari/537.36 Edg/88.0.705.81"}

url = "https://xxxxx"


def get_captcha():
    """
    获取验证码并存储
    :return: 
    """
    for i in range(0, 10000):
        time.sleep(2)
        print("sleeping...")
        resp = requests.get(url, headers=headers)
        with open(f"../picture/{i}.png", 'wb') as file:
            file.write(resp.content)


def main():
    get_captcha()


if __name__ == '__main__':
    main()


这里我们通过 resp = requests.get(url, headers=headers) 请求验证码图片并返回数据,然后通过 file.write(resp.content) 保存图片数据。

这里爬了很多个小时,终于把数据准备好了!(不敢爬的太快!爬虫爬得快,监狱进的早)爬完之后的数据长这样子。

深度学习之卷积神经网络识别图片验证码实战案例(十)_第5张图片

2、数据预处理

数据准备好之后,重头戏才刚刚开始。

在数据处理之前,我们先明确一个问题,验证码识别应该属于什么类型的机器学习项目?其实这是一个分类的项目,并且属于监督学习。以机器的视角来看,验证码识别,其实就是对验证码图片上的字符进行分类成A、B、C、7、8、9等等,所以这是监督学习中的分类问题,那为什么是监督学习呢?请你思考一下。

在数据的预处理阶段,我们要做哪些工作?再回顾一下数据预处理的经典5步:
深度学习之卷积神经网络识别图片验证码实战案例(十)_第6张图片

数据可视化阶段在这个案例中可以省略了!

数据清洗对于验证码图片数据而言,叫图片清洗分类更为贴切,其中包括图片的灰度、降噪、裁剪、分类等工作。

2.1、让图片更干净些

我们先看一下效果,如下是经过了验证码背景图清洗前和清洗后的对比:

深度学习之卷积神经网络识别图片验证码实战案例(十)_第7张图片

这里主要使用OpenCV库对图片进行灰度、降噪、二值化,这些都是图片预处理的常用手段。这里我们简单的介绍一下。

OpenCV是一个开源的计算机视觉库。它提供了一系列图像处理和计算机视觉算法,包括图像滤波、目标检测、人脸识别等。

灰度图像

在一张彩色图片中,每个像素点由三个RGB颜色通道(红、绿、蓝)组成,每个通道的颜色值可以是0到255之间的任何值。灰度图像是一种单通道图像,每个像素只有一个灰度值。灰度图像可以看作是将彩色图像的三个颜色通道(红、绿、蓝)合并为一个通道得到的结果,也可以通过将三个通道的值加权平均得到。

在机器学习领域,通常将彩色图像转换为灰度图像进行处理,因为与RGB图像相比,灰度图像具有更简单的结构和更低的计算复杂度。在OpenCV中使用 cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) 方法将RGB三通道图像转换为灰度图像。

降噪

降噪就是用于减少图像中的噪声。图像噪声是由于图像获取和传输过程中的信号干扰、电磁辐射等原因导致的随机扰动。这些噪声会影响图像质量和后续处理结果,因此需要使用降噪技术来减少噪声的影响。在OpenCV中,可以使用`cv2.GaussianBlur()函数实现高斯滤波,从而提高图像的质量和后续处理结果。

二值化

图片二值化是一种重要的图像预处理技术,可以用于去除噪声、提高对比度、简化图像信息、分离目标、降低数据量等目的。在实际应用中,需要根据具体情况选择合适的二值化方法和参数,以达到最佳的效果。在OpenCV中,可以使用 cv2.threshold()函数对图像进行二值化操作。

以下是降噪、灰度和二值化的完整代码,主要流程为

  1. OpenCV载入待处理图片:img = cv2.imread(image_path, 1)
  2. 将RGB三通道图像转为灰度图像 gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
  3. 使用高斯滤波降噪 cv2.GaussianBlur(gray_img, (5, 5), 0)
  4. 二值化图片 cv2.threshold(blur, 134, 255, 0, gray_img)
  5. 返回处理后的图片

完整代码如下:

def cv2_noise_remove(image_path, k):
    """
    8邻域降噪
    Args:
        image_path: 图片文件命名
        k: 判断阈值

    Returns:
    """

    def calculate_noise_count(img_obj, w, h):
        """
        计算邻域非白色的个数
        Args:
            img_obj: img obj
            w: width
            h: height
        Returns:
            count (int)
        """
        count = 0
        width, height = img_obj.shape
        for _w_ in [w - 1, w, w + 1]:
            for _h_ in [h - 1, h, h + 1]:
                if _w_ > width - 1:
                    continue
                if _h_ > height - 1:
                    continue
                if _w_ == w and _h_ == h:
                    continue
                if img_obj[_w_, _h_] < 230:  # 二值化的图片设置为255
                    count += 1
        return count

    img = cv2.imread(image_path, 1)
    # 灰度
    gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    w, h = gray_img.shape
    for _w in range(w):
        for _h in range(h):
            if _w == 0 or _h == 0:
                gray_img[_w, _h] = 255
                continue
            # 计算邻域pixel值小于255的个数
            pixel = gray_img[_w, _h]
            if pixel == 255:
                continue

            if calculate_noise_count(gray_img, _w, _h) < k:
                gray_img[_w, _h] = 255

    # gray_img = cv2.adaptiveThreshold(gray_img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)

    # 先使用一个 5x5 的高斯核除去噪音,然后再使用 Otsu 二值化
    blur = cv2.GaussianBlur(gray_img, (5, 5), 0)
    # ret3, th3 = cv2.threshold(blur, 1, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    # ret3, th3 = cv2.threshold(blur, 144, 255, 0, gray_img)
    ret3, th3 = cv2.threshold(blur, 134, 255, 0, gray_img)  # 更优秀
    # # 二值化处理
    # ret3, th3 = cv2.threshold(th3, 134, 255, 0, th3)  # 二值化函数

    return th3

2.2、裁剪图片

图片清理干净后,我们需要对图片进行裁剪。裁剪的目的是将图片按照字符进行切分,以便于后续的训练及识别。
深度学习之卷积神经网络识别图片验证码实战案例(十)_第8张图片

切割的方法比较简单,这里我们将验证码图片等比例切分为4份。并保存切割后的图片。主要逻辑为:

  1. 等比例裁剪图片 image.copy()[box[1]:box[3], box[0]:box[2]] # 裁剪坐标为[y0:y1, x0:x1]
  2. 使用OpenCV保存图片 cv2.imwrite(temp_path, temp_image)
def cv2_split_image_and_save(img_path):
    """
    根据图片路径cv2处理图片并拆分
    :param img_path: 图片download路径
    :return: 拆分后图片路径
    """
    # '/Users/rongtao7/IdeaProjects/yaoCaptchaDiscern/temp/97090039-4859-4bb6-a47e-003654b36881.png'
    image = cv2_noise_remove(img_path, 4)
    save_path = []
    for i in range(ConfigUtil.IMG_CHAR_COUNT):
        box = cv2_img_crop_box(i)
        temp_image = image.copy()[box[1]:box[3], box[0]:box[2]]  # 裁剪坐标为[y0:y1, x0:x1]
        file_name = f"{img_path.split('/temp/')[1].split('.')[0]}{ConfigUtil.TEMP_IMG_NAME_SEPARATOR}{i}.png"
        # print(file_name)
        temp_path = f"{sys.path[0]}/temp/{file_name}.png"
        cv2.imwrite(temp_path, temp_image)
        save_path.append(temp_path)
    return save_path

2.3、图片分类

裁剪好的图片,我们需要将图片分类,相当于给图片打标签,告诉机器这张图片应该属于什么分类,也就是它是什么。那我们一共有哪些分类呢?

由数字和英文字母组成,一共32个分类类别,其中排除掉了 1I 0O的易错选项,因为他们容易混淆,人眼都容易弄错,用户的体验也不好。

深度学习之卷积神经网络识别图片验证码实战案例(十)_第9张图片

那我们现在要做的工作就是将所有切割后的图片分类到这32个文件夹中!好家伙!这可是一个庞大的工程啊,看一下我是怎么做的?

。。。。。。省略人工标注过程

前期我做了大量的人工标注工作,简直怀疑人生

那有没有什么工具能帮帮我呢!这让我又想起了 pytesseract 这个开源的OCR识别库,前面我们提到过,针对整个验证码图片它的识别率是极低的,因为它只能处理简单的字符图片识别工作!但是我们的图片经过预处理和切割后,相对也好识别一些了,所以我就想到了让 pytesseract 帮我识别一部分,它识别不了的或者识别错误的,我们再手动标注一部分数据,这样我们图片手动标注的工作也是提效了约 50%

深度学习之卷积神经网络识别图片验证码实战案例(十)_第10张图片
那有的同学就想到了!是不是图片切割好以后,用 pytesseract 识别字符,就可以完成验证码识别工作了?

当然可以!这个我也尝试过了,只不过识别的准确率较低,每个字符图片的准确率大概在 40%左右,但是4张图片结果加到一起后准确率相对就比较低了,一个免费开源的库你还要啥自行车啊!

使用 pytesseract辅助分类的代码如下,主要有2个步骤:(1)通过 ocr方法识别图片(2)通过 collect将图片移动到指定文件夹下

import os
import cv2
from PIL import Image, ImageFilter
import shutil

import pytesseract

"""
OCR图片分类
"""

split_list = os.listdir("./splits")
list_new = os.listdir("./captchas_new")


def ocr(img_path):
    """
    pytesseract ocr识别
    :param img_path: 图片路径
    :return: 识别结果
    """
    image = cv2.imread(img_path, 1)
    if image is None:
        return ""
    test_message = Image.fromarray(image)
    if test_message is None:
        return ""
    target = pytesseract.image_to_string(test_message, lang='eng',
                                         config='--psm 10 --oem 3 -c '
                                                'tessedit_char_whitelist=0123456789QWERTYUIOPLKJHGFDSAZXCVBNM')
    target = target.replace('\n', '').replace('\r', '')
    print(f"图片路径:{img_path},ocr识别结果为:{target}")
    return target


def collect(target, source):
    """
    收集图片
    :param target: 目标路径
    :param source: 源路径
    :return: 
    """
    target = "./captchas_new/" + target + "/"
    if str(target) in list_new:
        shutil.move(source, target)
        print(f"移动文件成功,源文件为:[{source}]")
    else:
        print(f"移动文件失败,{source}文件识别结果为[{target}]")


for path in split_list:
    print(path)
    new_path = "./splits/" + path
    source = ocr(new_path)
    collect(source, new_path)

至此,我们的数据清洗工作就完成了!

2.4、特征工程

在特征工程阶段,我们要对图片的数据特征进行变换。特征变换的手段对于数值特征和分类特征是不同的。

我们这里属于分类特征,那对标签我们使用独热编码进行变换。而图片数据,我们通过特征缩放变换来压缩特征的空间。

深度学习之卷积神经网络识别图片验证码实战案例(十)_第11张图片

在这个环节,我们要将图片转换成机器可以识别的数据,然后就可以把数据集喂给模型了。这里我们将图片转换成 NumPy 数组也叫张量数组,对张量数组进行归一化缩放;将标签转换成One-Hot编码

什么是张量数组

在深度学习中,模型的输入通常都是张量数组。通过使用张量数组,可以对大量的数据进行高效的处理和计算。

张量数组其实就是一个多维数组。他可以存储和处理大量的数据。例如,图像可以表示为三维数组,其中第一个维度表示图像的高度,第二个维度表示图像的宽度,第三个维度表示图像的颜色通道。文本数据可以表示为二维数组,其中第一个维度表示文本的序列长度,第二个维度表示每个单词的向量表示。

什么是One-Hot编码

One-hot编码是一种常见的数据编码方式,用于将离散的、分类的数据转换为机器学习算法能够使用的数值型数据。在One-hot编码中,每个离散的特征值(也称为类别、标签或因子)被编码为一个长度为特征数量的二进制向量,其中只有一个元素为1,其他元素均为0。这个1所在的位置就代表了该特征值所属的类别。

首先,我们通过OpenCV来读入图片的数据,并使用NumPy将图片转换成张量数组。

import numpy as np
import pandas as pd
import os
import cv2


list = ["2","3","4","5","6","7","8","9","A","B","C","D","E","F","G","H","J","K","L","M","N","P","Q","R","S","T","U","V","W","X","Y","Z"]

X = []
y_label = []
imgsize = [105, 96]

def training_data(label, data_dir):
    for img in os.listdir(data_dir):
        path = os.path.join(data_dir, img)  # 目录+文件名
        img = cv2.imread(path,cv2.IMREAD_COLOR) #读入图片
        img = cv2.resize(img,(imgsize[0],imgsize[1])) #设定图片像素维度
        X.append(np.array(img)) #X特征集
        y_label.append(str(label)) #y标签

for label in list:
    training_data(label, f'./captchas_new/{label}')

这段代码很简单,我们通过 for 循环调用 training_data() 方法,在这个方法中,通过 cv2.imread 读取os路径的图片数据,然后通过 cv2.resize(img,(imgsize[0],imgsize[1]))统一图片的像素维度。收集特征和标签分别到 X = []y_label = []集合中。

然后通过 NumPy将图片转换为张量数组

X = np.array(X) # 将X从列表转换为张量数组

现在我们要对张量数组再进行特征变换,由于我们的特征都是0~255之间的数值,所以这里选择特征缩放,即归一化缩放。

X = X/255 # 将X张量归一化

然后我们对标签进行编码及特征变换的处理。这里要使用 sklearn 库的LabelEncoder编码工具,然后通过 keras 库的 to_categorical 进行One-hot编码。

from sklearn.preprocessing import LabelEncoder # 导入标签编码工具
from keras.utils import to_categorical # 导入One-hot编码工具

label_encoder = LabelEncoder()
y = label_encoder.fit_transform(y_label) # 标签编码
y = to_categorical(y, 32) # 将标签转换为One-hot编码

好了,现在我们的特征集X和标签集 y 就构建完毕了,在特征工程阶段,我们对特征集X进行了归一化缩放,对标签集y进行了One-hot编码,做这些工作的目的就是为了能够把数据集喂给模型。

2.4、构建特征集和标签集

这里我们要借助 sklearn 库的 model_selection 模块的 train_test_split 拆分工具来拆分数据集。我们将特征集拆分为训练集 X_train 和 测试集 X_test,将标签集拆分为训练集 y_train 和 测试集 y_test。并且训练集和测试集的比例是8:2

from sklearn.model_selection import train_test_split # 导入拆分工具

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,random_state=1)

3、选择算法

图像的处理,使用深度学习的神经网络算法肯定是更胜一筹,它擅长对复杂特征的提取。

神经网络算法又分为CNN、RNN、DNN等,而卷积神经网络对图像等数据进行特征提取和分类则是比较有优势,所以这里我们选择卷积神经网络CNN算法。

举例:车牌识别

卷积神经网络?

卷积神经网络(CNN)是一种常用的神经网络模型,特别适用于图像、视频和语音等高维度数据的处理和分析。其主要原理是通过卷积操作和池化操作来提取数据的特征,并通过全连接层将这些特征映射到输出层进行分类或回归。

卷积神经网络结构:卷积神经网络由输入层、一个或多个卷积层和输出层的全连接层组成。

深度学习之卷积神经网络识别图片验证码实战案例(十)_第12张图片

  1. 输入层:接收输入数据,并将其传递到下一层。什么输入数据?就是特征缩放后的数据。
  2. 卷积层:主要负责提取图片的特征。其中的卷积核(上图中红框部分)也叫滤波器,能够自动进行图像特征的提取。
  3. 最大池化层:就是将特征映射划分为若干个矩形区域,挑选每个区域中的最大值,也就是最明显的特征作为采样的结果。可以避免过拟合。
  4. 多个卷积层和池化层能够实现对图像特征的逐层提取
  5. 展平层,主要负责将网络展平。展平之后通常会接一个普通的全连接层。而最右边的输出层也是全连接层,用 Softmax 进行激活分类输出层,Softmax 函数的主要作用是将神经网络输出的实数值转化为概率分布。

建立CNN算法模型

借助 keras库的layers和models工具我们建立CNN模型

from keras import layers # 导入所有层 
from keras import models # 导入所有模型 
import joblib

# 贯序模型 ,序贯模型也是最简单的模型,就是像盖楼一样,一层一层往上堆叠着搭新的层。
cnn = models.Sequential() 


# 激活函数接收神经元的输入信号,经过非线性变换后输出神经元的激活值。这个激活值通常被用于传递到下一层神经元或输出层中。激活函数可以增加模型的表达能力和拟合能力
cnn.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(96, 105, 3)))# 输入卷积层
cnn.add(layers.MaxPooling2D((2, 2))) # 最大池化层 

cnn.add(layers.Conv2D(64, (3, 3), activation='relu')) # 卷积层 
cnn.add(layers.MaxPooling2D((2, 2))) # 最大池化层 

cnn.add(layers.Conv2D(128, (3, 3), activation='relu')) # 卷积层 
cnn.add(layers.MaxPooling2D((2, 2))) # 最大池化层 

cnn.add(layers.Conv2D(128, (3, 3), activation='relu')) # 卷积层 
cnn.add(layers.MaxPooling2D((2, 2))) # 最大池化层 

cnn.add(layers.Flatten()) # 展平层 

cnn.add(layers.Dense(512, activation='relu')) # 全连接层 

# 32表示种类,激活函数使用Softmax
cnn.add(layers.Dense(32, activation='softmax')) # 分类输出层 


# 设置优化器
cnn.compile(loss='categorical_crossentropy', # 损失函数 
            optimizer='RMSprop',
            metrics=['acc']) # 评估指标

4、训练模型

通过fit 拟合模型,指定训练轮次,训练的同事进行验证

在训练过程中,我们还指定了 validation_split,它可以在训练的同时,自动把训练集部分拆出来,进行验证,在每一个训练轮次中,求出该轮次在训练集和验证集上面的损失和预测准确率。

# 训练网络并把训练过程信息存入history对象
history = cnn.fit(X_train,y_train, #训练数据
                  epochs=50, #训练轮次(梯度下降)
                  validation_split=0.2) #训练的同时进行验证

然后将训练的模型保存到 model.h5文件中

cnn.save(os.path.join(os.path.dirname("./result"), 'model.h5'))
Train on 2089 samples, validate on 523 samples
Epoch 1/50
2089/2089 [==============================] - 86s 41ms/step - loss: 1.3523 - acc: 0.3978 - val_loss: 1.0567 - val_acc: 0.5411
Epoch 2/50
2089/2089 [==============================] - 85s 41ms/step - loss: 1.0167 - acc: 0.5692 - val_loss: 1.0336 - val_acc: 0.5526
Epoch 3/50
2089/2089 [==============================] - 85s 41ms/step - loss: 0.8912 - acc: 0.6343 - val_loss: 0.9183 - val_acc: 0.6310
Epoch 4/50
2089/2089 [==============================] - 84s 40ms/step - loss: 0.8295 - acc: 0.6596 - val_loss: 0.9289 - val_acc: 0.6138
Epoch 5/50
2089/2089 [==============================] - 85s 41ms/step - loss: 0.7228 - acc: 0.7056 - val_loss: 1.0086 - val_acc: 0.5736
... ...

这个输出的信息包括了训练的轮次(梯度下降的次数)、每轮训练的时长、每轮训练过程中的平均损失,以及分类的准确度。这里的每一个轮次,其实就是神经网络对其中的每一个神经元自动调参、通过梯度下降进行最优化的过程。

5、评估和优化模型

优化器和学习速率

在卷积神经网络中,优化器和学习速率是两个常用的超参数,用于调节模型的训练过程和优化效果。

**优化器(Optimizer)**是指模型在训练过程中使用的优化算法,用于更新模型的权重和偏置参数,使得模型的损失函数最小化。前较常用的是 RMSprop 和 Adam

学习速率(Learning Rate)是指模型在每次参数更新时,更新的步长大小。学习速率通常是一个非常重要的超参数,它能够影响模型的训练速度和优化效果。如果学习速率过大,可能会导致模型参数在更新过程中产生过大的波动,使得模型无法收敛;而如果学习速率过小,可能会导致模型训练缓慢,需要更长时间才能收敛。

优化器是用于解决神经网络中的局部最低点的问题。

神经网络也是通过梯度下降来实现参数的最优化,梯度下降是通过求导实现的。神经网络因为函数十分复杂,会出现很多的局部最低点,在每一个局部最低点,导数的值都为 0。没有求导后的正负,梯度下降也就没有任何方向感,所以这时候,优化神经网络的参数也不知道应该往哪里走了。
深度学习之卷积神经网络识别图片验证码实战案例(十)_第13张图片

学习速率(Learning Rate)是指模型在每次参数更新时,更新的步长大小。学习速率通常是一个非常重要的超参数,它能够影响模型的训练速度和优化效果。如果学习速率过大,可能会导致模型参数在更新过程中产生过大的波动,使得模型无法收敛;而如果学习速率过小,可能会导致模型训练缓慢,需要更长时间才能收敛。因此,选择合适的学习速率非常重要,通常需要通过实验和调参来确定最佳的学习速率。

如何设定优化器?==**

cnn.compile(loss='categorical_crossentropy', # 损失函数 行15
            optimizer=Adam(learning_rate=1e-4), # 优化器和学习速率
            metrics=['acc']) # 评估指标

显示训练过程中的损失曲线

在训练模型时,我们将训练的过程信息保存到了history对象中,通过history对象我们可以查看训练集上的损失以及验证集上的准确率。

# 训练网络并把训练过程信息存入history对象
history = cnn.fit(X_train,y_train, #训练数据
                  epochs=50, #训练轮次(梯度下降)
                  validation_split=0.2) #训练的同时进行验证

通过matplotlib画出损失曲线和准确率曲线

def show_history(history): # 显示训练过程中的学习曲线
    loss = history.history['loss'] #训练损失
    val_loss = history.history['val_loss'] #验证损失
    epochs = range(1, len(loss) + 1) #训练轮次
    plt.figure(figsize=(12,4)) # 图片大小
    plt.subplot(1, 2, 1) #子图1
    plt.plot(epochs, loss, 'bo', label='Training loss') #训练损失
    plt.plot(epochs, val_loss, 'b', label='Validation loss') #验证损失
    plt.title('Training and validation loss') #图题
    plt.xlabel('Epochs') #X轴文字
    plt.ylabel('Loss') #Y轴文字
    plt.legend() #图例
    acc = history.history['acc'] #训练准确率
    val_acc = history.history['val_acc'] #验证准确率
    plt.subplot(1, 2, 2) #子图2
    plt.plot(epochs, acc, 'bo', label='Training acc') #训练准确率
    plt.plot(epochs, val_acc, 'b', label='Validation acc') #验证准确率
    plt.title('Training and validation accuracy') #图题
    plt.xlabel('Epochs') #X轴文字
    plt.ylabel('Accuracy') #Y轴文字
    plt.legend() #图例
    plt.show() #绘图
show_history(history) # 调用这个函数

通过 evaluate方法 可以评估模型在测试集上的准确率

result = cnn.evaluate(X_test, y_test) #评估测试集上的准确率
print('CNN的测试准确率为',"{0:.2f}%".format(result[1]))

下面是训练集和验证集的损失曲线和准确率曲线。

1)训练5次的结果。下面的损失曲线在验证集上是有一些波动的,效果并不是很好
深度学习之卷积神经网络识别图片验证码实战案例(十)_第14张图片

2)训练24次,模型在测试集上的准确率为 95%
深度学习之卷积神经网络识别图片验证码实战案例(十)_第15张图片
3)训练50次,模型在测试集上的准确率为 96%
深度学习之卷积神经网络识别图片验证码实战案例(十)_第16张图片

这个时候,其实无论训练多少次,都没有多大作用了!我们要考虑优化模型的超参数了!

调整超参数:优化器和学习速率

我们将优化器由 Adam 更换为 RMSprop ,并且我们没有指定学习速率,RMSprop 优化器是一种自适应学习率算法,它可以根据梯度的大小自动调整学习速率。

cnn.compile(loss='categorical_crossentropy', # 损失函数 行15
            # optimizer=Adam(learning_rate=1e-4), # 优化器
            optimizer='RMSprop',
            metrics=['acc']) # 评估指标

训练50次,使用RMSprop优化器,模型在测试集上的准确率为 99%
深度学习之卷积神经网络识别图片验证码实战案例(十)_第17张图片
至此,我们训练的模型已经满足我们的要求了,它对验证码的识别准确率达到了 99%。

6、部署模型

模型已经训练出来了,我们现在要将模型部署到服务器上,然后通过域名对外提供API服务,这里我们选择了Django框架。因为有同事是使用这个框架部署的,可以借鉴一些经验,少踩坑!

Diango: Django是一个基于Python的Web应用程序框架。使用简单,社区很活跃,是python语言中开发Web应用的首选框架。

https://www.djangoproject.com/

具体涉及公司隐私内容,不便展示。

你可能感兴趣的:(机器学习入门与实战,深度学习,cnn,图片验证码识别案例,卷积神经网络,字符验证码识别)