利用Python+opencv+TensorFlow框架打造 一个试卷批改系统
本文编程采用Python语言，结合opencv库对图像进行处理，再利用TensorFlow框架下卷积神经网络 实现一个初步的简易试卷批改系统。
实现一个试卷批改系统，我将它主要分成俩个模块，第一个模块是图像识别，第二个模块是利用机器学习训练模型。
先说我们是如何训练模型的，对于一般的图像分类问题，利用卷积神经网络是一个不错的选择，卷积神经网络在图像分类的应用十分广泛，具体代码如下：
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist=input_data.read_data_sets('MNIST_data',one_hot=True)#下载mnist数据集
def compute_accuracy(v_xs,v_ys):
global prediction#定义全局变量
y_pre=sess.run(prediction,feed_dict={xs:v_xs,keep_prob:1})#
correct_prediction=tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1))#将实际值和预测值进行比较，返回Bool数据类型
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#将上面的bool类型转为float，求得矩阵中所有元素的平均值
result=sess.run(accuracy,feed_dict={xs:v_xs,ys:v_ys,keep_prob:1})#运行得到上面的平均值，这个值越大说明预测的越准确，因为都是0-1类型，所以平均值不超过1
return result
def weight_variable(shape):
initial=tf.truncated_normal(shape,stddev=0.1)#这个函数产生的随机数与均值的差距不会超过两倍的标准差
return tf.Variable(initial,dtype=tf.float32,name='weight')
def bias_variable(shape):
initial=tf.constant(0.1,shape=shape)
return tf.Variable(initial,dtype=tf.float32,name='biases')
def conv2d(x,W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')#strides第一个和第四个都是1，然后中间俩个代表x方向和y方向的步长,这个函数用来定义卷积神经网络
def max_pool_2x2(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
xs=tf.placeholder(tf.float32,[None,784])#输入是一个28*28的像素点的数据
ys=tf.placeholder(tf.float32,[None,10])
keep_prob=tf.placeholder(tf.float32)
x_image=tf.reshape(xs,[-1,28,28,1])#xs的维度暂时不管，用-1表示，28,28表示xs的数据，1表示该数据是一个黑白照片，如果是彩色的，则写成3
#卷积层1
W_conv1=weight_variable([5,5,1,32])#抽取一个5*5像素，高度是32的点,每次抽出原图像的5*5的像素点，高度从1变成32
b_conv1=bias_variable([32])
h_conv1=tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1)#输出 28*28*32的图像
h_pool1=max_pool_2x2(h_conv1)##输出14*14*32的图像，因为这个函数的步长是2*2，图像缩小一半。
#卷积层2
W_conv2=weight_variable([5,5,32,64])#随机生成一个5*5像素，高度是64的点,抽出原图像的5*5的像素点，高度从32变成64
b_conv2=bias_variable([64])
h_conv2=tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)#输出14*14*64的图像
h_pool2=max_pool_2x2(h_conv2)##输出7*7*64的图像，因为这个函数的步长是2*2，图像缩小一半。
#fully connected 1
W_fc1=weight_variable([7*7*64,1024])
b_fc1=bias_variable([1024])
h_pool2_flat=tf.reshape(h_pool2,[-1,7*7*64])#将输出的h_pool2的三维数据变成一维数据，平铺下来，（-1）代表的是有多少个例子
h_fc1=tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
h_fc1_drop=tf.nn.dropout(h_fc1,keep_prob)
#fully connected 2
W_fc2=weight_variable([1024,10])
b_fc2=bias_variable([10])
prediction=tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)#输出层
#开始训练数据
cross_entropy=tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),reduction_indices=[1]))#相当于loss（代价函数）
train_step=tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)#训练函数，降低cross_entropy（loss）,AdamOptimizer适用于大的神经网络
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(10000):
batch_xs,batch_ys=mnist.train.next_batch(250)#每次从mnist数据集里面拿100个数据训练
sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys,keep_prob:0.5})
if i%100==0:
print(compute_accuracy(mnist.test.images,mnist.test.labels))
save_path = saver.save(sess, "my_net/save_net.ckpt)- 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
测试下我们训练的准确率情况:训练10000次，每隔100次打印一次，最后的训练准确率大概是99%左右。
代码中使用的是mnist手写数字数据集，将图像分成10个类别，分别代表数字0-9，训练好的模型保存在my_net/save_net.ckpt里面，文件格式是.ckpt。
下一步工作是如何调用训练的模型。调用模型的方法很简单，首先需要重构一个和训练集一样的神经网络架构，注意这里不需要再训练数据了，直接调用模型就可以了，然后输入和mnist数据集相同格式的图片就能实现数字识别。如下代码 是如何重构模型以及调用模型的方法。（注意在保存和调用模型的代码中均有saver.restore(sess, “my_net/save_net.ckpt”)这段代码，唯一不同的是，保存代码用的是saver.save(sess, “my_net/save_net.ckpt”)，调用代码用的是saver.restore(sess, “my_net/save_net.ckpt”)。）
import tensorflow as tf
import cv2
from PIL import Image
import numpy as np
def weight_variable(shape):
initial=tf.truncated_normal(shape,stddev=0.1)
return tf.Variable(initial,dtype=tf.float32,name='weight')
def bias_variable(shape):
initial=tf.constant(0.1,shape=shape)
return tf.Variable(initial,dtype=tf.float32,name='biases')
def conv2d(x,W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
xs=tf.placeholder(tf.float32,[None,784])#输入是一个28*28的像素点的数据
keep_prob=tf.placeholder(tf.float32)
x_image=tf.reshape(xs,[-1,28,28,1])#xs的维度暂时不管，用-1表示，28,28表示xs的数据，1表示该数据是一个黑白照片，如果是彩色的，则写成3
#卷积层1
W_conv1=weight_variable([5,5,1,32])#抽取一个5*5像素，高度是32的点,每次抽出原图像的5*5的像素点，高度从1变成32
b_conv1=bias_variable([32])
h_conv1=tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1)#输出 28*28*32的图像
h_pool1=max_pool_2x2(h_conv1)##输出14*14*32的图像，因为这个函数的步长是2*2，图像缩小一半。
#卷积层2
W_conv2=weight_variable([5,5,32,64])#随机生成一个5*5像素，高度是64的点,抽出原图像的5*5的像素点，高度从32变成64
b_conv2=bias_variable([64])
h_conv2=tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)#输出14*14*64的图像
h_pool2=max_pool_2x2(h_conv2)##输出7*7*64的图像，因为这个函数的步长是2*2，图像缩小一半。
#fully connected 1
W_fc1=weight_variable([7*7*64,1024])
b_fc1=bias_variable([1024])
h_pool2_flat=tf.reshape(h_pool2,[-1,7*7*64])#将输出的h_pool2的三维数据变成一维数据，平铺下来，（-1）代表的是有多少个例子
h_fc1=tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
h_fc1_drop=tf.nn.dropout(h_fc1,keep_prob)
#fully connected 2
W_fc2=weight_variable([1024,10])
b_fc2=bias_variable([10])
prediction=tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)#输出层
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, "my_net/save_net.ckpt")
result= tf.argmax(prediction, 1)
#result= result.eval(feed_dict={xs:img, keep_prob: 1.0}, session=sess)
result=sess.run(prediction, feed_dict={xs:img,keep_prob: 1.0})
result1 =np.argmax(result,1)
print(result1)
# result = sess.run(prediction, feed_dict={x: data})
# print(result)- 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
接下来我们来做一个测试,测试图片如下： 
对于上面的图片，我们先对图像进行一系列处理，让它符合我们的格式，代码如下:
import tensorflow as tf
import cv2
from PIL import Image
import numpy as np
img = cv2.imread("D:\\opencv_camera\\digits\\10.jpg")
res=cv2.resize(img,(28,28),interpolation=cv2.INTER_CUBIC)
#cv2.namedWindow("Image")
#print(img.shape)
#灰度化
emptyImage3=cv2.cvtColor(res,cv2.COLOR_BGR2GRAY)
cv2.imshow("a",emptyImage3)
cv2.waitKey(0)
#二值化
ret, bin = cv2.threshold(emptyImage3, 140, 255,cv2.THRESH_BINARY)
cv2.imshow("a",bin)
cv2.waitKey(0)
print(bin)
def normalizepic(pic):
im_arr = pic
im_nparr = []
for x in im_arr:
x=1-x/255
im_nparr.append(x)
im_nparr = np.array([im_nparr])
return im_nparr
#print(normalizepic(bin))
img=normalizepic(bin).reshape((1,784))
#print(img)
img= img.astype(np.float32)- 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
灰度化的图片如下： 
二值化的图片如下： 
然后调用模型结果如下： 
结果是5，预测准确。
上面的是做测试结果，关于试卷识别，我们有下面的例子，图片如下: 
对这个图片我们要做的是提取方框内的分数，然后识别出来数字，进行统计，最后得出分数总和，保存起来，这就是整体思路。具体操作代码如下：
import numpy as np
import tensorflow as tf
import cv2
from PIL import Image
from skimage import data, util,measure,color
from skimage.measure import label
image = cv2.imread('D:\opencv_camera\digits\\12.jpg')
lower=np.array([50,50,150])
upper=np.array([140,140,250])
mask = cv2.inRange(image, lower, upper)
output1 = cv2.bitwise_and(image, image, mask=mask)
output=cv2.cvtColor(output1,cv2.COLOR_BGR2GRAY)
th2 = cv2.adaptiveThreshold(output,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,0)
# cv2.imshow("images",th2)
# cv2.waitKey(0)
roi=[]
for i in range(8):
img_roi = output1[260:310,35+55*i:80+58*i]
roi.append(img_roi)
#归一化
def normalizepic(pic):
im_arr = pic
im_nparr = []
for x in im_arr:
x=1-x/255
im_nparr.append(x)
im_nparr = np.array([im_nparr])
return im_nparr
########图片预处理##########
def weight_variable(shape):
initial=tf.truncated_normal(shape,stddev=0.1)
return tf.Variable(initial,dtype=tf.float32,name='weight')
def bias_variable(shape):
initial=tf.constant(0.1,shape=shape)
return tf.Variable(initial,dtype=tf.float32,name='biases')
def conv2d(x,W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
xs=tf.placeholder(tf.float32,[None,784])#输入是一个28*28的像素点的数据
keep_prob=tf.placeholder(tf.float32)
x_image=tf.reshape(xs,[-1,28,28,1])#xs的维度暂时不管，用-1表示，28,28表示xs的数据，1表示该数据是一个黑白照片，如果是彩色的，则写成3
#卷积层1
W_conv1=weight_variable([5,5,1,32])#抽取一个5*5像素，高度是32的点,每次抽出原图像的5*5的像素点，高度从1变成32
b_conv1=bias_variable([32])
h_conv1=tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1)#输出 28*28*32的图像
h_pool1=max_pool_2x2(h_conv1)##输出14*14*32的图像，因为这个函数的步长是2*2，图像缩小一半。
#卷积层2
W_conv2=weight_variable([5,5,32,64])#随机生成一个5*5像素，高度是64的点,抽出原图像的5*5的像素点，高度从32变成64
b_conv2=bias_variable([64])
h_conv2=tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)#输出14*14*64的图像
h_pool2=max_pool_2x2(h_conv2)##输出7*7*64的图像，因为这个函数的步长是2*2，图像缩小一半。
#fully connected 1
W_fc1=weight_variable([7*7*64,1024])
b_fc1=bias_variable([1024])
h_pool2_flat=tf.reshape(h_pool2,[-1,7*7*64])#将输出的h_pool2的三维数据变成一维数据，平铺下来，（-1）代表的是有多少个例子
h_fc1=tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
h_fc1_drop=tf.nn.dropout(h_fc1,keep_prob)
#fully connected 2
W_fc2=weight_variable([1024,10])
b_fc2=bias_variable([10])
prediction=tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)#输出层
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, "my_net/save_net.ckpt")
result= tf.argmax(prediction, 1)
SUM=[]
for i in range(8):
output = cv2.cvtColor(roi[i], cv2.COLOR_BGR2GRAY)
th2 = cv2.adaptiveThreshold(output, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 0)
# cv2.imshow("images", th2)
# cv2.waitKey(0)
labels = label(th2, connectivity=2)
dst = color.label2rgb(labels)
a=[]
for region in measure.regionprops(labels):
minr, minc, maxr, maxc = region.bbox
# img = cv2.rectangle(dst, (minc -10 , minr - 10), (maxc + 10, maxr + 10), (0, 255, 0), 1)
ROI = th2[minr - 2:maxr + 2, minc - 2:maxc + 2]
if ROI.shape[1] < 10:
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
ROI = cv2.erode(ROI, kernel, iterations=1)
ret, thresh2 = cv2.threshold(ROI, 0, 255, cv2.THRESH_BINARY_INV)
res = cv2.resize(thresh2, (28, 28), interpolation=cv2.INTER_CUBIC)
cv2.imshow("images", res)
cv2.waitKey(0)
img = normalizepic(res).reshape((1, 784))
img = img.astype(np.float32)
result=sess.run(prediction, feed_dict={xs:img,keep_prob: 1.0})
result1 =np.argmax(result,1)
print(result1)
a.append(result1)
if len(a)==2:
#print(a[1]*10+a[0])
SUM.append(a[1]*10+a[0])
else:
#print(a[0])
SUM.append(a[0])
print(sum(SUM))- 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
将最后的结果保存在列表中，得出结果。整个代码写到这里基本上就完成了，在图像处理过程中，需要掌握opencv的一些具体的操作，包括图像二值化，特定区域ROI提取，在对图像进行分割的时候用到了skimage库，这个库可以对不同连通区域的图像进行分割，非常方便实用。整个过程还存在一些问题需要完善，包括对于粘连的数字如何处理，之前查过一篇文献光学手写数字字符识别技术的研究,里面提到了一种用水滴法分割粘连字符，整个识别过程还存在一些不足，后续还有很大的改善空间。