专栏首页小鹏的专栏tf API 研读4:Inputs and Readers

tf API 研读4:Inputs and Readers

tensorflow中数据的读入相关类或函数:

占位符(Placeholders)

tf提供一种占位符操作,在执行时需要为其提供数据data。

操作

描述

tf.placeholder(dtype, shape=None, name=None)

为一个tensor插入一个占位符 eg:x = tf.placeholder(tf.float32, shape=(1024, 1024))

tf.placeholder_with_default(input, shape, name=None)

当输出没有fed时,input通过一个占位符op

tf.sparse_placeholder(dtype, shape=None, name=None)

为一个稀疏tensor插入一个占位符

读取器(Readers)

tf提供一系列读取各种数据格式的类。对于多文件输入,可以使用函数tf.train.string_input_producer,该函数将创建一个保持文件的FIFO队列,以供reader使用。或者如果输入的这些文件名有相雷同的字符串,也可以使用函数tf.train.match_filenames_once

操作

描述

class tf.ReaderBase

不同的读取器类型的基本类

tf.ReaderBase.read(queue, name=None)

返回下一个记录对(key, value),queue为tf文件队列FIFOQueue

tf.ReaderBase.read_up_to(queue, num_records, name=None)

返回reader产生的num_records对(key, value)

tf.ReaderBase.reader_ref

返回应用在该reader上的Op

tf.ReaderBase.reset(name=None)

恢复reader为初始状态

tf.ReaderBase.restore_state(state, name=None)

恢复reader为之前的保存状态state

tf.ReaderBase.serialize_state(name=None)

返回一个reader解码后产生的字符串tansor

class tf.TextLineReader

tf.TextLineReader.num_records_produced(name=None)

返回reader已经产生的记录(records )数目

tf.TextLineReader.num_work_units_completed(name=None)

返回该reader已经完成的处理的work数目

tf.TextLineReader.read(queue, name=None)

返回reader所产生的下一个记录对 (key, value),该reader可以限定新产生输出的行数

tf.TextLineReader.reader_ref

返回应用在该reader上的Op

tf.TextLineReader.reset(name=None)

恢复reader为初始状态

tf.TextLineReader.restore_state(state, name=None)

恢复reader为之前的保存状态state

tf.TextLineReader.serialize_state(name=None)

返回一个reader解码后产生的字符串tansor

class tf.WholeFileReader

一个阅读器,读取整个文件,返回文件名称key,以及文件中所有的内容value,该类的方法同上,不赘述

class tf.IdentityReader

一个reader,以key和value的形式,输出一个work队列。该类其他方法基本同上

class tf.TFRecordReader

读取TFRecord格式文件的reader。该类其他方法基本同上

class tf.FixedLengthRecordReader

输出

数据转换(Converting)

tf提供一系列方法将各种格式数据转换为tensor表示。

操作

描述

tf.decode_csv(records, record_defaults,  field_delim=None, name=None)

将csv转换为tensor,与tf.TextLineReader搭配使用

tf.decode_raw(bytes, out_type,  little_endian=None, name=None)

将bytes转换为一个数字向量表示,bytes为一个字符串类型的tensor 与函数 tf.FixedLengthRecordReader搭配使用,详见tf的CIFAR-10例子

选取与要输入的文件格式相匹配的reader,并将文件队列提供给reader的读方法( read method)。读方法将返回文件唯一标识的key,以及一个记录(record)(有助于对出现一些另类的records时debug),以及一个标量的字符串值。再使用一个(或多个)解码器(decoder) 或转换操作(conversion ops)将字符串转换为tensor类型。

#读取文件队列,使用reader中read的方法,返回key与value
filename_queue = tf.train.string_input_producer(["file0.csv", "file1.csv"])
reader = tf.TextLineReader()
key, value = reader.read(filename_queue)

record_defaults = [[1], [1], [1], [1], [1]]
col1, col2, col3, col4, col5 = tf.decode_csv(
    value, record_defaults=record_defaults)
features = tf.pack([col1, col2, col3, col4])

