识别验证码

​

• 本文为🔗365天深度学习训练营 中的学习记录博客
• 参考文章地址： 🔗深度学习100例-卷积神经网络（CNN）识别验证码 | 第12天

​

活动地址：CSDN21天学习挑战赛

学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：
想系统/深入学习某技术知识点…
一个人摸索学习很难坚持，想组团高效学习…
想写博客但无从下手，急需写作干货注入能量…
热爱写作，愿意让自己成为更好的人…
…

**

创作计划

**
1，机缘

A，验证码识别项目中的经验分享
B，平时学习过程中的记录
C，通过验证码识别进行技术交流

2，收获

A，获得了10粉丝的关注
B，获得了20的赞、阅读量等
C，认识了解了验证码识别的同行

3，日常

1. 创作已经是我学习的一部分了
2. 有限的时间下，周二、周四、周六进行创作，其余时间学习

4，憧憬

创作规划是学习验证码识别的方法，创建验证码识别模型。进一步学习卷积神经网络。

**

学习计划

**
1，学习目标

掌握验证码识别知识

2，学习内容

A，分析验证码识别流程
B，掌握数据集划分方法
C，掌握构建数据集方法

3，学习时间

周一至周五晚上 7 点—晚上9点
周六下午 6 点-下午 9 点
周日下午6 点-下午 9 点

4，学习产出

技术笔记 1 篇
CSDN技术博客 3 篇
学习的vlog 视频 1 个

**

学习日记

**
1，学习知识点

学习验证码识别，模型构建方法

2，学习遇到的问题

数组越界、数据集构建、提高性能

3，学习的收获

学会了验证码识别模型

4，实操

import matplotlib.pyplot as plt
# 支持中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

import os,PIL,random,pathlib
from tensorflow.keras import datasets, layers, models
# 设置随机种子尽可能使结果可以重现
import numpy as np
np.random.seed(1)

# 设置随机种子尽可能使结果可以重现
import tensorflow as tf
tf.random.set_seed(1)

data_dir = "D:/BaiduNetdiskDownload/captcha"
data_dir = pathlib.Path(data_dir)

all_image_paths = list(data_dir.glob('*'))
all_image_paths = [str(path) for path in all_image_paths]
# 打乱数据
random.shuffle(all_image_paths)

# 获取数据标签,3表示获取第三个//中的内容
all_label_names = [path.split("\\")[3].split(".")[0] for path in all_image_paths]

image_count = len(all_image_paths)
print("图片总数为：",image_count)
#数据可视化
plt.figure(figsize=(10, 5))

for i in range(20):
    plt.subplot(5, 4, i + 1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)

     # 显示图片
     images = plt.imread(all_image_paths[i])
     plt.imshow(images)
     # 显示标签
     plt.xlabel(all_label_names[i])

 plt.show()
#标签数字化
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']
char_set       = number + alphabet
char_set_len   = len(char_set)
label_name_len = len(all_label_names[0])


# 将字符串数字化
def text2vec(text):
    vector = np.zeros([label_name_len, char_set_len])
    for i, c in enumerate(text):
        idx = char_set.index(c)
        vector[i][idx] = 1.0
    return vector

all_labels = [text2vec(i) for i in all_label_names]
##构建tf.data.Dataset
def preprocess_image(image):
    image = tf.image.decode_jpeg(image, channels=1)
    image = tf.image.resize(image, [50, 200])
    return image/255.0

def load_and_preprocess_image(path):
    image = tf.io.read_file(path)
    return preprocess_image(image)
##加载数据
AUTOTUNE = tf.data.experimental.AUTOTUNE

path_ds  = tf.data.Dataset.from_tensor_slices(all_image_paths)
image_ds = path_ds.map(load_and_preprocess_image, num_parallel_calls=AUTOTUNE)
label_ds = tf.data.Dataset.from_tensor_slices(all_labels)

image_label_ds = tf.data.Dataset.zip((image_ds, label_ds))
print(image_label_ds)

train_ds = image_label_ds.take(1000)  # 前1000个batch
val_ds   = image_label_ds.skip(1000)  # 跳过前1000，选取后面的

BATCH_SIZE = 16

train_ds = train_ds.batch(BATCH_SIZE)
train_ds = train_ds.prefetch(buffer_size=AUTOTUNE)

val_ds = val_ds.batch(BATCH_SIZE)
val_ds = val_ds.prefetch(buffer_size=AUTOTUNE)
print(val_ds)

model = models.Sequential([

    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(50, 200, 1)),  # 卷积层1，卷积核3*3
    layers.MaxPooling2D((2, 2)),  # 池化层1，2*2采样
    layers.Conv2D(64, (3, 3), activation='relu'),  # 卷积层2，卷积核3*3
    layers.MaxPooling2D((2, 2)),  # 池化层2，2*2采样

    layers.Flatten(),  # Flatten层，连接卷积层与全连接层
    layers.Dense(1000, activation='relu'),  # 全连接层，特征进一步提取

    layers.Dense(label_name_len * char_set_len),
    layers.Reshape([label_name_len, char_set_len]),
    layers.Softmax()  # 输出层，输出预期结果
])
# 打印网络结构
model.summary()
model.compile(optimizer="adam",
              loss='categorical_crossentropy',
              metrics=['accuracy'])
epochs = 20

history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=epochs
)
#模型评估
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(epochs)

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()




#保存加载模型
model.save('model/12_model.h5')
new_model = tf.keras.models.load_model('model/12_model.h5')
#预测
def vec2text(vec):
    """
    还原标签（向量->字符串）
    """
    text = []
    for i, c in enumerate(vec):
        text.append(char_set[c])
    return "".join(text)

plt.figure(figsize=(10, 8))            # 图形的宽为10高为8

for images, labels in val_ds.take(1):
    for i in range(6):
        ax = plt.subplot(5, 2, i + 1)
        # 显示图片
        plt.imshow(images[i])

        # 需要给图片增加一个维度
        img_array = tf.expand_dims(images[i], 0)

        # 使用模型预测验证码
        predictions = model.predict(img_array)
        plt.title(vec2text(np.argmax(predictions, axis=2)[0]))

        plt.axis("off")
plt.show()



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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

输出：


分析：可以看出模型在测试集上表现得不如在训练集上表现得好，有少许过拟合现象。但是总的趋势是与训练集相似。使用测试集验证模型时大部分字符预测都是正确的，有少部分预测错误，有待改进。