tf.layers.conv2d(
    inputs, 
    filters, 
    kernel_size, 
    strides=(1, 1), 
    padding='valid', 
    data_format='channels_last', 
    dilation_rate=(1, 1), 
    activation=None, 
    use_bias=True, 
    kernel_initializer=None, 
    bias_initializer=tf.zeros_initializer(), 
    kernel_regularizer=None, 
    bias_regularizer=None, 
    activity_regularizer=None, 
    trainable=True, 
    name=None, 
    reuse=None
)

tf.nn.conv2d(
    input, 
    filter, 
    strides, 
    padding, 
    use_cudnn_on_gpu=None, 
    data_format=None, 
    name=None
)

# Convolution Layer with 32 filters and a kernel size of 5
conv1 = tf.layers.conv2d(x, 32, 5, activation=tf.nn.relu) 
# Max Pooling (down-sampling) with strides of 2 and kernel size of 2
conv1 = tf.layers.max_pooling2d(conv1, 2, 2)

strides = 1
# Weights matrix looks like: [kernel_size(=5), kernel_size(=5), input_channels (=3), filters (= 32)]
# Similarly bias = looks like [filters (=32)]
out = tf.nn.conv2d(input, weights, padding="SAME", strides = [1, strides, strides, 1])
out = tf.nn.bias_add(out, bias)
out = tf.nn.relu(out)

__init__(
    num_units,
    activation=None,
    reuse=None,
    name=None,
    dtype=None,
    **kwargs
)

   myrnn = rnn.BasicRNNCell(rnn_size,activation=tf.nn.relu)
   zero_state = myrnn.zero_state(batch_size, dtype=tf.float32)
   outputs, states = rnn.static_rnn(myrnn, x, initial_state=zero_state, dtype=tf.float32)
return outputs

__init__(
    num_units, # 隐藏层的大小
    use_peepholes=False, # 
    cell_clip=None,
    initializer=None, # 权重的初始化构造器
    num_proj=None,
    proj_clip=None,
    num_unit_shards=None,
    num_proj_shards=None,
    forget_bias=1.0,
    state_is_tuple=True, # c_state和m_state的元组
    activation=None,
    reuse=None,
    name=None,
    dtype=None,
    **kwargs
)

lstm = rnn.BasicLSTMCell(lstm_size, forget_bias=1, state_is_tuple=True)
   zero_state = lstm.zero_state(batch_size, dtype=tf.float32)
   outputs, states = rnn.static_rnn(lstm, x, initial_state=zero_state, dtype=tf.float32)
return outputs

__init__(
    cells,
    state_is_tuple=True
)

num_units = [128, 64]
cells = [BasicLSTMCell(num_units=n) for n in num_units]
stacked_rnn_cell = MultiRNNCell(cells)
outputs, state = tf.nn.dynamic_rnn(cell=stacked_rnn_cell,
                                   inputs=data,
                                   dtype=tf.float32)

   lstm_cell = rnn.BasicLSTMCell(lstm_size, forget_bias=1, state_is_tuple=True)
   cell = rnn.MultiRNNCell([lstm_cell]*layers, state_is_tuple=True)
   state = cell.zero_state(batch_size, dtype=tf.float32)
   outputs = []
   with tf.variable_scope("Multi_Layer_RNN", reuse=reuse):
       for time_step in range(time_steps):
           if time_step > 0:
               tf.get_variable_scope().reuse_variables()
           
           cell_outputs, state = cell(x[time_step], state)
           outputs.append(cell_outputs)
return outputs

__init__(
    cell, # 
    input_keep_prob=1.0,
    output_keep_prob=1.0,
    state_keep_prob=1.0,
    variational_recurrent=False,
    input_size=None,
    dtype=None,
    seed=None,
    dropout_state_filter_visitor=None
)

   lstm_cell = rnn.BasicLSTMCell(lstm_size, forget_bias=1, state_is_tuple=True)
   lstm_cell = rnn.DropoutWrapper(lstm_cell, output_keep_prob=0.9)
   cell = rnn.MultiRNNCell([lstm_cell]*layers, state_is_tuple=True)
   state = cell.zero_state(batch_size, dtype=tf.float32)
   outputs = []
   with tf.variable_scope("Multi_Layer_RNN"):
       for time_step in range(time_steps):
           if time_step > 0:
               tf.get_variable_scope().reuse_variables()
           cell_outputs, state = cell(x[time_step], state)
           outputs.append(cell_outputs)
return outputs

