Tensorflow验证码识别应用

简单的Tensorflow验证码识别应用,供大家参考,具体内容如下

1.Tensorflow的安装方式简单,在此就不赘述了.

2.训练集训练集以及测试及如下(纯手工打造,所以数量不多):

3.实现代码部分(参考了网上的一些实现来完成的)

main.py(主要的神经网络代码)

?
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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
from gen_check_code import gen_captcha_text_and_image_new,gen_captcha_text_and_image
from gen_check_code import number
from test_check_code import get_test_captcha_text_and_image
import numpy as np
import tensorflow as tf
text, image = gen_captcha_text_and_image_new()
print("验证码图像channel:", image.shape) # (60, 160, 3)
# 图像大小
IMAGE_HEIGHT = image.shape[0]
IMAGE_WIDTH = image.shape[1]
image_shape = image.shape
MAX_CAPTCHA = len(text)
print("验证码文本最长字符数", MAX_CAPTCHA) # 验证码最长4字符; 我全部固定为4,可以不固定. 如果验证码长度小于4,用'_'补齐
# 把彩色图像转为灰度图像(色彩对识别验证码没有什么用)
# 度化是将三分量转化成一样数值的过程
def convert2gray(img):
 if len(img.shape) > 2:
  gray = np.mean(img, -1)
  # 上面的转法较快,正规转法如下
  # r, g, b = img[:,:,0], img[:,:,1], img[:,:,2]
  # gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
  # int gray = (int) (0.3 * r + 0.59 * g + 0.11 * b);
  return gray
 else:
  return img
"""
cnn在图像大小是2的倍数时性能最高, 如果你用的图像大小不是2的倍数,可以在图像边缘补无用像素。
np.pad(image,((2,3),(2,2)), 'constant', constant_values=(255,)) # 在图像上补2行,下补3行,左补2行,右补2行
"""
char_set = number # 如果验证码长度小于4, '_'用来补齐
CHAR_SET_LEN = len(char_set)
# 文本转向量
def text2vec(text):
 text_len = len(text)
 if text_len > MAX_CAPTCHA:
  raise ValueError('验证码最长4个字符')
 vector = np.zeros(MAX_CAPTCHA * CHAR_SET_LEN)
 def char2pos(c):
  try:
   k = ord(c)-ord('0')
  except:
   raise ValueError('No Map')
  return k
 for i, c in enumerate(text):
  idx = i * CHAR_SET_LEN + char2pos(c)
  vector[idx] = 1
 return vector
# 向量转回文本
def vec2text(vec):
 char_pos = vec.nonzero()[0]
 text = []
 for i, c in enumerate(char_pos):
  char_at_pos = i # c/63
  char_idx = c % CHAR_SET_LEN
  if char_idx < 10:
   char_code = char_idx + ord('0')
  elif char_idx < 36:
   char_code = char_idx - 10 + ord('A')
  elif char_idx < 62:
   char_code = char_idx - 36 + ord('a')
  elif char_idx == 62:
   char_code = ord('_')
  else:
   raise ValueError('error')
  text.append(chr(char_code))
 return "".join(text)
# 生成一个训练batch
def get_next_batch(batch_size=128):
 batch_x = np.zeros([batch_size, IMAGE_HEIGHT * IMAGE_WIDTH])
 batch_y = np.zeros([batch_size, MAX_CAPTCHA * CHAR_SET_LEN])
 # 有时生成图像大小不是(60, 160, 3)
 def wrap_gen_captcha_text_and_image():
  while True:
   text, image = gen_captcha_text_and_image_new()
   if image.shape == image_shape:
    return text, image
 for i in range(batch_size):
  text, image = wrap_gen_captcha_text_and_image()
  image = convert2gray(image)
  batch_x[i, :] = image.flatten() / 255 # (image.flatten()-128)/128 mean为0
  batch_y[i, :] = text2vec(text)
 return batch_x, batch_y
