Tensorflow一些常用基本概念与函数（二）

最新推荐文章于 2022-08-19 21:01:40 发布
最新推荐文章于 2022-08-19 21:01:40 发布
阅读量654 收藏
点赞数
分类专栏： TensorFlow 框架 文章标签： 函数

1、tensorflow的基本运作

为了快速的熟悉TensorFlow编程，下面从一段简单的代码开始：

import tensorflow as tf
 #定义‘符号’变量，也称为占位符
 a = tf.placeholder("float")
 b = tf.placeholder("float") y = tf.mul(a, b) #构造一个op节点 sess = tf.Session()#建立会话 #运行会话，输入数据，并计算节点，同时打印结果 print sess.run(y, feed_dict={a: 3, b: 3}) # 任务完成, 关闭会话. sess.close()

 

 

其中tf.mul(a, b)函数便是tf的一个基本的算数运算，接下来介绍跟多的相关函数。

2、tf函数

TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU。一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测。如果检测到 GPU, TensorFlow 会尽可能地利用找到的第一个 GPU 来执行操作.
并行计算能让代价大的算法计算加速执行，TensorFlow也在实现上对复杂操作进行了有效的改进。大部分核相关的操作都是设备相关的实现，比如GPU。本文主要涉及的相关概念或操作有以下内容：
操作组操作
Building GraphsCore graph data structures，Tensor types，Utility functions
Inputs and ReadersPlaceholders，Readers，Converting，Queues，Input pipeline

2.1 建立图(Building Graphs)

本节主要介绍建立tensorflow图的相关类或函数

* 核心图的数据结构（Core graph data structures）

tf.Graph

操作描述
class tf.Graphtensorflow中的计算以图数据流的方式表示
一个图包含一系列表示计算单元的操作对象
以及在图中流动的数据单元以tensor对象表现
tf.Graph.__init__()建立一个空图
tf.Graph.as_default()一个将某图设置为默认图，并返回一个上下文管理器
如果不显式添加一个默认图，系统会自动设置一个全局的默认图。
所设置的默认图，在模块范围内所定义的节点都将默认加入默认图中
tf.Graph.as_graph_def
(from_version=None, add_shapes=False)		返回一个图的序列化的GraphDef表示
序列化的GraphDef可以导入至另一个图中(使用 import_graph_def())
或者使用C++ Session API
tf.Graph.finalize()完成图的构建，即将其设置为只读模式
tf.Graph.finalized返回True，如果图被完成
tf.Graph.control_dependencies(control_inputs)定义一个控制依赖，并返回一个上下文管理器
with g.control_dependencies([a, b, c]):
# `d` 和 `e` 将在 `a`, `b`, 和`c`执行完之后运行.
d = …
e = …
tf.Graph.device(device_name_or_function)定义运行图所使用的设备，并返回一个上下文管理器
with g.device('/gpu:0'): ...
with g.device('/cpu:0'): ...
tf.Graph.name_scope(name)为节点创建层次化的名称，并返回一个上下文管理器
tf.Graph.add_to_collection(name, value)将value以name的名称存储在收集器(collection)中
tf.Graph.get_collection(name, scope=None)根据name返回一个收集器中所收集的值的列表
tf.Graph.as_graph_element
(obj, allow_tensor=True, allow_operation=True)		返回一个图中与obj相关联的对象，为一个操作节点或者tensor数据
tf.Graph.get_operation_by_name(name)根据名称返回操作节点
tf.Graph.get_tensor_by_name(name)根据名称返回tensor数据
tf.Graph.get_operations()返回图中的操作节点列表
tf.Graph.gradient_override_map(op_type_map)用于覆盖梯度函数的上下文管理器
#class tf.Graph
#tensorflow运行时需要设置默认的图
g = tf.Graph()
with g.as_default():
  # Define operations and tensors in `g`.
  c = tf.constant(30.0) assert c.graph is g ##也可以使用tf.get_default_graph()获得默认图，也可在基础上加入节点或子图 c = tf.constant(4.0) assert c.graph is tf.get_default_graph()

 

 

#tf.Graph.as_default
#以下两段代码功能相同
#1、使用Graph.as_default():
g = tf.Graph()
with g.as_default():
  c = tf.constant(5.0) assert c.graph is g #2、构造和设置为默认 with tf.Graph().as_default() as g: c = tf.constant(5.0) assert c.graph is g

 

 

#tf.Graph.control_dependencies(control_inputs)
# 错误代码
def my_func(pred, tensor): t = tf.matmul(tensor, tensor) with tf.control_dependencies([pred]): # 乘法操作(op)没有创建在该上下文，所以没有被加入依赖控制 return t # 正确代码 def my_func(pred, tensor): with tf.control_dependencies([pred]): # 乘法操作(op)创建在该上下文，所以被加入依赖控制中 #执行完pred之后再执行matmul return tf.matmul(tensor, tensor)

 

 