tf.nn.static_rnn(
    cell, # RNNCell的具体对象
    inputs, # 输入，长度为T的输入列表，列表中每一个Tensor的shape都是[batch_size, input_size]
    initial_state=None, # rnn的初始状态，如果cell.state_size是整数，它的shape需要是[batch_size, cell.state_size]，如果cell.state_size是元组，那么终究会是一个tensors的元组，[batch_size, s] for s in cell.state_size
    dtype=None, # 
    sequence_length=None, # 
    scope=None
)
# 最简单形式的RNN，就是该API的参数都是用默认值，给定cell和inputs，相当于做了以下操作：
#    state = cell.zero_state(...)
#    outputs = []
#    for input_ in inputs:
#      output, state = cell(input_, state)
#      outputs.append(output)
#    return (outputs, state)

myrnn = tf.nn.rnn_cell.BasicRNNCell(rnn_size,activation=tf.nn.relu)
   zero_state = myrnn.zero_state(batch_size, dtype=tf.float32)
   outputs, states = tf.nn.static_rnn(myrnn, x, initial_state=zero_state, dtype=tf.float32)

tf.nn.dynamic_rnn(
    cell, # RNNCell的具体对象
    inputs, # RNN的输入,time_major = False, [batch_size, max_time, ...],time_major=True, [max_time, batch_size, ...]
    sequence_length=None, # 
    initial_state=None, # rnn的初始状态，如果cell.state_size是整数，它的shape需要是[batch_size, cell.state_size]，如果cell.state_size是元组，那么就会是一个tensors的元组，[batch_size, s] for s in cell.state_size
    dtype=None,
    parallel_iterations=None,
    swap_memory=False, #
    time_major=False, # 如果为True,如果为False，对应不同的inputs 
    scope=None
)

# 例子1.创建一个BasicRNNCell
rnn_cell = tf.nn.rnn_cell.BasicRNNCell(hidden_size)

# 定义初始化状态
initial_state = rnn_cell.zero_state(batch_size, dtype=tf.float32)

# 'outputs' shape [batch_size, max_time, cell_state_size]
# 'state' shape [batch_size, cell_state_size]
outputs, state = tf.nn.dynamic_rnn(rnn_cell, input_data,
                                   initial_state=initial_state,
                                   dtype=tf.float32)

# 例子2.创建两个LSTMCells
rnn_layers = [tf.nn.rnn_cell.LSTMCell(size) for size in [128, 256]]

# 创建一个多层RNNCelss。
multi_rnn_cell = tf.nn.rnn_cell.MultiRNNCell(rnn_layers)

# 'outputs' is a tensor of shape [batch_size, max_time, 256]
# 'state' is a N-tuple where N is the number of LSTMCells containing a
# tf.contrib.rnn.LSTMStateTuple for each cell
outputs, state = tf.nn.dynamic_rnn(cell=multi_rnn_cell,
                                   inputs=data,
                                   dtype=tf.float32)

__init__(
    filters, # 卷积核的数量
    kernel_size, # 卷积核的大小
    strides=(1, 1),
    padding='valid',
    data_format='channels_last', # string, "channels_last", "channels_first"
    dilation_rate=(1, 1), #
    activation=None, # 激活函数
    use_bias=True,
    kernel_initializer=None, # 卷积核的构造器
    bias_initializer=tf.zeros_initializer(), # bias的构造器
    kernel_regularizer=None, #  卷积核的正则化
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True, # 如果为True的话，将变量添加到TRANABLE_VARIABELS collection中
    name=None,
    **kwargs
)

tf.layers.conv2d(
    inputs, # 输入
    filters, #  一个整数,输出的维度，就是有几个卷积核
    kernel_size,
    strides=(1, 1),
    padding='valid',
    data_format='channels_last',
    dilation_rate=(1, 1),
    activation=None,
    use_bias=True,
    kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(),
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True,
    name=None,
    reuse=None
)

tf.layers.Conv2d.__init__(
    filters,
    kernel_size,
    strides=(1, 1),
    padding='valid',
    data_format='channels_last',
    dilation_rate=(1, 1),
    activation=None,
    use_bias=True,
    kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(),
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True,
    name=None,
    **kwargs
)
tf.layers.conv2d(
    inputs,
    filters,
    kernel_size,
    strides=(1, 1),
    padding='valid',
    data_format='channels_last',
    dilation_rate=(1, 1),
    activation=None,
    use_bias=True,
    kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(),
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True,
    name=None,
    reuse=None
)

