Exemplo n.º 1
0
    def feedforward(self, s_inst, s_trans):

        y_r = act.sigmoid(s_inst, self.V_r)

        g = act.hard_sigmoid(s_inst, self.W_g, self.g_strength)
        f = act.hard_sigmoid(s_inst, self.W_f, self.f_strength)

        y_m, self.cumulative_memory = act.sigmoid_gated(
            s_trans, self.V_m, self.cumulative_memory, f, g)

        Q = act.linear(y_r, self.W_r) + act.linear(y_m, self.W_m)

        return y_r, y_m, g, f, Q
	def feedforward(self,s_inst,s_trans):

		g_strength = 3
		f_strength = 3

		y_r = act.sigmoid(s_inst, self.V_r)
		g = act.softmax(s_inst,self.W_g, g_strength)
		g = np.transpose(g)
		f = act.hard_sigmoid(s_inst,self.W_f, f_strength)
		f = np.transpose(f)
Exemplo n.º 3
0
    def feedforward(self, s_inst, s_trans):

        g = act.hard_sigmoid(s_inst, self.W_g, self.g_strength)
        g = np.transpose(g)
        #g = np.ones((self.L,1))

        y_m = 1e-6 * np.ones((self.L, 1, self.M))
        inp_r = 1e-6 * np.ones((self.L, 1, self.R))
        for l in np.arange(self.L):
            y_m[l, :, :], self.memory_content[l, :, :] = act.sigmoid_acc_leaky(
                s_trans, self.V_m[l, :, :], self.memory_leak, g[l, 0])
            inp_r[l, :, :] = act.linear(y_m[l, :, :], self.W_m[l, :, :])
            #print('\t MEM STATE ',str(l),':', y_m[l,:,:],'\t alpha=',self.ALPHA[l,0,0],'\t gate=',g[l,:])

        inp_r = np.sum(inp_r, axis=0)
        inp_r += act.linear(s_inst, self.V_r)
        y_r = act.sigmoidal(inp_r)
        #print(y_r)

        Q = act.linear(y_r, self.W_r)

        return y_r, y_m, g, Q
Exemplo n.º 4
0
    def feedforward(self, s_inst, s_trans):

        g_strength = 4

        y_r = act.sigmoid(s_inst, self.V_r)
        g = act.hard_sigmoid(s_inst, self.W_g, g_strength)
        g = np.transpose(g)

        y_m = 1e-6 * np.ones((self.L, 1, self.M))
        Q = act.linear(y_r, self.W_r)
        for l in np.arange(self.L):
            y_m[l, :, :], self.cumulative_memory[
                l, :, :] = act.sigmoid_acc_leaky(
                    s_trans, self.V_m[l, :, :],
                    self.cumulative_memory[l, :, :], self.LEAK[l, 0, 0], g[l,
                                                                           0])
            Q += act.linear(y_m[l, :, :], self.W_m[l, :, :])
            print('\t MEM STATE ', str(l), ':', y_m[l, :, :], '\t gate=',
                  g[l, :], '\t alpha=', self.ALPHA[l, 0, 0], '\t leak=',
                  self.LEAK[l, 0, 0])

        return y_r, y_m, g, Q