TensorFlow基础——常用函数（二）

 1 #class tf.Graph
 2 #tensorflow运行时需要设置默认的图
 3 g = tf.Graph()
 4 with g.as_default():
 5   # Define operations and tensors in `g`.
 6   c = tf.constant(30.0)
 7   assert c.graph is g
 8 
 9 ##也可以使用tf.get_default_graph()获得默认图，也可在基础上加入节点或子图
10 c = tf.constant(4.0)
11 assert c.graph is tf.get_default_graph()
12 #tf.Graph.as_default
13 #以下两段代码功能相同
14 #1、使用Graph.as_default():
15 g = tf.Graph()
16 with g.as_default():
17   c = tf.constant(5.0)
18   assert c.graph is g
19 
20 #2、构造和设置为默认
21 with tf.Graph().as_default() as g:
22   c = tf.constant(5.0)
23   assert c.graph is g
24 #tf.Graph.control_dependencies(control_inputs)
25 # 错误代码
26 def my_func(pred, tensor):
27   t = tf.matmul(tensor, tensor)
28   with tf.control_dependencies([pred]):
29     # 乘法操作(op)没有创建在该上下文，所以没有被加入依赖控制
30     return t
31 
32 # 正确代码
33 def my_func(pred, tensor):
34   with tf.control_dependencies([pred]):
35     # 乘法操作(op)创建在该上下文，所以被加入依赖控制中
36     #执行完pred之后再执行matmul
37     return tf.matmul(tensor, tensor) 
38 # tf.Graph.name_scope(name)
39 # 一个图中包含有一个名称范围的堆栈，在使用name_scope(...)之后，将压(push)新名称进栈中，
40 #并在下文中使用该名称
41 with tf.Graph().as_default() as g:
42   c = tf.constant(5.0, name="c")
43   assert c.op.name == "c"
44   c_1 = tf.constant(6.0, name="c")
45   assert c_1.op.name == "c_1"
46 
47   # Creates a scope called "nested"
48   with g.name_scope("nested") as scope:
49     nested_c = tf.constant(10.0, name="c")
50     assert nested_c.op.name == "nested/c"
51 
52     # Creates a nested scope called "inner".
53     with g.name_scope("inner"):
54       nested_inner_c = tf.constant(20.0, name="c")
55       assert nested_inner_c.op.name == "nested/inner/c"
56 
57     # Create a nested scope called "inner_1".
58     with g.name_scope("inner"):
59       nested_inner_1_c = tf.constant(30.0, name="c")
60       assert nested_inner_1_c.op.name == "nested/inner_1/c"
61 
62       # Treats `scope` as an absolute name scope, and
63       # switches to the "nested/" scope.
64       with g.name_scope(scope):
65         nested_d = tf.constant(40.0, name="d")
66         assert nested_d.op.name == "nested/d"
67 
68         with g.name_scope(""):
69           e = tf.constant(50.0, name="e")
70           assert e.op.name == "e"

 1 #tf.Tensor.get_shape()
 2 c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
 3 print(c.get_shape())
 4 ==> TensorShape([Dimension(2), Dimension(3)])
 5  
 6 #现在有个用于图像处理的tensor->image
 7 print(image.get_shape())
 8 ==> TensorShape([Dimension(None), Dimension(None), Dimension(3)])
 9 # 假如我们知道数据集中图像尺寸为28 x 28，那么可以设置
10 image.set_shape([28, 28, 3])
11 print(image.get_shape())
12 ==> TensorShape([Dimension(28), Dimension(28), Dimension(3)])

 1 #tf.RegisterGradient
 2 #该装饰器只使用于定义一个新的op类型时候，如果一个op有m个输入，n个输出。那么该梯度函数应该设置原始的
 3 #操作类型，以及n个Tensor对象（表示每一个op输出的梯度），以及m个对象(表示每一个op输入的偏梯度)
 4 #以操作节点类型为‘Sub‘为例，两输入为x,y。为一个输出x-y
 5 @tf.RegisterGradient("Sub")
 6 def _sub_grad(unused_op, grad):
 7   return grad, tf.neg(grad)
 8  
 9 