####################################################################
X = tf.placeholder(tf.float32, [None, IMAGE_HEIGHT * IMAGE_WIDTH])
Y = tf.placeholder(tf.float32, [None, MAX_CAPTCHA * CHAR_SET_LEN])
keep_prob = tf.placeholder(tf.float32) # dropout
# 定义CNN
def crack_captcha_cnn(w_alpha=0.01, b_alpha=0.1):
 x = tf.reshape(X, shape=[-1, IMAGE_HEIGHT, IMAGE_WIDTH, 1])
 # w_c1_alpha = np.sqrt(2.0/(IMAGE_HEIGHT*IMAGE_WIDTH)) #
 # w_c2_alpha = np.sqrt(2.0/(3*3*32))
 # w_c3_alpha = np.sqrt(2.0/(3*3*64))
 # w_d1_alpha = np.sqrt(2.0/(8*32*64))
 # out_alpha = np.sqrt(2.0/1024)
 # 定义三层的卷积神经网络
 # 定义第一层的卷积神经网络
 # 定义第一层权重
 w_c1 = tf.Variable(w_alpha * tf.random_normal([3, 3, 1, 32]))
 # 定义第一层的偏置
 b_c1 = tf.Variable(b_alpha * tf.random_normal([32]))
 # 定义第一层的激励函数
 conv1 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, w_c1, strides=[1, 1, 1, 1], padding='SAME'), b_c1))
 # conv1 为输入 ksize 表示使用2*2池化,即将2*2的色块转化成1*1的色块
 conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
 # dropout防止过拟合。
 conv1 = tf.nn.dropout(conv1, keep_prob)
 # 定义第二层的卷积神经网络
 w_c2 = tf.Variable(w_alpha * tf.random_normal([3, 3, 32, 64]))
 b_c2 = tf.Variable(b_alpha * tf.random_normal([64]))
 conv2 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv1, w_c2, strides=[1, 1, 1, 1], padding='SAME'), b_c2))
 conv2 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
 conv2 = tf.nn.dropout(conv2, keep_prob)
 # 定义第三层的卷积神经网络
 w_c3 = tf.Variable(w_alpha * tf.random_normal([3, 3, 64, 64]))
 b_c3 = tf.Variable(b_alpha * tf.random_normal([64]))
 conv3 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv2, w_c3, strides=[1, 1, 1, 1], padding='SAME'), b_c3))
 conv3 = tf.nn.max_pool(conv3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
 conv3 = tf.nn.dropout(conv3, keep_prob)
 # Fully connected layer
 # 随机生成权重
 w_d = tf.Variable(w_alpha * tf.random_normal([1536, 1024]))
 # 随机生成偏置
 b_d = tf.Variable(b_alpha * tf.random_normal([1024]))
 dense = tf.reshape(conv3, [-1, w_d.get_shape().as_list()[0]])
 dense = tf.nn.relu(tf.add(tf.matmul(dense, w_d), b_d))
 dense = tf.nn.dropout(dense, keep_prob)
 w_out = tf.Variable(w_alpha * tf.random_normal([1024, MAX_CAPTCHA * CHAR_SET_LEN]))
 b_out = tf.Variable(b_alpha * tf.random_normal([MAX_CAPTCHA * CHAR_SET_LEN]))
 out = tf.add(tf.matmul(dense, w_out), b_out)
 # out = tf.nn.softmax(out)
 return out
# 训练
def train_crack_captcha_cnn():
 # X = tf.placeholder(tf.float32, [None, IMAGE_HEIGHT * IMAGE_WIDTH])
 # Y = tf.placeholder(tf.float32, [None, MAX_CAPTCHA * CHAR_SET_LEN])
 # keep_prob = tf.placeholder(tf.float32) # dropout
 output = crack_captcha_cnn()
 # loss
 # loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(output, Y))
 loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output, Y))
 # 最后一层用来分类的softmax和sigmoid有什么不同?
 # optimizer 为了加快训练 learning_rate应该开始大,然后慢慢衰
 optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
 predict = tf.reshape(output, [-1, MAX_CAPTCHA, CHAR_SET_LEN])
 max_idx_p = tf.argmax(predict, 2)
 max_idx_l = tf.argmax(tf.reshape(Y, [-1, MAX_CAPTCHA, CHAR_SET_LEN]), 2)
 correct_pred = tf.equal(max_idx_p, max_idx_l)
 accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
 saver = tf.train.Saver()
 with tf.Session() as sess:
   sess.run(tf.global_variables_initializer())
   step = 0
   while True:
    batch_x, batch_y = get_next_batch(64)
    _, loss_ = sess.run([optimizer, loss], feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.75})
    print(step, loss_)
    # 每100 step计算一次准确率
    if step % 100 == 0:
     batch_x_test, batch_y_test = get_next_batch(100)
     acc = sess.run(accuracy, feed_dict={X: batch_x_test, Y: batch_y_test, keep_prob: 1.})
     print(step, acc)
     # 如果准确率大于50%,保存模型,完成训练
     if acc > 0.99:
      saver.save(sess, "./crack_capcha.model", global_step=step)
      break
    step += 1
