def forward(self, data, output_index=0):
assert data.ndim == 2
data = data[:, None, :] # add batch-dim
assert self.f_forwarder
res = self.f_forwarder(data)
res = make_var_tuple(res)[output_index]
assert res.ndim == 3
assert res.shape[1] == 1
res = res[:, 0]
return res
def local_gpu_NativeOp(node):
if isinstance(node.op, NativeOp):
# see also: https://github.com/Theano/Theano/blob/master/theano/sandbox/cuda/opt.py
from theano.sandbox.cuda import host_from_gpu, gpu_from_host, as_cuda_ndarray_variable
args = node.inputs
if any([(x.owner and x.owner.op == host_from_gpu) for x in args]):
gpu_op = GpuNativeOp(**{key: getattr(node.op, key) for key in node.op.__props__})
args = [x.owner.inputs[0] if (x.owner and x.owner.op == host_from_gpu) else x
for x in args]
from TheanoUtil import make_var_tuple
outputs = make_var_tuple(gpu_op(*args))
return [host_from_gpu(out) for out in outputs]
def forward(self, data, output_index=0):
"""
:param numpy.ndarray data: shape (time,in-dim)
:param int output_index:
:return: shape (time,out-dim)
:rtype: numpy.ndarray
"""
assert data.ndim == 2
data = data[:, None, :] # add batch-dim
assert self.f_forwarder
res = self.f_forwarder(data)
res = make_var_tuple(res)[output_index]
assert res.ndim == 3
assert res.shape[1] == 1
res = res[:, 0]
return res
def forward(self, data, output_index=0): """ :param numpy.ndarray data: shape (time,in-dim) :param int output_index: :return: shape (time,out-dim) :rtype: numpy.ndarray """ assert data.ndim == 2 data = data[:, None, :] # add batch-dim assert self.f_forwarder res = self.f_forwarder(data) res = make_var_tuple(res)[output_index] assert res.ndim == 3 assert res.shape[1] == 1 res = res[:, 0] return res
def inplace_NativeOp(node):
if isinstance(node.op, NativeOp) and not node.op.destroy_map:
kwargs = {k: getattr(node.op, k) for k in node.op.__props__}
# TODO: We could try to make each input inplace individually.
# What we do now is just to try to make all inplace.
kwargs["in_info"] = [dict(info) for info in node.op.in_info]
any_inplace = False
for info in kwargs["in_info"]:
if info.get("want_inplace", -1) >= 0:
any_inplace = True
info["is_inplace"] = True
if not any_inplace:
return False
new_op = node.op.__class__(**kwargs)
from TheanoUtil import make_var_tuple
new_v = make_var_tuple(new_op(*node.inputs))
return new_v
return False
def grad(self, inputs, output_grads):
if not self.c_bw_code:
# Unknown how to calculate gradient.
return [T.DisconnectedType()() for inp in inputs]
assert len(self.in_info) == len(inputs)
assert len(self.out_info) == len(output_grads)
# Some of output_grads might be of disconnected type.
out_shapes = self.infer_shape(None, [v.shape for v in inputs])
assert len(out_shapes) == len(output_grads)
for i, out_grad in enumerate(output_grads):
if isinstance(out_grad.type, T.DisconnectedType):
output_grads[i] = T.zeros(out_shapes[i], dtype="float32")
# Inputs: inputs + outputs + output_grads, where outputs = op(inputs),
# i.e. we might reuse some of the calculation.
grad_inputs = inputs + list(make_var_tuple(self(*inputs))) + output_grads
grad_inputs = self._filter_grad_inputs(grad_inputs)
in_info = list(self.in_info)
in_info += [self._bw_in_var_info(info) for info in self.out_info]
in_info += [self._bw_grad_var_info(info) for info in self.out_info]
in_info = self._filter_grad_inputs(in_info)
assert len(in_info) == len(grad_inputs)
in_idx_rev = {v: k for (k, v) in enumerate(self.grad_input_map)}
# Outputs: All like original inputs. Filter our the disconnected.
out_info = [info.copy() for info in self.in_info]
for idx, info in enumerate(out_info):
info.pop("shape")
if "bw_out_var" in info:
info.update(info["bw_out_var"])
if "shape" not in info:
# Refer to input shapes. See infer_shape().
info["shape"] = [(in_idx_rev[idx], i) for i in range(info["ndim"])]
out_info = [info for info in out_info if info.get("gradient", "") != "disconnected"]
grad_op = self.__class__(
name="grad-of-%s" % self.name,
in_info=in_info,
out_info=out_info,
c_fw_code=self.c_bw_code,
c_extra_support_code=self.c_extra_support_code,
code_version=self.code_version
)
input_grads = make_var_tuple(grad_op(*grad_inputs))
if grad_op.num_dummy_outs > 0:
input_grads = input_grads[:-grad_op.num_dummy_outs] # remove any dummy outputs
assert len(out_info) == len(input_grads)
def print_fn(op, x):
import numpy
first = x[(0,) * x.ndim]
stats = (first, x.shape, numpy.min(x), numpy.max(x), numpy.mean(x), numpy.std(x),
numpy.isinf(x).any(), numpy.isnan(x).any())
print(op.message, "first/shape/min/max/mean/std/any-inf/any-nan:", stats)
#input_grads = [theano.printing.Print("in grad %i" % i, global_fn=print_fn)(v)
# for (i, v) in enumerate(input_grads)]
results = []
for info in self.in_info:
if info.get("gradient", "") == "disconnected":
results += [T.DisconnectedType()()]
else:
results += input_grads[:1]
input_grads = input_grads[1:]
assert len(input_grads) == 0
assert len(results) == len(self.in_info)
return results
