标签：argmax cti 列操作 sha mes ini 完成 cap rgb
关键处理：加入ckpt操作：
ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
if ckpt andckpt.model_checkpoint_path:
saver.restore(sess,ckpt.model_checkpoint_path)
1、注解：
1）tf.train.get_checkpoint_state(checkpoint_dir,latest_filename=None)
该函数表示如果断点文件夹中包含有效断点状态文件，则返回该文件。
参数说明：checkpoint_dir：表示存储断点文件的目录
latest_filename=None：断点文件的可选名称，默认为“checkpoint”
2）saver.restore(sess,ckpt.model_checkpoint_path)
该函数表示恢复当前会话，将ckpt中的值赋给w和b。
参数说明：sess：表示当前会话，之前保存的结果将被加载入这个会话
ckpt.model_checkpoint_path：表示模型存储的位置，不需要提供模型的名字，它会去查看checkpoint文件，看看最新的是谁，叫做什么。
网络输入：一维数组（784个像素点）
像素点：0-1之间的浮点数（接近0越黑，接近1越白）
像素为0 像素为1
网络输出：一维数组（十个可能性概率），数组中最大的那个元素所对应的索引号就是预测的结果。
关键处理：
def application():
testNum =input("input the number of test pictures:")
for i in range(testNum):
testPic =raw_input("the path of test picture:")
testPicArr = pre_pic(testPic)
preValue = restore_model(testPicArr)
print "Theprediction number is:",preValue
注解： 任务分成两个函数完成
1）testPicArr =pre_pic(testPic)对手写数字图片做预处理
2）preValue =restore_model(testPicArr) 将符合神经网络输入要求的图片喂给复现的神经网络模型，输出预测值
示例代码如下：
#coding:utf-8
import tensorflow as tf
import numpy as np
from PIL import Image
import mnist_backward
import mnist_forward
def restore_model(testPicArr):
#利用tf.Graph()复现之前定义的计算图
with tf.Graph().as_default() as tg:
x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
#调用mnist_forward文件中的前向传播过程forword()函数
y = mnist_forward.forward(x, None)
#得到概率最大的预测值
preValue = tf.argmax(y, 1)
#实例化具有滑动平均的saver对象
variable_averages = tf.train.ExponentialMovingAverage(mnist_backward.MOVING_AVERAGE_DECAY)
variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
with tf.Session() as sess:
#通过ckpt获取最新保存的模型
ckpt = tf.train.get_checkpoint_state(mnist_backward.MODEL_SAVE_PATH)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
preValue = sess.run(preValue, feed_dict={x:testPicArr})
return preValue
else:
print("No checkpoint file found")
return -1
#预处理，包括resize，转变灰度图，二值化
def pre_pic(picName):
img = Image.open(picName)
reIm = img.resize((28,28), Image.ANTIALIAS)
im_arr = np.array(reIm.convert(‘L‘))
#对图片做二值化处理（这样以滤掉噪声，另外调试中可适当调节阈值）
threshold = 50
#模型的要求是黑底白字，但输入的图是白底黑字，所以需要对每个像素点的值改为255减去原值以得到互补的反色。
for i in range(28):
for j in range(28):
im_arr[i][j] = 255 - im_arr[i][j]
if (im_arr[i][j] < threshold):
im_arr[i][j] = 0
else: im_arr[i][j] = 255
#把图片形状拉成1行784列，并把值变为浮点型（因为要求像素点是0-1 之间的浮点数）
nm_arr = im_arr.reshape([1, 784])
nm_arr = nm_arr.astype(np.float32)
#接着让现有的RGB图从0-255之间的数变为0-1之间的浮点数
img_ready = np.multiply(nm_arr, 1.0/255.0)
return img_ready
def application():
#输入要识别的几张图片
testNum = input("input the number of test pictures:")
for i in range(testNum):
#给出待识别图片的路径和名称
testPic = raw_input("the path of test picture:")
#图片预处理
testPicArr = pre_pic(testPic)
#获取预测结果
preValue = restore_model(testPicArr)
print "The prediction number is:", preValue
def main():
application()
if __name__ == ‘__main__‘:
main()
实践代码验证
1）运行mnist_backward.py
2）运行 mnist_test.py来监测模型的准确率
3) 运行mnist_app.py输入10（表示循环验证十张图片）
tfrecords文件
1）tfrecords：是一种二进制文件，可先将图片和标签制作成该格式的文件。使用tfrecords进行数据读取，会提高内存利用率。
2）tf.train.Example: 用来存储训练数据。训练数据的特征用键值对的形式表示。
如:‘ img_raw ’ : 值
‘label ’ : 值
值是 Byteslist/FloatList/Int64List
3）SerializeToString()：把数据序列化成字符串存储。
生成tfrecords文件
示例代码：
#生成tfrecords文件
def write_tfRecord(tfRecordName, image_path, label_path):
#新建一个writer
writer = tf.python_io.TFRecordWriter(tfRecordName)
num_pic = 0
f = open(label_path, ‘r‘)
contents = f.readlines()
f.close()
#循环遍历每张图和标签
for content in contents:
value = content.split()
img_path = image_path + value[0]
img = Image.open(img_path)
img_raw = img.tobytes()
labels = [0] * 10
labels[int(value[1])] = 1
#把每张图片和标签封装到example中
example = tf.train.Example(features=tf.train.Features(feature={
‘img_raw‘: tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),
‘label‘: tf.train.Feature(int64_list=tf.train.Int64List(value=labels))
}))
#把example进行序列化
writer.write(example.SerializeToString())
num_pic += 1
print ("the number of picture:", num_pic)
#关闭writer
writer.close()
print("write tfrecord successful")
def generate_tfRecord():
isExists = os.path.exists(data_path)
if not isExists:
os.makedirs(data_path)
print ‘The directory was created successfully‘
else:
print ‘directory already exists‘
write_tfRecord(tfRecord_train, image_train_path, label_train_path)
write_tfRecord(tfRecord_test, image_test_path, label_test_path)
解析tfrecords文件
示例代码：
#解析tfrecords文件
def read_tfRecord(tfRecord_path):
#该函数会生成一个先入先出的队列，文件阅读器会使用它来读取数据
filename_queue = tf.train.string_input_producer([tfRecord_path], shuffle=True)
#新建一个reader
reader = tf.TFRecordReader()
#把读出的每个样本保存在serialized_example中进行解序列化，标签和图片的键名应该和制作tfrecords的键名相同，其中标签给出几分类。
_, serialized_example = reader.read(filename_queue)
#将tf.train.Example协议内存块(protocol buffer)解析为张量
features = tf.parse_single_example(serialized_example,
features={
‘label‘: tf.FixedLenFeature([10], tf.int64),
‘img_raw‘: tf.FixedLenFeature([], tf.string)
})
#将img_raw字符串转换为8位无符号整型
img = tf.decode_raw(features[‘img_raw‘], tf.uint8)
#将形状变为一行784列
img.set_shape([784])
img = tf.cast(img, tf.float32) * (1. / 255)
#变成0到1之间的浮点数
label = tf.cast(features[‘label‘], tf.float32)
#返回图片和标签
return img, label
def get_tfrecord(num, isTrain=True):
if isTrain:
tfRecord_path = tfRecord_train
else:
tfRecord_path = tfRecord_test
img, label = read_tfRecord(tfRecord_path)
#随机读取一个batch的数据
img_batch, label_batch = tf.train.shuffle_batch([img, label],
batch_size = num,
num_threads = 2,
capacity = 1000,
min_after_dequeue = 700)
#返回的图片和标签为随机抽取的batch_size组
return img_batch, label_batch
关键操作：利用多线程提高图片和标签的批获取效率
方法：将批获取的操作放到线程协调器开启和关闭之间开启线程协调器：
coord = tf.train.Coordinator( )
threads =tf.train.start_queue_runners(sess=sess, coord=coord)
关闭线程协调器：
coord.request_stop( ) coord.join(threads)
注解：
tf.train.start_queue_runners(sess=None,
coord=None,
daemon=True,
start=True,
collection=tf.GraphKeys.QUEUE_RUNNERS)
这个函数将会启动输入队列的线程，填充训练样本到队列中，以便出队操作可以从队列中拿到样本。这种情况下最好配合使用一个 tf.train.Coordinator，这样可以在发生错误的情况下正确地关闭这些线程。
参数说明：sess：用于运行队列操作的会话。 默认为默认会话。
coord：可选协调器，用于协调启动的线程。
daemon: 守护进程，线程是否应该标记为守护进程，这意味着它们不会阻止程序退出。
start：设置为False只创建线程，不启动它们。
collection：指定图集合以获取启动队列的 GraphKey。默认为
GraphKeys.QUEUE_RUNNERS。
反向传播中示例代码mnist_backward.py
#coding:utf-8
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import os
import mnist_generateds#1
BATCH_SIZE = 200
LEARNING_RATE_BASE = 0.1
LEARNING_RATE_DECAY = 0.99
REGULARIZER = 0.0001
STEPS = 50000
MOVING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH="./model/"
MODEL_NAME="mnist_model"
#手动给出训练的总样本数6万
train_num_examples = 60000#2
def backward():
x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
y = mnist_forward.forward(x, REGULARIZER)
global_step = tf.Variable(0, trainable=False)
ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
cem = tf.reduce_mean(ce)
loss = cem + tf.add_n(tf.get_collection(‘losses‘))
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step,
train_num_examples / BATCH_SIZE,
LEARNING_RATE_DECAY,
staircase=True)
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
ema_op = ema.apply(tf.trainable_variables())
with tf.control_dependencies([train_step, ema_op]):
train_op = tf.no_op(name=‘train‘)
saver = tf.train.Saver()
#一次批获取 batch_size张图片和标签
img_batch, label_batch = mnist_generateds.get_tfrecord(BATCH_SIZE, isTrain=True)#3
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
#利用多线程提高图片和标签的批获取效率
coord = tf.train.Coordinator()#4
#启动输入队列的线程
threads = tf.train.start_queue_runners(sess=sess, coord=coord)#5
for i in range(STEPS):
#执行图片和标签的批获取
xs, ys = sess.run([img_batch, label_batch])#6
_, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: xs, y_: ys})
if i % 1000 == 0:
print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)
#关闭线程协调器
coord.request_stop()#7
coord.join(threads)#8
def main():
backward()#9
if __name__ == ‘__main__‘:
main()
#coding:utf-8
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import mnist_backward
import mnist_generateds
TEST_INTERVAL_SECS = 5
#手动给出测试的总样本数1万
TEST_NUM = 10000#1
def test():
with tf.Graph().as_default() as g:
x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
y = mnist_forward.forward(x, None)
ema = tf.train.ExponentialMovingAverage(mnist_backward.MOVING_AVERAGE_DECAY)
ema_restore = ema.variables_to_restore()
saver = tf.train.Saver(ema_restore)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#用函数get_tfrecord替换读取所有测试集1万张图片
img_batch, label_batch = mnist_generateds.get_tfrecord(TEST_NUM, isTrain=False)#2
while True:
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(mnist_backward.MODEL_SAVE_PATH)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split(‘/‘)[-1].split(‘-‘)[-1]
#利用多线程提高图片和标签的批获取效率
coord = tf.train.Coordinator()#3
#启动输入队列的线程
threads = tf.train.start_queue_runners(sess=sess, coord=coord)#4
#执行图片和标签的批获取
xs, ys = sess.run([img_batch, label_batch])#5
accuracy_score = sess.run(accuracy, feed_dict={x: xs, y_: ys})
print("After %s training step(s), test accuracy = %g" % (global_step, accuracy_score))
#关闭线程协调器
coord.request_stop()#6
coord.join(threads)#7
else:
print(‘No checkpoint file found‘)
return
time.sleep(TEST_INTERVAL_SECS)
def main():
test()#8
if __name__ == ‘__main__‘:
main()
1）运行测试代码mnist_test.py
2）准确率稳定在95%以上后运行应用程序mnist_app.py
标签：argmax cti 列操作 sha mes ini 完成 cap rgb
原文地址：https://www.cnblogs.com/xiaojianliu/p/9368967.html