## 训练(如果要训练则去掉下面一行的注释)
train_crack_captcha_cnn()
def crack_captcha():
 output = crack_captcha_cnn()
 saver = tf.train.Saver()
 with tf.Session() as sess:
  saver.restore(sess, tf.train.latest_checkpoint('.'))
  predict = tf.argmax(tf.reshape(output, [-1, MAX_CAPTCHA, CHAR_SET_LEN]), 2)
  count = 0
  # 因为测试集共40个...写的很草率
  for i in range(40):
   text, image = get_test_captcha_text_and_image(i)
   image = convert2gray(image)
   captcha_image = image.flatten() / 255
   text_list = sess.run(predict, feed_dict={X: [captcha_image], keep_prob: 1})
   predict_text = text_list[0].tolist()
   predict_text = str(predict_text)
   predict_text = predict_text.replace("[", "").replace("]", "").replace(",", "").replace(" ","")
   if text == predict_text:
    count += 1
    check_result = ",预测结果正确"
   else:
    check_result = ",预测结果不正确"
    print("正确: {} 预测: {}".format(text, predict_text) + check_result)
  print("正确率:" + str(count) + "/40")
# 测试(如果要测试则去掉下面一行的注释)
# crack_captcha()

gen_check_code.py(得到训练集输入,需要注意修改root_dir为训练集的输入文件夹,下同)

?
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
from captcha.image import ImageCaptcha # pip install captcha
import numpy as np
from PIL import Image
import random
# import matplotlib.pyplot as plt
import os
from random import choice
# 验证码中的字符, 就不用汉字了
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']
# 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']
root_dir = "d:\\train"
# 验证码一般都无视大小写;验证码长度4个字符
def random_captcha_text(char_set=number, captcha_size=4):
 captcha_text = []
 for i in range(captcha_size):
  c = random.choice(char_set)
  captcha_text.append(c)
 return captcha_text
# 生成字符对应的验证码
def gen_captcha_text_and_image():
 image = ImageCaptcha()
 captcha_text = random_captcha_text()
 captcha_text = ''.join(captcha_text)
 captcha = image.generate(captcha_text)
 # image.write(captcha_text, captcha_text + '.jpg') # 写到文件
 captcha_image = Image.open(captcha)
 captcha_image = np.array(captcha_image)
 return captcha_text, captcha_image
def gen_list():
 img_list = []
 for parent, dirnames, filenames in os.walk(root_dir): # 三个参数:分别返回1.父目录 2.所有文件夹名字(不含路径) 3.所有文件名字
  for filename in filenames: # 输出文件信息
   img_list.append(filename.replace(".gif",""))
   # print("parent is:" + parent)
   # print("filename is:" + filename)
   # print("the full name of the file is:" + os.path.join(parent, filename)) # 输出文件路径信息
 return img_list
img_list = gen_list()
def gen_captcha_text_and_image_new():
 img = choice(img_list)
 captcha_image = Image.open(root_dir + "\\" + img + ".gif")
 captcha_image = np.array(captcha_image)
 return img, captcha_image
# if __name__ == '__main__':
#  # 测试
#  # text, image = gen_captcha_text_and_image()
#  #
#  # f = plt.figure()
#  # ax = f.add_subplot(111)
#  # ax.text(0.1, 0.9, text, ha='center', va='center', transform=ax.transAxes)
#  # plt.imshow(image)
#  # plt.show()
#  #
#
#  text, image = gen_captcha_text_and_image_new()
#
#  f = plt.figure()
#  ax = f.add_subplot(111)
#  ax.text(0.1, 0.9, text, ha='center', va='center', transform=ax.transAxes)
#  plt.imshow(image)
#  plt.show()

test_check_code.py(得到测试集输入)

