学习笔记TF049:TensorFlow 模型存储加载、队列线程、加载数据、自定义操作
学习笔记TF049:TensorFlow 模型存储加载、队列线程、加载数据、自定义操作
利炳根 发表于3个月前
学习笔记TF049:TensorFlow 模型存储加载、队列线程、加载数据、自定义操作
  • 发表于 3个月前
  • 阅读 19
  • 收藏 0
  • 点赞 0
  • 评论 0

生成检查点文件(chekpoint file),扩展名.ckpt,tf.train.Saver对象调用Saver.save()生成。包含权重和其他程序定义变量,不包含图结构。另一程序使用,需要重新创建图形结构,告诉TensorFlow如何处理权重。 生成图协议文件(graph proto file),二进制文件,扩展名.pb,tf.tran.write_graph()保存,只包含图形结构,不包含权重,tf.import_graph_def加载图形。

模型存储,建立一个tf.train.Saver()保存变量,指定保存位置,扩展名.ckpt。

神经网络,两个全连接层和一个输出层,训练MNIST数据集,存储训练好的模型。 加载数据、定义模型:

#加载数据
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
trX,trY,teX,teY = mnist.train.images,mnist.train.labels,mnist.test.images,mnist.test.labels
X = tf.placeholder("float",[None,784])
Y = tf.placeholder("float",[None,10])
#初始化权重参数
w_h = init_weights([784,625])
w_h2 = init_weights([625,625])
w_o = int_weights([625,10])

#定义权重函数
def init_weights(shape):
    return tf.Variable(tf.random_normal(shape,stddev=0.01))

#定义模型
def model(X,w_h,w_h2,w_o,p_keep_input,p_keep_hidden):
    #第一个全连接层
    X = tf.nn.dropout(X,p_keep_input)
    h = tf.nn.relu(tf.matmul(X,w_h))

    h = tf.nn.dropout(h,p_keep,hidden)
    #第二个全连接层
    h2 = tf.nn.relu(tf.matmul(h,w_h2))
    h2 = tf.nn.dropout(h2,p_keep_hidden)

    return tf.matmul(h2,w_o)#输出预测值

#定义损失函数
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(py_x,Y))
train_op = tf.train.RMSPropOptimizer(0.001,0.9).minimize(cost)
predict_op = tf.argmax(py_x,1)

训练模型及存储模型:

#定义存储路径
ckpt_dir = "./ckpt_dir"
if not os.path.exists(ckpt_dir):
    os.makedirs(ckpt_dir)

定义计数器,为训练轮数计数:

#计数器变量,设置它的trainable=False,不需要被训练
global_step = tf.Variable(0,name='global_step',trainable=False)

定义完所有变量,tf.train.Saver()保存、提取变量,后面定义变量不被存储:

#声明完所有变量,调tf.train.Saver
saver = tf.train.Saver()
#之后变量不被存储
non_storable_variable = tf.Variable(777)

训练模型并存储:

with tf.Session() as sess:
    tf.initialize_all_variables().run()
    start = global_step.eval() #得到global_stepp初始值
    print("Start from:",start)
    for i in range(start,100):
        #128 batch_size
        for start,end in zip(range(0,len(trX),128),range(128,len(trX)+1,128)):
            sess.run(train_op,feed_dict={X:trX[start:end],Y:trY[start:end],p_keep_input:0.8, p_keep_hidden:0.5})
        global_step.assign(i).eval() #更新计数器
        saver.save(sess,ckpt_dir+"/model.ckpt",global_step=global_step) #存储模型

训练过程,ckpt_dir出现16个文件,5个model.ckpt-{n}.data00000-of-00001文件,保存的模型。5个model.ckpt-{n}.meta文件,保存的元数据。TensorFlow默认只保存最近5个模型和元数据,删除前面没用模型和元数据。5个model.ckpt-{n}.index文件。{n}代表迭代次数。1个检查点文本文件,保存当前模型和最近5个模型。

