Tensorflow搭建卷积神经网络识别手写英语字母

更新记录：

2018年2月5日 初始文章版本

 

近几天需要进行英语手写体识别，查阅了很多资料，但是大多数资料都是针对MNIST数据集的，并且主要识别手写数字。为了满足实际的英文手写识别需求，需要从训练集构造到神经网络搭建各个方面对现有代码进行修改。

神经网络的结构：

1.输入28*28=784维行向量

2.卷积层：卷积核大小5*5，共32个，激活函数ReLu

3.池化层：最大值池化，2*2窗口

4.卷积层：卷积核大小5*5，共64个，激活函数ReLu

5.池化层：最大值池化，2*2窗口

6.全连接层（多层感知机）

 

训练代码：

  1 import tensorflow as tf
  2 import numpy as np
  3 import xlrd
  4 # 开始读取训练数据
  5 data = xlrd.open_workbook('train_set.xlsx')
  6 table = data.sheets()[0]
  7 nrows = table.nrows
  8 ncols = table.ncols
  9 c1 = np.arange(0, nrows, 1)
 10 datamatrix = np.zeros((nrows, ncols))
 11 for x in range(ncols):
 12     cols = table.col_values(x)
 13     cols1 = np.matrix(cols)   # 把list转换为矩阵进行矩阵操作
 14     datamatrix[:, x] = cols1  # 把数据进行存储
 15 x_data = datamatrix
 16 
 17 table = data.sheets()[1]
 18 nrows = table.nrows
 19 ncols = table.ncols
 20 c1 = np.arange(0, nrows, 1)
 21 datamatrix = np.zeros((nrows, ncols))
 22 for x in range(ncols):
 23     cols = table.col_values(x)
 24     cols1 = np.matrix(cols)   # 把list转换为矩阵进行矩阵操作
 25     datamatrix[:, x] = cols1  # 把数据进行存储
 26 y_data = datamatrix
 27 # 完成训练数据读取
 28 # 开始定义神经网络结构
 29 
 30 # 定义占位符x和y_
 31 x = tf.placeholder(tf.float32, shape=[None, 784])
 32 y_ = tf.placeholder(tf.float32, shape=[None, 26])
 33 
 34 
 35 # 开始定义用于初始化的两个函数
 36 def weight_variable(shape):
 37     initial = tf.truncated_normal(shape, stddev=0.1)
 38     return tf.Variable(initial)
 39 
 40 
 41 def bias_variable(shape):
 42     initial = tf.constant(0.1, shape=shape)
 43     return tf.Variable(initial)
 44 
 45 # 完成初始化函数定义
 46 
 47 
 48 # 开始定义卷积和池化的函数
 49 # 卷积使用1步长（stride size），0边距（padding size）的模板，保证输出和输入大小相同
 50 # 池化用简单传统的2x2大小的模板做max pooling，因此输出的长宽会变为输入的一半
 51 
 52 
 53 def conv2d(x, W):
 54     return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
 55 
 56 
 57 def max_pool_2x2(x):
 58     return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1, 2, 2, 1], padding='SAME')
 59 # 完成卷积池化函数定义
 60 
 61 
 62 # 开始定义神经网络结构定义
 63 # 第一层卷积，卷积在每个5x5的patch中算出32个特征
 64 W_conv1 = weight_variable([5, 5, 1, 32])
 65 b_conv1 = bias_variable([32])
 66 x_image = tf.reshape(x, [-1, 28, 28, 1])
 67 # 第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数(因为是灰度图所以这里的通道数为1，如果是rgb彩色图，则为3)
 68 h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
 69 h_pool1 = max_pool_2x2(h_conv1)
 70 
 71 # 第二层卷积，每个5x5的patch会得到64个特征
 72 W_conv2 = weight_variable([5, 5, 32, 64])
 73 b_conv2 = bias_variable([64])
 74 h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
 75 h_pool2 = max_pool_2x2(h_conv2)
 76 
 77 # 有1024个神经元的全连接层，此时图片大小为7*7
 78 W_fc1 = weight_variable([7*7*64, 1024])
 79 b_fc1 = bias_variable([1024])
 80 h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
 81 h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
 82 
 83 # 为了减少过拟合，在输出层之前加入dropout。用一个placeholder代表一个神经元的输出在dropout中保持不变的概率。
 84 # 这样可以在训练过程中启用dropout，在测试过程中关闭dropout。
 85 keep_prob = tf.placeholder(tf.float32)
 86 h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
 87 # softmax输出层
 88 W_fc2 = weight_variable([1024, 26])
 89 b_fc2 = bias_variable([26])
 90 y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
 91 # 应为 y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
 92 # 完成神经网络结构定义
 93 
 94 # 开始定义训练和评估操作
 95 # 用更加复杂的ADAM优化器来做梯度最速下降，在feed_dict中加入额外的参数keep_prob来控制dropout比例
 96 cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
 97 train_step = tf.train.AdamOptimizer(1e-6).minimize(cross_entropy)
 98 correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
 99 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
