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__ = []
)
_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__ = []
"""Get a tuple of the arguments used to construct this meta object.
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.
"""
x_owner = getattr(x, 'owner', None)
if x_owner and hasattr(x_owner, 'op'):
return x_owner.op
return operator_MetaSymbol(x)
operator.add((MetaSymbol, ), operator_MetaSymbol)
operator.add((MetaVariable, ), operator_MetaVariable)
operator.add((tt.Variable, ), lambda x: operator(MetaVariable.from_obj(x)))
def arguments_MetaSymbol(x):
return tuple(x.rands())
def arguments_MetaVariable(x):
"""Get a tuple of the arguments used to construct this meta object.
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)`.
# We don't want to lose special functionality (and caching) because `cdr` uses
# `islice`.
_cdr.add((ExpressionTuple, ), itemgetter(slice(1, None)))
def operator_MetaSymbol(x):
"""Return the operator/head/CAR of a meta symbol."""
return type(x)
def operator_MetaVariable(x):
"""Return the operator/head/CAR of a meta variable."""
return x.base_operator
operator.add((MetaSymbol, ), operator_MetaSymbol)
operator.add((MetaVariable, ), operator_MetaVariable)
operator.add((ExpressionTuple, ), itemgetter(0))
def arguments_MetaSymbol(x):
"""Return the arguments/tail/CDR of a meta symbol.
We build the full `etuple` for the argument, then return the
`cdr`/tail, so that the original object is retained when/if the
original object is later reconstructed and evaluated (e.g. using
`term`).
"""
x_e = etuple(type(x), *x.rands, eval_obj=x)
return x_e[1:]
# return type(x)
def car_MetaVariable(x):
"""Return the operator/head/CAR of a meta variable."""
try:
return x.base_operator
except NotImplementedError:
raise ConsError("Not a cons pair.")
# _car.add((MetaSymbol,), car_MetaSymbol)
_car.add((MetaVariable, ), car_MetaVariable)
# operator.add((MetaSymbol,), car_MetaSymbol)
operator.add((MetaVariable, ), car_MetaVariable)
# def cdr_MetaSymbol(x):
# """Return the arguments/tail/CDR of a meta symbol.
#
# We build the full `etuple` for the argument, then return the
# `cdr`/tail, so that the original object is retained when/if the
# 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.")
#