예제 #1
0
    def step(self, x, states):
        h_s = states[2]        
        P_j = states[3] 
        
        P_t = K.dot(x, self.W_t)
        P_a = K.dot(states[0], self.W_a)
        sum3 = P_j + P_t.dimshuffle((0,'x',1)) + P_a.dimshuffle((0,'x',1))
        E_kj = K.tanh(sum3).dot(self.w_e)
        Alpha_kj = K.softmax(E_kj)
        weighted = h_s * Alpha_kj.dimshuffle((0,1,'x'))
        a_k = weighted.sum(axis = 1)
        m_k = K.T.concatenate([a_k, x], axis = 1)
        
        x_i = K.dot(m_k, self.W_i) + self.b_i
        x_f = K.dot(m_k, self.W_f) + self.b_f
        x_c = K.dot(m_k, self.W_c) + self.b_c
        x_o = K.dot(m_k, self.W_o) + self.b_o

        i = self.inner_activation(x_i + K.dot(states[0], self.U_i))
        f = self.inner_activation(x_f + K.dot(states[0], self.U_f))
        c = f * states[1] + i * self.activation(x_c + K.dot(states[0], self.U_c))
        o = self.inner_activation(x_o + K.dot(states[0], self.U_o))
        h = o * self.activation(c)
        
        return h, [h, c]
예제 #2
0
    def step(self, x, states):
        h_s = states[2]
        P_j = states[3]

        P_t = K.dot(x, self.W_t)
        P_a = K.dot(states[0], self.W_a)
        sum3 = P_j + P_t.dimshuffle((0, 'x', 1)) + P_a.dimshuffle((0, 'x', 1))
        E_kj = K.tanh(sum3).dot(self.w_e)
        Alpha_kj = K.softmax(E_kj)
        weighted = h_s * Alpha_kj.dimshuffle((0, 1, 'x'))
        a_k = weighted.sum(axis=1)
        m_k = K.T.concatenate([a_k, x], axis=1)

        x_i = K.dot(m_k, self.W_i) + self.b_i
        x_f = K.dot(m_k, self.W_f) + self.b_f
        x_c = K.dot(m_k, self.W_c) + self.b_c
        x_o = K.dot(m_k, self.W_o) + self.b_o

        i = self.inner_activation(x_i + K.dot(states[0], self.U_i))
        f = self.inner_activation(x_f + K.dot(states[0], self.U_f))
        c = f * states[1] + i * self.activation(x_c +
                                                K.dot(states[0], self.U_c))
        o = self.inner_activation(x_o + K.dot(states[0], self.U_o))
        h = o * self.activation(c)

        return h, [h, c]
예제 #3
0
    def get_output(self, train=False):
        # input shape: (nb_samples, time (padded with zeros), input_dim)
        X = self.get_input(train)
        self.h_t = X[1]
        
        self.h_s = X[0]
        if self.feed_state:        
            self.h_init = X[2]

        self.P_j = K.dot(self.h_s, self.W_s)
        
        if self.stateful and not train:
            initial_states = self.states
        else:
            initial_states = self.get_initial_states(self.h_s)
            if self.feed_state:
                initial_states[0] =  self.h_init

        last_output, outputs, states = K.rnn(self.step, self.h_t, initial_states)
        
        if self.stateful:
            self.updates = []
            for i in range(len(states)):
                self.updates.append((self.states[i], states[i]))

        if self.return_sequences:
            return outputs
        else:
            return last_output
예제 #4
0
 def get_initial_states(self, X):
     # build an all-zero tensor of shape (samples, output_dim)
     initial_state = K.zeros_like(X)  # (samples, timesteps, input_dim)
     initial_state = K.sum(initial_state, axis=1)  # (samples, input_dim)
     reducer = K.zeros((self.output_dim, self.output_dim))
     initial_state = K.dot(initial_state, reducer)  # (samples, output_dim)
     initial_states = [initial_state for _ in range(len(self.states))]
     return initial_states
예제 #5
0
 def get_initial_states(self, x):
     # build an all-zero tensor of shape (samples, output_dim)
     initial_state = K.zeros_like(x)  # (samples, timesteps, input_dim)
     initial_state = K.sum(initial_state, axis=1)  # (samples, input_dim)
     reducer = K.zeros((self.input_dim, self.output_dim))
     initial_state = K.dot(initial_state, reducer)  # (samples, output_dim)
     initial_states = [initial_state for _ in range(len(self.states))]
     if self.feed_layer is not None:
         initial_states[1] =  self.feed_layer
     return initial_states
예제 #6
0
 def get_initial_states(self, x):
     # build an all-zero tensor of shape (samples, output_dim)
     initial_state = K.zeros_like(x)  # (samples, timesteps, input_dim)
     initial_state = K.sum(initial_state, axis=1)  # (samples, input_dim)
     reducer = K.zeros((self.input_dim, self.output_dim))
     initial_state = K.dot(initial_state, reducer)  # (samples, output_dim)
     initial_states = [initial_state for _ in range(len(self.states))]
     if self.feed_layer is not None:
         initial_states[1] = self.feed_layer
     return initial_states
예제 #7
0
 def get_constants(self, x):
     return [x[1], K.dot(x[1], self.W_s)]
예제 #8
0
 def get_constants(self, x):
     return [x[1], K.dot(x[1], self.W_s)]