(二) python爬虫验证码识别（去除干扰线）
（二）python爬虫验证码识别（去除干扰线）
钉钉钉~继完成第一波的任务之后，又来第二波了！！！！！！
1.开发环境与工具
- python36：sklearn、pytesser、opencv等
- pycharm
- windows7
2.数据集
3.解决思想讨论
观察验证码，发现这次验证码和之前的验证码不同：
（1）验证码类型：6位验证码，有数字字母，分类较多
（2）验证码分割：验证码字符位置随机，不固定，有些验证码字符甚至叠加在一起，而且出现的概率很高，基本占一半。如果进行图片切割，就会丧失一定的信息，识别精度也会很低，所以初步想法是，在较小标注样本的情况下，不进行图片分割，尝试使用迁移学习VGG16来进行验证码识别，看是否能够提高精度。
（3）噪声去除：由于噪声的颜色有时候会和字母的颜色一样或近似相似，不适合用之前那种方法。观察验证码，可根据点噪声方法来去噪。
4。解决方案
1、迁移学习： 在训练集为63000张、进行去噪但不进行图片分割等预处理之后，尝试使用迁移学习VGG16，参考链接：tensorflow vgg16、使用CNN进行4位验证码识别，结果效果不佳，大概验证码单个数字的准确率在65%左右，训练过程慢且对gpu要求较高。
2、KNN分类：由于迁移学习调参过程复杂麻烦，而且由于使用的迁移模型较复杂，训练时间比较久，自然迟迟都没取得实质性的效果，没办法交任务，于是想着，放弃那些重叠的验证码，尝试使用之前的验证码识别的方法，对图片进行分割，看效果如何，大概做了一个小时之后，发现效果还行，准确度达54%，但是因为KNN算法，注定训练集越多，所得的训练得到的模型越大，大概1G，这样不仅模型过大占内存，而且预测效率也很低。但是，终于可以交任务啦！！！！！！！
3、CNN分类：针对KNN一些缺点，博主觉得还有待改进，使用迁移学习，有点杀鸡用牛刀，然后写了个CNN看效果如何，由于时间紧，初步取了个模型，发现，效果不错，训练得到的模型大小为101M，预测效率也高了好几倍，精度在77%左右。
5.预测结果
KNN
CNN
6.图片预处理代码
图片去噪、进行图片扩充，224*224
# -*- coding:utf-8 -*-
import cv2
import os
import numpy as np
import copy
''' 根据该像素周围点为黑色的像素数（包括本身）来判断是否把它归属于噪声，如果是噪声就将其变为白色'''
'''
input: img:二值化图
number：周围像素数为黑色的小于number个，就算为噪声，并将其去掉，如number=6，
就是一个像素周围9个点（包括本身）中小于6个的就将这个像素归为噪声
output：返回去噪声的图像
'''
def del_noise(img,number):
height = img.shape[0]
width = img.shape[1]
img_new = copy.deepcopy(img)
for i in range(1, height - 1):
for j in range(1, width - 1):
point = [[], [], []]
count = 0
point[0].append(img[i - 1][j - 1])
point[0].append(img[i - 1][j])
point[0].append(img[i - 1][j + 1])
point[1].append(img[i][j - 1])
point[1].append(img[i][j])
point[1].append(img[i][j + 1])
point[2].append(img[i + 1][j - 1])
point[2].append(img[i + 1][j])
point[2].append(img[i + 1][j + 1])
for k in range(3):
for z in range(3):
if point[k][z] == 0:
count += 1
if count <= number:
img_new[i, j] = 255
return img_new
if __name__=='__main__':
img_dir = './img_down_sets/corpus_manual/test'
img_name = os.listdir(img_dir) # 列出文件夹下所有的目录与文件
kernel = np.ones((5, 5), np.uint8)
for i in range(len(img_name)):
path = os.path.join(img_dir, img_name[i])
image = cv2.imread(path)
name_list = list(img_name[i])[:6]
if '.' in name_list:
print("%s标签错误，请重新标签!" % img_name[i])
else:
name = ''.join(name_list)
# 灰度化
# print(image.shape)
grayImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 二值化
result = cv2.adaptiveThreshold(grayImage, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 21, 1)
# 去噪声
img = del_noise(result, 6)
img = del_noise(img, 4)
img = del_noise(img, 3)
# 加滤波去噪
im_temp = cv2.bilateralFilter(src=img, d=15, sigmaColor=130, sigmaSpace=150)
im_temp = im_temp[1:-1,1:-1]
im_temp = cv2.copyMakeBorder(im_temp, 83, 83, 13, 13, cv2.BORDER_CONSTANT, value=[255])
cv2.imwrite('./img_down_sets/new_corpus/%s.jpg' %(name), im_temp)
print("%s %s.jpg"%(i,name))
print("图片预处理完成！")
7.图片切割代码
分割得60*34
#-*-coding:utf-8 -*-
import cv2
import os
def cut_image(image, num, img_name):
# image = cv2.imread('./img/8.jpg')
im = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# im_cut_real = im[8:47, 28:128]
im_cut_1 = im[80:140, 23:57]
im_cut_2 = im[80:140, 53:87]
im_cut_3 = im[80:140, 83:117]
im_cut_4 = im[80:140, 113:147]
im_cut_5 = im[80:140, 143:177]
im_cut_6 = im[80:140, 173:207]
im_cut = [im_cut_1, im_cut_2, im_cut_3, im_cut_4, im_cut_5, im_cut_6]
for i in range(6):
im_temp = im_cut[i]
cv2.imwrite('./img_cut_train/'+str(num)+ '_' + str(i)+'_'+img_name[i]+'.jpg', im_temp)
if __name__ == '__main__':
img_dir = './new_corpus'
img_name = os.listdir(img_dir) # 列出文件夹下所有的目录与文件
for i in range(len(img_name)):
path = os.path.join(img_dir, img_name[i])
image = cv2.imread(path)
name_list = list(img_name[i])[:6]
# name = ''.join(name_list)
cut_image(image, i, name_list)
if i %2000==0:
print('图片%s分割完成' % (i))
print(u'*****图片分割预处理完成！*****')
8.KNN代码
knn代码与验证码（一）所用方法相似，在这不再贴代码。
9.CNN代码
vec_text.py（应要求贴出，加载数据的代码块）
#-*-coding:utf-8 -*-
import numpy as np
import os
import cv2
def text2vec(labels):
# 制作词典
number = ['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']
dictionary = number + alphabet
vec = [0]*34
for i in range(len(dictionary)):
if dictionary[i] == labels:
vec[i] = 1
return vec
def vec2text(index):
# 制作词典
number = ['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']
dictionary = number + alphabet
return dictionary[index]
def load_data(img_dir):
# 读入数据
data = []
labels = []
img_name = os.listdir(img_dir)
for i in range(len(img_name)):
path = os.path.join(img_dir, img_name[i])
# cv2读进来的图片是RGB3维的，转成灰度图，将图片转化成1维
image = cv2.imread(path,0)
data.append(image)
y_temp = img_name[i][-5]
y_vec = text2vec(y_temp)
labels.append(y_vec)
# 标签规范化
x = np.array(data)
y = np.array(labels)
return x, y
#
# img_dir = './img'
# x, y = load_data(img_dir)
# print(x.shape)
# print(y.shape)
训练CNN模型
# -*- coding:utf-8 -*-
import tensorflow as tf
import os
from sklearn.model_selection import train_test_split
import cv2
import numpy as np
from vec_text import text2vec,load_data
def weight_variable(shape):
initial = tf.truncated_normal(shape,stddev=0.001)
return tf.Variable(initial, name='w')
def bias_variable(shape):
initial = tf.constant(0.1,shape = shape)
return tf.Variable(initial, name='b')
def conv2d(x, W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
with tf.variable_scope("Input"):
x = tf.placeholder(tf.float32,[None,60,34],name='x')
x_image = tf.reshape(x,[-1,60,34,1])
y = tf.placeholder(tf.float32,[None,34],name='y')
with tf.variable_scope("Cnn_net"):
# 第一层 卷积层
with tf.variable_scope("conv_1"):
w_conv1 = weight_variable([3,3,1,32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image,w_conv1) + b_conv1)
h_pool1 = max_pool(h_conv1)
# 第二层 卷积层
with tf.variable_scope("conv_2"):
w_conv2 = weight_variable([5,5,32,64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1,w_conv2) + b_conv2)
h_pool2 = max_pool(h_conv2)
# 第三层 全连接层
with tf.variable_scope("full_connect"):
w_fc1 = weight_variable([15*9*64, 1024])
b_fc1 = weight_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1,15*9*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat , w_fc1)+b_fc1)
# dropout
with tf.variable_scope("dropout"):
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# 第四层 softmax输出层
with tf.variable_scope("softmax"):
w_fc2 = weight_variable([1024,34])
b_fc2 = bias_variable([34])
y_out = tf.nn.softmax(tf.matmul(h_fc1_drop,w_fc2)+b_fc2,name="output")
# 模型训练与评估
cross_entropy = -tf.reduce_sum(y * tf.log(tf.clip_by_value(y_out,1e-10,1.0))) #计算交叉熵
train_step = tf.train.AdamOptimizer(2e-6).minimize(cross_entropy) #使用adam优化器来以0.0001的学习率来进行微调
correct_prediction = tf.equal(tf.argmax(y_out,1), tf.argmax(y,1)) #判断预测标签和实际标签是否匹配
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('accuracy', accuracy)
tf.summary.scalar('loss', cross_entropy)
# # 将标签转化为向量，输入'2',输出数组[0,0,1....,0]
sess = tf.Session()
sess.run(tf.global_variables_initializer())
print('New_built')
writer = tf.summary.FileWriter('./logs/cnn', sess.graph)
merged = tf.summary.merge_all()
# 保存模型
def save(path='./models/cnn', step=1):
saver = tf.train.Saver()
saver.save(sess, path, write_meta_graph=False, global_step=step)
img_dir = './img_cut_train'
x_data, y_data = load_data(img_dir)
# 拆分训练数据与测试数据
x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.003)
for i in range(3000000):
b_idx = np.random.randint(0, len(x_train), 100)
# print(x_train[b_idx].shape)
# train = sess.run(train_step,{x:x_train[b_idx],y:y_train[b_idx],keep_prob:0.75})
# print(sess.run(x_image,{x:x_train[b_idx]}).shape)
train_loss, __ , train_merged= sess.run([cross_entropy, train_step, merged], {x: x_train[b_idx], y: y_train[b_idx], keep_prob: 0.5})
if (i+1)%100==0:
print(str(i+1),"train loss:",train_loss)
if (i+1) % 1000 == 0:
accuracy_result, test_merged = sess.run([accuracy,merged], {x: x_test, y: y_test, keep_prob:1.0})
print(str(i+1),"test accuracy:",str(accuracy_result))
writer.add_summary(train_merged)
writer.add_summary(test_merged)
if accuracy_result > 0.96 and (i+1)%10000==0:
save(step=i+1)
writer.close()
sess.close()
CNN加载模型预测
import tensorflow as tf
from vec_text import load_data,vec2text
def predict_single(x_data, restore_from = './models/cnn-3085000'):
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.001)
return tf.Variable(initial, name='w')
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial, name='b')
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
with tf.variable_scope("Input"):
x = tf.placeholder(tf.float32,[None,60,34],name='x')
x_image = tf.reshape(x,[-1,60,34,1])
y = tf.placeholder(tf.float32,[None,34],name='y')
with tf.variable_scope("Cnn_net"):
# 第一层 卷积层
with tf.variable_scope("conv_1"):
w_conv1 = weight_variable([3,3,1,32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image,w_conv1) + b_conv1)
h_pool1 = max_pool(h_conv1)
# 第二层 卷积层
with tf.variable_scope("conv_2"):
w_conv2 = weight_variable([5,5,32,64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1,w_conv2) + b_conv2)
h_pool2 = max_pool(h_conv2)
# 第三层 全连接层
with tf.variable_scope("full_connect"):
w_fc1 = weight_variable([15*9*64, 1024])
b_fc1 = weight_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1,15*9*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat , w_fc1)+b_fc1)
# dropout
with tf.variable_scope("dropout"):
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# 第四层 softmax输出层
with tf.variable_scope("softmax"):
w_fc2 = weight_variable([1024,34])
b_fc2 = bias_variable([34])
y_out = tf.nn.softmax(tf.matmul(h_fc1_drop,w_fc2)+b_fc2,name="output")
# 模型训练与评估
y_vec = tf.argmax(y_out,1)
cross_entropy = -tf.reduce_sum(y * tf.log(tf.clip_by_value(y_out,1e-10,1.0))) #计算交叉熵
train_step = tf.train.AdamOptimizer(2e-6).minimize(cross_entropy) #使用adam优化器来以0.0001的学习率来进行微调
correct_prediction = tf.equal(tf.argmax(y_out,1), tf.argmax(y,1)) #判断预测标签和实际标签是否匹配
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('accuracy', accuracy)
tf.summary.scalar('loss', cross_entropy)
sess = tf.Session()
# 重载模型
saver = tf.train.Saver()
saver.restore(sess, restore_from)
y_predict = sess.run(y_vec,{x:x_data,keep_prob:1.0}) # 输出格式[1 2 8 9]
y_predict_alpha = [vec2text(index) for index in y_predict] #用字典转换成字母
# print(y_predict_alpha)
sess.close()
tf.reset_default_graph()
return y_predict_alpha
# 输入单数字图片，返回该图片对应的字符
# if __name__ == "__main__":
# img_dir = './img_test'
# x_data, y_data = load_data(img_dir)
# predict_single(x_data, restore_from = './models/cnn-1139999')