tf.nn.conv2d(
    input, # 输入，[batch, in_height, in_width, in_channels]
    filter, # 4d tensor, [filter_height, filter_width, in_channels, out_channles]
    strides, # 长度为4的1d tensor。
    padding, # string, 可选"SAME"或者"VALID"
    use_cudnn_on_gpu=True, #
    data_format='NHWC', #
    dilations=[1, 1, 1, 1], #
    name=None
)

def conv2d(inputs, output_dim, kernel_size, stride, initializer, activation_fn,
           padding='VALID', data_format='NHWC', name="conv2d", reuse=False):
    kernel_shape = None
    with tf.variable_scope(name, reuse=reuse):
        if data_format == 'NCHW':
            stride = [1, 1, stride[0], stride[1]]
            kernel_shape = [kernel_size[0], kernel_size[1], inputs.get_shape()[1], output_dim]
        elif data_format == 'NHWC':
            stride = [1, stride[0], stride[1], 1]
            kernel_shape = [kernel_size[0], kernel_size[1], inputs.get_shape()[-1], output_dim ]

        w = tf.get_variable('w', kernel_shape, tf.float32, initializer=initializer)
        conv = tf.nn.conv2d(inputs, w, stride, padding, data_format=data_format)

        b = tf.get_variable('b', [output_dim], tf.float32, initializer=tf.constant_initializer(0.0))
        out = tf.nn.bias_add(conv, b, data_format=data_format)

    if activation_fn is not None:
        out = activation_fn(out)
    return out, w, b

tf.nn.convolution(
    input, # 输入
    filter, # 卷积核
    padding, # string, 可选"SAME"或者"VALID"
    strides=None, # 步长
    dilation_rate=None,
    name=None,
    data_format=None
)

tf.nn.conv2d_transpose(
    value, # 输入，4d tensor，[batch, in_channels, height, width] for NCHW,或者[batch,height, width, in_channels] for NHWC
    filter, # 4d卷积核，shape是[height, width, output_channels, in_channels]
    output_shape, # 表示反卷积输出的shape一维tensor
    strides, # 步长
    padding='SAME',
    data_format='NHWC',
    name=None
)

tf.nn.max_pool(
    value, # 输入，4d tensor
    ksize, # 4个整数的list或者tuple，max pooling的kernel size
    strides, # 4个整数的list或者tuple
    padding, # string, 可选"VALID"或者"VALID"
    data_format='NHWC', # string,可选"NHWC", "NCHW", NCHW_VECT_C"
    name=None
)

tf.nn.softmax(
	logits,
	axis=None,
	name=None
)

import tensorflow as tf

logits = [1.0, 1.0, 2.0, 2.0, 2.0, 2.0]
res_op = tf.nn.softmax(logits)
sess = tf.Session()
result = sess.run(res_op)
print(result)
print(sum(result))
# output
# [0.07768121 0.07768121 0.21115941 0.21115941 0.21115941 0.21115941]
# 1.0000000447034836
# 因为有指数运算，所以就不是整数

tf.nn.log_softmax(
	logits,
	axis=None,
	name=None
)

import tensorflow as tf

logits = [1.0, 1.0, 2.0, 2.0, 2.0, 2.0]
res_op = tf.nn.log_softmax(logits)
sess = tf.Session()
result = sess.run(res_op)
print(result)
print(sum(result))

# output
# [-2.555142  -2.555142  -1.5551419 -1.5551419 -1.5551419 -1.5551419]
# -11.330851554870605

tf.nn.softmax_cross_entropy_with_logits_v2(
    labels, # shape是[batch_size, num_calsses]，每一个labels[i]都应该是一个有效的probability distribution
    logits, # 没有normalized的log probabilities
    axis=None,
    name=None
    dim=-1,
)

tf.nn.sparse_softmax_cross_entropy_with_logits(
    _sentinel=None,  # pylint: disable=invalid-name
    labels=None,    # shape是[d_0, d_1, ..., d_{r-1}]其中r是labels的秩，type是int32或int64，每一个entry都应该在[0, num_classes)之间
    logits=None,    # logits 是[d_0, d_1, ..., d_{r-1}, num_classes]，是float类型的，可以看成unnormalized log probabilities
    name=None
)

import tensorflow as tf

a = tf.Variable([1, 2, 3])
b = tf.get_variable("bbb", shape=[2,3])
tf.constant([3])
c = tf.ones([3])
d = tf.random_uniform([3, 4])
e = tf.log(c)

