tensorflow学习笔记：

3.2 Tensorflow中定义数据流图

张量知识矩阵的一个超集。

超集：如果一个集合S2中的每一个元素都在集合S1中，且集合S1中可能包含S2中没有的元素，则集合S1就是S2的一个超集，反过来，S2是S1的子集。

张量形状：

固定长度： [],() 0阶次；[3],(2,3) 1/2阶次

不定长度：[None] 表示任意长度的向量，(None,3) 表示行数任意，3列的矩阵

获取Op：tf.shape(tensor, name="tensor_shape") , 当然只能通过Session对象得到执行

OP/operation

利用Tensor对象执行运算的节点。计算完毕，返回0/多个张量，可以为数据流图中的其他的Op所使用。

除了输入和属性外，还可以接受一个name参数，描述性的字符串来指代某个特定Op，若对不同Op希望复用name，则用name_scope变成方式将一系列运算组织即可。

运算符重载

一元：tf.neg()，tf.logical_not()，tf.abs()

二元：tf.add()，tf.subtract()，tf.multiply()元素相乘，tf.matmul()矩阵相乘，tf.truediv()，tf.mod()，tf.pow()，< tf.less()，≤ tf.less_equal()，tf.greater()，tf.greater_equal()，tf.logical_and()，tf.logical_or()，tf.logical_xor()

tf.equal()，tf.not_equal()检查张量值是否相同

Graph对象

多个流图协同工作，这样用户在一个python文件中可以计算和适应若干独立模型的输出。

为了方便起见，当Tf库被加载时，会自动创建一个Graph对象，可以用tf.get_default_graph获得默认数据流图的句柄。

创建数据流图。

g1 = tf.Graph()

g2 = tf.Graph()

g3 = tf.get_default_graph()

with g1.as_default():

一系列Op：a = tf.multiply(2, 3)....

with g2.as_default():

一系列Op：b = tf.add(2, 3)....

with g3.as_default():

#一系列Op：c = tf.pow(2, 3)....

Session类

负责数据流图的执行。tf.Session(target, graph, config)

target：大多数默认为空，他为制定所使用的引擎

graph：当使用多个数据流图时，指明Graph对象，默认是当前数据流图。

config：包含cpu/gpu数目，为数据流图设置优化参数以及日志选项等

import tensorflow as tf

#创建Op和Tensor对象

a = tf.add(3, 5)

b = tf.multiply(2, 4)

c = tf.add(a, 9)

sess = tf.Session()

sess.run([a, b])

#输出[8,8]

replace_dict = {a: 2}

sess.run(c, feed_dict=replace_dict)

#输出11

sess.close()

#还可以用上下文管理器

with tf.Session() as sess:

    #...

Session.run(fetches, feed_dict, options, run_medadata)

采用run()方法计算所期望的tensor对象输出。

fetches：接受任意数据流图元素，若为一个Tensor对象，输出Numpy数组。

若为一个Op，输出None。例如sess.run(tf.global_variables_initializer())，执行初始化Variables对象所需的计算，返回None。

feed_dict：传入一个字典,a的值被重新赋予2，主要用在流图局部测试场景，给定输入值。

tf.placeholder()

占位节点用来添加输入。 dtype必须指定，shape可选，还可以为None，接受任意形状的Tensor，name可选。

import tensorflow as tf

import numpy as np

#占位符，输入

a = tf.placeholder(tf.int32, shape=[2], name="my_input")

b = tf.reduce_prod(a, name="prod_b")   # 5x3=15

c = tf.reduce_sum(a, name="sum_c")     # 5+3=8

#完成数据流图的定义

d = tf.add(b, c, name="add_d")



sess = tf.Session()

input_dict = {a:np.array([5, 3], dtype=np.int32)}

sess.run(d, feed_dict=input_dict)      #输出15+8=23

sess.close()

Variables对象

创建：tf.Variables()

import tensorflow as tf

my_var = tf.Variables(3, name="my_var")

add = tf.add(5, my_var)



#2x2的全0矩阵

zeros = tf.zeros([2, 2])

#长度为6的全1向量

ones = tf.ones([6])

#大小为3x3x3，元素服从0~10的均匀分布

uniform = tf.random_uniform([3, 3, 3], minval=0, maxval=10)

#大小3x3x3，元素服从均值为0，标准差为2的正态分布

normal = tf.random_normal([3, 3, 3], mean=0.0, stddev=2.0)

#截断正态分布，大小2x2,元素值距离均值不会超过两倍的标准差。防止离群点出现

trunc = tf.truncated_normal([2, 2], mean=5.0, stddev=1.0)

#也可以像手工初始化张量那样，将这些Op作为Variavle对象作为初值传入

random_var = tf.Variable(tf.truncated_normal([2, 2]))

初始化：tf.global_variables_initializer() 或 tf.intialize_valiables([var1], name="init_var1")

#全部初始化

init = tf.global_variables_initializer()

sess = tf.Session()

sess.run(init)

init1 = tf.initialize_variables([var1], name="init_var1")

sess1 = tf.Session()

sess1.run(init1)

修改：Variables.assign()赋新值，Variables.assign_add()自增，Varables.assign_sub()自减

my_var = tf.Variables(1)

my_var_times_two = my_var.assign(my_var*2)

init = f.global_variables_initializer()

sess = tf.Session()

sess.run(init)

sess.run(my_var_times_two)

#输出2

sess.run(my_var_times_two)

#输出4

sess.run(my_var_times_two)

#输出8



sess.run(my_var.assign_add(1))

#输出9

sess.run(my_var.assign_sub(1))

