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 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