# 查看GLOBAL_VARIABLES collection中的变量
global_variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
for var in global_variables:
   print(var)

# 查看TRAINABLE_VARIABLES collection中的变量
trainable_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)
for var in global_variables:
   print(var)

import tensorflow as tf

# 生成一个图
graph = tf.Graph()

with graph.as_default():
    # 指定模型参数
    w = tf.Variable([0.3], name="w", dtype=tf.float32)
    b = tf.Variable([0.2], name="b", dtype=tf.float32)

    # 输入数据placeholder
    x = tf.placeholder(tf.float32, name="inputs")
    y = tf.placeholder(tf.float32, name="outputs")

    # 前向传播
    with tf.name_scope('linear_model'):
        linear = w * x + b

	# 计算loss
    with tf.name_scope('cal_loss'):
        loss = tf.reduce_mean(input_tensor=tf.square(y - linear), name='loss')

	# 定义summary saclar op
    with tf.name_scope('add_summary'):
        summary_loss = tf.summary.scalar('MSE', loss)
        summary_b = tf.summary.scalar('b', b[0])

	# 定义优化器
    with tf.name_scope('train_model'):
        optimizer = tf.train.GradientDescentOptimizer(0.01)
        train = optimizer.minimize(loss)

with tf.Session(graph=graph) as sess:
	inputs = [1, 2, 3, 4]
	outputs = [2, 3, 4, 5]
    # 定义写入文件类
    writer = tf.summary.FileWriter("./summary/", graph)
    # 获取所有的summary op，不用一个一个去单独run
    merged = tf.summary.merge_all()

	# 初始化
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    for i in range(5000):
		# 运行summary op merged
        _, summ = sess.run([train, merged], feed_dict={x: inputs, y: outputs})
		# 将summary op返回的变量转化为事件，写入文件
        writer.add_summary(summ, global_step=i)

    w_, b_, l_ = sess.run([w, b, loss], feed_dict={x: inputs, y: outputs})
    print("w: ", w_, "b: ", b_, "loss: ", l_)

    # 查看SUMMARIES collection
    for var in tf.get_collection(tf.GraphKeys.SUMMARIES):
        print(var)

import tensorflow as tf

# 定义第1个loss
x1 = tf.constant(1.0)
l1 = tf.nn.l2_loss(x1)

# 定义第2个loss
x2 = tf.constant([2.5, -0.3])
l2 = tf.nn.l2_loss(x2)

# 将loss添加到losses collection中
tf.add_to_collection("losses", l1)
tf.add_to_collection("losses", l2)

# 查看losses collection中的内容
losses = tf.get_collection('losses')
for var in tf.get_collection('losses'):
    print(var)

# 建立session运行
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    losses_val = sess.run(losses)
    print(losses_val)

# Print all of the operations in the default graph.
g = tf.get_default_graph()

# 清空当前session的默认图
tf.reset_default_graph()

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"

import tensorflow as tf

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"

g = tf.get_default_graph()
print(g.get_operations())
# [<tf.Operation 'c' type=Const>, <tf.Operation 'c_1' type=Const>, <tf.Operation 'outer/c' type=Const>, <tf.Operation 'outer/inner/c' type=Const>]

tf.Session.init(
		target, # 可选参数，指定设备。
		graph, #可选参数，默认情况下，新的session绑定到默认graph
		confi # 可选参数，常见的一个选择为gpu_options.allow_growth。将此参数设置为 True 可更改 GPU 内存分配器，使该分配器逐渐增加分配的内存量，而不是在启动时分配掉大多数内存。
)

# Create a default in-process session.
with tf.Session() as sess:
  # ...

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:
  # 初始化w
  sess.run(init_op)

  # Evaluate `output`. `sess.run(output)` will return a NumPy array containing
  # the result of the computation.
  # 计算output
  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和output
  y_val, output_val = sess.run([y, output])

# 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 <a href="../api_docs/python/tf/errors/InvalidArgumentError"><code>tf.errors.InvalidArgumentError</code></a>, 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})

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)

sess = tf.Session()
sess.graph

# Build your graph.
x = tf.constant([[37.0, -23.0], [1.0, 4.0]])
w = tf.Variable(tf.random_uniform([2, 2]))
y = tf.matmul(x, w)
# ...
loss = ...
train_op = tf.train.AdagradOptimizer(0.01).minimize(loss)

