tensorflow学习

1.初始化

所有变量同时初始化：

init_op = tf.global_variables_initializer()()
sess.run(init_op)

2.collection集合

在Tensorflow中，所有的变量都会被自动加入GraphKeys.VARIABLES这个集合中。通过tf.all_variables函数可以拿到计算图中的所有变量。通过变量声明函数中的trainable参数来区分需要优化的函数和其他参数。如果声明变量时参数trainable为True，那么这个变量会被加入GraphKeys.TRAINABLE_VARIABLES集合。在tensorflow中可以通过tf.trainable_variables函数得到所有需要优化的参数。

通过tensorflow可以更改变量的维度，validate_shape=False

3.placeholder提供输入数据

因为每生成一个常量，TensorFlow都会在计算图中增加一个节点（tf.Variable())，图中都会增加一个节点，为了避免计算图太大，TensowFlow提供了placeholder机制用于提供输入数据。placeholder相当于定义了一个位置，这个位置的数据在程序运行时再指定。placehol的类型是不可改变的，在定义的时候需要制定，但是维度可以由提供的数据推导出，所以不一定要给出。

x = tf.placeholder(tf.float32, shape=(2,1), name="input")
#shape可以不写

4.随机数字对生成

rdm = np.random.RandomState(1)
X = rdm.rand(data_size, 2)
print [[x1, x2] for (x1, x2) in X]

5.loss

分类问题可以用交叉熵，回归问题用均方误差

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(y, y_)
mse=tf.reduce_mean(tf.square(y-y_))

tf.train.exponential_decay((0.1,global_step,100,0.96,staircase=True))

6.正则化

对模型正则化做约束，通过限制权重的大小，减小拟合噪声的能力。L1的正则化会让参数稀疏化即变0，而L2则不会。L1不可导而L2可导，L1的正则化优化损失函数较难计算，而L2比较容易计算。

tf.contrib.layers.l1_regularizer(lambda)(weights)
tf.contrib.layers.l2_regularizer(lambda)(weights)

7.collection

tf.add_to_collection('losses', mse_loss)
tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambda_)(var))
loss = tf.add_n(tf.get_collection('losses'))

8.滑动移动平均

shadow_variable=decay×shadow_variable+(1−decay)×variable

当程序执行到 ema_op = ema.apply([w]) 的时候，如果 w 是 Variable， 那么将会用 w 的初始值初始化 ema 中关于 w 的 ema_value，所以 emaVal0=1.0。如果 w 是 Tensor的话，将会用 0.0 初始化。

 9.get_variable和Variable

tf.Variabel的name可以不写

tf.get_variable的name一定要写

通过variable_scope生成上下文管理器，然后通过tf.get_variable获取变量

tf.get_variable("v", shape=[1], initializer=tf.constant_initializer(1.0))
tf.Variable(tf.constant(1.0, shape=[1]), "v")

with tf.variable_scope("foo"): # 创建
    v=tf.get_variable("v",[1],initializer=tf.constant_initializer(1.0))

with tf.variable_scope("foo",reuse=True): # 获取
    v=tf.get_variable("v",[1])

10.保存和加载模型

saver = tf.train.Saver()
saver.save(sess,'/.ckpt')

saver = tf.train.Saver()
saver.restore(sess,'/.ckpt')

saver = tf.train.Saver({"v1":v1}) #只加载v1变量

 11.保存和加载节点

from tensorflow.python.framework import graph_util

v1 = tf.Variable(tf.constant(1.0, shape=[1], name="v1"))
v2 = tf.Variable(tf.constant(1.0, shape=[1], name="v2"))
result = v1 + v2

init_op = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init_op)
    graph_def = tf.get_default_graph().as_graph_def()
    output_graph_def = graph_util.convert_variables_to_constants(sess, graph_def,['add'])
    with tf.gfile.GFile("/combined_model.pb","wb") as f:
        f.write(output_graph_def.SerializeToString())

from tensorflow.python.platform import gfile
with tf.Session() as sess:
    model_filename="/combined_model.pb"
    with gfile.FastGFile(model_filename,'rb') as f:
        graph_def = tf.GraphDef()
        graph_def.ParseFromString(f.read())
    
    result=tf.import_graph_def(graph_def,return_elements=["add:0"])
    print sess.run(result)

12.池化层

一般每经历一次池化层，深度乘2

13.解码后的图像画bbox框

因为解码后的图像少一维度，而draw_bounding_box输入的是一个batch

