def __init__(self, params, vocab): super(Lstm, self).__init__() self.n_layer = params.n_layer self.emb_dim = params.emb_dim self.n_words = vocab.n_words self.hidden_dim = params.hidden_dim self.dropout = params.dropout self.bidirection = params.bidirection self.freeze_emb = params.freeze_emb self.emb_file = params.emb_file # embedding layer self.embedding = nn.Embedding(self.n_words, self.emb_dim, padding_idx=PAD_INDEX) # load embedding if self.emb_file.endswith("npy"): embedding = load_embedding_from_npy(self.emb_file) else: embedding = load_embedding(vocab, self.emb_dim, self.emb_file) self.embedding.weight.data.copy_(torch.FloatTensor(embedding)) # LSTM layers self.lstm = nn.LSTM(self.emb_dim, self.hidden_dim, num_layers=self.n_layer, dropout=self.dropout, bidirectional=self.bidirection, batch_first=True)
def __init__(self, params): super(EntityNamePredictor, self).__init__() self.input_dim = params.hidden_dim * 2 if params.bidirection else params.hidden_dim self.enc_type = params.enc_type if self.enc_type == "trs": print("using transformer to encoder entity tokens") self.trs_enc = TransformerEncoder( input_size=self.input_dim, hidden_size=params.trs_hidden_dim, num_layers=params.trs_layers, num_heads=params.num_heads, dim_key=params.dim_key, dim_value=params.dim_value, filter_size=params.filter_size) elif self.enc_type == "lstm": print("using lstm to encoder entity tokens") self.lstm_enc = nn.LSTM(self.input_dim, params.trs_hidden_dim // 2, num_layers=params.trs_layers, bidirectional=True, batch_first=True) else: print("simply sum the entity token features") self.entity_type_embs = torch.cuda.FloatTensor( load_embedding_from_npy( params.ner_entity_type_emb_file)).transpose( 0, 1) # (emb_dim, num_entity)
def gen_example_embs_based_on_each_domain(emb_file): # 1. generate example embeddings for each slot # get vocabulary _, vocab = datareader() # get word embeddings embedding = load_embedding_from_npy(emb_file) example2embs = {} for slot, examples in slot2example.items(): example_embs_list = [] for example in examples: tok_list = example.split() emb = np.zeros(400) # word and char level embeddings for token in tok_list: index = vocab.word2index[token] emb = emb + embedding[index] example_embs_list.append(emb) example2embs[slot] = np.stack(example_embs_list, axis=-1) # 2. generate example embeddings based on each domain example_embs_based_on_each_domain = {} for domain, slot_names in domain2slot.items(): example_embs = np.zeros((len(slot_names), 400, 2)) for i, slot in enumerate(slot_names): embs = example2embs[slot] example_embs[i] = embs example_embs_based_on_each_domain[domain] = example_embs with open("../data/snips/emb/example_embs_based_on_each_domain.dict", "wb") as f: pickle.dump(example_embs_based_on_each_domain, f)
def __init__(self, params, vocab): super(ConceptTagger, self).__init__() self.use_example = params.use_example if self.use_example: hidden_dim = params.hidden_dim * 2 if params.bidirection else params.hidden_dim self.w_a = nn.Parameter(torch.FloatTensor(hidden_dim)) torch.nn.init.uniform(self.w_a.data, -0.01, 0.01) self.softmax = nn.Softmax(dim=-1) self.example_embs = torch.cuda.FloatTensor( load_embedding_from_npy( params.ner_example_emb_file)) # (num_entity, emb_dim, 2) self.lstm_encoder = Lstm(params, vocab) self.lstm_predictor = LstmBasedSlotPredictor(params) self.entity_embs = torch.cuda.FloatTensor( load_embedding_from_npy( params.ner_entity_type_emb_file)) # (num_entity, emb_dim) self.entity_embs_size = self.entity_embs.size()