def check_inconsistent_input_size(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) with self.assertRaises(ValueError): functions.n_step_birnn( self.n_layers, self.dropout, h, ws, bs, xs, activation=self.activation)
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_birnn( self.n_layers, self.dropout, h, ws, bs, xs, activation=self.activation) xs_next = self.xs e_hy = self.hx.copy() for layer in range(self.n_layers): # forward di = 0 xf = [] layer_idx = layer * 2 + di w = self.ws[layer_idx] b = self.bs[layer_idx] for ind in range(self.length): x = xs_next[ind] batch = x.shape[0] h_prev = e_hy[layer_idx, :batch] if self.activation == 'tanh': e_h = numpy.tanh(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) elif self.activation == 'relu': e_h = _relu(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) e_hy[layer_idx, :batch] = e_h xf.append(e_h) # backward di = 1 xb = [] layer_idx = layer * 2 + di w = self.ws[layer_idx] b = self.bs[layer_idx] for ind in reversed(range(self.length)): x = xs_next[ind] batch = x.shape[0] h_prev = e_hy[layer_idx, :batch] if self.activation == 'tanh': e_h = numpy.tanh(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) elif self.activation == 'relu': e_h = _relu(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) e_hy[layer_idx, :batch] = e_h xb.append(e_h) xb.reverse() xs_next = [numpy.concatenate([hfi, hbi], axis=1) for (hfi, hbi) in zip(xf, xb)] for k, (ysi, xsi) in enumerate(zip(ys, xs_next)): testing.assert_allclose(ysi.data, xsi, rtol=1e-4, atol=1e-4) testing.assert_allclose(hy.data, e_hy, rtol=1e-4, atol=1e-4)
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_birnn( self.n_layers, self.dropout, h, ws, bs, xs, activation=self.activation) xs_next = self.xs e_hy = self.hx.copy() for layer in range(self.n_layers): # forward di = 0 xf = [] layer_idx = layer * 2 + di w = self.ws[layer_idx] b = self.bs[layer_idx] for ind in range(self.length): x = xs_next[ind] batch = x.shape[0] h_prev = e_hy[layer_idx, :batch] if self.activation == 'tanh': e_h = numpy.tanh(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) elif self.activation == 'relu': e_h = _relu(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) e_hy[layer_idx, :batch] = e_h xf.append(e_h) # backward di = 1 xb = [] layer_idx = layer * 2 + di w = self.ws[layer_idx] b = self.bs[layer_idx] for ind in reversed(range(self.length)): x = xs_next[ind] batch = x.shape[0] h_prev = e_hy[layer_idx, :batch] if self.activation == 'tanh': e_h = numpy.tanh(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) elif self.activation == 'relu': e_h = _relu(x.dot(w[0].T) + h_prev.dot(w[1].T) + b[0] + b[1]) e_hy[layer_idx, :batch] = e_h xb.append(e_h) xb.reverse() xs_next = [numpy.concatenate([hfi, hbi], axis=1) for (hfi, hbi) in zip(xf, xb)] for k, (ysi, xsi) in enumerate(zip(ys, xs_next)): testing.assert_allclose(ysi.data, xsi, rtol=1e-4, atol=1e-4) testing.assert_allclose(hy.data, e_hy, rtol=1e-4, atol=1e-4)
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_birnn( self.n_layers, self.dropout, hx, ws, bs, xs)
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_birnn(self.n_layers, self.dropout, hx, ws, bs, xs)
def forward(self, inputs, device): h, ws, bs, xs = self.process_inputs(inputs) out = F.n_step_birnn(self.n_layers, 0.0, h, ws, bs, xs, self.activation) rets = [] rets.append(out[0]) for i in range(len(out[1])): rets.append(out[1][i]) return tuple(rets)
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_birnn(self.n_layers, self.dropout, h, ws, bs, xs)
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_birnn( self.n_layers, self.dropout, h, ws, bs, xs, train=train, use_cudnn=self.use_cudnn)
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_birnn( 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 * 2): weights, inputs = _split(inputs, 2) ws.append(weights) bs = [] for i in range(self.n_layers * 2): biases, inputs = _split(inputs, 2) bs.append(biases) xs = inputs hy, ys = functions.n_step_birnn( self.n_layers, self.dropout, hx, ws, bs, xs, activation=self.activation) return (hy, ) + ys
def f(*inputs): (hx, ), inputs = _split(inputs, 1) ws = [] for i in range(self.n_layers * 2): weights, inputs = _split(inputs, 2) ws.append(weights) bs = [] for i in range(self.n_layers * 2): biases, inputs = _split(inputs, 2) bs.append(biases) xs = inputs hy, ys = functions.n_step_birnn( self.n_layers, self.dropout, hx, ws, bs, xs, activation=self.activation) 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_birnn(self.n_layers, self.dropout, h, ws, bs, xs, train=train, use_cudnn=self.use_cudnn)