with tf.Session() as sess:
  # Start populating the filename queue.
  coord = tf.train.Coordinator()
  threads = tf.train.start_queue_runners(coord=coord)

  for i in range(1200):
    # Retrieve a single instance:
    example, label = sess.run([features, col5])

  coord.request_stop()
  coord.join(threads)

Example protocol buffer

提供了一些Example protocol buffers,tf所推荐的用于训练样本的数据格式,它们包含特征信息,详情可见。  这是一种与前述将手上现有的各种数据类型转换为支持的格式的方法,这种方法更容易将网络结构与数据集融合或匹配。这种tensorflow所推荐的数据格式是一个包含tf.train.Example protocol buffers (包含特征Features域)的TFRecords文件。  1、获取这种格式的文件方式为,首先将一般的数据格式填入Example protocol buffer中,再将 protocol buffer序列化为一个字符串,然后使用tf.python_io.TFRecordWriter类的相关方法将字符串写入一个TFRecords文件中,参见MNIST例子,将MNIST 数据转换为该类型数据。  2、读取TFRecords格式文件的方法为,使用tf.TFRecordReader读取器和tf.parse_single_example解码器。parse_single_example操作将 example protocol buffers解码为tensor形式。参见MNIST例子

操作

描述

class tf.VarLenFeature

解析变长的输入特征feature相关配置

class tf.FixedLenFeature

解析定长的输入特征feature相关配置

class tf.FixedLenSequenceFeature

序列项目中的稠密(dense )输入特征的相关配置

tf.parse_example(serialized, features,  name=None, example_names=None)

将一组Example protos解析为tensor的字典形式 解析serialized所给予的序列化的一些Example protos 返回一个由特征keys映射Tensor和SparseTensor值的字典

tf.parse_single_example(serialized, features,  name=None, example_names=None)

解析一个单独的Example proto,与tf.parse_example方法雷同

tf.decode_json_example(json_examples, name=None)

将JSON编码的样本记录转换为二进制protocol buffer字符串

#tf.parse_example的使用举例
#输入序列化数据如下: 
serialized = [
  features
    { feature { key: "ft" value { float_list { value: [1.0, 2.0] } } } },
  features
    { feature []},
  features
    { feature { key: "ft" value { float_list { value: [3.0] } } }
]
#那么输出为一个字典(dict),如下:
{"ft": SparseTensor(indices=[[0, 0], [0, 1], [2, 0]],
                    values=[1.0, 2.0, 3.0],
                    shape=(3, 2)) }
#########
#再来看一个例子,给定两个序列化的原始输入样本:
[
  features {
    feature { key: "kw" value { bytes_list { value: [ "knit", "big" ] } } }
    feature { key: "gps" value { float_list { value: [] } } }
  },
  features {
    feature { key: "kw" value { bytes_list { value: [ "emmy" ] } } }
    feature { key: "dank" value { int64_list { value: [ 42 ] } } }
    feature { key: "gps" value { } }
  }
]
#相关参数如下:
example_names: ["input0", "input1"],
features: {
    "kw": VarLenFeature(tf.string),
    "dank": VarLenFeature(tf.int64),
    "gps": VarLenFeature(tf.float32),
}
#那么有如下输出:
{
  "kw": SparseTensor(
      indices=[[0, 0], [0, 1], [1, 0]],
      values=["knit", "big", "emmy"]
      shape=[2, 2]),
  "dank": SparseTensor(
      indices=[[1, 0]],
      values=[42],
      shape=[2, 1]),
  "gps": SparseTensor(
      indices=[],
      values=[],
      shape=[2, 0]),
}
#########
#对于两个样本的输出稠密结果情况
[
  features {
    feature { key: "age" value { int64_list { value: [ 0 ] } } }
    feature { key: "gender" value { bytes_list { value: [ "f" ] } } }
   },
   features {
    feature { key: "age" value { int64_list { value: [] } } }
    feature { key: "gender" value { bytes_list { value: [ "f" ] } } }
  }
]
#我们可以使用以下参数
example_names: ["input0", "input1"],
features: {
    "age": FixedLenFeature([], dtype=tf.int64, default_value=-1),
    "gender": FixedLenFeature([], dtype=tf.string),
}
#期望的结果如下
{
  "age": [[0], [-1]],
  "gender": [["f"], ["f"]],
}
##Example protocol buffer相关使用的例子
#将mnist的数据转换为TFRecords文件格式
import os
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets import mnist
SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/'

TRAIN_IMAGES = 'train-images-idx3-ubyte.gz'  # MNIST filenames
TRAIN_LABELS = 'train-labels-idx1-ubyte.gz'
TEST_IMAGES = 't10k-images-idx3-ubyte.gz'
TEST_LABELS = 't10k-labels-idx1-ubyte.gz'

tf.app.flags.DEFINE_string('directory', '/tmp/data',
                           'Directory to download data files and write the '
                           'converted result')
tf.app.flags.DEFINE_integer('validation_size', 5000,
                            'Number of examples to separate from the training '
                            'data for the validation set.')
FLAGS = tf.app.flags.FLAGS

def _int64_feature(value):
  return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))