100 # 完成训练和评估操作的定义
101 
102 # 开始定义储存器操作并装载已经训练过的神经网络
103 saver = tf.train.Saver(write_version=tf.train.SaverDef.V1)
104 sess = tf.InteractiveSession()
105 saver.restore(sess, "cnnres/model.ckpt")
106 # sess.run(tf.global_variables_initializer())
107 # 完成定义储存器操作和装载神经网络
108 
109 # 开始对训练集进行循环训练
110 for k in range(20):
111     for i in range(55):  # 为减少训练时间，降低迭代次数
112         x_datap = x_data[i*26:(i+1)*26, 0:28*28]
113         y_datap = y_data[i*26:(i+1)*26, 0:26]
114         for j in range(3000):
115             if j % 100 == 0:
116                 train_accuracy = accuracy.eval(feed_dict={x: x_data, y_: y_data, keep_prob: 1.0})
117                 print("step %d, training accuracy %g"%(i, train_accuracy))
118             train_step.run(feed_dict={x: x_datap, y_: y_datap, keep_prob: 0.5})
119 #        if train_accuracy >= 0.942:
120 #            train_step = tf.train.AdamOptimizer(1e-6).minimize(cross_entropy)
121 #        if train_accuracy <= 0.9:
122 #            train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
123         if train_accuracy >= 0.95:
124             saver_path = saver.save(sess, "cnnres/model.ckpt")
125             print('Save the par in', saver_path)
126 # 完成训练和储存过程

 

备注：

1.由于GUP运算能力的限制，需要将训练集每次取出一部分进行训练，但是对模型的准确度进行评估时应当feed全部数据。

相关代码：

x_datap = x_data[i*26:(i+1)*26, 0:28*28]
y_datap = y_data[i*26:(i+1)*26, 0:26]
train_accuracy = accuracy.eval(feed_dict={x: x_data, y_: y_data, keep_prob: 1.0})
train_step.run(feed_dict={x: x_datap, y_: y_datap, keep_prob: 0.5})
2.考虑到对训练集的读取是顺序的，因此训练集必须随机乱序，绝对不能按照字母表排序，否则将会出现严重的过拟合。

3.神经网络的训练结果被储存在cnnres/model.ckpt中

4.在精确度达到0.8之前将步长定为1E-4，在精确度达到0.9之后将步长定为1E-6，不要将步长设定为小于这个值，否则训练进展极为缓慢。

训练集构成：

储存在train_set.xlsx中。共有两张表，第一张表每一行有28*28=784列，对应一个784维输入向量；第二张表每一行有26列，该行与第一张表同一行的预期输出结果对应，在第x列值为1，其余列值为0，表示第一张表同一行的预期输出结果是字母表中第x个字母。

训练集的生成代码：

import numpy as np
from PIL import Image
import xlsxwriter


# 开始读取测试图片


def ImageToMatrix(filename):
    im = Image.open(filename)
    width, height = im.size
    im = im.convert("L")
    data = im.getdata()
    data = np.matrix(data, dtype='float')/255.0
    new_data = np.reshape(data, (height, width))
    return new_data

def ImageToMatrix2(ima):
    width, height = ima.size
    ima = ima.convert("L")
    data = ima.getdata()
    data = np.matrix(data, dtype='float')/255.0
    new_data = np.reshape(data, (height, width))
    return new_data

def MatrixToImage(data):
    data = data*255
    new_im = Image.fromarray(data.astype(np.uint8))
    return new_im