# tf.Graph.name_scope(name)
# 一个图中包含有一个名称范围的堆栈，在使用name_scope(...)之后，将压(push)新名称进栈中，
#并在下文中使用该名称
with tf.Graph().as_default() as g: c = tf.constant(5.0, name="c") assert c.op.name == "c" c_1 = tf.constant(6.0, name="c") assert c_1.op.name == "c_1" # Creates a scope called "nested" with g.name_scope("nested") as scope: nested_c = tf.constant(10.0, name="c") assert nested_c.op.name == "nested/c" # Creates a nested scope called "inner". with g.name_scope("inner"): nested_inner_c = tf.constant(20.0, name="c") assert nested_inner_c.op.name == "nested/inner/c" # Create a nested scope called "inner_1". with g.name_scope("inner"): nested_inner_1_c = tf.constant(30.0, name="c") assert nested_inner_1_c.op.name == "nested/inner_1/c" # Treats `scope` as an absolute name scope, and # switches to the "nested/" scope. with g.name_scope(scope): nested_d = tf.constant(40.0, name="d") assert nested_d.op.name == "nested/d" with g.name_scope(""): e = tf.constant(50.0, name="e") assert e.op.name == "e"

 

 

tf.Operation

操作描述
class tf.Operation代表图中的一个节点，用于计算tensors数据
该类型将由python节点构造器产生(比如tf.matmul())
或者Graph.create_op()
例如c = tf.matmul(a, b)创建一个Operation类
为类型为”MatMul”,输入为’a’,’b’，输出为’c’的操作类
tf.Operation.name操作节点(op)的名称
tf.Operation.type操作节点(op)的类型，比如”MatMul”
tf.Operation.inputs
tf.Operation.outputs		操作节点的输入与输出
tf.Operation.control_inputs操作节点的依赖
tf.Operation.run(feed_dict=None, session=None)在会话(Session)中运行该操作
tf.Operation.get_attr(name)获取op的属性值

tf.Tensor

操作描述
class tf.Tensor表示一个由操作节点op产生的值，
TensorFlow程序使用tensor数据结构来代表所有的数据, 
计算图中, 操作间传递的数据都是 tensor，一个tensor是一个符号handle,
里面并没有表示实际数据，而相当于数据流的载体
tf.Tensor.dtypetensor中数据类型
tf.Tensor.name该tensor名称
tf.Tensor.value_index该tensor输出外op的index
tf.Tensor.graph该tensor所处在的图
tf.Tensor.op产生该tensor的op
tf.Tensor.consumers()返回使用该tensor的op列表
tf.Tensor.eval(feed_dict=None, session=None)在会话中求tensor的值
需要使用with sess.as_default()或者 eval(session=sess)
tf.Tensor.get_shape()返回用于表示tensor的shape的类TensorShape
tf.Tensor.set_shape(shape)更新tensor的shape
tf.Tensor.device设置计算该tensor的设备
#tf.Tensor.get_shape()
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) print(c.get_shape()) ==> TensorShape([Dimension(2), Dimension(3)])

 

 

#现在有个用于图像处理的tensor->image
print(image.get_shape())
==> TensorShape([Dimension(None), Dimension(None), Dimension(3)])
# 假如我们知道数据集中图像尺寸为28 x 28，那么可以设置 image.set_shape([28, 28, 3]) print(image.get_shape()) ==> TensorShape([Dimension(28), Dimension(28), Dimension(3)])

 

 

* tensor类型(Tensor types)

tf.DType

