Example #1
0
    def __init__(self, name='PointerNet'):
        super(PointerNet, self).__init__()

        self.dense1_input = Dense(config.encoder_hidden_dim, config.ptrnet_hidden_dim, activation='linear', name='Dense1_input')

        self.dense1_h = Dense(config.decoder_hidden_dim + config.encoder_hidden_dim, config.ptrnet_hidden_dim, activation='linear', name='Dense1_h')

        self.dense2 = Dense(config.ptrnet_hidden_dim, 1, activation='linear', name='Dense2')

        self.params += self.dense1_input.params + self.dense1_h.params + self.dense2.params

        self.set_name(name)
Example #2
0
 def _set_layers(self, n_experts, hidden_dim, output_dim):
     mixture = Dense(input_dim=1,
                     output_dim=n_experts,
                     activation=None,
                     use_bias=False,
                     weight_init='zero',
                     bias_init='zero')
     hidden_layer = Dense(input_dim=hidden_dim,
                          output_dim=hidden_dim,
                          weight_init="identity")
     output_layer = Dense(input_dim=hidden_dim, output_dim=output_dim)
     self.hidden_dim = hidden_dim
     self.layers = [mixture, hidden_layer, output_layer]
Example #3
0
    def __init__(self):
        # self.node_embedding = Embedding(config.node_num, config.node_embed_dim, name='node_embed')

        self.query_embedding = Embedding(config.source_vocab_size, config.word_embed_dim, name='query_embed')

        if config.encoder_lstm == 'bilstm':
            self.query_encoder_lstm = BiLSTM(config.word_embed_dim, config.encoder_hidden_dim / 2, return_sequences=True,
                                             name='query_encoder_lstm')
        else:
            self.query_encoder_lstm = LSTM(config.word_embed_dim, config.encoder_hidden_dim, return_sequences=True,
                                           name='query_encoder_lstm')

        self.decoder_lstm = CondAttLSTM(config.rule_embed_dim + config.node_embed_dim + config.rule_embed_dim,
                                        config.decoder_hidden_dim, config.encoder_hidden_dim, config.attention_hidden_dim,
                                        name='decoder_lstm')

        self.src_ptr_net = PointerNet()

        self.terminal_gen_softmax = Dense(config.decoder_hidden_dim, 2, activation='softmax', name='terminal_gen_softmax')

        self.rule_embedding_W = initializations.get('normal')((config.rule_num, config.rule_embed_dim), name='rule_embedding_W', scale=0.1)
        self.rule_embedding_b = shared_zeros(config.rule_num, name='rule_embedding_b')

        self.node_embedding = initializations.get('normal')((config.node_num, config.node_embed_dim), name='node_embed', scale=0.1)

        self.vocab_embedding_W = initializations.get('normal')((config.target_vocab_size, config.rule_embed_dim), name='vocab_embedding_W', scale=0.1)
        self.vocab_embedding_b = shared_zeros(config.target_vocab_size, name='vocab_embedding_b')

        # decoder_hidden_dim -> action embed
        self.decoder_hidden_state_W_rule = Dense(config.decoder_hidden_dim, config.rule_embed_dim, name='decoder_hidden_state_W_rule')

        # decoder_hidden_dim -> action embed
        self.decoder_hidden_state_W_token= Dense(config.decoder_hidden_dim + config.encoder_hidden_dim, config.rule_embed_dim,
                                                 name='decoder_hidden_state_W_token')

        # self.rule_encoder_lstm.params
        self.params = self.query_embedding.params + self.query_encoder_lstm.params + \
                      self.decoder_lstm.params + self.src_ptr_net.params + self.terminal_gen_softmax.params + \
                      [self.rule_embedding_W, self.rule_embedding_b, self.node_embedding, self.vocab_embedding_W, self.vocab_embedding_b] + \
                      self.decoder_hidden_state_W_rule.params + self.decoder_hidden_state_W_token.params

        self.srng = RandomStreams()