def _bytes_feature(value):
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))

def convert_to(data_set, name):
  images = data_set.images
  labels = data_set.labels
  num_examples = data_set.num_examples

  if images.shape[0] != num_examples:
    raise ValueError('Images size %d does not match label size %d.' %
                     (images.shape[0], num_examples))
  rows = images.shape[1]
  cols = images.shape[2]
  depth = images.shape[3]

  filename = os.path.join(FLAGS.directory, name + '.tfrecords')
  print('Writing', filename)
  writer = tf.python_io.TFRecordWriter(filename)
  for index in range(num_examples):
    image_raw = images[index].tostring()
    example = tf.train.Example(features=tf.train.Features(feature={
        'height': _int64_feature(rows),
        'width': _int64_feature(cols),
        'depth': _int64_feature(depth),
        'label': _int64_feature(int(labels[index])),
        'image_raw': _bytes_feature(image_raw)}))
    writer.write(example.SerializeToString())
  writer.close()

def main(argv):
  # Get the data.
  data_sets = mnist.read_data_sets(FLAGS.directory,
                                   dtype=tf.uint8,
                                   reshape=False)

  # Convert to Examples and write the result to TFRecords.
  convert_to(data_sets.train, 'train')
  convert_to(data_sets.validation, 'validation')
  convert_to(data_sets.test, 'test')

if __name__ == '__main__':
  tf.app.run()

队列(Queues)

tensorflow提供了几个队列应用,用来将tf计算图与tensors的阶段流水组织到一起。队列是使用tensorflow计算的一个强大的机制,正如其他Tensorflow的元素一样,一个队列也是tf图中的一个节点(node),它是一个有状态的node,就像一个变量:其他节点可以改变其内容。  我们来看一个简单的例子,如下gif图,我们将创建一个先入先出队列(FIFOQueue)并且将值全设为0,然后我们构建一个图以获取队列出来的元素,对该元素加1操作,并将结果再放入队列末尾。渐渐地,队列中的数字便增加。 

操作

描述

class tf.QueueBase

基本的队列应用类.队列(queue)是一种数据结构, 该结构通过多个步骤存储tensors, 并且对tensors进行入列(enqueue)与出列(dequeue)操作

tf.QueueBase.enqueue(vals, name=None)

将一个元素编入该队列中。如果在执行该操作时队列已满, 那么将会阻塞直到元素编入队列之中

tf.QueueBase.enqueue_many(vals, name=None)

将零个或多个元素编入该队列中

tf.QueueBase.dequeue(name=None)

将元素从队列中移出。如果在执行该操作时队列已空, 那么将会阻塞直到元素出列,返回出列的tensors的tuple

tf.QueueBase.dequeue_many(n, name=None)

将一个或多个元素从队列中移出

tf.QueueBase.size(name=None)

计算队列中的元素个数

tf.QueueBase.close (cancel_pending_enqueues=False, name=None)

关闭该队列

f.QueueBase.dequeue_up_to(n, name=None)