将之前训练参数保存下来,在出现意外状竞接着上一次地方开始训练。每个固定轮数在检查点保存一个模型(.ckpt文件),随时将模型拿出来预测。

加载模型。 saver.restore加载模型:

with tf.Session() as sess:
    tf.initialize_all_variables().run()
    ckpt = tf.train.get_checkpoint_state(ckpt_dir)
    if ckpt and ckpt.model_checkpoint_path:
        print(ckpt.model_checkpoint_path)
        saver.restore(sess,ckpt.model_checkpoint_path) #加载所有参数

图存储加载。 仅保存图模型,图写入二进制协议文件:

v = tf.Variable(0,name='my_variable')
sess = tf.Session()
tf.train.write_graph(sess.graph_def,'/tmp/tfmodel','train.pbtxt')

读取:

with tf.Session() as _sess:
    with grile.FastGFile("/tmp/tfmodel/train.pbtxt",'rb') as f:
        graph_def = tf.GraphDef()
        graph_def.ParseFromString(f.read())
        _sess.graph.as_default()
        tf.import_graph_def(graph_def,name='tfgraph')

队列、线程。 队列(queue),图节点,有状态节点。其他节点(入队节点enqueue,出队节点depueue),修改它内容。入队节点把新元素插到队列末尾,出队节点把队列前面元素删除。 FIFOQueue、RandomShuffleQueue,源代码在tensorflow-1.0.0/tensorflow/python/ops/data_flow_ops.py 。 FIFOQueue,创建先入先出队列。循环神经网络结构,读入训练样本需要有序。 创建含队列图:

import tensorflow as tf
#创建先入先出队列,初始化队列插入0.1、0.2、0.3数字
q = tf.FIFOQueue(3,"float")
init = q.enqueue_many(([0.1,0.2,0.3]))
#定义出队、+1、入队操作
x = q.dequeue()
y = x +1
q_inc = q.enqueue([y])

开户会话,执行2次q_inc操作,查看队列内容:

with tf.Session() as sess:
    sess.run(init)
    quelen = sess.run(q.size())
    for i in range(2):
        sess.run(q_inc) #执行2次操作,队列值变0.3,1.1,1.2
    quelen = sess.run(q.size())
    for i in range(quelen):
        print(sess.run(q.dequeue())) #输出队列值

RandomShuffleQueue,创建随机队列。出队列,以随机顺序产生元素。训练图像样本,CNN网络结构,无序读入训练样本,每次随机产生一个训练样本。 异步计算时非常重要。TensorFlow会话支持多线程,在主线程训练操作,RandomShuffleQueue作训练输入,开多个线程准备训练样本。样本压入队列,主线程从队列每次取出mini-batch样本训练。 创建随机队列,最大长度10,出队后最小长度2:

q = tf.RandomShuffleQueue(capacity=10,min_after_dequeue=2,dtype="float")

开户会话,执行10次入队操作,8次出队操作:

sess = tf.Session()
for i in range(0,10): #10次入队
    sess.run(q.enqueue(i))
for i in range(0,8): #8次出队
    print(sess.run(q.dequeue()))

阻断,队列长度等于最小值,执行出队操作;队列长度等于最大值,执行入队操作。 设置绘画运行时等待时间解除阻断:

run_iptions = tf.RunOptions(timeout_in_ms = 10000) #等待10秒
try:
    sess.run(q.dequeue(),options=run_options)
except tf.errors.DeadlineExceededError:
    print('out of range')

会话主线程入队操作,数据量很大时,入队操作从硬盘读取数据,放入内存,主线程需要等待入队操作完成,才能进行训练操作。会话运行多个线程,线程管理器QueueRunner创建一系列新线程进行入队操作,主线程继续使用数据,训练网张和读取数据是异步的,主线程训练网络,另一线程将数据从硬盘读入内存。

队列管理器。 创建含队列图:

