一. 基本教程
官方推荐搭建模型的时候用更高层的api，但是知道tensorflow的低层api更有利于知道其运行原理，也是很必要的。
1. tensorflow中的基本结构
Tensor
tensor（张量）是tensorflow的核心单元，表示原始数据，内部用n维numpy.ndarray表示，rank表示其维度，shape表示其形状, 0维为常数，1维为向量，2维为矩阵，可以向更高维拓展。
3. # a rank 0 tensor; a scalar with shape [],
[1., 2., 3.] # a rank 1 tensor; a vector with shape [3]
[[1., 2., 3.], [4., 5., 6.]] # a rank 2 tensor; a matrix with shape [2, 3]
[[[1., 2., 3.]], [[7., 8., 9.]]] # a rank 3 tensor with shape [2, 1, 3]
my_image = tf.zeros([10, 299, 299, 3]) # batch x height x width x color
可以用tf.rank()得到tensor的维度
r = tf.rank(my_image)
# After the graph runs, r will hold the value 4.
可以用tf.shape()得到tensor的形状，tf.reshape(tensor, newShape)可以改变tensor的形状
rank_three_tensor = tf.ones([3, 4, 5])
matrix = tf.reshape(rank_three_tensor, [6, 10]) # Reshape existing content into
# a 6x10 matrix
可以用tf.cast(ori_tensor, dtype)进行tensor的数据类型转换
# Cast a constant integer tensor into floating point.
float_tensor = tf.cast(tf.constant([1, 2, 3]), dtype=tf.float32)
可用tensor.eval得到tensor的值
constant = tf.constant([1, 2, 3])
tensor = constant * constant
print tensor.eval() #返回ndarray格式类型
tf程序可以看成是构建一个利用输入tensor得到输出tensor关系的图，然后运行程序得到想要的结果。
Tensor组成
数据类型：float32, int32, or string等，tensor的数据类型都是已知的，并且里面的元素类型都是相同的。
形状：可以只知道一部分，有些只有在计算的时候才能知道完整的形状是多少，如shape = [3,?,3]
一些特殊的Tensor
- tf.Variable
- tf.constant
- tf.placeholder
- tf.SparseTensor
除了Variable外，其余的都是不可变的，也就是说在一次上下文执行中，它的数值都是固定的，但是不同的执行不一定相同，比如tf.placeholder的feeding是一组随机数，每次执行的初始值都是不变的，但是后面的运行过程中数值是不会改变的。
需要注意的是feed是可以对所有的tensor进行赋值的
tf.Variable
tf.Variable可以指定一个名字，通过这个名字来复用这个Variable
my_variable = tf.get_variable("my_variable", [1, 2, 3]) #[1,2,3]指shape
my_int_variable = tf.get_variable("my_int_variable", [1, 2, 3], dtype=tf.int32,
initializer=tf.zeros_initializer)
other_variable = tf.get_variable("other_variable", dtype=tf.int32,
initializer=tf.constant([23, 42]))
在创建一个variable时可以设置其trainable参数来控制它是否会在训练时被修改
低层api创建了一个variable必须要显式的对它进行初始化，可以自己同时将所有的初始化也可以自己手动初始化（尤其在有依赖的时候）
session.run(tf.global_variables_initializer())
# Now all variables are initialized.
session.run(my_variable.initializer) #手动初始化my_variable
有依赖情况时的赋值，用v.initialized_value()
v = tf.get_variable("v", shape=(), initializer=tf.zeros_initializer())
w = tf.get_variable("w", initializer=v.initialized_value() + 1)
在执行时得到variable的值
v = tf.get_variable("v", shape=(), initializer=tf.zeros_initializer())
assignment = v.assign_add(1)
with tf.control_dependencies([assignment]):
w = v.read_value() # w is guaranteed to reflect v's value after the
# assign_add operation.
因为tf.get_variable可以创建也可以复用，所以在同一个上下文中对同一个名称进行两次调用会报错，这个时候可以指定变量域，就可以避免这个问题。
因为是在不同的域中，所以两次都会进行创建
def my_image_filter(input_images):
with tf.variable_scope("conv1"):
# Variables created here will be named "conv1/weights", "conv1/biases".
relu1 = conv_relu(input_images, [5, 5, 32, 32], [32])
with tf.variable_scope("conv2"):
# Variables created here will be named "conv2/weights", "conv2/biases".
return conv_relu(relu1, [5, 5, 32, 32], [32])
也可以设置scope的reuse属性为true，同一个域下就会进行复用而不会有复用还是创建的矛盾
with tf.variable_scope("model"):
output1 = my_image_filter(input1)
with tf.variable_scope("model", reuse=True):
output2 = my_image_filter(input2)
或者
with tf.variable_scope("model") as scope:
output1 = my_image_filter(input1)
scope.reuse_variables()
output2 = my_image_filter(input2)
防止打错名字，可以将scope设为一个变量
with tf.variable_scope("model") as scope:
output1 = my_image_filter(input1)
with tf.variable_scope(scope, reuse=True):
output2 = my_image_filter(input2)
计算图
低层api的tf编程分为两部分，构建计算图（tf.Graph）和运算计算图（tf.Session），和spark中的RDD相似。不执行运算的话图就只是简单的图结构，没有tensor流过。
图的构成
图结构
边 - tensors
点 - 操作（计算或者定义）
如：
a = tf.constant(3.0, dtype=tf.float32)
b = tf.constant(4.0) # also tf.float32 implicitly
total = a + b
print(a)
print(b)
print(total)
不执行直接打印，是没有值的
Tensor("Const:0", shape=(), dtype=float32)
Tensor("Const_1:0", shape=(), dtype=float32)
Tensor("add:0", shape=(), dtype=float32)
每一个操作都有一个独特的名字，这个名字和Python程序中给定标记没有关系，比如定义了a，但是在图结构中，它的名字是Const
collections
提供了一系列的collections，不同的collection具备不同的功能，如tf.Variable创建后就会加入到“global variables" and "trainable variables“中，前者表示全局，后者表示可以被训练。
也可以对操作命名，便于debug和观察，输出Tensor的时候也会带上相应操作的名字
c_0 = tf.constant(0, name="c") # => operation named "c"
# Already-used names will be "uniquified".
c_1 = tf.constant(2, name="c") # => operation named "c_1"
# Name scopes add a prefix to all operations created in the same context.
with tf.name_scope("outer"):
c_2 = tf.constant(2, name="c") # => operation named "outer/c"
# Name scopes nest like paths in a hierarchical file system.
with tf.name_scope("inner"):
c_3 = tf.constant(3, name="c") # => operation named "outer/inner/c"
# Exiting a name scope context will return to the previous prefix.
c_4 = tf.constant(4, name="c") # => operation named "outer/c_1"
# Already-used name scopes will be "uniquified".
with tf.name_scope("inner"):
c_5 = tf.constant(5, name="c") # => operation named "outer/inner_1/c"
Session
tf.Session用于执行计算图，根据情况可以返回Tensor值或者为None（如train操作）,用with会在退出block后自动关闭，否则需要调用tf.Session.close释放资源。
# Create a default in-process session.
with tf.Session() as sess:
# ...
# Create a remote session.
with tf.Session("grpc://example.org:2222"):
# ...
tf.Session(args)可以指定执行的机器、图等其他参数
x = tf.constant([[37.0, -23.0], [1.0, 4.0]])
w = tf.Variable(tf.random_uniform([2, 2]))
y = tf.matmul(x, w)
output = tf.nn.softmax(y)
init_op = w.initializer
with tf.Session() as sess:
# Run the initializer on `w`.
sess.run(init_op)
# Evaluate `output`. `sess.run(output)` will return a NumPy array containing
# the result of the computation.
print(sess.run(output))
# Evaluate `y` and `output`. Note that `y` will only be computed once, and its
# result used both to return `y_val` and as an input to the `tf.nn.softmax()`
# op. Both `y_val` and `output_val` will be NumPy arrays.
y_val, output_val = sess.run([y, output])
在run的时候给placeholder赋值
# Define a placeholder that expects a vector of three floating-point values,
# and a computation that depends on it.
x = tf.placeholder(tf.float32, shape=[3])
y = tf.square(x)
with tf.Session() as sess:
# Feeding a value changes the result that is returned when you evaluate `y`.
print(sess.run(y, {x: [1.0, 2.0, 3.0]})) # => "[1.0, 4.0, 9.0]"
print(sess.run(y, {x: [0.0, 0.0, 5.0]})) # => "[0.0, 0.0, 25.0]"
# Raises `tf.errors.InvalidArgumentError`, because you must feed a value for
# a `tf.placeholder()` when evaluating a tensor that depends on it.
sess.run(y)
# Raises `ValueError`, because the shape of `37.0` does not match the shape
# of placeholder `x`.
sess.run(y, {x: 37.0})
可以对run进行配置，比如记录下它的执行过程和时间
y = tf.matmul([[37.0, -23.0], [1.0, 4.0]], tf.random_uniform([2, 2]))
with tf.Session() as sess:
# Define options for the `sess.run()` call.
options = tf.RunOptions()
options.output_partition_graphs = True
options.trace_level = tf.RunOptions.FULL_TRACE
# Define a container for the returned metadata.
metadata = tf.RunMetadata()
sess.run(y, options=options, run_metadata=metadata)
# Print the subgraphs that executed on each device.
print(metadata.partition_graphs)
# Print the timings of each operation that executed.
print(metadata.step_stats)