#输出8

不同Session会各自独立维护自己的Variables对象的值。

trainable参数

在自动训练的机器学习模型的Optimizer类，会自动修改Variables的值，而不需要做出显示的请求。若不希望这样，则制定trainable=False即可。

not_trainable = tf.Variable(0, trainable=False)

3.3 名称作用域name scope

语法：

with tf.name_scope("Transformation"):

...

它允许将Op划分到一些较大的，有名称的语句块中，有名称作用域都将自己的Op进行封装。如下图1

import tensorflow as tf

#此处显示创建一个tf.Graph()对象，并未使用默认Graph对象

graph = tf.Graph()

with graph.as_default():

    in_1 = tf.placeholder(tf.float32, shape=[], name="input_a")

    in_2 = tf.placeholder(tf.float32, shape=[], name="input_b")

    const = tf.constant(3, dtype=tf.float32, name="static_value")

    with tf.name_scope("Transformation"):

        with tf.name_scope("A"):

            #接受in_1，输出一些值

            A_mul = tf.multiply(in_1, const)

            A_out = tf.subtract(A_mul, in_1)

        with tf.name_scope("B"):

            #接受in_2，输出一些值

            B_mul = tf.multiply(in_2, const)

            B_out = tf.subtract(B_mul, in_1)

        with tf.name_scope("C"):

            #接受A和B，输出一些值

            C_div = tf.div(A_out, B_out)

            C_out = tf.add(C_div, const)

        with tf.name_scope("D"):

            #接受A和B，输出一些值

            D_div = tf.div(B_out, A_out)

            D_out = tf.subtract(D_div, const)

    #获取C，D的输出

    out = tf.maximum(C_out, D_out)

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

    writer.close()

　　在tensorboard上可视化数据流图：

借助一下代码可以实现

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

writer.close()

点开Transformation 它是一个名称作作用域，包含多个Op和作用域，子作用域还可以包含多个Op和作用域。并且相似操作会着色相同颜色。

并且常量tf.constant()，会放置在对应名称作用域中。

3.4 练习

任务：运用上述组件，完成对任意长度输入的Tensor进行一系列运算和更新，并且在tensorboard中进行研究。

要求：输入采用占位符，随时间计算输出综合，采用名称作用域对数据流图进行合理划分，每次运行时，都将数据流图的输出，所有输出的累加和，所有输出的均值保存到磁盘中，工Tensorboard使用。

设计如下：

代码：

import tensorflow as tf

print("----start----")

#显示创建一个数据流图

graph = tf.Graph()

with graph.as_default():

    #---variables---部分，记录运行次数globa_step和总的输出和total_output

    with tf.name_scope("variables"):

        #记录数据流图运行次数

        global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name="global_step")

        #模型输出累加和

        total_output = tf.Variable(0.0, dtype=tf.float32, trainable=False, name="total_sum")

    #---transformation---部分，构建数据流图：输入层input，中间层intermediate_layer，输出层output

    with tf.name_scope("transformation"):

        #独立的输入层

        with tf.name_scope("input"):

            a = tf.placeholder(tf.float32, shape=[None], name="input_placeholder_a")

        #独立的中间层

        with tf.name_scope("intermediate_layer"):

            b = tf.reduce_prod(a, name="prod_b")

            c = tf.reduce_sum(a, name="sum_c")

        #独立的输出层

        with tf.name_scope("output"):

            output = tf.add(b, c, name="output")

    #---Update---部分，更新variables域update_total,increment_step

    with tf.name_scope("update"):

        update_total = total_output.assign_add(output)

        increment_step = global_step.assign_add(1)

    #---summaries---部分，用于tensorboard汇总数据

    with tf.name_scope("summaries"):

        #随时间计算输出的均值

        avg = tf.div(update_total, tf.cast(increment_step, tf.float32), name="average")# tf.cast(x, dtype, name=None)数据类型转换函数

        #为输出节点创建汇总数据

        tf.summary.scalar('Output', output)#, name="output_summary")#tf.summary.scalar(name,tensor,collections=None,family=None),可用于tensorboard或者学习速率和loss等。

        tf.summary.scalar('Sum_of_outputs_over_time', update_total)#, name="total_summary")

        tf.summary.scalar('Average_of_outputs_over_time', avg)#, name="average_summary")

    #以上完成了数据流图的创建，还需要创建Variables初始化Op和利用汇总数据总之到一个Op的辅助节点

    #---global_ops部分---，全局variables和Op

    with tf.name_scope("global_ops"):

        #初始化Op

        init = tf.global_variables_initializer()

        #将所有汇总数据合并到一个Op中

        merged_summaries = tf.summary.merge_all()

    #用明确创建的Graph对象启动一个会话

    sess = tf.Session(graph=graph)

    # 开启一个summary.FileWriter对象，保存汇总数据

    writer = tf.summary.FileWriter('./graph/impoved_graph',graph)

    #初始化Variables对象

    sess.run(init)

    def run_graph(input_tensor):

        """

        辅助函数：用给定的输入张量运行数据流图并保存数据

        """

        feed_dict = {a: input_tensor}

        _, step, summary = sess.run([output, increment_step, merged_summaries],feed_dict=feed_dict)

        writer.add_summary(summary, global_step=step)

    run_graph([2,8])

    run_graph([3,1,3,3])

    run_graph([8])

    run_graph([1,2,3])

    #将汇总数据写入磁盘

    writer.flush()

    #关闭FileWriter对象，Session对象

    writer.close()

    sess.close()

print("----success----")

Tensorboard可视化：

edit by Strangewx 2019.01.03