def forward(self, inputs, device): h, ws, bs, xs = self.process_inputs(inputs) if h.array.dtype == numpy.float64: with chainer.using_config('use_cudnn', 'never'): out = F.n_step_gru(self.n_layers, 0.0, h, ws, bs, xs) else: out = F.n_step_gru(self.n_layers, 0.0, h, ws, bs, xs) rets = [] rets.append(out[0]) for i in range(len(out[1])): rets.append(out[1][i]) return tuple(rets)
def check_forward(self, h_data, xs_data, ws_data, bs_data): h = _wrap_variable(h_data) xs = _wrap_variable(xs_data) ws = _wrap_variable(ws_data) bs = _wrap_variable(bs_data) hy, ys = functions.n_step_gru( self.n_layers, self.dropout, h, ws, bs, xs) e_hy = self.hx.copy() for ind in range(self.length): x = self.xs[ind] batch = x.shape[0] for layer in range(self.n_layers): w = self.ws[layer] b = self.bs[layer] h_prev = e_hy[layer, :batch] # GRU z = sigmoid(x.dot(w[1].T) + h_prev.dot(w[4].T) + b[1] + b[4]) r = sigmoid(x.dot(w[0].T) + h_prev.dot(w[3].T) + b[0] + b[3]) h_bar = numpy.tanh(x.dot(w[2].T) + r * ((h_prev).dot(w[5].T) + b[5]) + b[2]) e_h = (1 - z) * h_bar + z * h_prev e_hy[layer, :batch] = e_h x = e_h testing.assert_allclose( ys[ind].data, x, rtol=1e-4, atol=1e-4) testing.assert_allclose(hy.data, e_hy, rtol=1e-4, atol=1e-4)
def __call__(self, hx, ws1, ws2, ws3, bs, xs): ws = [F.separate(ws1) + F.separate(ws2)] if n_layers > 1: ws.extend([F.separate(w) for w in F.separate(ws3)]) bs = [F.separate(b) for b in F.separate(bs)] xs = F.separate(xs) hy, ys = F.n_step_gru(n_layers, dropout_ratio, hx, ws, bs, xs) return hy, F.stack(ys, axis=0)
def call_forward(self, train): hx = _wrap_variable(_to_gpu(self.hx)) xs = _wrap_variable(_to_gpu(self.xs)) ws = _wrap_variable(_to_gpu(self.ws)) bs = _wrap_variable(_to_gpu(self.bs)) with chainer.using_config('enable_backprop', train), \ chainer.using_config('train', train): return functions.n_step_gru( self.n_layers, self.dropout, hx, ws, bs, xs)
def forward(self, train): with chainer.using_config('use_cudnn', self.use_cudnn), \ chainer.using_config('enable_backprop', train), \ chainer.using_config('train', train): h = chainer.Variable(self.hx) xs = [chainer.Variable(x) for x in self.xs] ws = [[chainer.Variable(w) for w in ws] for ws in self.ws] bs = [[chainer.Variable(b) for b in bs] for bs in self.bs] return functions.n_step_gru(self.n_layers, self.dropout, h, ws, bs, xs)
def forward(self, train): with chainer.using_config('use_cudnn', self.use_cudnn), \ chainer.using_config('enable_backprop', train), \ chainer.using_config('train', train): h = chainer.Variable(self.hx) xs = [chainer.Variable(x) for x in self.xs] ws = [[chainer.Variable(w) for w in ws] for ws in self.ws] bs = [[chainer.Variable(b) for b in bs] for bs in self.bs] return functions.n_step_gru( self.n_layers, self.dropout, h, ws, bs, xs)
def f(*inputs): (hx, ), inputs = _split(inputs, 1) ws = [] for i in range(self.n_layers): weights, inputs = _split(inputs, 6) ws.append(weights) bs = [] for i in range(self.n_layers): biases, inputs = _split(inputs, 6) bs.append(biases) xs = inputs hy, ys = functions.n_step_gru( self.n_layers, self.dropout, hx, ws, bs, xs) return (hy, ) + ys
def f(*inputs): (hx, ), inputs = _split(inputs, 1) ws = [] for i in range(self.n_layers): weights, inputs = _split(inputs, 6) ws.append(weights) bs = [] for i in range(self.n_layers): biases, inputs = _split(inputs, 6) bs.append(biases) xs = inputs hy, ys = functions.n_step_gru(self.n_layers, self.dropout, hx, ws, bs, xs) return (hy, ) + ys
def forward(self, train): volatile = not train h = chainer.Variable(self.hx, volatile=volatile) xs = [chainer.Variable(x, volatile=volatile) for x in self.xs] ws = [[chainer.Variable(w, volatile=volatile) for w in ws] for ws in self.ws] bs = [[chainer.Variable(b, volatile=volatile) for b in bs] for bs in self.bs] return functions.n_step_gru(self.n_layers, self.dropout, h, ws, bs, xs, train=train, use_cudnn=self.use_cudnn)
def check_forward(self, h_data, xs_data, ws_data, bs_data, volatile): h = chainer.Variable(h_data, volatile=volatile) xs = [chainer.Variable(x, volatile=volatile) for x in xs_data] ws = [[chainer.Variable(w, volatile=volatile) for w in ws] for ws in ws_data] bs = [[chainer.Variable(b, volatile=volatile) for b in bs] for bs in bs_data] hy, ys = functions.n_step_gru(self.n_layers, self.dropout, h, ws, bs, xs, use_cudnn=self.use_cudnn) e_hy = self.hx.copy() for ind in range(self.length): x = self.xs[ind] batch = x.shape[0] for layer in range(self.n_layers): w = self.ws[layer] b = self.bs[layer] h_prev = e_hy[layer, :batch] # GRU z = sigmoid(x.dot(w[1].T) + h_prev.dot(w[4].T) + b[1] + b[4]) r = sigmoid(x.dot(w[0].T) + h_prev.dot(w[3].T) + b[0] + b[3]) h_bar = numpy.tanh( x.dot(w[2].T) + r * ((h_prev).dot(w[5].T) + b[5]) + b[2]) e_h = (1 - z) * h_bar + z * h_prev e_hy[layer, :batch] = e_h x = e_h testing.assert_allclose(ys[ind].data, x, rtol=1e-4, atol=1e-4) testing.assert_allclose(hy.data, e_hy, rtol=1e-4, atol=1e-4)