10 #tf.op_scope
11 #定义一个名称为my_op的python操作节点op
12 def my_op(a, b, c, name=None):
13   with tf.op_scope([a, b, c], name, "MyOp") as scope:
14     a = tf.convert_to_tensor(a, name="a")
15     b = tf.convert_to_tensor(b, name="b")
16     c = tf.convert_to_tensor(c, name="c")
17     # Define some computation that uses `a`, `b`, and `c`.
18     return foo_op(..., name=scope)

 1 #读取文件队列，使用reader中read的方法，返回key与value
 2 filename_queue = tf.train.string_input_producer(["file0.csv", "file1.csv"])
 3 reader = tf.TextLineReader()
 4 key, value = reader.read(filename_queue)
 5 
 6 record_defaults = [[1], [1], [1], [1], [1]]
 7 col1, col2, col3, col4, col5 = tf.decode_csv(
 8     value, record_defaults=record_defaults)
 9 features = tf.pack([col1, col2, col3, col4])
10 
11 with tf.Session() as sess:
12   # Start populating the filename queue.
13   coord = tf.train.Coordinator()
14   threads = tf.train.start_queue_runners(coord=coord)
15 
16   for i in range(1200):
17     # Retrieve a single instance:
18     example, label = sess.run([features, col5])
19 
20   coord.request_stop()
21   coord.join(threads)

  1 #tf.parse_example的使用举例
  2 #输入序列化数据如下： 
  3 serialized = [
  4   features
  5     { feature { key: "ft" value { float_list { value: [1.0, 2.0] } } } },
  6   features
  7     { feature []},
  8   features
  9     { feature { key: "ft" value { float_list { value: [3.0] } } }
 10 ]
 11 #那么输出为一个字典(dict),如下：
 12 {"ft": SparseTensor(indices=[[0, 0], [0, 1], [2, 0]],
 13                     values=[1.0, 2.0, 3.0],
 14                     shape=(3, 2)) }
 15 #########
 16 #再来看一个例子，给定两个序列化的原始输入样本：
 17 [
 18   features {
 19     feature { key: "kw" value { bytes_list { value: [ "knit", "big" ] } } }
 20     feature { key: "gps" value { float_list { value: [] } } }
 21   },
 22   features {
 23     feature { key: "kw" value { bytes_list { value: [ "emmy" ] } } }
 24     feature { key: "dank" value { int64_list { value: [ 42 ] } } }
 25     feature { key: "gps" value { } }
 26   }
 27 ]
 28 #相关参数如下：
 29 example_names: ["input0", "input1"],
 30 features: {
 31     "kw": VarLenFeature(tf.string),
 32     "dank": VarLenFeature(tf.int64),
 33     "gps": VarLenFeature(tf.float32),
 34 }
 35 #那么有如下输出：
 36 {
 37   "kw": SparseTensor(
 38       indices=[[0, 0], [0, 1], [1, 0]],
 39       values=["knit", "big", "emmy"]
 40       shape=[2, 2]),
 41   "dank": SparseTensor(
 42       indices=[[1, 0]],
 43       values=[42],
 44       shape=[2, 1]),
 45   "gps": SparseTensor(
 46       indices=[],
 47       values=[],
 48       shape=[2, 0]),
 49 }
 50 #########
 51 #对于两个样本的输出稠密结果情况
 52 [
 53   features {
 54     feature { key: "age" value { int64_list { value: [ 0 ] } } }
 55     feature { key: "gender" value { bytes_list { value: [ "f" ] } } }
 56    },
 57    features {
 58     feature { key: "age" value { int64_list { value: [] } } }
 59     feature { key: "gender" value { bytes_list { value: [ "f" ] } } }
 60   }
 61 ]
 62 #我们可以使用以下参数
 63 example_names: ["input0", "input1"],
 64 features: {
 65     "age": FixedLenFeature([], dtype=tf.int64, default_value=-1),
 66     "gender": FixedLenFeature([], dtype=tf.string),
 67 }
 68 #期望的结果如下
 69 {
 70   "age": [[0], [-1]],
 71   "gender": [["f"], ["f"]],
 72 }
 73  
 74 
 75 ##Example protocol buffer相关使用的例子
 76 #将mnist的数据转换为TFRecords文件格式
 77 import os
 78 import tensorflow as tf
 79 from tensorflow.contrib.learn.python.learn.datasets import mnist
 80 SOURCE_URL = ‘http://yann.lecun.com/exdb/mnist/‘
 81 
 82 TRAIN_IMAGES = ‘train-images-idx3-ubyte.gz‘  # MNIST filenames
 83 TRAIN_LABELS = ‘train-labels-idx1-ubyte.gz‘
 84 TEST_IMAGES = ‘t10k-images-idx3-ubyte.gz‘
 85 TEST_LABELS = ‘t10k-labels-idx1-ubyte.gz‘
 86 
 87 tf.app.flags.DEFINE_string(‘directory‘, ‘/tmp/data‘,
 88                            ‘Directory to download data files and write the ‘
 89                            ‘converted result‘)
 90 tf.app.flags.DEFINE_integer(‘validation_size‘, 5000,
 91                             ‘Number of examples to separate from the training ‘
 92                             ‘data for the validation set.‘)
 93 FLAGS = tf.app.flags.FLAGS
 94 
 95 def _int64_feature(value):
 96   return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
 97 
 98 def _bytes_feature(value):
 99   return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
100 
101 def convert_to(data_set, name):
102   images = data_set.images
103   labels = data_set.labels
104   num_examples = data_set.num_examples
105 
106   if images.shape[0] != num_examples:
107     raise ValueError(‘Images size %d does not match label size %d.‘ %
108                      (images.shape[0], num_examples))
109   rows = images.shape[1]
110   cols = images.shape[2]
111   depth = images.shape[3]
112 
113   filename = os.path.join(FLAGS.directory, name + ‘.tfrecords‘)
114   print(‘Writing‘, filename)
115   writer = tf.python_io.TFRecordWriter(filename)
116   for index in range(num_examples):
117     image_raw = images[index].tostring()
118     example = tf.train.Example(features=tf.train.Features(feature={
119         ‘height‘: _int64_feature(rows),
120         ‘width‘: _int64_feature(cols),
121         ‘depth‘: _int64_feature(depth),
122         ‘label‘: _int64_feature(int(labels[index])),
123         ‘image_raw‘: _bytes_feature(image_raw)}))
124     writer.write(example.SerializeToString())
125   writer.close()
126 
127 def main(argv):
128   # Get the data.
129   data_sets = mnist.read_data_sets(FLAGS.directory,
130                                    dtype=tf.uint8,
131                                    reshape=False)
132 
133   # Convert to Examples and write the result to TFRecords.
134   convert_to(data_sets.train, ‘train‘)
135   convert_to(data_sets.validation, ‘validation‘)
136   convert_to(data_sets.test, ‘test‘)
137 
138 if __name__ == ‘__main__‘:
139   tf.app.run()

 1 # 一个简单例子，使用tf.train.shuffle_batch创建一个具有32张图像和32个标签的batches.
 2 image_batch, label_batch = tf.train.shuffle_batch(
 3       [single_image, single_label],
 4       batch_size=32,
 5       num_threads=4,
 6       capacity=50000,
 7       min_after_dequeue=10000)
 8  
 9 #Batching函数相关例子，以函数tf.train.shuffle_batch为例
10 #为training, evaluation等操作将样本batching，以下代码使用随机顺序打包样本
11 def read_my_file_format(filename_queue):
12   reader = tf.SomeReader()
13   key, record_string = reader.read(filename_queue)
14   example, label = tf.some_decoder(record_string)
15   processed_example = some_processing(example)
16   return processed_example, label
17 
18 def input_pipeline(filenames, batch_size, num_epochs=None):
19   filename_queue = tf.train.string_input_producer(
20       filenames, num_epochs=num_epochs, shuffle=True)
21   example, label = read_my_file_format(filename_queue)
22   # min_after_dequeue defines how big a buffer we will randomly sample
23   #   from -- bigger means better shuffling but slower start up and more
24   #   memory used.
25   # capacity must be larger than min_after_dequeue and the amount larger
26   #   determines the maximum we will prefetch.  Recommendation:
27   #   min_after_dequeue + (num_threads + a small safety margin) * batch_size
28   min_after_dequeue = 10000
29   capacity = min_after_dequeue + 3 * batch_size
30   example_batch, label_batch = tf.train.shuffle_batch(
31       [example, label], batch_size=batch_size, capacity=capacity,
32       min_after_dequeue=min_after_dequeue)
33   return example_batch, label_batch
34  
35 
36 #如果需要跟多的并行或文件之间的样本乱序操作，可以使用函数tf.train.shuffle_batch_join多实例化reader
37 def read_my_file_format(filename_queue):
38   # 与上例子相同
39 
40 def input_pipeline(filenames, batch_size, read_threads, num_epochs=None):
41   filename_queue = tf.train.string_input_producer(
42       filenames, num_epochs=num_epochs, shuffle=True)
43   example_list = [read_my_file_format(filename_queue)
44                   for _ in range(read_threads)]
45   min_after_dequeue = 10000
46   capacity = min_after_dequeue + 3 * batch_size
47   example_batch, label_batch = tf.train.shuffle_batch_join(
48       example_list, batch_size=batch_size, capacity=capacity,
49       min_after_dequeue=min_after_dequeue)