batched = tf.expand_dims(tf.image.convert_image_dtype(img_data,tf.float32),0)
boxes=tf.constant([[[0.05,0.05,0.9,0.7]]])
result = tf.image.draw_bounding_boxes(batched, boxes)

14.队列与多线程

Enqueue、EnqueueMany、Deque

# -*- coding:utf-8 -*-
import tensorflow as tf

# 创建一个FIFO队列，最多放两个元素，类型为int32
q = tf.FIFOQueue(2, 'int32')

init = q.enqueue_many(([0, 10],))  # 初始化元素
x = q.dequeue() # 出列

y = x + 1
q_inc = q.enqueue([y]) #入列

with tf.Session() as sess:
    init.run()
    for _ in range(5):
        v, _ = sess.run([x, q_inc])
        print v

15.输入文件队列

 当训练数据量较大时，可以将数据分成多个TFRecord文件来提高处理效率。

import tensorflow as tf
# -*- coding:utf-8 -*-

def _int64_feature(value):
    return tf.train.Feature()


num_shards = 2  # 定义总共写入多少文件
instance_per_shard = 2  # 定义每个文件中有多少数据

for i in range(num_shards):
    filename = ('data.tfrecords-%.5d-of-%.5d' % (i, num_shards))
    writer = tf.python_io.TFRecordWriter(filename)
    for j in range(instance_per_shard):
        # Example协议缓冲区，包含当前样例属于第几个文件以及是当前文件的第几个样本
        example=tf.train.Example(features=tf.train.Features(feature={
            'i': _int64_feature(i),
            'j': _int64_feature(j)
        }))
        writer.write(example.SerializeToString())
    writer.close()

files = tf.train.match_filenames_once("data.tfrecords-*")  # 获取相关文件的列表
filename_queue = tf.train.string_input_producer(files, shuffle=False)

reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
features = tf.parse_single_example(
    serialized_example,
    features={
        'i': tf.FixedLenFeature([], tf.int64),
        'j': tf.FixedLenFeature([], tf.int64)
    })

with tf.Session() as sess:
    tf.initialize_all_variables().run()
    print sess.run(files)
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    for i in range(6):
        print sess.run([features['i'], features['j']])
    coord.request_stop()
    coord.join(threads)

16.将单个样例组成batch

batch_size = 3
capacity = 1000 + 3 * batch_size
example, label = features['i'], features['j']
example_batch, label_batch = tf.train.batch([example, label], batch_size=batch_size, capacity=capacity)

17.LSTM

state = lstm.zero_state(batch_size, tf.float32) 表示初始状态

import tensorflow as tf

lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_hidden_size)

state = lstm.zero_state(batch_size, tf.float32)

loss = 0.0

for i in range(num_steps):
    if i > 0: tf.get_variable_scope().reuse_variables()
    lstm_output, state = lstm(current_input, state)
    final_output = tf.slim.fully_connected(lstm_output)
    loss+=calc_loss(final_output,expected_output)

18.创建模型并得到优化的步骤：

tf.contrib.layers.optimize_loss(
    loss,tf.contib.framework.get_globale_step(),
    optimizer='Adagrad',learning_rate=0.1
)

19.tensorboard可视化

writer=tf.summary.FileWriter('log/',tf.get_default_graph())

20.num_shards

num_shards设定的越多则样本出现随机性的概率也就越大。极限情况时num_shards=sample_num则每次一个epoch后的循序都不一样；num_shards=1则每次一个epoch后的顺序都是一样的

21.conv2d的默认参数

conv2层

1.默认有激活函数，且为relu

2.默认的padding方式为‘SAME’，补零

def convolution(inputs,
                num_outputs,
                kernel_size,
                stride=1,
                padding='SAME',
                data_format=None,
                rate=1,
                activation_fn=nn.relu,
                normalizer_fn=None,
                normalizer_params=None,
                weights_initializer=initializers.xavier_initializer(),
                weights_regularizer=None,
                biases_initializer=init_ops.zeros_initializer(),
                biases_regularizer=None,
                reuse=None,
                variables_collections=None,
                outputs_collections=None,
                trainable=True,
                scope=None,
                conv_dims=None):

22.max_pool层默认参数

def max_pool2d(inputs,
               kernel_size,
               stride=2,
               padding='VALID',
               data_format=DATA_FORMAT_NHWC,
               outputs_collections=None,
               scope=None):