Esempio n. 1
0
def logpy_join(node):
    if isinstance(node.op, tensor.Join):
        axis = node.inputs[0]
        tsrs = node.inputs[1:]
        if len(tsrs) < 2:
            return

        for i, (t0, t1) in enumerate(zip(tsrs[:-1], tsrs[1:])):
            reb_op = tensor.Rebroadcast((0, 0))
            x0 = reb_op(t0.type())
            x1 = reb_op(t1.type())
            op0 = var('op0')
            with variables(x0, x1):
                op(x[i], x[i+1])
                match = run(
                    1, [x0, x1, op0],
                    (eq, [t0, t1], [reb_op(x0), reb_op(x1)]),
                    (getattrreco, (x0, 'owner', 'op'), op0),
                    (getattrreco, (x1, 'owner', 'op'), op0),
                    (isinstanceo, op0, tensor.Elemwise),

                   )
                if match:
                    print 'MATCH', match
                else:
                    return
Esempio n. 2
0
def logpy_group_incsubtensor(node):
    # TODO: how to design re-usable patterns? (dtype, ndim, etc.)

    shape_of = node.fgraph.shape_feature.shape_of
    shape_dimo = goalifyN(
        shape_dim(shape_of))
    ndimo = goalify(lambda x: getattr(x, 'ndim'))
    x = node.outputs[0].type()
    if x.ndim == 0:
        return
    y = x[0].type()
    z = tensor.set_subtensor(x[1001], y)
    incs = []
    orig_out = node.outputs[0]
    while node:
        with variables(x, y, 1001):
            match = run(1, (x, y, 1001), (eq, node.outputs[0], z))
            if match:
                xx, yy, ii = match[0]
                incs.append((ii, xx, yy))
                node = xx.owner
                continue
        break
    if not incs:
        return
    incs.sort()
    if zip(*incs)[0] == tuple(range(shape_dim(shape_of)(xx, 0))):
        iin = tensor.concatenate([
            tensor.shape_padleft(yy)
            for ii, _, yy in incs])
        print 'INCS', incs
        return [iin]
Esempio n. 3
0
def test_context_type_not_matter():
    x1 = theano.tensor.fmatrix() # -- type doesn't really matter
    y1 = theano.tensor.fmatrix() # -- type doesn't really matter
    x2 = theano.tensor.dmatrix() # -- type doesn't really matter
    y2 = theano.tensor.dmatrix() # -- type doesn't really matter

    with variables(x2, y2):
        assert run(1, (x2, y2), (eq, tensor.dot(x1, y1).owner, tensor.dot(x2, y2).owner))
Esempio n. 4
0
def test_run_objects_with_context_manager():
    f = Foo(1, 1234)
    g = Foo(1, 2)
    unify_dispatch[(Foo, Foo)] = unify_object
    reify_dispatch[Foo] = reify_object
    with variables(1234):
        assert unify_object(f, g, {})
        assert run(1, 1234, (eq, f, g)) == (2,)
        assert run(1, Foo(1234, 1234), (eq, f, g)) == (Foo(2, 2),)

    del reify_dispatch[Foo]
    del unify_dispatch[(Foo, Foo)]
Esempio n. 5
0
def logpy_cut_subtensor(node):
    # TODO: how to design re-usable patterns? (dtype, ndim, etc.)
    shape_dimo = goalifyN(
        shape_dim(node.fgraph.shape_feature.shape_of))
    #jj = lpint(238908925034, 'j') # -- a number that cannot occur in the graph
    x = tensor.vector()
    jj = 12345
    with variables(x, jj) :
        rval = [x]
        goals = (
            (eq, node.outputs[0], x[:jj]),
            (shape_dimo, (x, 0), jj),
            )
    return rval, goals
Esempio n. 6
0
def test_context_manager():
    x = tensor.vector()
    y = tensor.vector()
    z = tensor.inc_subtensor(x[1:3], y)

    xp = tensor.vector()
    yp = tensor.vector()
    zp = tensor.inc_subtensor(xp[1:1234], yp)

    vars = (1234, xp, yp)

    with variables(*vars):
        match, = run(0, vars, (eq, z, zp))

    assert match == (3, x, y)
Esempio n. 7
0
def logpy_remove_dot_scalar_matrix(node):
    # TODO: how to design re-usable patterns? (dtype, ndim, etc.)
    shape_of = node.fgraph.shape_feature.shape_of
    shape_dimo = goalifyN(
        shape_dim(shape_of))
    ndimo = goalify(lambda x: getattr(x, 'ndim'))
    x = theano.tensor.matrix() # -- XXX type should not matter
    y = theano.tensor.matrix() # -- XXX type should not matter
    if isinstance(node.op, theano.tensor.Dot):
        with variables(x, y):
            #theano.printing.debugprint(tensor.dot(x, y))
            result = run(1, (x, y),
                    (eq, node, tensor.dot(x, y).owner),
                    (ndimo, x, 2),
                    (shape_dimo, (x, 0), 1),
                    (shape_dimo, (x, 1), 1),
               )
        if result:
            xx, yy = result[0]
            #print 'MATCHED xx!', xx, shape_of[xx], xx.type
            #print 'MATCHED yy!', yy, shape_of[yy], yy.type
            #theano.printing.debugprint(xx)
            return [tensor.addbroadcast(xx, 0, 1).dimshuffle() * yy]
Esempio n. 8
0
 def simplify(expr):
     source, target = var(), var()
     with variables(*vars):
         result = run(0, target, (reduces, source, target),
                                 (eq, expr, source))
     return result
Esempio n. 9
0
def test_context_manager():
    with variables(1):
        assert isvar(1)
    assert not isvar(1)