精华内容
参与话题
问答
  • Theano 符号图结构 使用 Theano,首先要定义符号变量,然后是利用这写符号变量进行计算,这些符号被称为 variables,而操作 +, -, **, sum(), tanh() 被称为 ops,一个 op 操作接受某些类型的输入,并返回某些类型的...

    Theano 符号图结构

    使用 Theano,首先要定义符号变量,然后是利用这写符号变量进行计算,这些符号被称为 variables,而操作 +, -, **, sum(), tanh() 被称为 ops,一个 op 操作接受某些类型的输入,并返回某些类型的输出。

    Theano 利用这些来构建一个图结构,一个图结构包括:

    • variable 节点
    • op 节点
    • apply 节点

    其中,apply 节点用来表示一个特定的 op 作用在一些特定的 variables 上,例如:

    import theano
    import theano.tensor as T
    
    x = T.dmatrix('x')
    y = T.dmatrix('y')
    z = x + y
    
    Using gpu device 0: GeForce GTX 850M
    

    要显示这个图结构可以用 pydotprint,先安装 graphviz

    Windows 下:

    在环境变量 path 后加上:

    • path
      • C:\Program Files (x86)\Graphviz2.38\bin

    然后要先安装 pydot 包:

    如果你的 pyparsing >= 2.0 ,则将其降为 1.5.7,下载并安装 pydot-1.0.28

    安装完之后,找到 pydot.py 将其中:

    graph.append( '%s %s {\n' % (self.obj_dict['type'], self.obj_dict['name']) )
    

    修改为:

    graph.append( '%s %s {\n' % (self.obj_dict['type'], quote_if_necessary(self.obj_dict['name'])) )
    
    theano.printing.pydotprint(z, outfile='apply1.png', var_with_name_simple=True)
    
    The output file is available at apply1.png
    

    它的图结构如下:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4zgw0577-1576404414445)(apply1.png)]

    zowner 是一个 apply 结构,其 op 为:

    z.owner.op.name
    
    'Elemwise{add,no_inplace}'
    

    这个 apply 结构的输入值有两个,输出值有一个:

    print z.owner.nin
    print z.owner.nout
    
    2
    1
    

    查看它的输入:

    z.owner.inputs
    
    [x, y]
    

    我们可以用 pprint 来显示它:

    print theano.printing.pprint(z)
    
    (x + y)
    

    debugprint 显示图结构:

    theano.printing.debugprint(z)
    
    Elemwise{add,no_inplace} [@A] ''   
     |x [@B]
     |y [@C]
    

    再看另一个稍微复杂的例子:

    y = x * 2
    

    查看 y 的图谱:

    theano.printing.debugprint(y)
    
    Elemwise{mul,no_inplace} [@A] ''   
     |x [@B]
     |DimShuffle{x,x} [@C] ''   
       |TensorConstant{2} [@D]
    

    这里我们看到,y 对应的第二个 input 并不是 2,而是一个 DimShuffle 的操作:

    y.owner.inputs[1].owner.op
    
    <theano.tensor.elemwise.DimShuffle at 0x1b816390>
    

    它的输入才是常数 2:

    y.owner.inputs[1].owner.inputs
    
    [TensorConstant{2}]
    
    theano.printing.pydotprint(y, outfile='apply2.png', var_with_name_simple=True)
    
    The output file is available at apply2.png
    

    其图结构为
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cLEqGGEi-1576404414446)(apply2.png)]

    function 对图的优化

    a = T.dscalar('a')
    b = a + a ** 10
    
    f = theano.function([a], b)
    
    theano.printing.pydotprint(b, outfile='apply_no_opti.png', var_with_name_simple=True)
    theano.printing.pydotprint(f, outfile='apply_opti.png', var_with_name_simple=True)
    
    The output file is available at apply_no_opti.png
    The output file is available at apply_opti.png
    

    比较一下 function 函数对图结构进行的优化:

    未优化前:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nc9OU5C2-1576404414446)(apply_no_opti.png)]

    优化后:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CwWXBWJT-1576404414447)(apply_opti.png)]

    图结构的作用

    • 计算按照图结构来计算
    • 优化,求导
    展开全文
  • Theano tensor 模块:conv 子模块 conv 是 tensor 中处理卷积神经网络的子模块。 卷积 这里只介绍二维卷积: T.nnet.conv2d(input, filters, input_shape=None, filter_shape=None, border_mode='valid', subsample=...

    Theano tensor 模块:conv 子模块

    convtensor 中处理卷积神经网络的子模块。

    卷积

    这里只介绍二维卷积:

    T.nnet.conv2d(input, filters, input_shape=None, filter_shape=None, border_mode='valid', subsample=(1, 1), filter_flip=True, image_shape=None, **kwargs)

    conv2d 函数接受两个输入:

    • 4D 张量 input,其形状如下:

      [b, ic, i0, i1]

    • 4D 张量 filter ,其形状如下:

      [oc, ic, f0, f1]

    border_mode 控制输出大小:

    • 'valid':输出形状:

      [b, oc, i0 - f0 + 1, i1 - f1 + 1]

    • 'full':输出形状:

      [b, oc, i0 + f0 - 1, i1 + f1 - 1]

    池化

    池化操作:

    T.signal.downsample.max_pool_2d(input, ds, ignore_border=None, st=None, padding=(0, 0), mode='max')

    input 池化操作在其最后两维进行。

    ds 是池化区域的大小,用长度为 2 的元组表示。

    ignore_border 设为 Ture 时,(5, 5)(2, 2) 的池化下会变成 (2, 2)(5 % 2 == 1,多余的 1 个被舍去了),否则是 (3, 3)

    MNIST 卷积神经网络形状详解

    def model(X, w, w2, w3, w4, p_drop_conv, p_drop_hidden):
        
        # X:  128 * 1 * 28 * 28
        # w:  32 * 1 * 3 * 3
        # full mode
        # l1a: 128 * 32 * (28 + 3 - 1) * (28 + 3 - 1)
        l1a = rectify(conv2d(X, w, border_mode='full'))
        # l1a: 128 * 32 * 30 * 30
        # ignore_border False
        # l1:  128 * 32 * (30 / 2) * (30 / 2)
        l1 = max_pool_2d(l1a, (2, 2), ignore_border=False)
        l1 = dropout(l1, p_drop_conv)
    
        # l1:  128 * 32 * 15 * 15
        # w2:  64 * 32 * 3 * 3
        # valid mode
        # l2a: 128 * 64 * (15 - 3 + 1) * (15 - 3 + 1)
        l2a = rectify(conv2d(l1, w2))    
        # l2a: 128 * 64 * 13 * 13
        # l2:  128 * 64 * (13 / 2 + 1) * (13 / 2 + 1)
        l2 = max_pool_2d(l2a, (2, 2), ignore_border=False)
        l2 = dropout(l2, p_drop_conv)
    
        # l2:  128 * 64 * 7 * 7
        # w3:  128 * 64 * 3 * 3
        # l3a: 128 * 128 * (7 - 3 + 1) * (7 - 3 + 1)
        l3a = rectify(conv2d(l2, w3))
        # l3a: 128 * 128 * 5 * 5
        # l3b: 128 * 128 * (5 / 2 + 1) * (5 / 2 + 1)
        l3b = max_pool_2d(l3a, (2, 2), ignore_border=False)    
        # l3b: 128 * 128 * 3 * 3
        # l3:  128 * (128 * 3 * 3)
        l3 = T.flatten(l3b, outdim=2)
        l3 = dropout(l3, p_drop_conv)
        
        # l3: 128 * (128 * 3 * 3)
        # w4: (128 * 3 * 3) * 625
        # l4: 128 * 625
        l4 = rectify(T.dot(l3, w4))
        l4 = dropout(l4, p_drop_hidden)
    
        # l5:  128 * 625
        # w5:  625 * 10
        # pyx: 128 * 10
        pyx = softmax(T.dot(l4, w_o))
        return l1, l2, l3, l4, pyx
    
    展开全文
  • 【Python学习之路】Theano Theano 基础

    万次阅读 2019-12-15 20:39:53
    Theano 基础 %matplotlib inline import numpy as np import matplotlib.pyplot as plt 首先导入 theano 及其 tensor 子模块(tensor,张量): import theano # 一般都把 `tensor` 子模块导入并命名为 T import ...

    Theano 基础

    %matplotlib inline
    import numpy as np
    import matplotlib.pyplot as plt
    

    首先导入 theano 及其 tensor 子模块(tensor,张量):

    import theano
    
    # 一般都把 `tensor` 子模块导入并命名为 T
    import theano.tensor as T
    
    Using gpu device 1: Tesla K10.G2.8GB (CNMeM is disabled)
    

    tensor 模块包含很多我们常用的数学操作,所以为了方便,将其命名为 T。

    符号计算

    theano 中,所有的算法都是用符号计算的,所以某种程度上,用 theano 写算法更像是写数学(之前在[04.06 积分](…/04. scipy/04.06 integration in python.ipynb)一节中接触过用 sympy 定义的符号变量)。

    T.scalar 来定义一个符号标量:

    foo = T.scalar('x')
    
    print foo
    
    x
    

    支持符号计算:

    bar = foo ** 2
    
    print bar
    
    Elemwise{pow,no_inplace}.0
    

    这里定义 fooxxbar 就是变量 x2x^2,但显示出来的却是看不懂的东西。

    为了更好的显示 bar,我们使用 theano.pp() 函数(pretty print)来显示:

    print theano.pp(bar)
    
    (x ** TensorConstant{2})
    

    查看类型:

    print type(foo)
    print foo.type
    
    <class 'theano.tensor.var.TensorVariable'>
    TensorType(float32, scalar)
    

    theano 函数

    有了符号变量,自然可以用符号变量来定义函数,theano.function() 函数用来生成符号函数:

    theano.function(input, output)
    

    其中 input 对应的是作为参数的符号变量组成的列表,output 对应的是输出,输出可以是一个,也可以是多个符号变量组成的列表。

    例如,我们用刚才生成的 foobar 来定义函数:

    square = theano.function([foo], bar)
    

    使用 square 函数:

    print square(3)
    
    9.0
    

    也可以使用 bareval 方法,将 x 替换为想要的值,eval 接受一个字典作为参数,键值对表示符号变量及其对应的值:

    print bar.eval({foo: 3})
    
    9.0
    

    theano.tensor

    除了 T.scalar() 标量之外,Theano 中还有很多符号变量类型,这些都包含在 tensor(张量)子模块中,而且 tensor 中也有很多函数对它们进行操作。

    • T.scalar(name=None, dtype=config.floatX)
      • 标量,shape - ()
    • T.vector(name=None, dtype=config.floatX)
      • 向量,shape - (?,)
    • T.matrix(name=None, dtype=config.floatX)
      • 矩阵,shape - (?,?)
    • T.row(name=None, dtype=config.floatX)
      • 行向量,shape - (1,?)
    • T.col(name=None, dtype=config.floatX)
      • 列向量,shape - (?,1)
    • T.tensor3(name=None, dtype=config.floatX)
      • 3 维张量,shape - (?,?,?)
    • T.tensor4(name=None, dtype=config.floatX)
      • 4 维张量,shape - (?,?,?,?)

    shape 中为 1 的维度支持 broadcast 机制。

    除了直接指定符号变量的类型(默认 floatX),还可以直接在每类前面加上一个字母来定义不同的类型:

    • b int8
    • w int16
    • i int32
    • l int64
    • d float64
    • f float32
    • c complex64
    • z complex128

    例如 T.dvector() 表示的就是一个 float64 型的向量。

    除此之外,还可以用它们的复数形式一次定义多个符号变量:

    x,y,z = T.vectors('x','y','z')
    x,y,z = T.vectors(3)
    
    A = T.matrix('A')
    x = T.vector('x')
    b = T.vector('b')
    

    T.dot() 表示矩阵乘法:
    y=Ax+by = Ax+b

    y = T.dot(A, x) + b
    

    T.sum() 表示进行求和:
    z=i,jAij2z = \sum_{i,j} A_{ij}^2

    z = T.sum(A**2)
    

    来定义一个线性函数,以 A,x,bA,x,b 为参数,以 y,zy,z 为输出:

    linear_mix = theano.function([A, x, b],
                                 [y, z])
    

    使用这个函数:

    A=[123456],x=[123],b=[45] A = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}, x = \begin{bmatrix} 1 \\ 2 \\ 3 \end{bmatrix}, b = \begin{bmatrix} 4 \\ 5 \end{bmatrix}

    print linear_mix(np.array([[1, 2, 3],
                               [4, 5, 6]], dtype=theano.config.floatX),    #A
                     np.array([1, 2, 3], dtype=theano.config.floatX),      #x
                     np.array([4, 5], dtype=theano.config.floatX))         #b
    
    [array([ 18.,  37.], dtype=float32), array(91.0, dtype=float32)]
    

    这里 dtype=theano.config.floatX 是为了与 theano 设置的浮点数精度保持一致,默认是 float64,但是在 GPU 上一般使用 float32 会更高效一些。

    我们还可以像定义普通函数一样,给 theano 函数提供默认值,需要使用 theano.Param 类:

    linear_mix_default = theano.function([A, x, theano.Param(b, default=np.zeros(2, dtype=theano.config.floatX))],
                                         [y, z])
    

    计算默认参数下的结果:

    print linear_mix_default(np.array([[1, 2, 3],
                               [4, 5, 6]], dtype=theano.config.floatX),    #A
                     np.array([1, 2, 3], dtype=theano.config.floatX))      #x
    
    [array([ 14.,  32.], dtype=float32), array(91.0, dtype=float32)]
    

    计算刚才的结果:

    print linear_mix_default(np.array([[1, 2, 3],
                                       [4, 5, 6]], dtype=theano.config.floatX),    #A
                             np.array([1, 2, 3], dtype=theano.config.floatX),      #x
                             np.array([4, 5], dtype=theano.config.floatX))         #b
    
    [array([ 18.,  37.], dtype=float32), array(91.0, dtype=float32)]
    

    共享的变量

    Theano 中可以定义共享的变量,它们可以在多个函数中被共享,共享变量类似于普通函数定义时候使用的全局变量,同时加上了 global 的属性以便在函数中修改这个全局变量的值。

    shared_var = theano.shared(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=theano.config.floatX))
    
    print shared_var.type
    
    CudaNdarrayType(float32, matrix)
    

    可以通过 set_value 方法改变它的值:

    shared_var.set_value(np.array([[3.0, 4], [2, 1]], dtype=theano.config.floatX))
    

    通过 get_value() 方法返回它的值:

    print shared_var.get_value()
    
    [[ 3.  4.]
     [ 2.  1.]]
    

    共享变量进行运算:

    shared_square = shared_var ** 2
    
    f = theano.function([], shared_square)
    
    print f()
    
    [[  9.  16.]
     [  4.   1.]]
    

    这里函数不需要参数,因为共享变量隐式地被认为是一个参数。

    得到的结果会随这个共享变量的变化而变化:

    shared_var.set_value(np.array([[1.0, 2], [3, 4]], dtype=theano.config.floatX))
    
    print f()
    
    [[  1.   4.]
     [  9.  16.]]
    

    一个共享变量的值可以用 updates 关键词在 theano 函数中被更新:

    subtract = T.matrix('subtract')
    
    f_update = theano.function([subtract], shared_var, updates={shared_var: shared_var - subtract})
    

    这个函数先返回当前的值,然后将当前值更新为原来的值减去参数:

    print 'before update:'
    print shared_var.get_value()
    
    print 'the return value:'
    print f_update(np.array([[1.0, 1], [1, 1]], dtype=theano.config.floatX))
    
    print 'after update:'
    print shared_var.get_value()
    
    before update:
    [[ 1.  2.]
     [ 3.  4.]]
    the return value:
    <CudaNdarray object at 0x7f7f3c16a6f0>
    after update:
    [[ 0.  1.]
     [ 2.  3.]]
    

    导数

    Theano 的一大好处在于它对符号变量计算导数的能力。

    我们用 T.grad() 来计算导数,之前我们定义了 foobar (分别是 xxx2x^2),我们来计算 bar 关于 foo 的导数(应该是 2x2x):

    bar_grad = T.grad(bar, foo)  # 表示 bar (x^2) 关于 foo (x) 的导数
    
    print bar_grad.eval({foo: 10})
    
    20.0
    

    再如,对之前的 y=Ax+by = Ax + byy 关于 xx 的雅可比矩阵(应当是 AA):

    y_J = theano.gradient.jacobian(y, x)
    
    print y_J.eval({A: np.array([[9.0, 8, 7], [4, 5, 6]], dtype=theano.config.floatX), #A
                    x: np.array([1.0, 2, 3], dtype=theano.config.floatX),              #x
                    b: np.array([4.0, 5], dtype=theano.config.floatX)})                #b
    
    [[ 9.  8.  7.]
     [ 4.  5.  6.]]
    

    theano.gradient.jacobian 用来计算雅可比矩阵,而 theano.gradient.hessian 可以用来计算 Hessian 矩阵。

    R-opL-op

    Rop 用来计算 fxv\frac{\partial f}{\partial x}v,Lop 用来计算 vfxv\frac{\partial f}{\partial x}

    一个是雅可比矩阵与列向量的乘积,另一个是行向量与雅可比矩阵的乘积。

    W = T.dmatrix('W')
    V = T.dmatrix('V')
    x = T.dvector('x')
    y = T.dot(x, W)
    JV = T.Rop(y, W, V)
    f = theano.function([W, V, x], JV)
    
    print f([[1, 1], [1, 1]], [[2, 2], [2, 2]], [0,1])
    
    [ 2.  2.]
    
    展开全文
  • Theano 条件语句 theano 中提供了两种条件语句,ifelse 和 switch,两者都是用于在符号变量上使用条件语句: ifelse(condition, var1, var2) 如果 condition 为 true,返回 var1,否则返回 var2 switch(tensor, ...

    Theano 条件语句

    theano 中提供了两种条件语句,ifelseswitch,两者都是用于在符号变量上使用条件语句:

    • ifelse(condition, var1, var2)
      • 如果 conditiontrue,返回 var1,否则返回 var2
    • switch(tensor, var1, var2)
      • Elementwise ifelse 操作,更一般化
    • switch 会计算两个输出,而 ifelse 只会根据给定的条件,计算相应的输出。

    ifelse 需要从 theano.ifelse 中导入,而 switchtheano.tensor 模块中。

    import theano, time
    import theano.tensor as T
    import numpy as np
    from theano.ifelse import ifelse
    
    Using gpu device 1: Tesla K10.G2.8GB (CNMeM is disabled)
    

    假设我们有两个标量参数:a,ba, b,和两个矩阵 x,y\mathbf{x, y},定义函数为:

    z=f(a,b,x,y)={x, a<=by, a>b \mathbf z = f(a, b,\mathbf{x, y}) = \left\{ \begin{aligned} \mathbf x & ,\ a <= b\\ \mathbf y & ,\ a > b \end{aligned} \right.

    定义变量:

    a, b = T.scalars('a', 'b')
    x, y = T.matrices('x', 'y')
    

    ifelse 构造,小于等于用 T.lt(),大于等于用 T.gt()

    z_ifelse = ifelse(T.lt(a, b), x, y)
    
    f_ifelse = theano.function([a, b, x, y], z_ifelse)
    

    switch 构造:

    z_switch = T.switch(T.lt(a, b), x, y)
    
    f_switch = theano.function([a, b, x, y], z_switch)
    

    测试数据:

    val1 = 0.
    val2 = 1.
    big_mat1 = np.ones((10000, 1000), dtype=theano.config.floatX)
    big_mat2 = np.ones((10000, 1000), dtype=theano.config.floatX)
    

    比较两者的运行速度:

    n_times = 10
    
    tic = time.clock()
    for i in xrange(n_times):
        f_switch(val1, val2, big_mat1, big_mat2)
    print 'time spent evaluating both values %f sec' % (time.clock() - tic)
    
    tic = time.clock()
    for i in xrange(n_times):
        f_ifelse(val1, val2, big_mat1, big_mat2)
    print 'time spent evaluating one value %f sec' % (time.clock() - tic)
    
    time spent evaluating both values 0.638598 sec
    time spent evaluating one value 0.461249 sec
    
    展开全文
  • Theano 随机数流变量 import theano import theano.tensor as T import numpy as np Using gpu device 1: Tesla C2075 (CNMeM is disabled) Theano 的随机数变量由 theano.sandbox.rng_mrg 中的 MRG_RandomStreams...
  • Theano 简介及其安装 简介 Theano 是一个 Python 科学计算库,允许我们进行符号运算,并在 CPU 和 GPU 上执行。 它最初由 Montreal 大学的机器学习研究者们所开发,用来进行机器学习的计算。 按照官网上的说明,它...
  • Theano 实例:Softmax 回归 MNIST 数据集的下载和导入 MNIST 数据集 是一个手写数字组成的数据集,现在被当作一个机器学习算法评测的基准数据集。 这是一个下载并解压数据的脚本: %%file download_mnist.py import ...
  • Theano 实例:线性回归 基本模型 在用 theano 进行线性回归之前,先回顾一下 theano 的运行模式。 theano 是一个符号计算的数学库,一个基本的 theano 结构大致如下: 定义符号变量 编译用符号变量定义的函数,使它...
  • Theano 配置和编译模式 配置 之前我们已经知道, theano 的配置可以用 config 模块来查看: import theano import theano.tensor as T print theano.config floatX (('float64', 'float32', 'float16')) Doc: ...
  • Theano tensor 模块:索引 import theano import theano.tensor as T import numpy as np Using gpu device 1: Tesla C2075 (CNMeM is disabled) 简单索引 tensor 模块完全支持 numpy 中的简单索引: t = T.arange...
  • Theano 实例:卷积神经网络 import theano import theano.tensor as T from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams import numpy as np from load import mnist srng = RandomStreams...
  • Theano 在 Windows 上的配置 注意:不建议在 windows 进行 theano 的配置。 务必确认你的显卡支持 CUDA。 我个人的电脑搭载的是 Windows 10 x64 系统,显卡是 Nvidia GeForce GTX 850M。 安装 theano 首先是用 ...
  • Theano 实例:Logistic 回归 %matplotlib inline import numpy as np import matplotlib.pyplot as plt import theano import theano.tensor as T Using gpu device 0: GeForce GTX 850M sigmoid 函数 一个 ...
  • Theano tensor 模块:nnet 子模块 nnet 是 tensor 模块中与神经网络 Neural Networks 相关的子模块。 import theano from theano import tensor as T Using gpu device 1: Tesla C2075 (CNMeM is disabled) ...
  • Theano 实例:人工神经网络 神经网络的模型可以参考 UFLDL 的教程,这里不做过多描述。 http://ufldl.stanford.edu/wiki/index.php/%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C import theano import theano.tensor as T ...
  • Theano 循环:scan(详解) import theano, time import theano.tensor as T import numpy as np def floatX(X): return np.asarray(X, dtype=theano.config.floatX) Using gpu device 1: Tesla C2075 (CNMeM is ...
  • Theano tensor 模块:基础 张量是向量在数学上的一种推广,具体内容可以参考维基百科: https://en.wikipedia.org/wiki/Tensor 在 Theano 中有一个专门处理张量变量的模块:theano.tensor (以下简称 T)。 import ...
  • Theano 实例:更复杂的网络 import theano import theano.tensor as T import numpy as np from load import mnist from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams srng = RandomStreams...
  • Theano tensor 模块:操作符和逐元素操作 操作符 import theano from theano import tensor as T Using gpu device 1: Tesla C2075 (CNMeM is disabled) tensor 类型支持很多基本的操作: # 两个整形三维张量 a, ...

空空如也

1 2 3 4 5 ... 20
收藏数 6,180
精华内容 2,472
关键字:

Theano