操作描述
class tf.DType数据类型主要包含
tf.float16，tf.float16,tf.float32,tf.float64,
tf.bfloat16,tf.complex64,tf.complex128,
tf.int8,tf.uint8,tf.uint16,tf.int16,tf.int32,
tf.int64,tf.bool,tf.string
tf.DType.is_compatible_with(other)判断other的数据类型是否将转变为该DType
tf.DType.name数据类型名称
tf.DType.base_dtype返回该DType的基础DType，而非参考的数据类型(non-reference)
tf.DType.as_ref返回一个基于DType的参考数据类型
tf.DType.is_floating判断是否为浮点类型
tf.DType.is_complex判断是否为复数
tf.DType.is_integer判断是否为整数
tf.DType.is_unsigned判断是否为无符号型数据
tf.DType.as_numpy_dtype返回一个基于DType的numpy.dtype类型
tf.DType.max
tf.DType.min		返回这种数据类型能表示的最大值及其最小值
tf.as_dtype(type_value)返回由type_value转变得的相应tf数据类型
* 通用函数（Utility functions）
操作描述
tf.device(device_name_or_function)基于默认的图，其功能便为Graph.device()
tf.container(container_name)基于默认的图，其功能便为Graph.container()
tf.name_scope(name)基于默认的图，其功能便为 Graph.name_scope()
tf.control_dependencies(control_inputs)基于默认的图，其功能便为Graph.control_dependencies()
tf.convert_to_tensor
(value, dtype=None, name=None, as_ref=False)		将value转变为tensor数据类型
tf.get_default_graph()返回返回当前线程的默认图
tf.reset_default_graph()清除默认图的堆栈，并设置全局图为默认图
tf.import_graph_def(graph_def, input_map=None,
return_elements=None, name=None, op_dict=None,
producer_op_list=None)		将graph_def的图导入到python中
* 图收集（Graph collections）
操作描述
tf.add_to_collection(name, value)基于默认的图，其功能便为Graph.add_to_collection()
tf.get_collection(key, scope=None)基于默认的图，其功能便为Graph.get_collection()
* 定义新操作节点（Defining new operations）

tf.RegisterGradient

操作描述
class tf.RegisterGradient返回一个用于寄存op类型的梯度函数的装饰器
tf.NoGradient(op_type)设置操作节点类型op_type的节点没有指定的梯度
class tf.RegisterShape返回一个用于寄存op类型的shape函数的装饰器
class tf.TensorShape表示tensor的shape
tf.TensorShape.merge_with(other)与other合并shape信息，返回一个TensorShape类
tf.TensorShape.concatenate(other)与other的维度相连结
tf.TensorShape.ndims返回tensor的rank
tf.TensorShape.dims返回tensor的维度
tf.TensorShape.as_list()以list的形式返回tensor的shape
tf.TensorShape.is_compatible_with(other)判断shape是否为兼容
TensorShape(None)与其他任何shape值兼容
class tf.Dimension 
tf.Dimension.is_compatible_with(other)判断dims是否为兼容
tf.Dimension.merge_with(other)与other合并dims信息
tf.op_scope(values, name, default_name=None)在python定义op时，返回一个上下文管理器
#tf.RegisterGradient
#该装饰器只使用于定义一个新的op类型时候，如果一个op有m个输入，n个输出。那么该梯度函数应该设置原始的
#操作类型，以及n个Tensor对象（表示每一个op输出的梯度），以及m个对象(表示每一个op输入的偏梯度)
#以操作节点类型为'Sub'为例，两输入为x,y。为一个输出x-y
@tf.RegisterGradient("Sub") def _sub_grad(unused_op, grad): return grad, tf.neg(grad)

 

 

#tf.op_scope
#定义一个名称为my_op的python操作节点op
def my_op(a, b, c, name=None): with tf.op_scope([a, b, c], name, "MyOp") as scope: a = tf.convert_to_tensor(a, name="a") b = tf.convert_to_tensor(b, name="b") c = tf.convert_to_tensor(c, name="c") # Define some computation that uses `a`, `b`, and `c`. return foo_op(..., name=scope)

 

 