q = tf.FIFOQueue(1000,"float")
counter = tf.Variable(0.0) #计数器
increment_op = tf.assign_add(counter,tf.constant(1.0)) #操作:给计算器加1
enqueue_op = q.enqueue(counter) #操作:计数器值加入队列

创建队列管理器QueueRunner,两个操作向队列q添加元素。只用一个线程:

qr = tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueue_op] * 1)

启动会话,从队列管理器qr创建线程:

#主线程
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    enqueue_threads = qr.create_threads(sess,start=True) #启动入队线程
    #主线程
    for i in range(10):
        print(sess.run(q.dequeue()))

不是自然数列,线程被阴断。加1操作和入队操作不同步。加1操作执行多次后,才进行一次入队操作。主线程训练(出队操作)和读取数据线程的训练(入队操作)异步,主线程一直等待数据送入。 入队线程自顾执行,出队操作完成,程序无法结束。tf.train.Coordinator实现线程同步,终止其他线程。

线程、协调器。 协调器(coordinator)管理线程。

#主线程
sess = tf.Session()
sess.run(tf.global_variables_initializer())
#Coordinator:协调器,协调线程间关系可以视为一种信号量,用来做同步
coord = tf.train.Coordinator()
#启动入队线程,协调器是线程的参数
enqueue_threads = qr.create_threads(sess,coord = coord,start=True)
#主线程
for i in range(0,10):
    print(sess.run(q.dequeue()))
coord.request_stop() #通知其他线程关闭
coord.join(enqueue_threads) #join操作等待其他线程结束,其他所有线程关闭之后,函数才能返回

关闭队列线程,执行出队操作,抛出tf.errors.OutOfRange错误。coord.request_stop()和主线程出队操作q.dequeue()调换位置。

coord.request_stop()
#主线程
for i in range(0,10):
    print(sess.run(q.dequeue()))
coord.join(enqueue_threads)
tf.errors.OutOfRangeError捕捉错误:
coord.request_stop()
#主线程
for i in range(0,10):
    try:
        print(sess.run(q.dequeue()))
    except tf.errors.OutOfRangeError:
        break
coord.join(enqueue_threads)

所有队列管理器默认加在图tf.GraphKeys.QUEUE_RENNERS集合。

加载数据。 预加载数据(preloaded data),在TensorFlow图中定义常量或变量保存所有数据。填充数据(feeding),Python产生数据,数据填充后端。从文件读取数据(reading from file),队列管理器从文件中读取数据。

预加载数据。数据直接嵌在数据流图中,训练数据大时,很消耗内存。

x1 = tf.constant([2,3,4])
x2 = tf.constant([4,0,1])
y = tf.add(x1,x2)

填充数据。sess.run()中的feed_dict参数,Python产生数据填充后端。数据量大、消耗内存,数据类型转换等中间环节增加开销。

import tensorflow as tf
#设计图
a1 = tf.placeholder(tf.int16)
a2 = tf.placeholder(tf.int16)
b = tf.add(x1,x2)
#用Python产生数据
li1 = [2,3,4]
li2 = [4,0,1]
#打开会话,数据填充后端
with tf.Session() as sess:
    print sess.run(b,feed_dict={a1:li1,a2:li2})