Example #4
0
    def __init__(self):
        # self.node_embedding = Embedding(config.node_num, config.node_embed_dim, name='node_embed')

        self.query_embedding = Embedding(config.source_vocab_size,
                                         config.word_embed_dim,
                                         name='query_embed')

        encoder_dim = config.word_embed_dim
        logging.info("Concatenation type: %s" % config.concat_type)
        logging.info("Include canon_id matrix: %s" % config.include_cid)
        if config.concat_type == 'basic':
            encoder_dim += 2
            if config.include_cid == True:
                encoder_dim += 1
        else:
            # define layers
            self.query_phrase_embedding = Embedding(14,
                                                    8,
                                                    name='query_phrase_embed')
            self.query_pos_embedding = Embedding(44,
                                                 32,
                                                 name='query_pos_embed')
            self.query_canon_embedding = Embedding(
                102, 64, name='query_canon_embedding')
            aug_dim = 8 + 32
            if config.include_cid == True:
                aug_dim += 64
            self.projector = Dense(config.word_embed_dim + aug_dim,
                                   config.word_embed_dim,
                                   activation='linear',
                                   name='concat_projector')

        if config.encoder == 'bilstm':
            self.query_encoder_lstm = BiLSTM(encoder_dim,
                                             config.encoder_hidden_dim / 2,
                                             return_sequences=True,
                                             name='query_encoder_lstm')
        else:
            self.query_encoder_lstm = LSTM(encoder_dim,
                                           config.encoder_hidden_dim,
                                           return_sequences=True,
                                           name='query_encoder_lstm')

        self.decoder_lstm = CondAttLSTM(config.rule_embed_dim +
                                        config.node_embed_dim +
                                        config.rule_embed_dim,
                                        config.decoder_hidden_dim,
                                        config.encoder_hidden_dim,
                                        config.attention_hidden_dim,
                                        name='decoder_lstm')
        self.src_ptr_net = PointerNet()

        self.terminal_gen_softmax = Dense(config.decoder_hidden_dim,
                                          2,
                                          activation='softmax',
                                          name='terminal_gen_softmax')

        self.rule_embedding_W = initializations.get('normal')(
            (config.rule_num, config.rule_embed_dim),
            name='rule_embedding_W',
            scale=0.1)
        self.rule_embedding_b = shared_zeros(config.rule_num,
                                             name='rule_embedding_b')

        self.node_embedding = initializations.get('normal')(
            (config.node_num, config.node_embed_dim),
            name='node_embed',
            scale=0.1)

        self.vocab_embedding_W = initializations.get('normal')(
            (config.target_vocab_size, config.rule_embed_dim),
            name='vocab_embedding_W',
            scale=0.1)
        self.vocab_embedding_b = shared_zeros(config.target_vocab_size,
                                              name='vocab_embedding_b')

        # decoder_hidden_dim -> action embed
        self.decoder_hidden_state_W_rule = Dense(
            config.decoder_hidden_dim,
            config.rule_embed_dim,
            name='decoder_hidden_state_W_rule')

        # decoder_hidden_dim -> action embed
        self.decoder_hidden_state_W_token = Dense(
            config.decoder_hidden_dim + config.encoder_hidden_dim,
            config.rule_embed_dim,
            name='decoder_hidden_state_W_token')

        # self.rule_encoder_lstm.params
        self.params = self.query_embedding.params + self.query_encoder_lstm.params + \
                      self.decoder_lstm.params + self.src_ptr_net.params + self.terminal_gen_softmax.params + \
                      [self.rule_embedding_W, self.rule_embedding_b, self.node_embedding, self.vocab_embedding_W, self.vocab_embedding_b] + \
                      self.decoder_hidden_state_W_rule.params + self.decoder_hidden_state_W_token.params

        self.srng = RandomStreams()
Example #5
0
 def _set_layers(self, hidden_dim, output_dim):
     self.layers = [Dense(input_dim=hidden_dim,
                          output_dim=output_dim)]