?
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
from captcha.image import ImageCaptcha # pip install captcha
import numpy as np
from PIL import Image
import random
import matplotlib.pyplot as plt
import os
from random import choice
root_dir = "d:\\test"
img_list = []
def gen_list():
 for parent, dirnames, filenames in os.walk(root_dir): # 三个参数:分别返回1.父目录 2.所有文件夹名字(不含路径) 3.所有文件名字
  for filename in filenames: # 输出文件信息
   img_list.append(filename.replace(".gif",""))
   # print("parent is:" + parent)
   # print("filename is:" + filename)
   # print("the full name of the file is:" + os.path.join(parent, filename)) # 输出文件路径信息
 return img_list
img_list = gen_list()
def get_test_captcha_text_and_image(i=None):
 img = img_list[i]
 captcha_image = Image.open(root_dir + "\\" + img + ".gif")
 captcha_image = np.array(captcha_image)
 return img, captcha_image

4.效果

在测试集上的识别率 

5.相关文件下载

训练集以及测试集 下载

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/387287.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Linux 桌面玩家指南:09. X Window 的奥秘

Linux 桌面玩家指南&#xff1a;09. X Window 的奥秘 原文:Linux 桌面玩家指南&#xff1a;09. X Window 的奥秘特别说明&#xff1a;要在我的随笔后写评论的小伙伴们请注意了&#xff0c;我的博客开启了 MathJax 数学公式支持&#xff0c;MathJax 使用$标记数学公式的开始和结…

Storm教程1理论介绍

流式计算的历史: 早在7、8年前诸如UC伯克利、斯坦福等大学就开始了对流式数据处理的研究&#xff0c;但是由于更多的关注于金融行业的业务场景或者互联网流量监控的业务场景&#xff0c;以及当时互联网数据场景的限制&#xff0c;造成了研究多是基于对传统数据库处理的流式化&…

梯度下降原理及Python实现

梯度下降算法是一个很基本的算法&#xff0c;在机器学习和优化中有着非常重要的作用&#xff0c;本文首先介绍了梯度下降的基本概念&#xff0c;然后使用python实现了一个基本的梯度下降算法。梯度下降有很多的变种&#xff0c;本文只介绍最基础的梯度下降&#xff0c;也就是批…

matplotlib一些常用知识点的整理,

本文作为学习过程中对matplotlib一些常用知识点的整理&#xff0c;方便查找。 强烈推荐ipython 无论你工作在什么项目上&#xff0c;IPython都是值得推荐的。利用ipython --pylab&#xff0c;可以进入PyLab模式&#xff0c;已经导入了matplotlib库与相关软件包&#xff08;例如…

Storm教程3编程接口

Spouts Spout是Stream的消息产生源&#xff0c;Spout组件的实现可以通过继承BaseRichSpout类或者其他Spout类来完成&#xff0c;也可以通过实现IRichSpout接口来实现。 需要根据情况实现Spout类中重要的几个方法有&#xff1a; open方法 当一个Task被初始化的时候会调用此…

梳理操作系统概论

1、用一张图总结操作系统的结构、功能特征、采用的技术和提供服务方式等。 2、用一张图描述CPU的工作原理。 3、用一张图描述系统程序与应用程序、特权指令与非特权指令、CPU状态、PSW及中断是如何协同工作的&#xff1f; 转载于:https://www.cnblogs.com/ljgljg/p/10503190.ht…

位置指纹法的实现(KNN)

基本原理 位置指纹法可以看作是分类或回归问题&#xff08;特征是RSS向量&#xff0c;标签是位置&#xff09;&#xff0c;监督式机器学习方法可以从数据中训练出一个从特征到标签的映射关系模型。kNN是一种很简单的监督式机器学习算法&#xff0c;可以用来做分类或回归。 对于…

室内定位系列 ——WiFi位置指纹(译)

摘要 GPS难以解决室内环境下的一些定位问题&#xff0c;大部分室内环境下都存在WiFi&#xff0c;因此利用WiFi进行定位无需额外部署硬件设备&#xff0c;是一个非常节省成本的方法。然而WiFi并不是专门为定位而设计的&#xff0c;传统的基于时间和角度的定位方法并不适用于WiFi…

机器学习02线性回归、多项式回归、正规方程

单变量线性回归&#xff08;Linear Regression with One Variable&#xff09; 预测器表达式&#xff1a; 选择合适的参数&#xff08;parameters&#xff09;θ0 和 θ1&#xff0c;其决定了直线相对于训练集的准确程度。 建模误差&#xff08;modeling error&#xff09;&a…

机器学习03Logistic回归

