zoukankan      html  css  js  c++  java
  • Theano2.1.4-基础知识之图结构

    来自:http://deeplearning.net/software/theano/tutorial/symbolic_graphs.html

    Graph Structures

        Theano是将符号数学化的计算表示成graphs。这些graphs是由将Apply 和 Variable节点内连接而组成的,它们是分别与函数的应用和数据相连接的。 操作是由 Op 实例所表示的,而数据类型是由 Type 实例所表示的。下面有一段代码和一个图表,该图表用来说明由这些代码所构建的结构。这些应该有助于你理解如何将这些片拟合到一起:

    代码:

    x = dmatrix('x')
    y = dmatrix('y')
    z = x + y

                                                                    ../_images/apply.png

        箭头用来表示对指向的python对象的引用。这里的蓝色盒子是一个 Apply 节点。红色盒子是 Variable 节点。绿色圆圈是Ops.。紫色盒子是 Types

        在创建 Variables 之后,对它们应用 Apply Ops 从而得到更多的变量,并得到一个二分、有向、无环图。变量指向 Apply 节点的过程是用来表示函数通过它们的owner 域来生成它们 。这些Apply节点是通过它们的inputs和outputs域来得到它们的输入和输出变量的 (Apply 的实例同样包含指向他们outputs的引用的列表,不过这些指针不计算在这个graph内)。

       x 和 y 的owner 域的指向都是None是因为它们不是另一个计算的结果。如果它们中的一个是另一个计算的结果,那么owner域将会指向另一个的蓝色盒子比如 z 。

        注意到 Apply 实例的输出指向z ,而z.owner也指回Apply实例的。

    一、一个显式的例子

        在这个例子中,我们将会对比两种定义相同graph的方式。首先,一段短代码用来构建一个表达式 (graph),该正常的方式是大多数graph构建的时候自动使用的。第二种方式,我们将会使用一段较长的代码来干相同的事情,这里面没有用到任何的快捷方式,所以这可以让graph的构建变得很 explicit。

    1.1 Short example

    这就是通常的方式:

    # create 3 Variables with owner = None
    x = T.matrix('x')
    y = T.matrix('y')
    z = T.matrix('z')
    
    # create 2 Variables (one for 'e', one intermediate for y*z)
    # create 2 Apply instances (one for '+', one for '*')
    e = x + y * z

    1.2 Long example

    这就是显式的构建graph的方式:

    from theano.tensor import add, mul, Apply, Variable, TensorType
    
    # Instantiate a type that represents a matrix of doubles
    float64_matrix = TensorType(dtype = 'float64',              # double
                                broadcastable = (False, False)) # matrix
    
    # We make the Variable instances we need.
    x = Variable(type = float64_matrix, name = 'x')
    y = Variable(type = float64_matrix, name = 'y')
    z = Variable(type = float64_matrix, name = 'z')
    
    # This is the Variable that we want to symbolically represents y*z
    mul_variable = Variable(type = float64_matrix)
    assert mul_variable.owner is None
    
    # Instantiate a symbolic multiplication
    node_mul = Apply(op = mul,
                     inputs = [y, z],
                     outputs = [mul_variable])
    # Fields 'owner' and 'index' are set by Apply
    assert mul_variable.owner is node_mul
    # 'index' is the position of mul_variable in mode_mul's outputs
    assert mul_variable.index == 0
    
    # This is the Variable that we want to symbolically represents x+(y*z)
    add_variable = Variable(type = float64_matrix)
    assert add_variable.owner is None
    
    # Instantiate a symbolic addition
    node_add = Apply(op = add,
                     inputs = [x, mul_variable],
                     outputs = [add_variable])
    # Fields 'owner' and 'index' are set by Apply
    assert add_variable.owner is node_add
    assert add_variable.index == 0
    
    e = add_variable
    
    # We have access to x, y and z through pointers
    assert e.owner.inputs[0] is x
    assert e.owner.inputs[1] is mul_variable
    assert e.owner.inputs[1].owner.inputs[0] is y
    assert e.owner.inputs[1].owner.inputs[1] is z

        注意到如何调用 Apply 来修改当 Variables指向的输出是自身的时候的 owner 和 index 域,和如何改变在输出列表中占据的顺序位置。这整个机制建立的一个DAG  (有向无环图,Directed Acyclic Graph),从而来表示计算的过程,graph可以在theano中被编译和优化。

    二、自动包装

        在graph中所有的节点都必须是 Apply 或者 Result的实例,不过  <Op subclass>.make_node() 通常会包装常量来满足这些约束。例如, tensor.add() 操作实例可以写成如下形式:

    e = dscalar('x') + 1

    构建如下的graph:
    node = Apply(op = add,
                 inputs = [Variable(type = dscalar, name = 'x'),
                           Constant(type = lscalar, data = 1)],
                 outputs = [Variable(type = dscalar)])
    e = node.outputs[0]

    三、Graph Structures

        下面的部分概述了可以用在建立theano计算graph的结构的每个类型。这里介绍这几种结构: ApplyConstantOpVariable and Type.

    3.1 Apply

        一个Apply 节点是一个内部节点的类型,用来表示theano中的 computation graph 。不同于 Variable nodes,Apply 节点通常不是直接被最终用户操作的。。它们可以通过变量的onwer域来访问。

        Apply节点通常是Apply类的一个实例。它表示Op 在一个或多个输入上的应用,这里每个输入都是一个 Variable。按照惯例,每个Op都有责任去了解如何从一个输入列表中构建一个Apply节点。因此, Apply节点可以从 Op和输入列表的基础上,通过调用 Op.make_node(*inputs)来得到。

        相比较于python语言来说, Apply 节点是函数调用的theano版本,而 Op 是函数定义的theano版本。

        一个Apply实例有着下面三个很重要的域::

    3.1.1 op
    Op 决定着在什么地方使用函数/转换。
    3.1.2 inputs
     Variables 的列表,用来表示函数的参数。
    3.1.3 outputs
    Variables 的列表,用来表示函数的返回值。

        Apply实例可以通过调用 gof.Apply(op, inputs, outputs)来创建。

    3.2 Op

          theano中的Op 是在某些类型的输入上定义一个具体的计算,并生成某些类型的输出。它等效于在大多数编程语言中的函数定义。从一个输入 Variables 的列表和一个Op,你就可以建立一个 Apply 节点,来表示Op 对输入的应用。

        理解一个Op(函数的定义)和Apply节点(函数的应用)之间的差别是很重要的。如果你使用theano的结构来解释python语言,写的代码就像 def f(x): ... ,将会对f 生成一个Op,然而如果像 a = f(x) 或者 g(f(4), 5) 那么就生成一个涉及到f Op的Apply节点。

    3.3 Type

        theano中的 Type 用来表示潜在数据对象上的一组约束。这些约束允许theano能够定制C 代码来处理它们,并对计算graph进行静态优化。例如, 在theano.tensor中的irow 类型会在数据上有以下约束:

    1. 必须是 numpy.ndarrayisinstance(x, numpy.ndarray)的实例
    2. 必须是32位整数的数组: str(x.dtype) == 'int32'
    3. shape必须是1xN: len(x.shape) == 2 and x.shape[0] == 1

        在知道这些约束条件下,theano可以生成额外的C代码,声明正确的数据类型和基于维度上进行准确次数的循环。

         Theano的 Type 不等同于 Python 的type 或者 class。在Theano中, irow 和 dmatrix 都是使用 numpy.ndarray 来作为潜在的类型来进行计算和存储数据,然而他们都是不同的theano type。使用dmatrix时候的约束如下:

    1. 必须是 numpy.ndarrayisinstance(x, numpy.ndarray)的实例
    2. 必须是64位的浮点数数组: str(x.dtype) == 'float64'
    3. shape必须是 MxN,在 M 或 N上都没有限制: len(x.shape) == 2

        这些约束不同于上面列出的irow的约束。

       在这些情况中,type可以完全对应于python的type,例如我们这里定义的double 类型,对应着python的float。不过这些不是必须的,除非指定了,所以当我们说“type”的时候,说的就是theano的type。 

    3.4 Variable

        Variable 是当你使用theano的时候主要用到的数据结构。你操作的符号输入都是变量,而且通过各种Ops在输入上的使用得到的也是变量。例如,当输入下面的命令:

    >>> x = theano.tensor.ivector()
    >>> y = -x

        x 和 y 都是变量,即变量类的实例。x和y 的 Type 都是 theano.tensor.ivector.

         y 是计算的输出值对应的变量,而x是对应于输入的变量。计算的自身是通过另一个节点来表示的,一个Apply 节点,和通过 y.owner来进行访问。

        更具体的说,theano中一个变量是是一个基本结构,用来表示在计算中某个具体的点上的基准。通常是类 Variable 或者是它的一个子类的实例。

    变量 r 包含着4个重要的域:

    3.4.1 type
     Type 定义这可以在计算中使用的变量。
    3.4.2 owner
    t是为None 或者一个变量的 Apply 节点的一个输出。
    3.4.3 index
    整数,例如 owner.outputs[index] 是 r (当 owner 为 None的时候忽略)
    3.4.4 name
    一个字符串,用于友好的打印和调试。

    变量还有一个特殊的子类: Constant.

    3.4.5 Constant

        一个常量就是有着一个额外域data的 Variable ,它只能被设置一次。当在计算graph中用作 Opapplication的输入的时候,需要假设该输入总是常量的数据域部分。更进一步的说,需要假设 Op 不会修改该输入,也就是说一个常量是可以参与大量的优化的,比如在C中的常量内联,常量折叠等。

         在一个 function的输入列表中,常量是无需指定的。事实上,做的话还会引起一个异常。

    四、Graph 结构的扩展

        当我们开始对一个theano函数进行编写的时候,我们需要计算一些额外的信息。这部分描述的是所提供的信息的一部分,不是所有都说清楚了,所以如果当你找不到的时候,可以 email theano的开发团队。

       该 graph是在编译的开始进行复制。所以在编译的时候修改不会影响到用户的graph。

        每个变量都接受的一个新域叫做clients。它是一个对图中使用过的变量的每个位置的引用列表, 。如果length为0,就意味着该变量没有被使用。每个被使用的位置都是通过包含2个元素的元组描述的。下面就是该对的两个类型:

    • 第一个元素是一个 Apply节点.
    • 第一个元素是字符串“output”,也就是说该函数的输出是这个变量。

    在对的这两个类型中,元组的第二个元素是一个索引,例如: var.clients[*][0].inputs[index] orfgraph.outputs[index] 就是这个变量。

    import theano
    v = theano.tensor.vector()
    f = theano.function([v], (v+1).sum())
    theano.printing.debugprint(f)
    # Sorted list of all nodes in the compiled graph.
    topo = f.maker.fgraph.toposort()
    topo[0].outputs[0].clients
    # [(Sum(Elemwise{add,no_inplace}.0), 0)]
    topo[1].outputs[0].clients
    # [('output', 0)]
    
    # An internal variable
    var = topo[0].outputs[0]
    client = var.clients[0]
    client
    # (Sum(Elemwise{add,no_inplace}.0), 0)
    type(client[0])
    # <class 'theano.gof.graph.Apply'>
    assert client[0].inputs[client[1]] is var
    
    # An output of the graph
    var = topo[1].outputs[0]
    client = var.clients[0]
    client
    # ('output', 0)
    assert f.maker.fgraph.outputs[client[1]] is var

    参考资料:

    [1] 官网:http://deeplearning.net/software/theano/extending/graphstructures.html#type


  • 相关阅读:
    UGUI Toggle控件
    UGUI Scrollbar控件
    利用头插法——创建、遍历链表
    函数指针
    opencv 图像通道操作
    三维点云匹配算法
    点与三角形位置关系
    室内场景mesh 的自动分块---用于加载显示,参数化等
    eigen 四元数
    string 、char*、const char *
  • 原文地址:https://www.cnblogs.com/shouhuxianjian/p/4590233.html
Copyright © 2011-2022 走看看