import sys from load_wikidata2 import load_wikidata import json from itertools import izip import re wikidata, reverse_dict, prop_data, child_par_dict, wikidata_fanout_dict = load_wikidata( ) par_child_dict = json.load( open('/dccstor/cssblr/vardaan/dialog-qa/par_child_dict.json')) def parse_active_set(active_set, target): active_set = active_set.strip() anding = False orring = False notting1 = False notting2 = False if active_set.startswith('AND(') or active_set.startswith('OR('): if active_set.startswith('AND('): anding = True active_set = re.sub('^\(|\)$', '', active_set.replace('AND', '', 1)) if active_set.startswith('OR('): anding = True active_set = re.sub('^\(|\)$', '', active_set.replace('OR', '', 1)) while active_set.startswith('(') and active_set.endswith(')'): active_set = re.sub('^\(|\)$', '', active_set) active_set_parts = active_set.split(', ') active_set_part1 = active_set_parts[0].strip() active_set_part2 = active_set_parts[1].strip() if active_set_part1.startswith('NOT('):
def __init__(self, wikidata_dir, num_timesteps, program_type_vocab, argument_type_vocab, printing, relaxed_reward_strict, reward_function="jaccard", boolean_reward_multiplier=0.1, relaxed_reward_till_epoch=[-1, -1], unused_var_penalize_after_epoch=[1000, 100000], length_based_penalization=False): """ wikidata_dir: directory containing the wikidata knowledge base num_timesteps: maximum length of the generated program program_type_vocab: vocabulary of operator types argument_type_vocab: vocabulary of argument types printing: boolean flag indicating whether printing should be on or off relaxed_reward_strict: boolean flag indicating whether the relaxed reward (auxiliary reward) should be on reward function: can be F1, jaccard, Prec or Recall boolean_reward_multiplier: an internal weight multiplier for the reward, which ensures that the model does not bias itself towards producing boolean (True/False) answers which have dense reward structure relaxed_reward_till_epoch: maximum epoch number till which the relaxed (auxiliary) reward would be activated unused_var_penalize_after_epoch: epoch number after which the model would be penalized for producing variables in its program which it does not consume length_based_penalization: boolean flag indicating whether the model should be penalized for producing longer programs """ np.random.seed(1) self.wikidata, self.reverse_wikidata, self.wikidata_type, self.reverse_wikidata_type, self.wikidata_ent_type, self.reverse_wikidata_ent_type = load_wikidata( wikidata_dir) self.argument_type_vocab = argument_type_vocab self.printing = printing self.argument_type_vocab_inv = { v: k for k, v in self.argument_type_vocab.items() } self.program_type_vocab = program_type_vocab self.length_based_penalization = length_based_penalization self.relaxed_reward_strict = relaxed_reward_strict self.relaxed_reward_till_epoch = relaxed_reward_till_epoch self.unused_var_penalize_after_epoch = unused_var_penalize_after_epoch self.reward_function = reward_function if self.reward_function not in ["jaccard", "recall", "f1"]: raise Exception( 'reward function must be either jaccard or recall or f1') self.boolean_reward_multiplier = boolean_reward_multiplier self.program_type_vocab_inv = { v: k for k, v in self.program_type_vocab.items() } self.map_program_to_func = {} self.map_program_to_func["gen_set"] = self.execute_gen_set self.map_program_to_func["gen_map1"] = self.execute_gen_map1 self.map_program_to_func["verify"] = self.execute_verify self.map_program_to_func[ "set_oper_count"] = self.execute_set_oper_count self.map_program_to_func[ "set_oper_union"] = self.execute_set_oper_union self.map_program_to_func[ "set_oper_ints"] = self.execute_set_oper_intersec self.map_program_to_func["set_oper_diff"] = self.execute_set_oper_diff self.map_program_to_func[ "map_oper_count"] = self.execute_map_oper_count self.map_program_to_func[ "map_oper_union"] = self.execute_map_oper_union self.map_program_to_func[ "map_oper_ints"] = self.execute_map_oper_intersec self.map_program_to_func["map_oper_diff"] = self.execute_map_oper_diff self.map_program_to_func[ "select_oper_max"] = self.execute_select_oper_max self.map_program_to_func[ "select_oper_min"] = self.execute_select_oper_min self.map_program_to_func[ "select_oper_atleast"] = self.execute_select_oper_atleast self.map_program_to_func[ "select_oper_atmost"] = self.execute_select_oper_atmost self.map_program_to_func[ "select_oper_more"] = self.execute_select_oper_more self.map_program_to_func[ "select_oper_less"] = self.execute_select_oper_less self.map_program_to_func[ "select_oper_equal"] = self.execute_select_oper_equal self.map_program_to_func[ "select_oper_approx"] = self.execute_select_oper_approx self.map_program_to_func["none"] = self.execute_none self.map_program_to_func["terminate"] = self.execute_terminate self.HIGH_NEGATIVE_REWARD = 1 self.HIGHEST_NEGATIVE_REWARD = 1 self.num_timesteps = num_timesteps self.rewards = None self.parallel = 0
def __init__(self, wikidata_dir, num_timesteps, program_type_vocab, argument_type_vocab, printing, terminate_prog, relaxed_reward_strict, reward_function="jaccard", boolean_reward_multiplier=0.1, relaxed_reward_till_epoch=[-1, -1], unused_var_penalize_after_epoch=[1000, 100000], length_based_penalization=False): np.random.seed(1) self.wikidata, self.reverse_wikidata, self.wikidata_type, self.reverse_wikidata_type, self.wikidata_ent_type, self.reverse_wikidata_ent_type = load_wikidata( wikidata_dir) self.argument_type_vocab = argument_type_vocab self.printing = printing self.terminate_prog = terminate_prog self.argument_type_vocab_inv = { v: k for k, v in self.argument_type_vocab.items() } self.program_type_vocab = program_type_vocab self.length_based_penalization = length_based_penalization self.relaxed_reward_strict = relaxed_reward_strict self.relaxed_reward_till_epoch = relaxed_reward_till_epoch self.unused_var_penalize_after_epoch = unused_var_penalize_after_epoch self.reward_function = reward_function if self.reward_function not in ["jaccard", "recall", "f1"]: raise Exception( 'reward function must be either jaccard or recall or f1') self.boolean_reward_multiplier = boolean_reward_multiplier self.program_type_vocab_inv = { v: k for k, v in self.program_type_vocab.items() } self.map_program_to_func = {} self.map_program_to_func["gen_set"] = self.execute_gen_set self.map_program_to_func["gen_map1"] = self.execute_gen_map1 self.map_program_to_func["verify"] = self.execute_verify self.map_program_to_func[ "set_oper_count"] = self.execute_set_oper_count self.map_program_to_func[ "set_oper_union"] = self.execute_set_oper_union self.map_program_to_func[ "set_oper_ints"] = self.execute_set_oper_intersec self.map_program_to_func["set_oper_diff"] = self.execute_set_oper_diff self.map_program_to_func[ "map_oper_count"] = self.execute_map_oper_count self.map_program_to_func[ "map_oper_union"] = self.execute_map_oper_union self.map_program_to_func[ "map_oper_ints"] = self.execute_map_oper_intersec self.map_program_to_func["map_oper_diff"] = self.execute_map_oper_diff self.map_program_to_func[ "select_oper_max"] = self.execute_select_oper_max self.map_program_to_func[ "select_oper_min"] = self.execute_select_oper_min self.map_program_to_func[ "select_oper_atleast"] = self.execute_select_oper_atleast self.map_program_to_func[ "select_oper_atmost"] = self.execute_select_oper_atmost self.map_program_to_func[ "select_oper_more"] = self.execute_select_oper_more self.map_program_to_func[ "select_oper_less"] = self.execute_select_oper_less self.map_program_to_func[ "select_oper_equal"] = self.execute_select_oper_equal self.map_program_to_func[ "select_oper_approx"] = self.execute_select_oper_approx self.map_program_to_func["none"] = self.execute_none self.map_program_to_func["terminate"] = self.execute_terminate self.HIGH_NEGATIVE_REWARD = 1 self.HIGHEST_NEGATIVE_REWARD = 1 self.num_timesteps = num_timesteps self.rewards = None self.parallel = 0 self.printing = False
def __init__(self, data_dir, embed_dim=100, fanout_thresh=2, eval_batch=32): self.__embed_dim = embed_dim self.__initialized = True self.eval_batch = eval_batch # self.__trainable = list() # ******************************************************************************************** with tf.device('/cpu'): wikidata, prop_data, wikidata_fanout_dict, child_par_dict = load_wikidata( ) # print len(wikidata) wikidata_remove_list = [ q for q in wikidata if wikidata_fanout_dict[q] <= fanout_thresh ] if fanout_thresh == 2: wikidata_remove_list.extend(wikidata.keys()[-100000:]) for q in wikidata_remove_list: wikidata.pop(q, None) self.__relation_id_map = { pid: i for i, pid in enumerate(prop_data.keys()) } self.__entity_id_map = { qid: i for i, qid in enumerate(wikidata.keys()) } self.__id_relation_map = { i: pid for i, pid in enumerate(prop_data.keys()) } self.__id_entity_map = { i: qid for i, qid in enumerate(wikidata.keys()) } self.__n_entity = len(self.__entity_id_map.keys()) self.__n_relation = len(self.__relation_id_map.keys()) def load_triple(): triples_arr = [] for QID in self.__entity_id_map.keys(): for pid in [ p for p in wikidata[QID] if p in self.__relation_id_map ]: for qid in [ q for q in wikidata[QID][pid] if q in child_par_dict and q in self.__entity_id_map ]: triples_arr.append([ self.__entity_id_map[QID], self.__entity_id_map[qid], self.__relation_id_map[pid] ]) # if len(triples_arr) > 10000: # return np.asarray(triples_arr,dtype=np.int32) return np.asarray(triples_arr, dtype=np.int32) # self.__n_entity = 2900000 # self.__n_relation = 567 # def load_triple(): # triples_arr = [] # for i in xrange(11963): #11963105 # triples_arr.append([random.randint(0,self.__n_entity-1), random.randint(0,self.__n_entity-1), random.randint(0,self.__n_relation-1)]) # # if len(triples_arr) > 1000000: # # return np.asarray(triples_arr) # return np.asarray(triples_arr, dtype=np.int32) triples_arr = load_triple() idx = np.random.permutation(np.arange(triples_arr.shape[0])) self.__train_triple = triples_arr[:int(0.7 * idx.shape[0])] self.__valid_triple = triples_arr[int(0.7 * idx.shape[0] ):int(0.8 * idx.shape[0])] self.__test_triple = triples_arr[int(0.8 * idx.shape[0]):] # ******************************************************************************************** # with codecs.open(os.path.join(data_dir, 'entity2id.txt'), 'r', encoding='utf-8') as f: # self.__n_entity = len(f.readlines()) # with codecs.open(os.path.join(data_dir, 'entity2id.txt'), 'r', encoding='utf-8') as f: # self.__entity_id_map = {x.strip().split('\t')[0]: int(x.strip().split('\t')[1]) for x in f.readlines()} # self.__id_entity_map = {v: k for k, v in self.__entity_id_map.items()} # with codecs.open(os.path.join(data_dir, 'relation2id.txt'), 'r', encoding='utf-8') as f: # self.__n_relation = len(f.readlines()) # with codecs.open(os.path.join(data_dir, 'relation2id.txt'), 'r', encoding='utf-8') as f: # self.__relation_id_map = {x.strip().split('\t')[0]: int(x.strip().split('\t')[1]) for x in f.readlines()} # self.__id_relation_map = {v: k for k, v in self.__entity_id_map.items()} # def load_triple(file_path): # with codecs.open(file_path, 'r', encoding='utf-8') as f_triple: # return np.asarray([[self.__entity_id_map[x.strip().split('\t')[0]], # self.__entity_id_map[x.strip().split('\t')[1]], # self.__relation_id_map[x.strip().split('\t')[2]]] for x in f_triple.readlines()], # dtype=np.int32) # self.__train_triple = load_triple(os.path.join(data_dir, 'train.txt')) # self.__test_triple = load_triple(os.path.join(data_dir, 'test.txt')) # self.__valid_triple = load_triple(os.path.join(data_dir, 'valid.txt')) # ******************************************************************************************** print("N_ENTITY: %d" % self.__n_entity) print("N_RELATION: %d" % self.__n_relation) print("N_TRAIN_TRIPLES: %d" % self.__train_triple.shape[0]) print("N_TEST_TRIPLES: %d" % self.__test_triple.shape[0]) print("N_VALID_TRIPLES: %d" % self.__valid_triple.shape[0]) def gen_hr_t(triple_data): hr_t = dict() for h, t, r in triple_data: if h not in hr_t: hr_t[h] = dict() if r not in hr_t[h]: hr_t[h][r] = set() hr_t[h][r].add(t) return hr_t def gen_tr_h(triple_data): tr_h = dict() for h, t, r in triple_data: if t not in tr_h: tr_h[t] = dict() if r not in tr_h[t]: tr_h[t][r] = set() tr_h[t][r].add(h) return tr_h #self.__train_hr_t = gen_hr_t(self.__train_triple) #self.__train_tr_h = gen_tr_h(self.__train_triple) #self.__test_hr_t = gen_hr_t(self.__test_triple) #self.__test_tr_h = gen_tr_h(self.__test_triple) self.__hr_t = gen_hr_t( np.concatenate([ self.__train_triple, self.__test_triple, self.__valid_triple ], axis=0)) self.__tr_h = gen_tr_h( np.concatenate([ self.__train_triple, self.__test_triple, self.__valid_triple ], axis=0)) bound = 6 / math.sqrt(embed_dim) # with tf.device('/cpu'): self.ent_embeddings = tf.get_variable( "ent_embedding", [self.__n_entity, embed_dim], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=345)) # self.__trainable.append(self.ent_embeddings) self.rel_embeddings = tf.get_variable( "rel_embedding", [self.__n_relation, embed_dim], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=346))
def __init__(self, max_utter, max_len, start_symbol_index, end_symbol_index, unk_symbol_index, pad_symbol_index, pad_kb_symbol_index, nkb_symbol_index, stopwords, stopwords_histogram, lucene_dir, transe_dir, wikidata_dir, glove_dir, max_mem_size, max_target_size, vocab_max_len, all_possible_ngrams, cutoff=-1): logging.basicConfig(level=logging.INFO) self.logger = logging.getLogger('prepare_data_for_hred') self.max_utter = max_utter self.max_len = max_len self.unknown_word_id = unk_symbol_index self.start_word_id = start_symbol_index self.pad_word_id = pad_symbol_index self.end_word_id = end_symbol_index self.kb_word_id = 4 self.start_word_symbol = '</s>' self.end_word_symbol = '</e>' self.pad_symbol = '<pad>' self.unk_symbol = '<unk>' self.kb_word_symbol = '<kb>' self.pad_kb_symbol_index = pad_kb_symbol_index self.nkb_symbol_index = nkb_symbol_index self.pad_kb_symbol = '<pad_kb>' self.nkb_symbol = '<nkb>' self.cutoff = cutoff self.vocab_max_len = vocab_max_len self.all_possible_ngrams = all_possible_ngrams self.input = None self.output = None self.vocab_file = None self.vocab_dict = None self.response_vocab_file = None self.response_vocab_dict = None self.word_counter = None self.max_mem_size = max_mem_size self.max_target_size = max_target_size self.lemmatizer = nltk.WordNetLemmatizer() self.stemmer = nltk.stem.porter.PorterStemmer() self.bad_qids = set( ['Q184386', 'Q1541554', 'Q540955', 'Q2620241', 'Q742391']) #adding Yes/No self.bad_qids.update( pkl.load(open('wikidata_entities_with_digitnames.pkl'))) self.wikidata_qid_to_name = json.load( open(wikidata_dir + '/items_wikidata_n.json')) self.use_gold_entities = False self.use_gold_relations = False self.use_gold_types = False self.use_direct_only = False #Taken from Su Nam Kim Paper... self.grammar = r""" NBAR: {<NN.*|JJ>*<NN.*>} # Nouns and Adjectives, terminated with Nouns NP: {<NBAR>} {<NBAR><IN><NBAR>} # Above, connected with in/of/etc... """ self.chunker = nltk.RegexpParser(self.grammar) #************************************************************************# self.stop_set = pkl.load(open(stopwords)) self.stop_vocab = read_file_as_dict(stopwords_histogram) self.ls = LuceneSearch(lucene_dir) self.question_parser = QuestionParser(None, self.stop_vocab, self.stop_set, self.bad_qids, self.ls, self.wikidata_qid_to_name, self.all_possible_ngrams) self.wikidata, self.reverse_dict, self.prop_data, self.child_par_dict, self.child_all_par_dict, self.wikidata_fanout_dict, self.par_child_dict = load_wikidata( wikidata_dir) self.id_entity_map = { self.pad_kb_symbol_index: self.pad_kb_symbol, self.nkb_symbol_index: self.nkb_symbol } self.id_entity_map.update({ (k + 2): v for k, v in pkl.load(open(transe_dir + '/id_ent_map.pickle', 'rb')).iteritems() }) self.id_rel_map = { self.pad_kb_symbol_index: self.pad_kb_symbol, self.nkb_symbol_index: self.nkb_symbol } self.id_rel_map.update({ (k + 2): v for k, v in pkl.load(open(transe_dir + '/id_rel_map.pickle', 'rb')).iteritems() }) self.entity_id_map = {v: k for k, v in self.id_entity_map.iteritems()} self.rel_id_map = {v: k for k, v in self.id_rel_map.iteritems()} self.kb_ov_idx = 1 # symbol assigned to entries out of kb or for padding to target_ids self.kb_rel_ov_idx = 1 # symbol assigned to entries out of kb or for padding to target_ids glove_model = gensim.models.KeyedVectors.load_word2vec_format( glove_dir + '/GoogleNews-vectors-negative300.bin', binary=True ) #/dccstor/cssblr/amrita/resources/glove/GoogleNews-vectors-negative300.bin', binary=True) vocab = glove_model.wv.vocab.keys() self.glove_embedding = {v: glove_model.wv[v] for v in vocab} print 'loaded glove embeddings' self.ann_rel = AnnoyIndex(300, metric='euclidean') self.ann_rel.load( 'relation_linker/annoy_index_rel_noisy/glove_embedding_of_vocab.ann' ) self.ann_pickle_rel = pkl.load( open('relation_linker/annoy_index_rel_noisy/index2rel.pkl')) self.ann_type = AnnoyIndex(300, metric='euclidean') self.ann_type.load( 'type_linker/annoy_index_type/glove_embedding_of_vocab.ann') self.ann_pickle_type = pkl.load( open('type_linker/annoy_index_type/index2type.pkl')) self.types = json.load( open('type_linker/annoy_index_type/type_names.json'))
def __init__(self, data_dir, embed_dim=100, combination_method='simple', dropout=0.5, neg_weight=0.5, n_load_triples=1000000): if combination_method.lower() not in ['simple', 'matrix']: raise NotImplementedError( "ProjE does not support using %s as combination method." % combination_method) self.__combination_method = combination_method self.__embed_dim = embed_dim self.__initialized = False self.__trainable = list() self.__dropout = dropout # ******************************************************************************************** wikidata, reverse_dict, item_data, prop_data, wikidata_fanout_dict, child_par_dict = load_wikidata( ) print len(wikidata) self.__n_entity = len(wikidata) self.__relation_id_map = { pid: i for i, pid in enumerate(prop_data.keys()) } self.__entity_id_map = { qid: i for i, qid in enumerate(wikidata.keys()) } self.__id_relation_map = { i: pid for i, pid in enumerate(prop_data.keys()) } self.__id_entity_map = { i: qid for i, qid in enumerate(wikidata.keys()) } self.__n_relation = len(prop_data) def load_triple(): triples_arr = [] for QID in wikidata: for pid in [p for p in wikidata[QID] if p in prop_data]: for qid in [ q for q in wikidata[QID][pid] if q in child_par_dict and q in self.__entity_id_map ]: triples_arr.append([ self.__entity_id_map[QID], self.__entity_id_map[qid], self.__relation_id_map[pid] ]) if len(triples_arr ) > n_load_triples and n_load_triples > 0: return np.asarray(triples_arr) return np.asarray(triples_arr, dtype=np.int32) triples_arr = load_triple() idx = np.random.permutation(np.arange(triples_arr.shape[0])) self.__train_triple = triples_arr[:int(0.7 * idx.shape[0])] self.__valid_triple = triples_arr[int(0.7 * idx.shape[0]):int(0.8 * idx.shape[0])] self.__test_triple = triples_arr[int(0.8 * idx.shape[0]):] # ******************************************************************************************** # with codecs.open(os.path.join(data_dir, 'entity2id.txt'), 'r', encoding='utf-8') as f: # self.__n_entity = len(f.readlines()) # with codecs.open(os.path.join(data_dir, 'entity2id.txt'), 'r', encoding='utf-8') as f: # self.__entity_id_map = {x.strip().split('\t')[0]: int(x.strip().split('\t')[1]) for x in f.readlines()} # self.__id_entity_map = {v: k for k, v in self.__entity_id_map.items()} # with codecs.open(os.path.join(data_dir, 'relation2id.txt'), 'r', encoding='utf-8') as f: # self.__n_relation = len(f.readlines()) # with codecs.open(os.path.join(data_dir, 'relation2id.txt'), 'r', encoding='utf-8') as f: # self.__relation_id_map = {x.strip().split('\t')[0]: int(x.strip().split('\t')[1]) for x in f.readlines()} # self.__id_relation_map = {v: k for k, v in self.__entity_id_map.items()} # def load_triple(file_path): # with codecs.open(file_path, 'r', encoding='utf-8') as f_triple: # return np.asarray([[self.__entity_id_map[x.strip().split('\t')[0]], # self.__entity_id_map[x.strip().split('\t')[1]], # self.__relation_id_map[x.strip().split('\t')[2]]] for x in f_triple.readlines()],dtype=np.int32) # self.__train_triple = load_triple(os.path.join(data_dir, 'train.txt')) # self.__test_triple = load_triple(os.path.join(data_dir, 'test.txt')) # self.__valid_triple = load_triple(os.path.join(data_dir, 'valid.txt')) # ******************************************************************************************** print("N_ENTITY: %d" % self.__n_entity) print("N_RELATION: %d" % self.__n_relation) print("N_TRAIN_TRIPLES: %d" % self.__train_triple.shape[0]) print("N_TEST_TRIPLES: %d" % self.__test_triple.shape[0]) print("N_VALID_TRIPLES: %d" % self.__valid_triple.shape[0]) def gen_hr_t(triple_data): hr_t = dict() for h, t, r in triple_data: if h not in hr_t: hr_t[h] = dict() if r not in hr_t[h]: hr_t[h][r] = set() hr_t[h][r].add(t) return hr_t def gen_tr_h(triple_data): tr_h = dict() for h, t, r in triple_data: if t not in tr_h: tr_h[t] = dict() if r not in tr_h[t]: tr_h[t][r] = set() tr_h[t][r].add(h) return tr_h self.__train_hr_t = gen_hr_t(self.__train_triple) self.__train_tr_h = gen_tr_h(self.__train_triple) self.__test_hr_t = gen_hr_t(self.__test_triple) self.__test_tr_h = gen_tr_h(self.__test_triple) self.__hr_t = gen_hr_t( np.concatenate( [self.__train_triple, self.__test_triple, self.__valid_triple], axis=0)) self.__tr_h = gen_tr_h( np.concatenate( [self.__train_triple, self.__test_triple, self.__valid_triple], axis=0)) bound = 6 / math.sqrt(embed_dim) with tf.device('/cpu'): self.__ent_embedding = tf.get_variable( "ent_embedding", [self.__n_entity, embed_dim], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=345)) self.__trainable.append(self.__ent_embedding) self.__rel_embedding = tf.get_variable( "rel_embedding", [self.__n_relation, embed_dim], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=346)) self.__trainable.append(self.__rel_embedding) if combination_method.lower() == 'simple': self.__hr_weighted_vector = tf.get_variable( "simple_hr_combination_weights", [embed_dim * 2], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=445)) self.__tr_weighted_vector = tf.get_variable( "simple_tr_combination_weights", [embed_dim * 2], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=445)) self.__trainable.append(self.__hr_weighted_vector) self.__trainable.append(self.__tr_weighted_vector) self.__hr_combination_bias = tf.get_variable("combination_bias_hr", initializer=tf.zeros( [embed_dim])) self.__tr_combination_bias = tf.get_variable("combination_bias_tr", initializer=tf.zeros( [embed_dim])) self.__trainable.append(self.__hr_combination_bias) self.__trainable.append(self.__tr_combination_bias) else: self.__hr_combination_matrix = tf.get_variable( "matrix_hr_combination_layer", [embed_dim * 2, embed_dim], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=555)) self.__tr_combination_matrix = tf.get_variable( "matrix_tr_combination_layer", [embed_dim * 2, embed_dim], initializer=tf.random_uniform_initializer(minval=-bound, maxval=bound, seed=555)) self.__trainable.append(self.__hr_combination_matrix) self.__trainable.append(self.__tr_combination_matrix) self.__hr_combination_bias = tf.get_variable("combination_bias_hr", initializer=tf.zeros( [embed_dim])) self.__tr_combination_bias = tf.get_variable("combination_bias_tr", initializer=tf.zeros( [embed_dim])) self.__trainable.append(self.__hr_combination_bias) self.__trainable.append(self.__tr_combination_bias)