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)
