return False def __gt__(self, other): return math_ops.greater(self, other) def __ge__(self, other): return math_ops.greater_equal(self, other) def __lt__(self, other): return math_ops.less(self, other) def __le__(self, other): return math_ops.less_equal(self, other) ag_core.register_node(TensorNode, tensor.Tensor) ag_core.register_node(TensorNode, ops.Tensor) def _zeros(shape, dtype): with context.device("cpu:0"): shape = tensor.Tensor(shape, dtype=dtypes.int32) return array_ops.fill(shape, tensor.Tensor(0, dtype=dtype)) def _ones(shape, dtype): return array_ops.fill(tensor.Tensor(shape, dtype=dtypes.int32), tensor.Tensor(1, dtype=dtype)) def _lazy_zero_tensor(zero):
"""VSpace needed to have ImplicitTape be a valid progenitor.""" def zeros(self): return ImplicitTape() class ImplicitTapeNode(ag_core.Node): """Node to wrap ImplicitTape in.""" def __eq__(self, other): return self is other def __hash__(self): return id(self) ag_core.register_node(ImplicitTapeNode, ImplicitTape) ag_core.register_vspace(ImplicitTapeVSpace, ImplicitTape) # TODO(apassos) try to not do this. class NoneVSpace(ag_core.VSpace): """VSpace for python None.""" def __init__(self, _): self.size = 0 def zeros(self): return 0 ag_core.register_vspace(NoneVSpace, type(None))
self.scalartype = complex def flatten(self, value, covector=False): if covector: return anp.ravel(anp.stack([anp.real(value), - anp.imag(value)])) else: return anp.ravel(anp.stack([anp.real(value), anp.imag(value)])) def unflatten(self, value, covector=False): reshaped = anp.reshape(value, (2,) + self.shape) if covector: return anp.array(reshaped[0] - 1j * reshaped[1]) else: return anp.array(reshaped[0] + 1j * reshaped[1]) register_node(ArrayNode, np.ndarray) register_vspace(lambda x: ComplexArrayVSpace(x) if np.iscomplexobj(x) else ArrayVSpace(x), np.ndarray) array_types = set([anp.ndarray, ArrayNode]) for type_ in [float, anp.float64, anp.float32, anp.float16]: register_node(ArrayNode, type_) register_vspace(ArrayVSpace, type_) for type_ in [complex, anp.complex64, anp.complex128]: register_node(ArrayNode, type_) register_vspace(ComplexArrayVSpace, type_) # These numpy.ndarray methods are just refs to an equivalent numpy function nondiff_methods = ['all', 'any', 'argmax', 'argmin', 'argpartition',
__slots__ = [] def __getitem__(self, idx): return sequence_take(self, idx) def __len__(self): return len(self.value) def __add__(self, other): return sequence_extend_right(self, *other) def __radd__(self, other): return sequence_extend_left(self, *other) register_node(SequenceNode, tuple) register_node(SequenceNode, list) @primitive def sequence_take(A, idx): return A[idx] def grad_sequence_take(g, ans, vs, gvs, A, idx): return sequence_untake(g, idx, vs) sequence_take.defvjp(grad_sequence_take)
"""VSpace needed to have ImplicitTape be a valid progenitor.""" def zeros(self): return ImplicitTape() class ImplicitTapeNode(ag_core.Node): """Node to wrap ImplicitTape in.""" def __eq__(self, other): return self is other def __hash__(self): return id(self) ag_core.register_node(ImplicitTapeNode, ImplicitTape) ag_core.register_vspace(ImplicitTapeVSpace, ImplicitTape) # TODO(apassos) try to not do this. class NoneVSpace(ag_core.VSpace): """VSpace for python None.""" def __init__(self, _): self.size = 0 ag_core.register_vspace(NoneVSpace, type(None)) class _TapeStack(threading.local):
def flatten(self, value, covector=False): if covector: return np.ravel(np.stack([np.real(value), -np.imag(value)])) else: return np.ravel(np.stack([np.real(value), np.imag(value)])) def unflatten(self, value, covector=False): reshaped = np.reshape(value, (2, ) + self.shape) if covector: return np.array(reshaped[0] - 1j * reshaped[1]) else: return np.array(reshaped[0] + 1j * reshaped[1]) register_node(ArrayNode, np.ndarray) register_vspace( lambda x: ComplexArrayVSpace(x) if np.iscomplexobj(x) else ArrayVSpace(x), np.ndarray) array_types = set([anp.ndarray, ArrayNode]) for type_ in [float, anp.float64, anp.float32, anp.float16]: register_node(ArrayNode, type_) register_vspace(ArrayVSpace, type_) for type_ in [complex, anp.complex64, anp.complex128]: register_node(ArrayNode, type_) register_vspace(ComplexArrayVSpace, type_) # These numpy.ndarray methods are just refs to an equivalent numpy function nondiff_methods = [
return False def __gt__(self, other): return math_ops.greater(self, other) def __ge__(self, other): return math_ops.greater_equal(self, other) def __lt__(self, other): return math_ops.less(self, other) def __le__(self, other): return math_ops.less_equal(self, other) ag_core.register_node(TensorNode, tensor.Tensor) ag_core.register_node(TensorNode, ops.Tensor) def _zeros(shape, dtype): with context.device("cpu:0"): shape = tensor.Tensor(shape, dtype=dtypes.int32) return array_ops.fill(shape, tensor.Tensor(0, dtype=dtype)) def _ones(shape, dtype): return array_ops.fill( tensor.Tensor(shape, dtype=dtypes.int32), tensor.Tensor(1, dtype=dtype)) def _lazy_zero_tensor(zero):
from __future__ import absolute_import from autograd.core import (primitive, Node, VSpace, register_node, vspace, register_vspace, SparseObject) from builtins import zip from future.utils import iteritems from functools import partial import autograd.numpy as np class SequenceNode(Node): __slots__ = [] def __getitem__(self, idx): return sequence_take(self, idx) def __len__(self): return len(self.value) def __add__(self, other): return sequence_extend_right(self, *other) def __radd__(self, other): return sequence_extend_left(self, *other) register_node(SequenceNode, tuple) register_node(SequenceNode, list) @primitive def sequence_take(A, idx): return A[idx] def grad_sequence_take(g, ans, vs, gvs, A, idx): return sequence_untake(g, idx, vs) sequence_take.defvjp(grad_sequence_take) @primitive def sequence_extend_right(seq, *elts): return seq + type(seq)(elts) def grad_sequence_extend_right(argnum, g, ans, vs, gvs, args, kwargs): seq, elts = args[0], args[1:] return g[:len(seq)] if argnum == 0 else g[len(seq) + argnum - 1]