2.2 输入和读取器(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

转自：http://blog.csdn.net/lenbow/article/details/52181159
sinat_29552923
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
神经网络-常见函数、定义
qq_58466532的博客
12-13 5715
V1只含有__iter__，而没有__next__方法,V1.__iter__方法的返回值V2内含有__iter__和__next__方法。可迭代对象(类）——只含有__iter__方法，不含__next__方法，且__iter__方法返回的是一个迭代器对象；一般都是将迭代器类（对象）、可迭代类（对象）进行混合使用： IT（）是一个迭代器类，Foo（）是一个可迭代类，Foo()的__iter__方法返回的是一个迭代器对象IT。将矩阵y改变形状，这里（a，b）前面的数(a)表示行数，后面的数(b)表示列数。
Tensorflow一些常用基本概念与函数（2）
热门推荐
lenbow的博客
08-11 8万+
摘要：本文主要对tf的一些常用概念与方法进行描述。为‘Tensorflow一些常用基本概念与函数’系列之二。
深度学习 笔记（线性神经网络）
han_lx_的博客
08-19 2400
线性回归基本知识，softmax学习笔记，简单实现
tf.Graph.get_tensor_by_name()
u013049912的博客
07-16 1万+
https://www.jianshu.com/p/3cee7ca5ebd8
register_shape
piglite的专栏
05-25 3293
海龟默认的画笔形状（shape）包括箭头、三角、方形、圆形和海龟，通过设置resizemode和shapesize，可以改变它们的大小。 import turtle pen = turtle.Turtle() pen.shape('turtle') pen.shapesize(5, 5, 1) turtle.done() 通过turtle的register_shape指令，可以新增更多的画笔shape。 register_shape支持三种添加方式： 1.添加指定的图片作为画笔的shape
Tensorflow一些常用基本概念与函数
09-08
Tensorflow一些常用基本概念与函数， [1] 安装Tensorflow（Linux ubuntu） http://blog.csdn.net/lenbow/article/details/51203526 [2] ubuntu下CUDA编译的GCC降级安装 ...
TensorFlow的常量.变量.常用函数.docx
06-23
除了上述常量和变量的操作，TensorFlow 还提供了许多其他常用函数，如： - `tf.placeholder()`: 创建占位符，用于在运行时提供数据。 - `tf.add()`, `tf.subtract()`, `tf.multiply()`, `tf.divide()`: 基本的数学...
那些数据和命令.zip_a_tensorflow_tensorflow 函数
09-24
"那些数据和命令.zip_a_tensorflow_tensorflow 函数"这个压缩包文件可能包含了关于TensorFlow中一些常用函数的资料，这对于理解和应用TensorFlow至关重要。在这个文件中，我们可能会找到有关如何操作张量、构建计算...
基于数值分析和Tensorflow对Himmelblau 函数优化实战预测
最新发布
03-07
在本文中，我们将深入探讨如何使用数值分析方法与TensorFlow框架来解决Himmelblau函数的优化问题。Himmelblau函数是一个经典的测试函数，常用于优化算法的性能评估，其数学表达式为： \[ f(x, y) = (x^2 + y - 11)^...
tensorflow 自定义损失函数示例代码
12-20
通常情况下，回归问题中最常用的损失函数是均方误差（Mean Squared Error, MSE），它衡量的是预测值与真实值之间的平均平方差。然而，在某些特定场景下，MSE可能不是最优的选择，例如在上述例子中，预测商品销量时，...
TensorFlow语法小结
06-11
里面总结了TensorFlow常用的语法与几个常用的cmd命令，希望能帮助大家更好地学习
Tensorflow 中 RNN softmax输出层采样 tf.multinomial(logits, num_samples)
jasonzzj的博客
03-04 7619
Tensorflow 中，想要使用sequence to sequence 模型，在RNN的输出端采样(sampling)，可以在softmax层之后，做简单的log p 再用tf.multinomial()来实现： tf.multinomial(logits, num_samples, seed=None, name=None)例如： # samples has shape [1, 5
python中num是什么意思_python – num_epochs和步骤有什么区别？
weixin_39528029的博客
12-04 3184
在tensorflow入门代码中：import tensorflow as tfimport numpy as npfeatures = [tf.contrib.layers.real_valued_column("x", dimension=1)]estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)x = n...
Tensorflow之占位符
遨游大海的猪
08-26 1037
占位符: 用于将值输入tensorflow图中, 搭配feed_dict一起用来输入数据.在训练神经网络时,通常用来提供新的训练样本.在会话中运行计算图时,可以为占位符赋值.这样在构建一个计算图时不需要真正的输入数据. 注意: 占位符不包含任何数据,因此,不需要初始化 使用方式: tf.placeholder(dtype, shape=None, name=None) 使用说明: dtype: 固...
tf.Graph().get_tensor_by_name
weixin_34227447的博客
05-03 2088
get_tensor_by_name(name) method of tensorflow.python.framework.ops.Graph instance Returns the `Tensor` with the given `name`. This method may be called concurrently ...
tensorflow 学习笔记之 变量的一些操作
wchzh2015的博客
10-31 6880
TensorFlow学习笔记
Tensorflow中常用的函数总结(一)
csdnforyou的博客
11-07 2134
  1、tf.shape()和x.get_shape().as_list()的使用 (1) tf.shape() 先说tf.shape()很显然这个是获取张量的大小的，用法无需多说，直接上例子吧！ import tensorflow as tf import numpy as np a_array=np.array([[1,2,3],[4,5,6]]) b_list=[[1,2,3],[3,...
tensorflow学习笔记（1）如何高效地学习TensorFlow（附链接）
满城风絮
12-25 9181
且看知乎上的帖子：如何高效的学习tensorflow？ 本篇简要总结以下，并不断更新中～～ tensorflow官网（需要翻墙）一个有用的链接学习TensorFlow 极客学院的MNIST入门github的tensorflow主页Stanford的CS 20SI课程，专门针对TensorFlow的课程First Contact With TensorFlow，中文：与Tensor
tensorflow常用的函数
04-26
一些常用的TensorFlow函数包括tf.placeholder, tf.Variable, tf.constant, tf.matmul, tf.nn.softmax, tf.nn.relu, tf.train.AdamOptimizer, tf.Session等等。这些函数涉及到TensorFlow中很多重要的概念和操作，包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值