从该队列中移出n个元素并将之连接

tf.QueueBase.dtypes

列出组成元素的数据类型

tf.QueueBase.from_list(index, queues)

根据queues[index]的参考队列创建一个队列

tf.QueueBase.name

返回最队列下面元素的名称

tf.QueueBase.names

返回队列每一个组成部分的名称

class tf.FIFOQueue

在出列时依照先入先出顺序,其他方法与tf.QueueBase雷同

class tf.PaddingFIFOQueue

一个FIFOQueue ,同时根据padding支持batching变长的tensor

class tf.RandomShuffleQueue

该队列将随机元素出列,其他方法与tf.QueueBase雷同

文件系统的处理(Dealing with the filesystem)

操作

描述

tf.matching_files(pattern, name=None)

返回与pattern匹配模式的文件名称

tf.read_file(filename, name=None)

读取并输出输入文件的整个内容

输入管道(Input pipeline)

用于设置输入预取数的管道TF函数,函数 “producer”添加一个队列至图中,同时一个相应用于运行队列中子图(subgraph)的QueueRunner

操作

描述

tf.train.match_filenames_once(pattern, name=None)

保存与pattern的文件列表

tf.train.limit_epochs(tensor, num_epochs=None, name=None)

返回一个num_epochs次数,然后报告OutOfRange错误

tf.train.input_producer(input_tensor, element_shape=None,  num_epochs=None, shuffle=True, seed=None, capacity=32,  shared_name=None, summary_name=None, name=None)

为一个输入管道输出input_tensor中的多行至一个队列中

tf.train.range_input_producer(limit, num_epochs=None,  shuffle=True, seed=None, capacity=32,  shared_name=None, name=None)

产生一个从1至limit-1的整数至队列中

tf.train.slice_input_producer(tensor_list, num_epochs=None,  shuffle=True, seed=None, capacity=32,  shared_name=None, name=None)

对tensor_list中的每一个tensor切片

tf.train.string_input_producer(string_tensor, num_epochs=None, shuffle=True, seed=None, capacity=32,  shared_name=None, name=None)

为一个输入管道输出一组字符串(比如文件名)至队列中

在输入管道末端批量打包(Batching at the end of an input pipeline)

该相关函数增添一个队列至图中以将数据一样本打包为batch。它们也会添加 一个QueueRunner,以便执行的已经被填满队列的子图

操作

描述

tf.train.batch(tensors, batch_size, num_threads=1, capacity=32, enqueue_many=False, shapes=None,  dynamic_pad=False, allow_smaller_final_batch=False,  shared_name=None, name=None)

在输入的tensors中创建一些tensor数据格式的batch, 若输入为shape[*, x, y, z],那么输出则为[batch_size, x, y, z] 返回一个列表或者一个具有与输入tensors相同类型tensors的字典

tf.train.batch_join(tensors_list, batch_size,  capacity=32, enqueue_many=False, shapes=None,  dynamic_pad=False, allow_smaller_final_batch=False,  shared_name=None, name=None)

将一个tensors的列表添加至一个队列中以创建样本的batches len(tensors_list)个线程将启动, 线程i将tensors_list[i]的tensors入列 tensors_list[i1][j]与tensors_list[i2][j]有相同的类型和shape

tf.train.shuffle_batch(tensors, batch_size, capacity,  min_after_dequeue, num_threads=1, seed=None,  enqueue_many=False, shapes=None,  allow_smaller_final_batch=False, shared_name=None, name=None)

使用随机乱序的方法创建batches tensors:用于入列的一个list或者dict capacity:一个整数,表示队列中元素最大数目

tf.train.shuffle_batch_join(tensors_list, batch_size,  capacity, min_after_dequeue, seed=None,  enqueue_many=False, shapes=None,  allow_smaller_final_batch=False,  shared_name=None, name=None)

随机乱序的tensors创建batches, 其中tensors_list参数为tensors元组或tensors字典的列表 len(tensors_list)个线程将启动, 线程i将tensors_list[i]的tensors入列 tensors_list[i1][j]与tensors_list[i2][j]有相同的类型和shape