从文件读取数据。图中定义好文件读取方法,TensorFlow从文件读取数据,解码成可使用样本集。 把样本数据写入TFRecords二进制文件。再从队列读取。 TFRecords二进制文件,更好利用内存,方便复制和移动,不需要单独标记文件。tensorflow-1.1.0/tensorflow/examples/how_tos/reading_data/convert_to_records.py。 生成TFRecords文件。定义主函数,给训练、验证、测试数据集做转换。获取数据。编码uint8。数据转换为tf.train.Example类型,写入TFRecords文件。转换函数convert_to,数据填入tf.train.Example协议缓冲区(protocol buffer),协议组冲区序列转为字符串,tf.python_io.TFRecordWriter写入TFRecords文件。55000个训练数据,5000个验证数据,10000个测试数据。黑白图像,单通道。写入协议缓冲区,height、width、depth、label编码int64类型,image_raw编码成二进制。序列化为字符串。运行结束,在/tmp/data生成文件train.tfrecords、validation.tfrecords、test.tfrecords。 从队列读取。创建张量,从二进制文件读取一个样本。创建张量,从二进制文件随机读取一个mini-batch。把每一批张量传入网络作为输入节点。代码 tensorflow-1.1.0/tensorflow/examples/how_tos/reading_data/fully_connected_reader.py。首先定义从文件中读取并解析一个样本。输入文件名队列。解析example。写明features里key名称。图片 string类型。标记 int64类型。BytesList 重新解码,把string类型0维Tensor变成unit8类型一维Tensor。image张量形状Tensor("input/sub:0",shape=(784,),dtype=float32)。把标记从uint8类型转int32类型。label张量形状Tensor("input/Cast_1:0",shape=(),dtype=int32)。 tf.train.shuffle_batch样本随机化,获得最小批次张量。输入参数,train 选择输入训练数据/验证数据,batch_size 训练每批样本数,num_epochs 过几遍数据 设置0/None表示永远训练下去。返回结果,images,类型float, 形状[batch_size,mnist.IMAGE_PIXELS],范围[-0.5,0.5]。labels,类型int32,形状[batch_size],范围[0,mnist.NUM_CLASSES]。tf.train.QueueRunner用tf.train.start_queue_runners()启动线程。获取文件路径,/tmp/data/train.tfrecords, /tmp/data/validation.records。tf.train.string_input_producer返回一个QueueRunner,里面有一个FIFOQueue。如果样本量很大,分成若干文件,文件名列表传入。随机化example,规整成batch_size大小。留下部分队列,保证每次有足够数据做随机打乱。 生成batch张量作网络输入,训练。输入images、labels。构建从揄模型预测数据的图。定义损失函数。加入图操作,训练模型。初始化参数,string_input_producer内疗创建一个epoch计数变量,归入tf.GraphKeys.LOCAL_VARIABLES集合,单独用initialize_local_variables()初始化。开启输入入阶线程。进入永久循环。每100次训练输出一次结果。通知其他线程关闭。数据集大小55000,2轮训练,110000个数据,batch_size大小100,训练次数1100次,每100次训练输出一次结果,输出11次结果。 TensorFlow使用TFRecords文件训练样本步骤:在生成文件名队列中,设定epoch数量。训练时,设定为无穷循环。在读取数据时,如果捕捉到错误,终止。

实现自定义操作。 需要熟练掌握C++语言。对张量流动和前向传播、反向传播有深理解。 步骤。在C++文件(_ops.cc文件)中注册新操作。定义操作功能接口规范,操作名称、输入、输出、属性等。在C++文件(_kenels.cc文件)实现操作,可以实现在CPU、GPU多个内核上。测试操作,编译操作库文件(*_ops.so文件),Python使用操作。 最佳实践。词嵌入。源代码 https://github.com/tensorflow/models/blob/master/tutorials/embedding/word2vec_optimized.py 。 第一步,创建word2vec_ops.cc注册两个操作,SkipgramWord2vec、NegTrainWord2vec。 第二步,两个操作在CPU设备实现,生成word2vec_kernels.cc文件。 第三步,编译操作类文件,测试。在特定头文件目录下编译,Python提供get_include获取头文件目录,C++编译器把操作编译成动态库。TensorFlow Python API提供tf.load_op_library函数加载动态库,向TensorFlow 框架注册操作。load_op_library返回包含操作和内核Python模块。

参考资料: 《TensorFlow技术解析与实战》

欢迎付费咨询(150元每小时),我的微信:qingxingfengzi

共有 人打赏支持
粉丝 8
博文 43
码字总数 99594
×
利炳根
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: