python tensorflow验证码识别_TensorFlow验证码识别

最新推荐文章于 2023-02-03 09:51:32 发布

weixin_39936086

最新推荐文章于 2023-02-03 09:51:32 发布

阅读量116

点赞数

文章标签： python tensorflow验证码识别

本节我们来用 TensorFlow 来实现一个深度学习模型，用来实现验证码识别的过程，这里我们识别的验证码是图形验证码，首先我们会用标注好的数据来训练一个模型，然后再用模型来实现这个验证码的识别。

验证码

首先我们来看下验证码是怎样的，这里我们使用 Python 的 captcha 库来生成即可，这个库默认是没有安装的，所以这里我们需要先安装这个库，另外我们还需要安装 pillow 库，使用 pip3 即可：

pip3 install captcha pillow

安装好之后，我们就可以用如下代码来生成一个简单的图形验证码了：

from captcha.image import ImageCaptcha

from PIL import Image

text='1234'

image=ImageCaptcha()

captcha=image.generate(text)

captcha_image=Image.open(captcha)

captcha_image.show()

运行之后便会弹出一张图片，结果如下：

可以看到图中的文字正是我们所定义的 text 内容，这样我们就可以得到一张图片和其对应的真实文本，这样我们就可以用它来生成一批训练数据和测试数据了。

预处理

在训练之前肯定是要进行数据预处理了，现在我们首先定义好了要生成的验证码文本内容，这就相当于已经有了 label 了，然后我们再用它来生成验证码，就可以得到输入数据 x 了，在这里我们首先定义好我们的输入词表，由于大小写字母加数字的词表比较庞大，设想我们用含有大小写字母和数字的验证码，一个验证码四个字符，那么一共可能的组合是 (26 + 26 + 10) ^ 4 = 14776336 种组合，这个数量训练起来有点大，所以这里我们精简一下，只使用纯数字的验证码来训练，这样其组合个数就变为 10 ^ 4 = 10000 种，显然少了很多。

所以在这里我们先定义一个词表和其长度变量：

VOCAB=['0','1','2','3','4','5','6','7','8','9']

CAPTCHA_LENGTH=4

VOCAB_LENGTH=len(VOCAB)

这里 VOCAB 就是词表的内容，即 0 到 9 这 10 个数字，验证码的字符个数即 CAPTCHA_LENGTH 是 4，词表长度是 VOCAB 的长度，即 10。

接下来我们定义一个生成验证码数据的方法，流程类似上文，只不过这里我们将返回的数据转为了 Numpy 形式的数组：

from PIL import Image

from captcha.image import ImageCaptcha

import numpy asnp

def generate_captcha(captcha_text):

"""

get captcha text and np array

:param captcha_text: source text

:return: captcha image and array

"""

image=ImageCaptcha()

captcha=image.generate(captcha_text)

captcha_image=Image.open(captcha)

captcha_array=np.array(captcha_image)

returncaptcha_array

这样调用此方法，我们就可以得到一个 Numpy 数组了，这个其实是把验证码转化成了每个像素的 RGB，我们调用一下这个方法试试：

captcha=generate_captcha('1234')

print(captcha,captcha.shape)

内容如下：

[[[239244244]

[239244244]

...,

[239244244]

[239244244]]]

(60,160,3)

可以看到它的 shape 是 (60, 160, 3)，这其实代表验证码图片的高度是 60，宽度是 160，是 60 x 160 像素的验证码，每个像素都有 RGB 值，所以最后一维即为像素的 RGB 值。

接下来我们需要定义 label，由于我们需要使用深度学习模型进行训练，所以这里我们的 label 数据最好使用 One-Hot 编码，即如果验证码文本是 1234，那么应该词表索引位置置 1，总共的长度是 40，我们用程序实现一下 One-Hot 编码和文本的互相转换：

def text2vec(text):

"""

text to one-hot vector

:param text: source text

:return: np array

"""

iflen(text)>CAPTCHA_LENGTH:

returnFalse

vector=np.zeros(CAPTCHA_LENGTH *VOCAB_LENGTH)

fori,cinenumerate(text):

index=i *VOCAB_LENGTH+VOCAB.index(c)

vector[index]=1

returnvector

def vec2text(vector):

"""

vector to captcha text

:param vector: np array

:return: text

"""

ifnotisinstance(vector,np.ndarray):

vector=np.asarray(vector)

vector=np.reshape(vector,[CAPTCHA_LENGTH,-1])

text=''

foritem invector:

text+=VOCAB[np.argmax(item)]

returntext

这里 text2vec() 方法就是将真实文本转化为 One-Hot 编码，vec2text() 方法就是将 One-Hot 编码转回真实文本。