逻辑回归 &#xff08;Logistic Regression&#xff09; 目前最流行&#xff0c;使用最广泛的一种学习算法。 分类问题&#xff0c;要预测的变量 y 是离散的值。 逻辑回归算法的性质是&#xff1a;它的输出值永远在 0 到 1 之间。 逻辑回归模型的假设是&#xff1a; 其中&a…

CNN理解比较好的文章

什么是卷积神经网络&#xff1f;为什么它们很重要&#xff1f; 卷积神经网络&#xff08;ConvNets 或者 CNNs&#xff09;属于神经网络的范畴&#xff0c;已经在诸如图像识别和分类的领域证明了其高效的能力。卷积神经网络可以成功识别人脸、物体和交通信号&#xff0c;从而为机…

Windows 安装Angular CLI

1、安装nvm npm cnpm nrm&#xff08;onenote笔记上有记录&#xff09; 参考&#xff1a;https://blog.csdn.net/tyro_java/article/details/51232458 提示&#xff1a;如果发现配置完后&#xff0c;出现类似“npm不是内部命令……”等信息。 可采取如下措施进行解决—— 检查环…

机器学习04正则化

正则化&#xff08;Regularization&#xff09; 过拟合问题&#xff08;Overfitting&#xff09;&#xff1a; 如果有非常多的特征&#xff0c;通过学习得到的假设可能能够非常好地适应训练集 &#xff1a;代价函数可能几乎为 0&#xff09;&#xff0c; 但是可能会不能推广到…

Adaboost算法

概述 一句话概述Adaboost算法的话就是&#xff1a;把多个简单的分类器结合起来形成个复杂的分类器。也就是“三个臭皮匠顶一个诸葛亮”的道理。 可能仅看上面这句话还没什么概念&#xff0c;那下面我引用个例子。 如下图所示&#xff1a; 在D1这个数据集中有两类数据“”和“-”…

机器学习05神经网络--表示

神经网络&#xff1a;表示&#xff08;Neural Networks: Representation&#xff09; 如今的神经网络对于许多应用来说是最先进的技术。 对于现代机器学习应用&#xff0c;它是最有效的技术方法。 神经网络模型是许多逻辑单元按照不同层级组织起来的网络&#xff0c; 每一层…

逻辑回归(Logistic Regression, LR)又称为逻辑回归分析,是分类和预测算法中的一种。通过历史数据的表现对未来结果发生的概率进行预测。例如,我们可以将购买的概率设置为因变量,将用户的

逻辑回归(Logistic Regression, LR)又称为逻辑回归分析&#xff0c;是分类和预测算法中的一种。通过历史数据的表现对未来结果发生的概率进行预测。例如&#xff0c;我们可以将购买的概率设置为因变量&#xff0c;将用户的特征属性&#xff0c;例如性别&#xff0c;年龄&#x…

机器学习06神经网络--学习

代价函数 标记方法&#xff1a; 神经网络的训练样本有 m 个 每个包含一组输入 x 和一组输出信号 y L 表示神经网络层数 Sl表示每层的 neuron 个数(SL 表示输出层神经元个数) 将神经网络的分类定义为两种情况&#xff1a; 二类分类&#xff1a;SL1, y0 or 1 表示哪一类&…

Logistic Regression Classifier逻辑回归

Logistic Regression Classifier逻辑回归主要思想就是用最大似然概率方法构建出方程&#xff0c;为最大化方程&#xff0c;利用牛顿梯度上升求解方程参数。 优点&#xff1a;计算代价不高&#xff0c;易于理解和实现。缺点&#xff1a;容易欠拟合&#xff0c;分类精度可能不高…

机器学习07应用机器学习的建议

决定下一步做什么&#xff08;Deciding What to Try Next&#xff09; 确保在设计机器学习系统时&#xff0c;能够选择一条最合适、最正确的道路。 具体来讲&#xff0c;将重点关注的问题是&#xff1a;假如你在开发一个机器学习系统&#xff0c;或者想试着改进一个机器学习…

CSS3--5.颜色属性

HTML5中添加了一些新的颜色的表示方式 1.RGBA&#xff1a;说得简单一点就是在RGB的基础上加进了一个通道Alpha。RGBA在RGB的基础上多了控制alpha透明度的参数。以上R、G、B三个参数&#xff0c;正整数值的取值范围为&#xff1a;0 - 255。百分数值的取值范围为&#xff1a;0.0%…