def check_inconsistent_input_size( self, h_data, c_data, xs_data, ws_data, bs_data): h = _wrap_variable(h_data) c = _wrap_variable(c_data) xs = _wrap_variable(xs_data) ws = _wrap_variable(ws_data) bs = _wrap_variable(bs_data) with self.assertRaises(ValueError): functions.n_step_bilstm( self.n_layers, self.dropout, h, c, ws, bs, xs)
def check_inconsistent_input_size(self, h_data, c_data, xs_data, ws_data, bs_data): h = _wrap_variable(h_data) c = _wrap_variable(c_data) xs = _wrap_variable(xs_data) ws = _wrap_variable(ws_data) bs = _wrap_variable(bs_data) with self.assertRaises(ValueError): functions.n_step_bilstm(self.n_layers, self.dropout, h, c, ws, bs, xs)
def forward(self, inputs, device): h, c, ws, bs, xs = self.process_inputs(inputs) if h.array.dtype == numpy.float64: with chainer.using_config('use_cudnn', 'never'): out = F.n_step_bilstm(self.n_layers, 0.0, h, c, ws, bs, xs) else: out = F.n_step_bilstm(self.n_layers, 0.0, h, c, ws, bs, xs) rets = [] rets.append(out[0]) rets.append(out[1]) for i in range(len(out[2])): rets.append(out[2][i]) return tuple(rets)
def call_forward(self, train): hx = _wrap_variable(_to_gpu(self.hx)) cx = _wrap_variable(_to_gpu(self.cx)) 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_bilstm( self.n_layers, self.dropout, hx, cx, 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) c = chainer.Variable(self.cx) 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_bilstm(self.n_layers, self.dropout, h, c, ws, bs, xs)
def forward(self, train): volatile = not train h = chainer.Variable(self.hx, volatile=volatile) c = chainer.Variable(self.cx, 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_bilstm( self.n_layers, self.dropout, h, c, 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) c = chainer.Variable(self.cx) 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_bilstm( self.n_layers, self.dropout, h, c, ws, bs, xs)
def f(*inputs): (hx, cx), inputs = _split(inputs, 2) ws = [] for i in range(self.n_layers * 2): weights, inputs = _split(inputs, 8) ws.append(weights) bs = [] for i in range(self.n_layers * 2): biases, inputs = _split(inputs, 8) bs.append(biases) xs = inputs hy, cy, ys = functions.n_step_bilstm(self.n_layers, self.dropout, hx, cx, ws, bs, xs) return (hy, cy) + ys
def f(*inputs): (hx, cx), inputs = _split(inputs, 2) ws = [] for i in range(self.n_layers * 2): weights, inputs = _split(inputs, 8) ws.append(weights) bs = [] for i in range(self.n_layers * 2): biases, inputs = _split(inputs, 8) bs.append(biases) xs = inputs hy, cy, ys = functions.n_step_bilstm( self.n_layers, self.dropout, hx, cx, ws, bs, xs) return (hy, cy) + ys
def forward(self, train): volatile = not train h = chainer.Variable(self.hx, volatile=volatile) c = chainer.Variable(self.cx, 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_bilstm(self.n_layers, self.dropout, h, c, ws, bs, xs, train=train, use_cudnn=self.use_cudnn)
def check_forward(self, h_data, c_data, xs_data, ws_data, bs_data): h = chainer.Variable(h_data) c = chainer.Variable(c_data) xs = [chainer.Variable(x) for x in xs_data] ws = [[chainer.Variable(w) for w in ws] for ws in ws_data] bs = [[chainer.Variable(b) for b in bs] for bs in bs_data] hy, cy, ys = functions.n_step_bilstm(self.n_layers, self.dropout, h, c, ws, bs, xs) xs_next = self.xs e_hy = self.hx.copy() e_cy = self.cx.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] c_prev = e_cy[layer_idx, :batch] i = sigmoid(x.dot(w[0].T) + h_prev.dot(w[4].T) + b[0] + b[4]) f = sigmoid(x.dot(w[1].T) + h_prev.dot(w[5].T) + b[1] + b[5]) c_bar = numpy.tanh( x.dot(w[2].T) + h_prev.dot(w[6].T) + b[2] + b[6]) o = sigmoid(x.dot(w[3].T) + h_prev.dot(w[7].T) + b[3] + b[7]) e_c = (f * c_prev + i * c_bar) e_h = o * numpy.tanh(e_c) e_hy[layer_idx, :batch] = e_h e_cy[layer_idx, :batch] = e_c 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] c_prev = e_cy[layer_idx, :batch] i = sigmoid(x.dot(w[0].T) + h_prev.dot(w[4].T) + b[0] + b[4]) f = sigmoid(x.dot(w[1].T) + h_prev.dot(w[5].T) + b[1] + b[5]) c_bar = numpy.tanh( x.dot(w[2].T) + h_prev.dot(w[6].T) + b[2] + b[6]) o = sigmoid(x.dot(w[3].T) + h_prev.dot(w[7].T) + b[3] + b[7]) e_c = (f * c_prev + i * c_bar) e_h = o * numpy.tanh(e_c) e_hy[layer_idx, :batch] = e_h e_cy[layer_idx, :batch] = e_c 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) testing.assert_allclose(cy.data, e_cy, rtol=1e-4, atol=1e-4)
def check_forward( self, h_data, c_data, xs_data, ws_data, bs_data, volatile): h = chainer.Variable(h_data, volatile=volatile) c = chainer.Variable(c_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, cy, ys = functions.n_step_bilstm( self.n_layers, self.dropout, h, c, ws, bs, xs, use_cudnn=self.use_cudnn) xs_next = self.xs e_hy = self.hx.copy() e_cy = self.cx.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] c_prev = e_cy[layer_idx, :batch] i = sigmoid(x.dot(w[0].T) + h_prev.dot(w[4].T) + b[0] + b[4]) f = sigmoid(x.dot(w[1].T) + h_prev.dot(w[5].T) + b[1] + b[5]) c_bar = numpy.tanh( x.dot(w[2].T) + h_prev.dot(w[6].T) + b[2] + b[6]) o = sigmoid(x.dot(w[3].T) + h_prev.dot(w[7].T) + b[3] + b[7]) e_c = (f * c_prev + i * c_bar) e_h = o * numpy.tanh(e_c) e_hy[layer_idx, :batch] = e_h e_cy[layer_idx, :batch] = e_c 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] c_prev = e_cy[layer_idx, :batch] i = sigmoid(x.dot(w[0].T) + h_prev.dot(w[4].T) + b[0] + b[4]) f = sigmoid(x.dot(w[1].T) + h_prev.dot(w[5].T) + b[1] + b[5]) c_bar = numpy.tanh( x.dot(w[2].T) + h_prev.dot(w[6].T) + b[2] + b[6]) o = sigmoid(x.dot(w[3].T) + h_prev.dot(w[7].T) + b[3] + b[7]) e_c = (f * c_prev + i * c_bar) e_h = o * numpy.tanh(e_c) e_hy[layer_idx, :batch] = e_h e_cy[layer_idx, :batch] = e_c 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) testing.assert_allclose(cy.data, e_cy, rtol=1e-4, atol=1e-4)