例如这里调用一下这两个方法，我们将 1234 文本转换为 One-Hot 编码，然后在将其转回来：

vector=text2vec('1234')

text=vec2text(vector)

print(vector,text)

运行结果如下：

[0.1.0.0.0.0.0.0.0.0.0.0.1.0.0.0.0.0.

0.0.0.0.0.1.0.0.0.0.0.0.0.0.0.0.1.0.

0.0.0.0.]

1234

这样我们就可以实现文本到 One-Hot 编码的互转了。

接下来我们就可以构造一批数据了，x 数据就是验证码的 Numpy 数组，y 数据就是验证码的文本的 One-Hot 编码，生成内容如下：

import random

from os.path import join,exists

import pickle

import numpy asnp

from os import makedirs

DATA_LENGTH=10000

DATA_PATH='data'

def get_random_text():

text=''

foriinrange(CAPTCHA_LENGTH):

text+=random.choice(VOCAB)

returntext

def generate_data():

print('Generating Data...')

data_x,data_y=[],[]

# generate data x and y

foriinrange(DATA_LENGTH):

text=get_random_text()

# get captcha array

captcha_array=generate_captcha(text)

# get vector

vector=text2vec(text)

data_x.append(captcha_array)

data_y.append(vector)

# write data to pickle

ifnotexists(DATA_PATH):

makedirs(DATA_PATH)

x=np.asarray(data_x,np.float32)

y=np.asarray(data_y,np.float32)

with open(join(DATA_PATH,'data.pkl'),'wb')asf:

pickle.dump(x,f)

pickle.dump(y,f)

这里我们定义了一个 get_random_text() 方法，可以随机生成验证码文本，然后接下来再利用这个随机生成的文本来产生对应的 x、y 数据，然后我们再将数据写入到 pickle 文件里，这样就完成了预处理的操作。

构建模型

有了数据之后，我们就开始构建模型吧，这里我们还是利用 train_test_split() 方法将数据分为三部分，训练集、开发集、验证集：

with open('data.pkl','rb')asf:

data_x=pickle.load(f)

data_y=pickle.load(f)

returnstandardize(data_x),data_y

train_x,test_x,train_y,test_y=train_test_split(data_x,data_y,test_size=0.4,random_state=40)

dev_x,test_x,dev_y,test_y,=train_test_split(test_x,test_y,test_size=0.5,random_state=40)

接下来我们使用者三个数据集构建三个 Dataset 对象：

# train and dev dataset

train_dataset=tf.data.Dataset.from_tensor_slices((train_x,train_y)).shuffle(10000)

train_dataset=train_dataset.batch(FLAGS.train_batch_size)

dev_dataset=tf.data.Dataset.from_tensor_slices((dev_x,dev_y))

dev_dataset=dev_dataset.batch(FLAGS.dev_batch_size)

test_dataset=tf.data.Dataset.from_tensor_slices((test_x,test_y))

test_dataset=test_dataset.batch(FLAGS.test_batch_size)

然后初始化一个迭代器，并绑定到这个数据集上：

# a reinitializable iterator

iterator=tf.data.Iterator.from_structure(train_dataset.output_types,train_dataset.output_shapes)

train_initializer=iterator.make_initializer(train_dataset)

dev_initializer=iterator.make_initializer(dev_dataset)

test_initializer=iterator.make_initializer(test_dataset)

接下来就是关键的部分了，在这里我们使用三层卷积和两层全连接网络进行构造，在这里为了简化写法，直接使用 TensorFlow 的 layers 模块：

# input Layer

with tf.variable_scope('inputs'):

# x.shape = [-1, 60, 160, 3]

x,y_label=iterator.get_next()

keep_prob=tf.placeholder(tf.float32,[])

y=tf.cast(x,tf.float32)

# 3 CNN layers

for_inrange(3):

y=tf.layers.conv2d(y,filters=32,kernel_size=3,padding='same',activation=tf.nn.relu)

y=tf.layers.max_pooling2d(y,pool_size=2,strides=2,padding='same')

# y = tf.layers.dropout(y, rate=keep_prob)

# 2 dense layers

y=tf.layers.flatten(y)

y=tf.layers.dense(y,1024,activation=tf.nn.relu)

y=tf.layers.dropout(y,rate=keep_prob)

y=tf.layers.dense(y,VOCAB_LENGTH)

这里卷积核大小为 3，padding 使用 SAME 模式，激活函数使用 relu。

经过全连接网络变换之后，y 的 shape 就变成了 [batch_size, n_classes]，我们的 label 是 CAPTCHA_LENGTH 个 One-Hot 向量拼合而成的，在这里我们想使用交叉熵来计算，但是交叉熵计算的时候，label 参数向量最后一维各个元素之和必须为 1，不然计算梯度的时候会出现问题。详情参见 TensorFlow 的官方文档：https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits：

