def __call__(self, hx, cx, xs): """Calculate all hidden states and cell states. Args: hx (~chainer.Variable): Initial hidden states. cx (~chainer.Variable): Initial cell states. xs (list of ~chianer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ assert isinstance(xs, (list, tuple)) indices = argsort_list_descent(xs) xs = permutate_list(xs, indices, inv=False) hx = permutate.permutate(hx, indices, axis=1, inv=False) cx = permutate.permutate(cx, indices, axis=1, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1, w.w2, w.w3, w.w4, w.w5, w.w6, w.w7] for w in self] bs = [[w.b0, w.b1, w.b2, w.b3, w.b4, w.b5, w.b6, w.b7] for w in self] hy, cy, trans_y = rnn.n_step_lstm( self.n_layers, self.dropout, hx, cx, ws, bs, trans_x, use_cudnn=self.use_cudnn) hy = permutate.permutate(hy, indices, axis=1, inv=True) cy = permutate.permutate(cy, indices, axis=1, inv=True) ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hy, cy, ys
def _call(self, hs, xs, **kwargs): if kwargs: argument.check_unexpected_kwargs( kwargs, train="train argument is not supported anymore. " "Use chainer.using_config", ) argument.assert_kwargs_empty(kwargs) assert isinstance(xs, (list, tuple)) indices = argsort_list_descent(xs) assert self.ws[0][0].shape[1] == xs[0].shape[1] # input check xs = permutate_list(xs, indices, inv=False) hxs = [] for hx in hs: if hx is None: hx = self.init_hx(xs) else: hx = permutate.permutate(hx, indices, axis=1, inv=False) hxs.append(hx) trans_x = transpose_sequence.transpose_sequence(xs) args = [self.n_layers, self.dropout] + hxs + [self.ws, self.bs, trans_x] result = self.rnn(*args) hys = [permutate.permutate(h, indices, axis=1, inv=True) for h in result[:-1]] trans_y = result[-1] ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hys, ys
def __call__(self, hx, cx, xs, train=True): """Calculate all hidden states and cell states. Args: hx (~chainer.Variable): Initial hidden states. cx (~chainer.Variable): Initial cell states. xs (list of ~chianer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ assert isinstance(xs, (list, tuple)) indices = argsort_list_descent(xs) xs = permutate_list(xs, indices, inv=False) hx = permutate.permutate(hx, indices, axis=1, inv=False) cx = permutate.permutate(cx, indices, axis=1, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1, w.w2, w.w3, w.w4, w.w5, w.w6, w.w7] for w in self] bs = [[w.b0, w.b1, w.b2, w.b3, w.b4, w.b5, w.b6, w.b7] for w in self] hy, cy, trans_y = rnn.n_step_lstm( self.n_layers, self.dropout, hx, cx, ws, bs, trans_x, train=train, use_cudnn=self.use_cudnn) hy = permutate.permutate(hy, indices, axis=1, inv=True) cy = permutate.permutate(cy, indices, axis=1, inv=True) ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hy, cy, ys
def __call__(self, hx, xs, train=True): """Calculate all hidden states and cell states. Args: hx (~chainer.Variable or None): Initial hidden states. If ``None`` is specified zero-vector is used. xs (list of ~chianer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ assert isinstance(xs, (list, tuple)) indices = argsort_list_descent(xs) xs = permutate_list(xs, indices, inv=False) if hx is None: hx = self.init_hx(xs) else: hx = permutate.permutate(hx, indices, axis=1, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1] for w in self] bs = [[w.b0, w.b1] for w in self] hy, trans_y = self.rnn( self.n_layers, self.dropout, hx, ws, bs, trans_x, train=train, use_cudnn=self.use_cudnn, activation=self.activation) hy = permutate.permutate(hy, indices, axis=1, inv=True) ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hy, ys
def __call__(self, hx, cx, xs, **kwargs): """__call__(self, hx, cx, xs) Calculate all hidden states and cell states. .. warning:: ``train`` argument is not supported anymore since v2. Instead, use ``chainer.using_config('train', train)``. See :func:`chainer.using_config`. Args: hx (~chainer.Variable or None): Initial hidden states. If ``None`` is specified zero-vector is used. cx (~chainer.Variable or None): Initial cell states. If ``None`` is specified zero-vector is used. xs (list of ~chainer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ argument.check_unexpected_kwargs( kwargs, train='train argument is not supported anymore. ' 'Use chainer.using_config') argument.assert_kwargs_empty(kwargs) assert isinstance(xs, (list, tuple)) xp = cuda.get_array_module(hx, *xs) indices = n_step_rnn.argsort_list_descent(xs) indices_array = xp.array(indices) xs = n_step_rnn.permutate_list(xs, indices, inv=False) if hx is None: hx = self.init_hx(xs) else: hx = permutate.permutate(hx, indices_array, axis=1, inv=False) if cx is None: cx = self.init_hx(xs) else: cx = permutate.permutate(cx, indices_array, axis=1, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1, w.w2, w.w3, w.w4, w.w5, w.w6, w.w7] for w in self] bs = [[w.b0, w.b1, w.b2, w.b3, w.b4, w.b5, w.b6, w.b7] for w in self] hy, cy, trans_y = self.rnn(self.n_layers, self.dropout, hx, cx, ws, bs, trans_x) hy = permutate.permutate(hy, indices_array, axis=1, inv=True) cy = permutate.permutate(cy, indices_array, axis=1, inv=True) ys = transpose_sequence.transpose_sequence(trans_y) ys = n_step_rnn.permutate_list(ys, indices, inv=True) return hy, cy, ys
def __call__(self, hx, cx, xs, train=True): """Calculate all hidden states and cell states. Args: hx (~chainer.Variable or None): Initial hidden states. If ``None`` is specified zero-vector is used. cx (~chainer.Variable or None): Initial cell states. If ``None`` is specified zero-vector is used. xs (list of ~chianer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ assert isinstance(xs, (list, tuple)) indices = argsort_list_descent(xs) xs = permutate_list(xs, indices, inv=False) if hx is None: with cuda.get_device(self._device_id): hx = chainer.Variable(self.xp.zeros( (self.n_layers, len(xs), self.out_size), dtype=xs[0].dtype), volatile='auto') else: hx = permutate.permutate(hx, indices, axis=1, inv=False) if cx is None: with cuda.get_device(self._device_id): cx = chainer.Variable(self.xp.zeros( (self.n_layers, len(xs), self.out_size), dtype=xs[0].dtype), volatile='auto') else: cx = permutate.permutate(cx, indices, axis=1, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1, w.w2, w.w3, w.w4, w.w5, w.w6, w.w7] for w in self] bs = [[w.b0, w.b1, w.b2, w.b3, w.b4, w.b5, w.b6, w.b7] for w in self] hy, cy, trans_y = rnn.n_step_lstm(self.n_layers, self.dropout, hx, cx, ws, bs, trans_x, train=train, use_cudnn=self.use_cudnn) hy = permutate.permutate(hy, indices, axis=1, inv=True) cy = permutate.permutate(cy, indices, axis=1, inv=True) ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hy, cy, ys
def __call__(self, hx, cx, xs, **kwargs): """__call__(self, hx, cx, xs) Calculate all hidden states and cell states. .. warning:: ``train`` argument is not supported anymore since v2. Instead, use ``chainer.using_config('train', train)``. See :func:`chainer.using_config`. Args: hx (~chainer.Variable or None): Initial hidden states. If ``None`` is specified zero-vector is used. cx (~chainer.Variable or None): Initial cell states. If ``None`` is specified zero-vector is used. xs (list of ~chianer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ argument.check_unexpected_kwargs( kwargs, train='train argument is not supported anymore. ' 'Use chainer.using_config') argument.assert_kwargs_empty(kwargs) assert isinstance(xs, (list, tuple)) indices = n_step_rnn.argsort_list_descent(xs) xs = n_step_rnn.permutate_list(xs, indices, inv=False) if hx is None: hx = self.init_hx(xs) else: hx = permutate.permutate(hx, indices, axis=1, inv=False) if cx is None: cx = self.init_hx(xs) else: cx = permutate.permutate(cx, indices, axis=1, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1, w.w2, w.w3, w.w4, w.w5, w.w6, w.w7] for w in self] bs = [[w.b0, w.b1, w.b2, w.b3, w.b4, w.b5, w.b6, w.b7] for w in self] hy, cy, trans_y = self.rnn( self.n_layers, self.dropout, hx, cx, ws, bs, trans_x) hy = permutate.permutate(hy, indices, axis=1, inv=True) cy = permutate.permutate(cy, indices, axis=1, inv=True) ys = transpose_sequence.transpose_sequence(trans_y) ys = n_step_rnn.permutate_list(ys, indices, inv=True) return hy, cy, ys
def __call__(self, hx, cx, xs, train=True): """Calculate all hidden states and cell states. Args: hx (~chainer.Variable or None): Initial hidden states. If ``None`` is specified zero-vector is used. cx (~chainer.Variable or None): Initial cell states. If ``None`` is specified zero-vector is used. xs (list of ~chianer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ assert isinstance(xs, (list, tuple)) indices = argsort_list_descent(xs) xs = permutate_list(xs, indices, inv=False) if hx is None: with cuda.get_device(self._device_id): hx = chainer.Variable( self.xp.zeros( (self.n_layers, len(xs), self.out_size), dtype=xs[0].dtype), volatile='auto') else: hx = permutate.permutate(hx, indices, axis=1, inv=False) if cx is None: with cuda.get_device(self._device_id): cx = chainer.Variable( self.xp.zeros( (self.n_layers, len(xs), self.out_size), dtype=xs[0].dtype), volatile='auto') else: cx = permutate.permutate(cx, indices, axis=1, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1, w.w2, w.w3, w.w4, w.w5, w.w6, w.w7] for w in self] bs = [[w.b0, w.b1, w.b2, w.b3, w.b4, w.b5, w.b6, w.b7] for w in self] hy, cy, trans_y = rnn.n_step_lstm( self.n_layers, self.dropout, hx, cx, ws, bs, trans_x, train=train, use_cudnn=self.use_cudnn) hy = permutate.permutate(hy, indices, axis=1, inv=True) cy = permutate.permutate(cy, indices, axis=1, inv=True) ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hy, cy, ys
def _call(self, hs, xs, **kwargs): """Calls RNN function. Args: hs (list of ~chainer.Variable or None): Lisit of hidden states. Its length depends on its implementation. If ``None`` is specified zero-vector is used. xs (list of ~chainer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. Returns: tuple: hs """ if kwargs: argument.check_unexpected_kwargs( kwargs, train='train argument is not supported anymore. ' 'Use chainer.using_config') argument.assert_kwargs_empty(kwargs) assert isinstance(xs, (list, tuple)) xp = cuda.get_array_module(*(list(hs) + list(xs))) indices = argsort_list_descent(xs) indices_array = xp.array(indices) xs = permutate_list(xs, indices, inv=False) hxs = [] for hx in hs: if hx is None: hx = self.init_hx(xs) else: hx = permutate.permutate(hx, indices_array, axis=1, inv=False) hxs.append(hx) trans_x = transpose_sequence.transpose_sequence(xs) args = [self.n_layers, self.dropout] + hxs + \ [self.ws, self.bs, trans_x] result = self.rnn(*args) hys = [ permutate.permutate(h, indices_array, axis=1, inv=True) for h in result[:-1] ] trans_y = result[-1] ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hys, ys
def _call(self, hs, xs, **kwargs): """Calls RNN function. Args: hs (list of ~chainer.Variable or None): Lisit of hidden states. Its length depends on its implementation. If ``None`` is specified zero-vector is used. xs (list of ~chainer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. Returns: tuple: hs """ if kwargs: argument.check_unexpected_kwargs( kwargs, train='train argument is not supported anymore. ' 'Use chainer.using_config') argument.assert_kwargs_empty(kwargs) assert isinstance(xs, (list, tuple)) xp = cuda.get_array_module(*(list(hs) + list(xs))) indices = argsort_list_descent(xs) indices_array = xp.array(indices) xs = permutate_list(xs, indices, inv=False) hxs = [] for hx in hs: if hx is None: hx = self.init_hx(xs) else: hx = permutate.permutate(hx, indices_array, axis=1, inv=False) hxs.append(hx) trans_x = transpose_sequence.transpose_sequence(xs) args = [self.n_layers, self.dropout] + hxs + \ [self.ws, self.bs, trans_x] result = self.rnn(*args) hys = [permutate.permutate(h, indices_array, axis=1, inv=True) for h in result[:-1]] trans_y = result[-1] ys = transpose_sequence.transpose_sequence(trans_y) ys = permutate_list(ys, indices, inv=True) return hys, ys
def __call__(self, h0, hx, xs, **kwargs): """__call__(self, hx, xs) Calculate all hidden states and cell states. .. warning:: ``train`` argument is not supported anymore since v2. Instead, use ``chainer.using_config('train', train)``. See :func:`chainer.using_config`. Args: hx (~chainer.Variable or None): Initial hidden states. If ``None`` is specified zero-vector is used. xs (list of ~chianer.Variable): List of input sequences. Each element ``xs[i]`` is a :class:`chainer.Variable` holding a sequence. """ argument.check_unexpected_kwargs( kwargs, train='train argument is not supported anymore. ' 'Use chainer.using_config') argument.assert_kwargs_empty(kwargs) assert isinstance( xs, (list, tuple)), "xs in not a list or tupple: %r" % type(xs) indices = argsort_list_descent(xs) xs = permutate_list(xs, indices, inv=False) if h0 is None: h0 = self.init_hx(xs) else: h0 = permutate.permutate(h0, indices, axis=1, inv=False) hx = permutate_list(hx, indices, inv=False) trans_x = transpose_sequence.transpose_sequence(xs) ws = [[w.w0, w.w1, w.w2, w.w3, w.w4, w.w5] for w in self] bs = [[w.b0, w.b1, w.b2, w.b3, w.b4, w.b5] for w in self] for w in self: w1 = w.w6 w2 = w.w7 w3 = w.w8 b1 = w.b6 b2 = w.b7 b3 = w.b8 W = [w1, w2, w3] B = [b1, b2, b3] h_list, h_bar_list, c_s_list, z_s_list = self.rnn( self.n_layers, self.dropout, h0, hx, ws, bs, trans_x, W, B) ''' print(type(h_list),len(h_list)) print(type(h_list[0]),len(h_list[0])) print(type(h_list[0][0]),len(h_list[0][0])) ''' #batch内で入れ替え h_list = transpose_sequence.transpose_sequence(h_list) h_list = permutate_list(h_list, indices, inv=True) ''' print(type(h_list),len(h_list)) print(type(h_list[0]),len(h_list[0])) print(type(h_list[0][0]),len(h_list[0][0])) ''' h_bar_list = transpose_sequence.transpose_sequence(h_bar_list) h_bar_list = permutate_list(h_bar_list, indices, inv=True) ''' print(type(c_s_list),len(c_s_list)) print(type(c_s_list[0]),len(c_s_list[0])) print(type(c_s_list[0][0]),len(c_s_list[0][0]), c_s_list[0][0]) print(type(z_s_list), len(z_s_list)) print(type(z_s_list[0]), len(z_s_list[0]), z_s_list[0]) ''' c_s_list = transpose_sequence.transpose_sequence(c_s_list) c_s_list = permutate_list(c_s_list, indices, inv=True) z_s_list = transpose_sequence.transpose_sequence(z_s_list) z_s_list = permutate_list(z_s_list, indices, inv=True) return h_list, h_bar_list, c_s_list, z_s_list