Ejemplo n.º 1
0
    lambda u, v, s: unify_MetaSymbol(u, metatize(v), s),
)
_unify.add(
    (tf_class_abstractions, TFlowMetaSymbol, Mapping),
    lambda u, v, s: unify_MetaSymbol(metatize(u), v, s),
)
_unify.add(
    (tf_class_abstractions, tf_class_abstractions, Mapping),
    lambda u, v, s: unify_MetaSymbol(metatize(u), metatize(v), s),
)


def _reify_TFlowClasses(o, s):
    meta_obj = metatize(o)
    return reify(meta_obj, s)


_reify.add((tf_class_abstractions, Mapping), _reify_TFlowClasses)


_car.add((tf.Tensor,), lambda x: operator(metatize(x)))
operator.add((tf.Tensor,), lambda x: operator(metatize(x)))

_cdr.add((tf.Tensor,), lambda x: arguments(metatize(x)))
arguments.add((tf.Tensor,), lambda x: arguments(metatize(x)))

etuplize.add(tf_class_abstractions, lambda x, shallow=False: etuplize(metatize(x), shallow))


__all__ = []
Ejemplo n.º 2
0
)
_unify.add(
    (tt_class_abstractions, TheanoMetaSymbol, Mapping),
    lambda u, v, s: unify_MetaSymbol(metatize(u), v, s),
)
_unify.add(
    (tt_class_abstractions, tt_class_abstractions, Mapping),
    lambda u, v, s: unify_MetaSymbol(metatize(u), metatize(v), s),
)


def _reify_TheanoClasses(o, s):
    meta_obj = metatize(o)
    return reify(meta_obj, s)


_reify.add((tt_class_abstractions, Mapping), _reify_TheanoClasses)

operator.add((tt.Variable, ), lambda x: operator(metatize(x)))
_car.add((tt.Variable, ), lambda x: operator(metatize(x)))

arguments.add((tt.Variable, ), lambda x: arguments(metatize(x)))
_cdr.add((tt.Variable, ), lambda x: arguments(metatize(x)))

term.add((tt.Op, ExpressionTuple), lambda op, args: term(metatize(op), args))

etuplize.add(tt_class_abstractions,
             lambda x, shallow=False: etuplize(metatize(x), shallow))

__all__ = []
Ejemplo n.º 3
0
    This applies a special consideration for Theano `Variable`s: if it has a
    non-`None` `owner` with non-`None` `op` and `inputs`, then the `Variable`
    is more aptly given as the output of `op(inputs)`.

    Otherwise, considering the `Variable` in isolation, it can be constructed
    directly using its `type` constructor.
    """
    # Get an apply node, if any
    x_owner = getattr(x, 'owner', None)
    if x_owner and hasattr(x_owner, 'op'):
        return x_owner.inputs
    return arguments_MetaSymbol(x)


arguments.add((MetaSymbol, ), arguments_MetaSymbol)
arguments.add((MetaVariable, ), arguments_MetaVariable)
arguments.add((tt.Variable, ), lambda x: arguments(MetaVariable.from_obj(x)))

# Enable [re]construction of terms
term.add((tt.Op, (list, tuple)),
         lambda op, args: term(MetaOp.from_obj(op), args))
term.add((MetaOp, (list, tuple)), lambda op, args: op(*args))

# Function application for tuples/lists starting with a function or partial
term.add(((types.FunctionType, partial), (tuple, list)),
         lambda op, args: op(*args))


class ExpressionTuple(tuple):
    """A tuple object that represents an expression.
Ejemplo n.º 4
0
    x_e = etuple(type(x), *x.rands, eval_obj=x)
    return x_e[1:]


def arguments_MetaVariable(x):
    """Return the arguments/tail/CDR of a variable object.

    See `arguments_MetaSymbol`
    """
    x_op = x.base_operator
    if x_op is not None:
        x_e = etuple(x_op, *x.base_arguments, eval_obj=x)
        return x_e[1:]


arguments.add((MetaSymbol, ), arguments_MetaSymbol)
arguments.add((MetaVariable, ), arguments_MetaVariable)
arguments.add((ExpressionTuple, ), itemgetter(slice(1, None)))


def _term_ExpressionTuple(rand, rators):
    res = (rand, ) + rators
    return res.eval_obj


term.add((object, ExpressionTuple), _term_ExpressionTuple)


@_reify.register(ExpressionTuple, dict)
def _reify_ExpressionTuple(t, s):
    """When `kanren` reifies `etuple`s, we don't want them to turn into regular `tuple`s.
Ejemplo n.º 5
0
#     original object is later reconstructed and evaluated (e.g. using
#     `term`).
#
#     """
#     try:
#         x_e = etuple(_car(x), *x.rands, eval_obj=x)
#     except NotImplementedError:
#         raise ConsError("Not a cons pair.")
#
#     return x_e[1:]


def cdr_MetaVariable(x):
    """Return the arguments/tail/CDR of a variable object.

    See `cdr_MetaSymbol`
    """
    try:
        x_e = etuple(_car(x), *x.base_arguments, eval_obj=x)
    except NotImplementedError:
        raise ConsError("Not a cons pair.")

    return x_e[1:]


# _cdr.add((MetaSymbol,), cdr_MetaSymbol)
_cdr.add((MetaVariable, ), cdr_MetaVariable)

# arguments.add((MetaSymbol,), cdr_MetaSymbol)
arguments.add((MetaVariable, ), cdr_MetaVariable)