NOTE: While the classes are mutually exclusive, their probabilities need not be. All that is required is that each row of labels is a valid probability distribution. If they are not, the computation of the gradient will be incorrect.

但是现在的 label 参数是 CAPTCHA_LENGTH 个 One-Hot 向量拼合而成，所以这里各个元素之和为 CAPTCHA_LENGTH，所以我们需要重新 reshape 一下，确保最后一维各个元素之和为 1：

y_reshape=tf.reshape(y,[-1,VOCAB_LENGTH])

y_label_reshape=tf.reshape(y_label,[-1,VOCAB_LENGTH])

这样我们就可以确保最后一维是 VOCAB_LENGTH 长度，而它就是一个 One-Hot 向量，所以各元素之和必定为 1。

然后 Loss 和 Accuracy 就好计算了：

# loss

cross_entropy=tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits=y_reshape,labels=y_label_reshape))

# accuracy

max_index_predict=tf.argmax(y_reshape,axis=-1)

max_index_label=tf.argmax(y_label_reshape,axis=-1)

correct_predict=tf.equal(max_index_predict,max_index_label)

accuracy=tf.reduce_mean(tf.cast(correct_predict,tf.float32))

再接下来执行训练即可：

# train

train_op=tf.train.RMSPropOptimizer(FLAGS.learning_rate).minimize(cross_entropy,global_step=global_step)

forepoch inrange(FLAGS.epoch_num):

tf.train.global_step(sess,global_step_tensor=global_step)

# train

sess.run(train_initializer)

forstep inrange(int(train_steps)):

loss,acc,gstep,_=sess.run([cross_entropy,accuracy,global_step,train_op],

feed_dict={keep_prob:FLAGS.keep_prob})

# print log

ifstep%FLAGS.steps_per_print==0:

print('Global Step',gstep,'Step',step,'Train Loss',loss,'Accuracy',acc)

ifepoch%FLAGS.epochs_per_dev==0:

# dev

sess.run(dev_initializer)

forstep inrange(int(dev_steps)):

ifstep%FLAGS.steps_per_print==0:

print('Dev Accuracy',sess.run(accuracy,feed_dict={keep_prob:1}),'Step',step)

在这里我们首先初始化 train_initializer，将 iterator 绑定到 Train Dataset 上，然后执行 train_op，获得 loss、acc、gstep 等结果并输出。

训练

运行训练过程，结果类似如下：

...

Dev Accuracy0.9580078Step0

Dev Accuracy0.9472656Step2

Dev Accuracy0.9501953Step4

Dev Accuracy0.9658203Step6

GlobalStep3243Step0Train Loss1.1920928e-06Accuracy1.0

GlobalStep3245Step2Train Loss1.5497207e-06Accuracy1.0

GlobalStep3247Step4Train Loss1.1920928e-06Accuracy1.0

GlobalStep3249Step6Train Loss1.7881392e-06Accuracy1.0

...

验证集准确率 95% 以上。

测试

训练过程我们还可以每隔几个 Epoch 保存一下模型：

# save model

ifepoch%FLAGS.epochs_per_save==0:

saver.save(sess,FLAGS.checkpoint_dir,global_step=gstep)

当然也可以取验证集上准确率最高的模型进行保存。

验证时我们可以重新 Reload 一下模型，然后进行验证：

# load model

ckpt=tf.train.get_checkpoint_state('ckpt')

ifckpt:

saver.restore(sess,ckpt.model_checkpoint_path)

print('Restore from',ckpt.model_checkpoint_path)

sess.run(test_initializer)

forstep inrange(int(test_steps)):

ifstep%FLAGS.steps_per_print==0:

print('Test Accuracy',sess.run(accuracy,feed_dict={keep_prob:1}),'Step',step)

else:

print('No Model Found')

验证之后其准确率基本是差不多的。

如果要进行新的 Inference 的话，可以替换下 test_x 即可。

结语

出处：https://cuiqingcai.com/5709.html

weixin_39936086

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python tensorflow验证码识别_TensorFlow验证码识别

本节我们来用 TensorFlow 来实现一个深度学习模型，用来实现验证码识别的过程，这里我们识别的验证码是图形验证码，首先我们会用标注好的数据来训练一个模型，然后再用模型来实现这个验证码的识别。验证码首先我们来看下验证码是怎样的，这里我们使用 Python 的 captcha 库来生成即可，这个库默认是没有安装的，所以这里我们需要先安装这个库，另外我们还需要安装 pillow 库，使用 pip3...
复制链接

扫一扫