with tf.Session() as sess:
  # `sess.graph` provides access to the graph used in a <a href="../api_docs/python/tf/Session"><code>tf.Session</code></a>.
  writer = tf.summary.FileWriter("/tmp/log/...", sess.graph)

  # Perform your computation...
  for i in range(1000):
    sess.run(train_op)
    # ...

  writer.close()

g_1 = tf.Graph()
with g_1.as_default():
  # Operations created in this scope will be added to `g_1`.
  c = tf.constant("Node in g_1")

  # Sessions created in this scope will run operations from `g_1`.
  sess_1 = tf.Session()

g_2 = tf.Graph()
with g_2.as_default():
  # Operations created in this scope will be added to `g_2`.
  d = tf.constant("Node in g_2")

# Alternatively, you can pass a graph when constructing a <a href="../api_docs/python/tf/Session"><code>tf.Session</code></a>:
# `sess_2` will run operations from `g_2`.
sess_2 = tf.Session(graph=g_2)

assert c.graph is g_1
assert sess_1.graph is g_1

assert d.graph is g_2
assert sess_2.graph is g_2

tf.Variable.__init__(
	initial_value=None,  # 指定变量的初值
	trainable=True,  # 是否在BP时训练该参数
	collections=None, # 指定变量的collection
	validate_shape=True, 
	caching_device=None, 
	name=None,  # 指定变量的名字
	...
)

tensor1 = tf.Variable([[1,2], [3,5]])
tensor2 = tf.Variable(tf.constant([[1,2], [3,5]]))
sess.run(tf.global_variables_initializer())
sess.run(tensor1)
sess.run(tensor2)

tf.get_variable(
    name, # 指定变量的名字，必选项
    shape=None, # 指定变量的shape，可选项
    dtype=None, # 指定变量类型
    initializer=None, # 指定变量初始化器
    regularizer=None,
    trainable=None,
    collections=None,
    caching_device=None,
    partitioner=None,
    validate_shape=True,
    use_resource=None,
    custom_getter=None,
    constraint=None,
    synchronization=tf.VariableSynchronization.AUTO,
    aggregation=tf.VariableAggregation.NONE
)

with tf.variable_scope("model") as scope:
  output1 = my_image_filter(input1)
  scope.reuse_variables()
  output2 = my_image_filter(input2)

my_local = tf.get_variable("my_local", shape=(), collections=[tf.GraphKeys.LOCAL_VARIABLES])

my_non_trainable = tf.get_variable("my_non_trainable",
                                   shape=(),
                                   trainable=False)

import tensorflow as tf

a = tf.Variable([1, 2, 3])
b = tf.get_variable("bbb", shape=[2,3])
tf.constant([3])
c = tf.ones([3])
d = tf.random_uniform([3, 4])
print(tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES))
# [<tf.Variable 'Variable:0' shape=(3,) dtype=int32_ref>, <tf.Variable 'bbb:0' shape=(2, 3) dtype=float32_ref>]
# 可以看出来，只有tf.Variable()和tf.get_variable()产生的变量会加入到这个图中

tf.add_to_collection("my_collection_name", my_local)

sess.run(tf.global_variables_initializer())

sess.run(my_variable.initializer)

print(sess.run(tf.report_uninitialized_variables()))

def conv_relu(input, kernel_shape, bias_shape):
    # Create variable named "weights".
    weights = tf.get_variable("weights", kernel_shape,
        initializer=tf.random_normal_initializer())
    # Create variable named "biases".
    biases = tf.get_variable("biases", bias_shape,
        initializer=tf.constant_initializer(0.0))
    conv = tf.nn.conv2d(input, weights,
        strides=[1, 1, 1, 1], padding='SAME')
    return tf.nn.relu(conv + biases)

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])

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)

import tensorflow as tf
import numpy as np

# 创建一个长度为n的placeholder list
n = 4
ph_list = [tf.placeholder(tf.float32, [None, 10]) for _ in range(4)]
# 对这个ph list的操作
result = tf.Variable(0.0)
for x in ph_list:
    result = tf.add(result, x)
hhhh = tf.log(result)


if __name__ == "__main__":
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())

    # 生成数据
    inputs = []
    for _ in range(n):
        x = np.random.rand(16, 10)
        inputs.append(x)
    # 声明一个字典，存放placeholder和value键值对
    feed_dictionary = {}
    for k,v in zip(ph_list, inputs):
       feed_dictionary[k] = v
    # feed 数据
    print(sess.run(hhhh, feed_dict=feed_dictionary).shape)