def compute_idx(pages_path_in, pages_path_out, vocab): f = h5py.File(pages_path_in, 'r') if prm.att_doc and prm.att_segment_type == 'sentence': nltk.download('punkt') tokenizer = nltk.data.load('tokenizers/punkt/english.pickle') os.remove(pages_path_out) if os.path.exists(pages_path_out) else None # Save to HDF5 fout = h5py.File(pages_path_out,'a') if prm.att_doc: shape = (f['text'].shape[0],prm.max_segs_doc,prm.max_words) else: shape=(f['text'].shape[0],prm.max_words) idxs = fout.create_dataset('idx', shape=shape, dtype=np.int32) mask = fout.create_dataset('mask', shape=(f['text'].shape[0],), dtype=np.float32) i = 0 for text in f['text']: st = time.time() if prm.att_doc: if prm.att_segment_type.lower() == 'section' or prm.att_segment_type.lower() == 'subsection': segs = [''] for line in text.split('\n'): if prm.att_segment_type == 'section': line = line.replace('===', '') if line.strip().startswith('==') and line.strip().endswith('=='): segs.append('') segs[-1] += line.lower() + '\n' elif prm.att_segment_type.lower() == 'sentence': segs = tokenizer.tokenize(text.lower().decode('ascii', 'ignore')) else: raise ValueError('Not a valid value for the attention segment type (att_segment_type) parameter. Valid options are "section", "subsection" or "sentence".') segs = segs[:prm.max_segs_doc] idxs_, _ = utils.text2idx2(segs, vocab, prm.max_words) idxs[i,:len(idxs_),:] = idxs_ mask[i] = len(idxs_) else: idx, _ = utils.text2idx2([text.lower()], vocab, prm.max_words) idxs[i,:] = idx[0] i += 1 #if i > 3000: # break print 'processing article', i, 'time', time.time()-st f.close() fout.close()
def reset(self): print '********************reset**********' """ Reset environment and setup for new episode. Returns: initial state of resetted environment. """ t0 = time() qi, qi_i, qi_lst, D_gt_id, D_gt_title = self.get_samples( sample_num=self.batch_size, max_words_input=self.search.max_words_input) current_query_text = qi_lst current_query_code = qi_i self.action = current_query_code print 'reset current query text:', current_query_text print 'reset current query code:', current_query_code print 'reset action code:', self.action self.D_gt_id = D_gt_id self.D_gt_title = D_gt_title metrics, D_i_, D_id_, D_gt_m_ = self.search.perform( current_query_code, D_gt_id, self.is_train, current_query_text) expanded_query_text = current_query_text metric_idx = self.search.metrics_map[self.rewardtype.upper()] reward = metrics[:, metric_idx] expanded_query_text = self.process_expanded_words(expanded_query_text) print ' reset expanded text:', expanded_query_text expanded_query_code, expandes_lst_ = utils.text2idx2( expanded_query_text, self.vocab, self.cfg['search']['max_terms']) #expanded_query_code, terminal,reward = self.execute(self.action) print 'reward', reward self.state = expanded_query_code self.counsteps = 0 return self.state
def execute(self, actions): print 'execute' done = False reformulated_query = actions current_queries = self.current_queries D_gt_id = self.D_gt_id metrics, D_i_, D_id_, D_gt_m_ = self.search.perform( reformulated_query, D_gt_id, self.is_train, current_queries) # print "D_id_", D_id_ # i = 3 # print "ALALALA ", [self.search.engine.id_title_map[d_id] for d_id in D_id_[i]] text = [[self.search.engine.id_title_map[d_id] for d_id in D_id_[i]] for i in range(D_id_.shape[0])] actions = current_queries metric_idx = self.search.metrics_map[self.reward.upper()] reward = metrics[metric_idx] if (len(actions) == 0): # or self.counsteps > 10): done = True state = [ utils.text2idx2(t, self.vocab, dim=self.search.max_words_input)[0] for t in text ] # reward = 1.0 metric_idx = self.search.metrics_map[self.reward.upper()] reward = metrics[:, metric_idx].sum() return state, done, reward
def get_samples(self, input_queries, target_docs, vocab, index, engine, max_words_input=200): qi = [utils.clean(input_queries[t].lower()) for t in index] D_gt_title = [target_docs[t] for t in index] D_gt_id_lst = [] for j, t in enumerate(index): #print("j",j) D_gt_id_lst.append([]) for title in D_gt_title[j]: #print("title", title) if title in engine.title_id_map: D_gt_id_lst[-1].append(engine.title_id_map[title]) #else: # print 'ground-truth doc not in index:', title D_gt_id = utils.lst2matrix(D_gt_id_lst) qi_i, qi_lst_ = utils.text2idx2(qi, vocab, max_words_input) qi_lst = [] for qii_lst in qi_lst_: # append empty strings, so the list size becomes <dim>. qi_lst.append(qii_lst + max(0, max_words_input - len(qii_lst)) * ['']) return qi, qi_i, qi_lst, D_gt_id, D_gt_title
def get_samples(self, sample_num=1, max_words_input=200): if sample_num <= 0: sample_num = 1 train_index = utils.get_one_random_batch_idx(len(self.qi), sample_num) input_queries = self.qi target_docs = self.dt vocab = self.vocab engine = self.search.engine qi = [utils.clean(input_queries[t].lower()) for t in train_index] D_gt_title = [target_docs[t] for t in train_index] D_gt_id_lst = [] for j, t in enumerate(train_index): #print("j",j) D_gt_id_lst.append([]) for title in D_gt_title[j]: #print("title", title) if title in engine.title_id_map: D_gt_id_lst[-1].append(engine.title_id_map[title]) #else: # print 'ground-truth doc not in train_index:', title D_gt_id = utils.lst2matrix(D_gt_id_lst) qi_i, qi_lst_ = utils.text2idx2(qi, vocab, max_words_input) #print("qi_i", qi_i) #print("qi_lst_", qi_lst_) qi_lst = [] for qii_lst in qi_lst_: # append empty strings, so the list size becomes <dim>. qi_lst.append(qii_lst + max(0, max_words_input - len(qii_lst)) * ['']) return qi, qi_i, qi_lst, D_gt_id, D_gt_title
def execute(self, actions): done = False # reformulated_query, current_queries, D_gt_id = action # print(actions) reformulated_query = actions # print(reformulated_query) current_queries = self.current_queries D_gt_id = self.D_gt_id metrics, D_i_, D_id_, D_gt_m_ = self.search.perform( reformulated_query, D_gt_id, self.is_train, current_queries) print "D_id_", D_id_ i = 3 print "ALALALA ", [ self.search.engine.id_title_map[d_id] for d_id in D_id_[i] ] text = [[self.search.engine.id_title_map[d_id] for d_id in D_id_[i]] for i in range(D_id_.shape[0])] actions = current_queries metric_idx = self.search.metrics_map[self.reward.upper()] reward = metrics[metric_idx] if (len(actions) == 0): # or self.counsteps > 10): done = True # return [text, actions], reward, done, {} # text: candidates return by search, actions: previous query. Combine provide the states # return text, reward, done, {} state = [ utils.text2idx2(t, self.vocab, dim=self.search.max_words_input)[0] for t in text ] reward = 1.0 return state, done, reward
def add_doc(self, doc_id, title, txt, add_terms): doc = Document() txt = utils.clean(txt) if add_terms: if prm.top_tfidf > 0: words_idx = [] words, _ = utils.top_tfidf(txt.lower(), self.idf, prm.top_tfidf, prm.min_term_freq) if len(words) == 0: words.append('unk') for w in words: if w in self.vocab: words_idx.append(self.vocab[w]) else: words_idx.append(-1) # unknown words. else: txt_ = txt.lower() words_idx, words = utils.text2idx2([txt_], self.vocab, prm.max_terms_per_doc) words_idx = words_idx[0] words = words[0] doc.add(Field("id", str(doc_id), self.t1)) doc.add(Field("title", title, self.t1)) doc.add(Field("text", txt, self.t2)) if add_terms: doc.add(Field("word_idx", ' '.join(map(str, words_idx)), self.t3)) doc.add(Field("word", '<&>'.join(words), self.t3)) self.writer.addDocument(doc)
def execute(self, actions): """ Executes action, observes next state(s) and reward. Args: actions: Actions to execute. Returns: (Dict of) next state(s), boolean indicating terminal, and reward signal. """ done = False #reformulated_query, current_queries, D_gt_id = actions self.counsteps += 1 print "************execute query reformulation iteration:", self.counsteps #print 'current states........', self.state #query_text = utils.idx2text2(self.state, self.vocabinv) n, m = np.shape(actions) query_index = -2 * np.ones((n, m), dtype='int') for i in range(len(actions)): actionids = actions[i] for j in range(len(actionids)): query_index[i, j] = self.state[i, actionids[j]] print 'current_actions = ', np.shape(query_index), query_index '''action_status=utils.is_emptyaction(query_index) if sum(action_status)<self.batch_size: self.state=self.reset() query_index=self.action print 'current_actions = ', np.shape(query_index), query_index''' query_text = utils.idx2text2(query_index, self.vocabinv) print 'current actions = ', query_text D_gt_id = self.D_gt_id metrics, D_i_, D_id_, D_gt_m_ = self.search.perform( query_index, D_gt_id, self.is_train, query_text) #self.D_gt_id=D_id_ #print 'current_queries (after calling search.perform) = ',query_text i = 0 expanded_query_text = query_text metric_idx = self.search.metrics_map[self.rewardtype.upper()] reward = metrics[:, metric_idx] if self.counsteps > self.cfg['reformulation']['max_steps']: done = True print 'expanded query text,:', expanded_query_text expanded_query_text = self.process_expanded_words(expanded_query_text) #print ' process_expanded_words:', expanded_query_text expanded_i, expandes_lst_ = utils.text2idx2( expanded_query_text, self.vocab, self.cfg['search']['max_terms']) #self.state= expanded_i #print 'execution__new state id after expansion',expanded_i terminal = done return self.state, terminal, sum(reward)
def add_doc(self, doc_id, title, txt, add_terms): doc = Document() txt = utils.clean(txt) if add_terms: txt_ = txt.lower() words_idx, words = utils.text2idx2([txt_], self.vocab, prm.max_terms_per_doc) words_idx = words_idx[0] words = words[0] doc.add(Field("id", str(doc_id), self.t1)) doc.add(Field("title", title, self.t1)) doc.add(Field("text", txt, self.t2)) if add_terms: doc.add(Field("word_idx", ' '.join(map(str, words_idx)), self.t3)) doc.add(Field("word", '<&>'.join(words), self.t3)) self.writer.addDocument(doc)
def get_samples(input_queries, target_docs, index, options): qi = [utils.clean(input_queries[t].lower()) for t in index] D_gt_title = [target_docs[t] for t in index] D_gt_id_lst = [] for j, t in enumerate(index): D_gt_id_lst.append([]) for title in D_gt_title[j]: if title in options['engine'].title_id_map: D_gt_id_lst[-1].append(options['engine'].title_id_map[title]) else: print 'ground-truth doc not in index:', title D_gt_id = lst2matrix(D_gt_id_lst) qi_i, qi_lst_ = utils.text2idx2(qi, options['vocab'], prm.max_words_input) qi_lst = [] for qii_lst in qi_lst_: # append empty strings, so the list size becomes <dim>. qi_lst.append(qii_lst + max(0, prm.max_words_input - len(qii_lst)) * ['']) return qi, qi_i, qi_lst, D_gt_id, D_gt_title
def compute_idx(pages_path_in, pages_path_out, vocab): f = h5py.File(pages_path_in, 'r') if prm.att_doc and prm.att_segment_type == 'sentence': nltk.download('punkt') tokenizer = nltk.data.load('tokenizers/punkt/english.pickle') os.remove(pages_path_out) if os.path.exists(pages_path_out) else None # Save to HDF5 fout = h5py.File(pages_path_out, 'a') if prm.att_doc: shape = (f['text'].shape[0], prm.max_segs_doc, prm.max_words) else: shape = (f['text'].shape[0], prm.max_words) idxs = fout.create_dataset('idx', shape=shape, dtype=np.int32) mask = fout.create_dataset('mask', shape=(f['text'].shape[0], ), dtype=np.float32) i = 0 for text in f['text']: st = time.time() if prm.att_doc: if prm.att_segment_type.lower( ) == 'section' or prm.att_segment_type.lower() == 'subsection': segs = [''] for line in text.split('\n'): if prm.att_segment_type == 'section': line = line.replace('===', '') if line.strip().startswith('==') and line.strip().endswith( '=='): segs.append('') segs[-1] += line.lower() + '\n' elif prm.att_segment_type.lower() == 'sentence': segs = tokenizer.tokenize(text.lower().decode( 'ascii', 'ignore')) elif prm.att_segment_type.lower() == 'word': segs = wordpunct_tokenize(text.decode('ascii', 'ignore')) else: raise ValueError( 'Not a valid value for the attention segment type (att_segment_type) parameter. Valid options are "section", "subsection", "sentence", or "word".' ) segs = segs[:prm.max_segs_doc] idxs_, _ = utils.text2idx2(segs, vocab, prm.max_words) idxs[i, :len(idxs_), :] = idxs_ mask[i] = len(idxs_) else: idx, _ = utils.text2idx2([text.lower()], vocab, prm.max_words) idxs[i, :] = idx[0] i += 1 #if i > 3000: # break print 'processing article', i, 'time', time.time() - st f.close() fout.close()
def train_lstm(): optimizer=adam # only adam is supported by now. options = locals().copy() with open(prm.outpath, "a") as fout: fout.write("parameters:" + str(options) + str(prm.__dict__)) print "loading dictionary..." vocab = utils.load_vocab(prm.vocab_path, prm.n_words) options['vocab'] = vocab options['vocabinv'] = {} for k,v in vocab.items(): options['vocabinv'][v] = k print 'Loading data...' options['wiki'] = wiki.Wiki(prm.pages_path) options['wikiemb'] = wiki_emb.WikiEmb(prm.pages_emb_path) #load Q&A Wiki dataset qpp = qp.QP(prm.qp_path) q_train, q_valid, q_test = qpp.get_queries() a_train, a_valid, a_test = qpp.get_paths() print 'Building model' # This create the initial parameters as np ndarrays. # Dict name (string) -> np ndarray params, exclude_params = init_params() if prm.wordemb_path: print 'loading pre-trained weights for word embeddings' params = load_wemb(params, vocab) options['W'] = params['W'] if prm.reload_model: load_params(prm.reload_model, params) params_next = OrderedDict() if prm.learning.lower() == 'q_learning' and prm.update_freq > 0: # copy params to params_next for kk, kv in params.items(): params_next[kk] = kv.copy() # This create Theano Shared Variable from the parameters. # Dict name (string) -> Theano Tensor Shared Variable # params and tparams have different copy of the weights. tparams = init_tparams(params) if prm.update_freq > 0: tparams_next = init_tparams(params_next) else: tparams_next = None if prm.learning.lower() == 'reinforce': R_mean = theano.shared(0.71*np.ones((1,)), name='R_mean') R_std = theano.shared(np.ones((1,)), name='R_std') baseline_vars = {'R_mean': R_mean, 'R_std': R_std} else: baseline_vars = {} iin, out, updates, is_train, sup, max_hops, k_beam, mixer, f_pred, consider_constant \ = build_model(tparams, tparams_next, baseline_vars, options) #get only parameters that are not in the exclude_params list tparams_ = OrderedDict([(kk, vv) for kk, vv in tparams.iteritems() if kk not in exclude_params]) grads = tensor.grad(out[0], wrt=itemlist(tparams_), consider_constant=consider_constant) lr = tensor.scalar(name='lr') f_grad_shared, f_update = optimizer(lr, tparams_, grads, iin, out, updates) print 'Optimization' if prm.train_size == -1: train_size = len(q_train) else: train_size = prm.train_size if prm.valid_size == -1: valid_size = len(q_valid) else: valid_size = prm.valid_size if prm.test_size == -1: test_size = len(q_test) else: test_size = prm.test_size with open(prm.outpath, "a") as fout: fout.write("\n%d train examples" % len(q_train)) with open(prm.outpath, "a") as fout: fout.write("\n%d valid examples" % len(q_valid)) with open(prm.outpath, "a") as fout: fout.write("\n%d test examples" % len(q_test)) history_errs = [] best_p = None if prm.validFreq == -1: validFreq = len(q_train) / prm.batch_size_train else: validFreq = prm.validFreq if prm.saveFreq == -1: saveFreq = len(q_train) / prm.batch_size_train else: saveFreq = prm.saveFreq uidx = 0 # the number of update done estop = False # early stop start_time = time.time() experience = deque(maxlen=prm.replay_mem_size) # experience replay memory as circular buffer. experience_r = deque(maxlen=prm.replay_mem_size) # reward of each entry in the replay memory. try: for eidx in xrange(prm.max_epochs): n_samples = 0 # Get new shuffled index for the training set. kf = get_minibatches_idx(len(q_train), prm.batch_size_train, shuffle=True) for _, train_index in kf: st = time.time() uidx += 1 is_train.set_value(1.) max_hops.set_value(prm.max_hops_train) # select training dataset k_beam.set_value(1) # Training does not use beam search # Select the random examples for this minibatch queries = [q_train[t].lower() for t in train_index] actions = [a_train[t] for t in train_index] if prm.learning.lower() == 'supervised': sup.set_value(1.) # select supervised mode else: sup.set_value(0.) # Get correct actions (supervision signal) acts_p = get_acts(actions, prm.max_hops_train, k_beam=1) # MIXER if prm.mixer > 0 and prm.learning.lower() == 'reinforce': mixer.set_value(max(0, prm.max_hops_train - uidx // prm.mixer)) else: if prm.learning.lower() == 'supervised': mixer.set_value(prm.max_hops_train+1) else: mixer.set_value(0) root_pages = get_root_pages(actions) # Get the BoW for the queries. q_i, q_m = utils.text2idx2(queries, vocab, prm.max_words_query*prm.n_consec) n_samples += len(queries) if uidx > 1 and prm.learning.lower() == 'q_learning': # Randomly select experiences and convert them to numpy arrays. idxs = np.random.choice(np.arange(len(experience)), size=len(queries)) rvs = [] for j in range(len(experience[idxs[0]])): rv = [] for idx in idxs: rv.append(experience[idx][j]) rvs.append(np.asarray(rv)) else: rvs = [np.zeros((len(queries),prm.max_words_query*prm.n_consec),dtype=np.float32), # rs_q np.zeros((len(queries),prm.max_words_query*prm.n_consec),dtype=np.float32), # rs_q_m np.zeros((len(queries),prm.max_hops_train+1),dtype=np.int32), # rl_idx np.zeros((len(queries),prm.max_hops_train+1),dtype=np.float32), # rt np.zeros((len(queries),prm.max_hops_train+1),dtype=np.float32) # rr ] cost, R, l_idx, pages_idx, best_page_idx, best_answer, mask, dist \ = f_grad_shared(q_i, q_m, root_pages, acts_p, uidx, *rvs) f_update(prm.lrate) if prm.learning.lower() == 'q_learning': # update weights of the next_q_val network. if (prm.update_freq > 0 and uidx % prm.update_freq == 0) or (uidx == prm.replay_start): for tk, tv in tparams.items(): if tk in tparams_next: tparams_next[tk].set_value(tv.get_value().copy()) # Only update memory after freeze_mem or before replay_start. if (uidx < prm.replay_start or uidx > prm.freeze_mem) and prm.learning.lower() == 'q_learning': # Update Replay Memory. t = np.zeros((len(queries), prm.max_hops_train+1)) rR = np.zeros((len(queries), prm.max_hops_train+1)) for i in range(len(queries)): j = np.minimum(mask[i].sum(), prm.max_hops_train) # If the agent chooses to stop or the episode ends, # the reward will be the reward obtained with the chosen document. rR[i,j] = R[i] t[i,j] = 1. add = True if prm.selective_mem >= 0 and uidx > 1: # Selective memory: keep the percentage of memories # with reward=1 approximately equal to <selective_mem>. pr = float(np.asarray(experience_r).sum()) / max(1., float(len(experience_r))) if (pr < prm.selective_mem) ^ (rR[i,j] == 1.): # xor add = False if add: experience.append([q_i[i], q_m[i], l_idx[i], t[i], rR[i]]) experience_r.append(rR[i]) if np.isnan(cost) or np.isinf(cost): print 'NaN detected' return 1., 1., 1. #if uidx % 100 == 0: # vis_att(pages_idx[:,-1], queries[-1], alpha[:,-1,:], uidx, options) if np.mod(uidx, prm.dispFreq) == 0: with open(prm.outpath, "a") as fout: fout.write("\n\nQuery: " + queries[-1].replace("\n"," ")) fout.write('\nBest Answer: ' + utils.idx2text(best_answer[-1], options['vocabinv'])) fout.write('\nBest page: ' + options['wiki'].get_article_title(best_page_idx[-1])) for i, page_idx in enumerate(pages_idx[:,-1]): fout.write('\niteration: ' +str(i) + " page idx " + str(page_idx) + ' title: ' + options['wiki'].get_article_title(page_idx)) fout.write('\nEpoch '+ str(eidx) + ' Update '+ str(uidx) + ' Cost ' + str(cost) + \ ' Reward Mean ' + str(R.mean()) + ' Reward Max ' + str(R.max()) + \ ' Reward Min ' + str(R.min()) + \ ' Q-Value Max (avg per sample) ' + str(dist.max(2).mean()) + \ ' Q-Value Mean ' + str(dist.mean())) #fout.write("\nCost Supervised: " + str(cost_sup)) #fout.write("\nCost RL: " + str(cost_RL)) fout.write("\nTime per Minibatch Update: " + str(time.time() - st)) if prm.saveto and np.mod(uidx, saveFreq) == 0: print 'Saving...', if best_p is not None: params = best_p else: params = unzip(tparams) np.savez(prm.saveto, history_errs=history_errs, **params) pkl.dump(options, open('%s.pkl' % prm.saveto, 'wb'), -1) print 'Done' if np.mod(uidx, validFreq) == 0 or uidx == 1: if prm.visited_pages_path: shuffle = False else: shuffle = True kf_train = get_minibatches_idx(len(q_train), prm.batch_size_pred, shuffle=shuffle, max_samples=train_size) kf_valid = get_minibatches_idx(len(q_valid), prm.batch_size_pred, shuffle=shuffle, max_samples=valid_size) kf_test = get_minibatches_idx(len(q_test), prm.batch_size_pred, shuffle=shuffle, max_samples=test_size) is_train.set_value(0.) sup.set_value(0.) # supervised mode off mixer.set_value(0) # no supervision max_hops.set_value(prm.max_hops_pred) k_beam.set_value(prm.k) with open(prm.outpath, 'a') as fout: fout.write('\n\nComputing Error Training Set') train_err, train_R, train_accp, visited_pages_train = pred_error(f_pred, q_train, a_train, options, kf_train) with open(prm.outpath, 'a') as fout: fout.write('\n\nComputing Error Validation Set') valid_err, valid_R, valid_accp, visited_pages_valid = pred_error(f_pred, q_valid, a_valid, options, kf_valid) with open(prm.outpath, 'a') as fout: fout.write('\n\nComputing Error Test Set') test_err, test_R, test_accp, visited_pages_test = pred_error(f_pred, q_test, a_test, options, kf_test) if prm.visited_pages_path: pkl.dump([visited_pages_train, visited_pages_valid, visited_pages_test], open(prm.visited_pages_path, 'wb')) history_errs.append([valid_err[-1], test_err[-1]]) if (uidx == 0 or valid_err[-1] <= np.array(history_errs)[:,0].min()): best_p = unzip(tparams) bad_counter = 0 with open(prm.outpath, "a") as fout: fout.write('\n[{per hop}, Avg] Train err ' + str(train_err) + ' Valid err ' + str(valid_err) + ' Test err ' + str(test_err)) fout.write('\n[{per hop}, Avg] Train R ' + str(train_R) + ' Valid R ' + str(valid_R) + ' Test R ' + str(test_R)) fout.write('\nAccuracy Page Actions Train ' + str(train_accp) + ' Valid ' + str(valid_accp) + ' Test ' + str(test_accp)) if (len(history_errs) > prm.patience and valid_err[-1] >= np.array(history_errs)[:-prm.patience, 0].min()): bad_counter += 1 if bad_counter > prm.patience: print 'Early Stop!' estop = True break with open(prm.outpath, "a") as fout: fout.write('\nSeen %d samples' % n_samples) if estop: break except KeyboardInterrupt: print "Training interupted" end_time = time.time() if best_p is not None: zipp(best_p, tparams) else: best_p = unzip(tparams) is_train.set_value(0.) sup.set_value(0.) # supervised mode off mixer.set_value(0) # no supervision max_hops.set_value(prm.max_hops_pred) k_beam.set_value(prm.k) kf_train_sorted = get_minibatches_idx(len(q_train), prm.batch_size_train) train_err, train_R, train_accp, visited_pages_train = pred_error(f_pred, q_train, a_train, options, kf_train_sorted) valid_err, valid_R, valid_accp, visited_pages_valid = pred_error(f_pred, q_valid, a_valid, options, kf_valid) test_err, test_R, test_accp, visited_pages_test = pred_error(f_pred, q_test, a_test, options, kf_test) with open(prm.outpath, "a") as fout: fout.write('\n[{per hop}, Avg] Train err ' + str(train_err) + ' Valid err ' + str(valid_err) + ' Test err ' + str(test_err)) fout.write('\n[{per hop}, Avg] Train R ' + str(train_R) + ' Valid R ' + str(valid_R) + ' Test R ' + str(test_R)) fout.write('\nAccuracy Page Actions Train ' + str(train_accp) + ' Valid ' + str(valid_accp) + ' Test ' + str(test_accp)) if prm.saveto: np.savez(prm.saveto, train_err=train_err, valid_err=valid_err, test_err=test_err, history_errs=history_errs, **best_p) with open(prm.outpath, "a") as fout: fout.write('\nThe code run for %d epochs, with %f sec/epochs' % ((eidx + 1), (end_time - start_time) / (1. * (eidx + 1)))) with open(prm.outpath, "a") as fout: fout.write('\nTraining took %.1fs' % (end_time - start_time)) return train_err, valid_err, test_err
def pred_error(f_pred, queries, actions, options, iterator, verbose=False): """ Just compute the error f_pred: Theano functin computing the prediction """ valid_acc = np.zeros((prm.max_hops_train + 2), dtype=np.float32) valid_R = np.zeros((prm.max_hops_train + 2), dtype=np.float32) n = np.zeros((prm.max_hops_train + 2), dtype=np.float32) acts_pc = 0. acts_pt = 0. uidx = -1 visited_pages = [] for _, valid_index in iterator: q_i, q_m = utils.text2idx2([queries[t].lower() for t in valid_index], options['vocab'], prm.max_words_query*prm.n_consec) acts = [actions[t] for t in valid_index] #fake acts that won't be used in the prediction acts_p = -np.ones((prm.max_hops_pred+1, len(q_i) * prm.k), dtype=np.float32) root_pages = get_root_pages(acts) best_answer, best_page_idx, R, pages_idx = f_pred(q_i, q_m, root_pages, acts_p, uidx) pages_idx_ = np.swapaxes(pages_idx,0,1) pages_idx_ = pages_idx_.reshape(pages_idx_.shape[0],-1) #get pages visited: for page_idx in pages_idx_: visited_pages.append([]) for idx in page_idx: if idx != -1: visited_pages[-1].append(idx) R_binary = np.ones_like(R) R_binary[R<1.0] = 0.0 n[-1] += len(valid_index) valid_R[-1] += R.sum() valid_acc[-1] += R_binary.sum() # get correct page-actions. acts_p = get_acts(acts, prm.max_hops_pred, prm.k) pages_idx = pages_idx.reshape((pages_idx.shape[0],-1)) # Check how many page actions the model got right. mask_pc = np.logical_or((pages_idx != -1.0), (acts_p != -1.0)).astype('float32') acts_pc += ((pages_idx == acts_p).astype('float32') * mask_pc).sum() acts_pt += mask_pc.sum() #total number of actions # compute accuracy per hop for i in range(prm.max_hops_train+1): n_hops = (acts_p != -1.0).astype('float32').sum(0) n_hops= n_hops.reshape((-1, prm.k))[:,0] # beam search use only the first n_samples actions ih = (n_hops==i) valid_R[i] += R[ih].sum() valid_acc[i] += R_binary[ih].sum() n[i] += ih.astype('float32').sum() with open(prm.outpath, 'a') as fout: fout.write("\n\nQuery: " + queries[valid_index[-1]].replace("\n"," ")) nh = (acts_p[:,-1] != -1.0).astype('int32').sum() if nh == 0: fout.write('\nCorrect Path: ' + options['wiki'].get_article_title(int(root_pages[-1]))) else: path = '' for a in acts_p[:nh, -1]: path += ' -> ' + options['wiki'].get_article_title(int(a)) fout.write('\nCorrect Path: ' + path) fout.write('\nNumber of hops: ' + str(int(nh))) fout.write('\nBest answer: ' + utils.idx2text(best_answer[-1], options['vocabinv'])) fout.write('\nBest page: ' + options['wiki'].get_article_title(best_page_idx[-1])) for i, pageidx in enumerate(pages_idx[:,-1]): fout.write('\niteration: ' +str(i) + " page idx " + str(pageidx) + ' title '+ options['wiki'].get_article_title(pageidx)) uidx -= 1 valid_R = valid_R / n valid_err = 1 - valid_acc / n acts_pc = acts_pc / acts_pt return valid_err, valid_R, acts_pc, visited_pages