Tensorflow学习笔记：变量作用域、模型的加载与保存、线程与队列实现多线程读取样本

最新推荐文章于 2023-04-09 15:24:04 发布

WilliamCode

最新推荐文章于 2023-04-09 15:24:04 发布

阅读量378

点赞数

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/WilliamCode/article/details/85255980

版权

python 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

# tensorflow变量作用域
   用上下文语句规定作用域
   with tf.variable_scope("作用域_name")
       ......
   这样可以使得变量在tensorboard中的显示更加简介

# 增加变量显示
   1、用tf.summary.scalar(name="",tensor)   收集单个值（0维的值）
   用tf.summary.histogram(name="",tensor) 收集高维度的值
2、合并变量并写入event文件
   merged = tf.summary.merge_all()
   summary = sess.run(merged)   #每次迭代都需要运行
   FileWriter.add_summary(summary,i)   #i代表第几次的值

#模型的保存与加载
   保存为checkpoint文件
   tf.train.Saver(var_list=None,   #用字典或列表传递要保存和还原的变量
           max_to_keep   #保留最近的几个文件的最大数目
           )
   返回一个实例saver
   saver.save(sess,'path+name')
   saver.restore(sess,'path+name')
   示例：

saver = tf.train.Saver(var_list=(w,b),max_to_keep = 3)
    with tf.Session() as sess:
        saver.save(sess,'./train_data/model')

Saver不是op，不用run

   如果需要加载模型，在训练开始之前进行加载
   if os.path.exists("checkpoint")   #判断保存时创建的checkpoint是否存在
   saver.restore(sess,'./trained_data/model')

#线程队列与IO操作
#队列
   tf.FIFOQueue()队列，先进先出
   tf.RandomShuffleQueue()随机出队列
#主要用到FIFOQueue
   FIFOQueue(capacity,   #最大数量
       dtype，   #数据类型
       name = None)
   方法：
   dequeue()出队列
   enqueue(vals)进队列
   enqueue_many(vals)    #vals为包含多组数据的列表或元组
   size()   返回大小

#队列管理器（可以创建线程）
   tf.train.QueueRunner(queue,enqueue_ops = None)
   其中queue是列表对象实例,en   queue_ops = [enqueue_op,dequque_op,...],指定线程做什么操作，[]*2代表指定两个线程
   create_threads(sess,
           coord=None   #线程协调器，后面再说
           start=False   #为True直接启动线程，为False必须调用start()来启动
           )        #运行线程进行操作
   返回一个线程的实例

示例：

#队列中加入数，每次取出后加1放入队列
    import tensorflow as tf
    import os

    #定义队列
    Q = tf.FIFOQueue(100,tf.float32)

    #定义变量
    var = tf.Variable(0.0,dtype = tf.float32)

    #取出变量自增后放入队列
    data = tf.assign_add(var,tf.constant(1.0))

    #data放入队列Q
    enq_op = Q.enqueue(data)

    Q_thread_op = tf.train.QueueRunner(Q,enqueue_ops = [enq_op])

    init_op = tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init_op)
        threads = Q_thread_op.create_threads(sess, start = True)

        for i in range(300):
            print(sess.run(Q.dequeue()),Q.size().eval())

#线程协调器tf.train.Coordinator()
示例：加入线程协调器

import tensorflow as tf
    import os

    #定义队列
    Q = tf.FIFOQueue(100,tf.float32)

    #定义变量
    var = tf.Variable(0.0,dtype = tf.float32)

    #取出变量自增后放入队列
    data = tf.assign_add(var,tf.constant(1.0))

    #data放入队列Q
    enq_op = Q.enqueue(data)

    Q_thread_op = tf.train.QueueRunner(Q,enqueue_ops = [enq_op])

    init_op = tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init_op)
        coord = tf.train.Coordinator()    #创建线程协调器
        threads = Q_thread_op.create_threads(sess,coord = coord, start = True)    #用线程协调器开启线程
        for i in range(300):
            print(sess.run(Q.dequeue()),Q.size().eval())
        coord.request_stop()    #请求线程结束
        coord.join(threads)    #回收线程

#文件读取
   1、构造文件读取队列
   tf.train.string_input_producer(string_tensor, num_epochs=None, shuffle=True, capacity=32)
   string_tensor：一维字符串张量，存储要读取的样本文件的字符串
   num_epochs：读取循环次数，默认无限次
   shuffle：随机选择文件读取
   capacity：文件读取队列的容量

   2、文件阅读器------读取队列内容
   tf.TextLineReader
       阅读文本文件(.txt,.CSV等)格式，默认按行读取
       return：读取器实例
   tf.FixedLengthRecordReader(record_bytes)
       阅读二进制文件，参数为要读取的字节数
       return 读取器实例
   tf.TFRecordReader()(后面再说)

   阅读器都有一个共同的方法：read(file_queue)
   return :一个张量，(文件名字，value读取的内容(行，字节))

   3、文件内容解码器
   tf.decode_csv(   records,   #即上面的value
           record_defaults = None   #所返回张量的类型
           field_delim = None #默认分隔符
           name = None)
   tf.decode_raw(bytes,out_type,little_endian = None)
       读取二进制文件

#批处理：在解码器解码之后进行，系统将运行多遍读取操作

   read_result_batch = tf.train.batch(read_result,   #解码器的解码结果
                       batch_size = 5,   #每个batch的数量，该大小跟队列大小，数据个数无关，一般数据可以循环读取，如果batch_size很大，则会重复取
                       num_threads = 1,#利用多少个线程处理
                       capacity = 5)   #队列的大小，没有关系，只是定义队列的大小

#实例：读取CSV文件
   1、找到文件构造样本文件的目录+文件名
   2、构造文件队列
   3、构造阅读器，读取文件（一行）
   4、构造解码器，解码内容
   5、批处理

def csvread(filelist):
    
    #1、构造文件字符串列表
    file_queue = tf.train.string_input_producer(filelist)

    #2、构造阅读器读取数据
    reader = tf.TextLineReader()
    key, value = reader.read(file_queue)

    #3、构造解码器进行解码
    recoders = [[1],[1]]
    read_result = tf.decode_csv(value, record_defaults = recoders)

    #4、批量读取
    read_result_batch = tf.train.batch(read_result, batch_size = 5, num_threads = 1, capacity = 7)

    return read_result_batch


import tensorflow as tf
import os

if __name__ == "__main__":

    #用os模块查询存放数据文件的目录下是否真的存在数据文件
    dir_file_list = os.listdir("C:\\Users\\xie\\csv_data")

    #构造数据文件路径+文件名的字符串列表
    for i in range(len(dir_file_list)):
        dir_file_list[i] = "C:\\Users\\xie\\csv_data\\" + dir_file_list[i]

    #调用函数获得样本batch
    result_batch = csvread(dir_file_list)

    with tf.Session() as sess:

        #定义线程管理器
        coord = tf.train.Coordinator()

        #用tf.train.start_queue_runners方法开启queue的子线程文件读取，其机制是：
        #所有关于queue读取的操作都被放在一个集合内部，当调用该函数时，所有的读取子进程启动，进行读取
        thread = tf.train.start_queue_runners(sess, coord = coord)

        print(sess.run(result_batch))

        coord.request_stop()
        coord.join(thread)