# 循环读取测试图片并写入
# 开始进行写excel的准备
book = xlsxwriter.Workbook(r'train_set.xlsx')
sheet1 = book.add_worksheet('train_input1')
sheet2 = book.add_worksheet('train_input2')
sheet3 = book.add_worksheet('train_input3')
sheet4 = book.add_worksheet('train_input4')
# 完成写excel的准备
for i in range(1, 1430+1):
    test_pic = ImageToMatrix(str(i)+'.png')
# 完成测试图片读取
# -------------------------
# 开始处理测试图片
# 开始寻找图片四边
    hang, lie = np.shape(test_pic)
    for top in range(0, hang):
        if np.min(test_pic[top, :]) != 1:
            break
    for bot in range(hang-1, 0, -1):
        if np.min(test_pic[bot, :]) != 1:
            break
    for left in range(0, lie):
        if np.min(test_pic[:, left]) != 1:
            break
    for right in range(lie - 1, 0, -1):
        if np.min(test_pic[:, right]) != 1:
            break
    new_test_pic = test_pic[top:bot, left:right]
# 完成图片四边寻找
# 开始进行图片尺寸转换
    pic = MatrixToImage(new_test_pic)
    pic2 = pic.resize((28, 28))
    test_datap = ImageToMatrix2(pic2)
    test_data = np.reshape(test_datap, (1, 784))
# 完成图片尺寸转换
# 对行向量进行储存
    for j in range(0, 200):
        sheet1.write(i-1, j, test_data[0, j])
        sheet2.write(i - 1, j, test_data[0, j+200])
        sheet3.write(i - 1, j, test_data[0, j+400])
        if j+600 <= 783:
            sheet4.write(i - 1, j, test_data[0, j+600])
    print(i)
book.close()

 

备注：此处由于python提供的xlsxwriter库存如下限制：每一行最多可以写256列，因此必须将这个786维的向量分别写到4张表的同一行，再进行手工合并。而第二张预期输出表需要使用其它方法进行构造，此处不给出相关代码。

 

测试代码：

  1 import tensorflow as tf
  2 import numpy as np
  3 from PIL import Image
  4 import matplotlib.pyplot as plt
  5 # 开始读取测试图片
  6 
  7 
  8 def ImageToMatrix(filename):
  9     im = Image.open(filename)
 10     width, height = im.size
 11     im = im.convert("L")
 12     data = im.getdata()
 13     data = np.matrix(data, dtype='float')/255.0
 14     new_data = np.reshape(data, (height, width))
 15     return new_data
 16 
 17 def ImageToMatrix2(ima):
 18     width, height = ima.size
 19     ima = ima.convert("L")
 20     data = ima.getdata()
 21     data = np.matrix(data, dtype='float')/255.0
 22     new_data = np.reshape(data, (height, width))
 23     return new_data
 24 
 25 def MatrixToImage(data):
 26     data = data*255
 27     new_im = Image.fromarray(data.astype(np.uint8))
 28     return new_im
 29 
 30 
 31 test_pic = ImageToMatrix('test.png')
 32 
 33 # 完成测试图片读取
 34 # -------------------------
 35 # 开始处理测试图片
 36 # 开始寻找图片四边
 37 hang, lie = np.shape(test_pic)
 38 for top in range(0, hang):
 39     if np.min(test_pic[top, :]) != 1:
 40         break
 41 for bot in range(hang-1, 0, -1):
 42     if np.min(test_pic[bot, :]) != 1:
 43         break
 44 for left in range(0, lie):
 45     if np.min(test_pic[:, left]) != 1:
 46         break
 47 for right in range(lie - 1, 0, -1):
 48     if np.min(test_pic[:, right]) != 1:
 49         break
 50 new_test_pic = test_pic[top:bot, left:right]
 51 # 完成图片四边寻找
 52 # 开始进行图片尺寸转换
 53 pic = MatrixToImage(new_test_pic)
 54 pic2 = pic.resize((28, 28))
 55 test_data = ImageToMatrix2(pic2)
 56 test_data = np.reshape(test_data, (1, 784))
 57 # 完成图片尺寸转换
 58 
 59 # 完成测试图片的处理
 60 # --------------------------
 61 # 开始定义神经网络结构
 62 
 63 # 定义占位符x和y_
 64 x = tf.placeholder(tf.float32, shape=[None, 784])
 65 y_ = tf.placeholder(tf.float32, shape=[None, 26])
 66 
 67 
 68 # 开始定义用于初始化的两个函数
 69 def weight_variable(shape):
 70     initial = tf.truncated_normal(shape, stddev=0.1)
 71     return tf.Variable(initial)
 72 
 73 
 74 def bias_variable(shape):
 75     initial = tf.constant(0.1, shape=shape)
 76     return tf.Variable(initial)
 77 
 78 # 完成初始化函数定义
 79 
 80 
 81 # 开始定义卷积和池化的函数
 82 # 卷积使用1步长（stride size），0边距（padding size）的模板，保证输出和输入大小相同
 83 # 池化用简单传统的2x2大小的模板做max pooling，因此输出的长宽会变为输入的一半
 84 
 85 
 86 def conv2d(x, W):
 87     return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
 88 
 89 
 90 def max_pool_2x2(x):
 91     return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1, 2, 2, 1], padding='SAME')
 92 # 完成卷积池化函数定义
 93 
 94 
 95 # 开始定义神经网络结构定义
 96 # 第一层卷积，卷积在每个5x5的patch中算出32个特征
 97 W_conv1 = weight_variable([5, 5, 1, 32])
 98 b_conv1 = bias_variable([32])
 99 x_image = tf.reshape(x, [-1, 28, 28, 1])
100 # 第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数(因为是灰度图所以这里的通道数为1，如果是rgb彩色图，则为3)
101 h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
102 h_pool1 = max_pool_2x2(h_conv1)
103 
104 # 第二层卷积，每个5x5的patch会得到64个特征
105 W_conv2 = weight_variable([5, 5, 32, 64])
106 b_conv2 = bias_variable([64])
107 h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
108 h_pool2 = max_pool_2x2(h_conv2)
109 
110 # 有1024个神经元的全连接层，此时图片大小为7*7
111 W_fc1 = weight_variable([7*7*64, 1024])
112 b_fc1 = bias_variable([1024])
113 h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
114 h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
115 
116 # 为了减少过拟合，在输出层之前加入dropout。用一个placeholder代表一个神经元的输出在dropout中保持不变的概率。
117 # 这样可以在训练过程中启用dropout，在测试过程中关闭dropout。
118 keep_prob = tf.placeholder(tf.float32)
119 h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
120 # softmax输出层
121 W_fc2 = weight_variable([1024, 26])
122 b_fc2 = bias_variable([26])
123 y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
124 # 应为 y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
125 # 完成神经网络结构定义
126 
127 # 开始定义训练和评估操作
128 # 用更加复杂的ADAM优化器来做梯度最速下降，在feed_dict中加入额外的参数keep_prob来控制dropout比例
129 cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
130 train_step = tf.train.AdamOptimizer(1e-6).minimize(cross_entropy)
131 correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
132 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
133 # 完成训练和评估操作的定义
134 
135 # 开始定义储存器操作并装载已经训练过的神经网络
136 saver = tf.train.Saver(write_version=tf.train.SaverDef.V1)
137 sess = tf.InteractiveSession()
138 saver.restore(sess, "cnnres/model.ckpt")
139 # sess.run(tf.global_variables_initializer())
140 # 完成定义储存器操作和装载神经网络
141 
142 # 开始对神经网络进行输入测试
143 res = sess.run(y_conv, feed_dict={x: test_data, keep_prob: 1.0})
144 temp = np.argmax(res)
145 letter = chr(97+temp)
146 print('The test letter is '+letter)
147 # 完成测试

 

备注：

1.要求已经被训练完成的模型储存在cnnres/model.ckpt

2.预测函数为：res = sess.run(y_conv, feed_dict={x: test_data, keep_prob: 1.0})

不要试图计算y_占位符的值，那是用于训练的，不是用于结果预测的

对CNN的效果备注和研究：

1.在训练集为较粗字体的情况下测试图片必须相应采用较粗字体，否则结果很差

 posted on 2018-02-05 22:54  Chen_YQ  阅读(8663)  评论(12)  编辑  收藏  举报