# 一个简单例子,使用tf.train.shuffle_batch创建一个具有32张图像和32个标签的batches.
image_batch, label_batch = tf.train.shuffle_batch(
      [single_image, single_label],
      batch_size=32,
      num_threads=4,
      capacity=50000,
      min_after_dequeue=10000)
#Batching函数相关例子,以函数tf.train.shuffle_batch为例
#为training, evaluation等操作将样本batching,以下代码使用随机顺序打包样本
def read_my_file_format(filename_queue):
  reader = tf.SomeReader()
  key, record_string = reader.read(filename_queue)
  example, label = tf.some_decoder(record_string)
  processed_example = some_processing(example)
  return processed_example, label

def input_pipeline(filenames, batch_size, num_epochs=None):
  filename_queue = tf.train.string_input_producer(
      filenames, num_epochs=num_epochs, shuffle=True)
  example, label = read_my_file_format(filename_queue)
  # min_after_dequeue defines how big a buffer we will randomly sample
  #   from -- bigger means better shuffling but slower start up and more
  #   memory used.
  # capacity must be larger than min_after_dequeue and the amount larger
  #   determines the maximum we will prefetch.  Recommendation:
  #   min_after_dequeue + (num_threads + a small safety margin) * batch_size
  min_after_dequeue = 10000
  capacity = min_after_dequeue + 3 * batch_size
  example_batch, label_batch = tf.train.shuffle_batch(
      [example, label], batch_size=batch_size, capacity=capacity,
      min_after_dequeue=min_after_dequeue)
  return example_batch, label_batch
#如果需要跟多的并行或文件之间的样本乱序操作,可以使用函数tf.train.shuffle_batch_join多实例化reader
def read_my_file_format(filename_queue):
  # 与上例子相同

def input_pipeline(filenames, batch_size, read_threads, num_epochs=None):
  filename_queue = tf.train.string_input_producer(
      filenames, num_epochs=num_epochs, shuffle=True)
  example_list = [read_my_file_format(filename_queue)
                  for _ in range(read_threads)]
  min_after_dequeue = 10000
  capacity = min_after_dequeue + 3 * batch_size
  example_batch, label_batch = tf.train.shuffle_batch_join(
      example_list, batch_size=batch_size, capacity=capacity,
      min_after_dequeue=min_after_dequeue)
  return example_batch, label_batch

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • tf24: GANs—生成明星脸

    GANs是Generative Adversarial Networks的简写,中文翻译为生成对抗网络,它最早出现在2014年Goodfellow发表的论文中...

    MachineLP
  • tf API 研读2:math

    TF API数学计算 tf...... :math (1)刚开始先给一个运行实例。         tf是基于图(Graph)的计算系统。而图的节点则是由操作(...

    MachineLP
  • tensorflow中的上采样(unpool)和反卷积(conv2d_transpose)

    import tensorflow as tf import numpy as np def max_pool(inp, k=2): return t...

    MachineLP
  • tensorflow常用函数API介绍

    TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU。一般你不需要显式指定使用 CPU 还是 GPU, T...

    砸漏
  • TensorFLow 数学运算的示例代码

    大多数运算符都进行了重载操作,使我们可以快速使用 (+ – * /) 等,但是有一点不好的是使用重载操作符后就不能为每个操作命名了。

    砸漏
  • tensorflow math api 汇总表

      Defined in tensorflow/python/ops/math_ops.py

    JNingWei
  • TensorFlow 常用函数汇总

    郭耀华
  • tensorflow | 维度转换

    努力在北京混出人样
  • tensorflow | 维度转换

    努力在北京混出人样
  • 在NetOps和SecOps的拉锯战中,SD-WAN起到了什么作用?

    跨越园区、分支机构、云和边缘的连接是构建数字化企业的基本要求,但是随着网络结构的扩展,端到端集成安全性的需求变得愈加重要。加上在园区,分支机构和边缘位置持续监视...

    SDNLAB

扫码关注云+社区

领取腾讯云代金券