def _convert_batch(self, py_batch): degree_input_np = np.array(py_batch['degree']) u_input_np = pad_sequences(py_batch['user'], cfg.u_max_ts, padding='post', truncating='pre').transpose((1, 0)) z_input_np = pad_sequences(py_batch['latent'], padding='post').transpose((1, 0)) m_input_np = pad_sequences(py_batch['response'], cfg.max_ts, padding='post', truncating='post').transpose((1, 0)) # fix p input p_input_np = pad_sequences(py_batch['post'], cfg.u_max_ts, padding='post', truncating='post').transpose((1, 0)) u_len = np.array(py_batch['u_len']) m_len = np.array(py_batch['m_len']) p_len = np.array(py_batch['p_len']) degree_input = Variable(torch.from_numpy(degree_input_np).float()) u_input = Variable(torch.from_numpy(u_input_np).long()) z_input = Variable(torch.from_numpy(z_input_np).long()) m_input = Variable(torch.from_numpy(m_input_np).long()) p_input = Variable(torch.from_numpy(p_input_np).long()) if cfg.cuda: u_input, z_input, m_input, p_input, degree_input = u_input.cuda(), z_input.cuda(), m_input.cuda(),\ p_input.cuda(), degree_input.cuda() supervised = py_batch['supervised'][0] return u_input, u_input_np, z_input, m_input, m_input_np, p_input, p_input_np, u_len, m_len, p_len,\ degree_input, supervised
def _convert_batch_para(self, py_batch, mode, prev_a_py=None): u_input_np = pad_sequences(py_batch['delex_user'], cfg.max_para_len, padding='post', truncating='pre').transpose((1, 0)) delex_para_input_np = pad_sequences(py_batch['delex_para'], cfg.max_para_len, padding='post', truncating='pre').transpose((1, 0)) u_len = np.array(py_batch['delex_u_len']) u_input = cuda_(Variable(torch.from_numpy(u_input_np).long())) delex_para_input = cuda_(Variable(torch.from_numpy(delex_para_input_np).long())) if mode == 'test': if prev_a_py: for i in range(len(prev_a_py)): eob = self.reader.vocab.encode('EOS_A') if eob in prev_a_py[i] and prev_a_py[i].index(eob) != len(prev_a_py[i]) - 1: idx = prev_a_py[i].index(eob) prev_a_py[i] = prev_a_py[i][:idx + 1] else: prev_a_py[i] = [eob] for j, word in enumerate(prev_a_py[i]): if word >= cfg.vocab_size or word < 0: prev_a_py[i][j] = 2 #unk else: prev_a_py = py_batch['pre_dial_act'] prev_dial_act_input_np = pad_sequences(prev_a_py, cfg.a_length, padding='post', truncating='pre').transpose((1, 0)) prev_dial_act_input = cuda_(Variable(torch.from_numpy(prev_dial_act_input_np).long())) else: prev_dial_act_input_np = pad_sequences(py_batch['pre_dial_act'], cfg.a_length, padding='post', truncating='pre').transpose((1, 0)) prev_dial_act_input = cuda_(Variable(torch.from_numpy(prev_dial_act_input_np).long())) return u_input, u_input_np, delex_para_input, delex_para_input_np, u_len, prev_dial_act_input
def _convert_batch(self, py_batch, prev_z_py=None, mode="train"): domain = py_batch['domain'] if mode == "train": u_input_py = py_batch['final_user'] u_len_py = py_batch['final_u_len'] else: u_input_py = py_batch['user'] u_len_py = py_batch['u_len'] kw_ret = {} if cfg.prev_z_method == 'concat' and prev_z_py is not None: for i in range(len(u_input_py)): eob = self.reader.vocab.encode('EOS_Z2') if eob in prev_z_py[i] and prev_z_py[i].index(eob) != len(prev_z_py[i]) - 1: idx = prev_z_py[i].index(eob) u_input_py[i] = prev_z_py[i][:idx + 1] + u_input_py[i] else: u_input_py[i] = prev_z_py[i] + u_input_py[i] u_len_py[i] = len(u_input_py[i]) for j, word in enumerate(prev_z_py[i]): if word >= cfg.vocab_size or word < 0: prev_z_py[i][j] = 2 #unk elif cfg.prev_z_method == 'separate' and prev_z_py is not None: for i in range(len(prev_z_py)): eob = self.reader.vocab.encode('EOS_Z2') if eob in prev_z_py[i] and prev_z_py[i].index(eob) != len(prev_z_py[i]) - 1: idx = prev_z_py[i].index(eob) prev_z_py[i] = prev_z_py[i][:idx + 1] for j, word in enumerate(prev_z_py[i]): if word >= cfg.vocab_size: prev_z_py[i][j] = 2 #unk prev_z_input_np = pad_sequences(prev_z_py, cfg.max_ts, padding='post', truncating='pre').transpose((1, 0)) prev_z_len = np.array([len(_) for _ in prev_z_py]) prev_z_input = cuda_(Variable(torch.from_numpy(prev_z_input_np).long())) kw_ret['prev_z_len'] = prev_z_len kw_ret['prev_z_input'] = prev_z_input kw_ret['prev_z_input_np'] = prev_z_input_np degree_input_np = np.array(py_batch['degree']) u_input_np = pad_sequences(u_input_py, cfg.max_ts, padding='post', truncating='pre').transpose((1, 0)) z_input_np = pad_sequences(py_batch['bspan'], padding='post').transpose((1, 0)) m_input_np = pad_sequences(py_batch['response'], cfg.max_ts, padding='post', truncating='post').transpose( (1, 0)) u_len = np.array(u_len_py) m_len = np.array(py_batch['m_len']) degree_input = cuda_(Variable(torch.from_numpy(degree_input_np).float())) u_input = cuda_(Variable(torch.from_numpy(u_input_np).long())) z_input = cuda_(Variable(torch.from_numpy(z_input_np).long())) m_input = cuda_(Variable(torch.from_numpy(m_input_np).long())) kw_ret['z_input_np'] = z_input_np return u_input, u_input_np, z_input, m_input, m_input_np, u_len, m_len, degree_input, kw_ret, domain
def _convert_batch_para(self, py_batch, mode, prev_a_py=None): combined_input = [] combined_length = [] for prev_response, delex_user in zip(py_batch['pv_resp'], py_batch['usdx']): combined_input.append(prev_response + delex_user) combined_length.append(len(prev_response + delex_user)) u_input_np = pad_sequences(combined_input, cfg.max_nl_length, padding='post', truncating='pre').transpose((1, 0)) u_len = np.array(combined_length) delex_para_input_np = pad_sequences(py_batch['padx'], cfg.max_nl_length, padding='post', truncating='pre').transpose((1, 0)) u_input = cuda_(torch.from_numpy(u_input_np).long()) delex_para_input = cuda_(torch.from_numpy(delex_para_input_np).long()) if mode == 'test': if prev_a_py: for i in range(len(prev_a_py)): eob = self.reader.vocab.encode('<eos_a>') if eob in prev_a_py[i] and prev_a_py[i].index(eob) != len( prev_a_py[i]) - 1: idx = prev_a_py[i].index(eob) prev_a_py[i] = prev_a_py[i][:idx + 1] else: prev_a_py[i] = [eob] ''' for j, word in enumerate(prev_a_py[i]): if word >= cfg.vocab_size: prev_a_py[i][j] = 2 #unk ''' else: prev_a_py = py_batch['pv_aspn'] prev_dial_act_input_np = pad_sequences(prev_a_py, cfg.max_nl_length, padding='post', truncating='pre').transpose( (1, 0)) prev_dial_act_input = cuda_( torch.from_numpy(prev_dial_act_input_np).long()) else: prev_dial_act_input_np = pad_sequences(py_batch['pv_aspn'], cfg.max_nl_length, padding='post', truncating='pre').transpose( (1, 0)) prev_dial_act_input = cuda_( torch.from_numpy(prev_dial_act_input_np).long()) return u_input, u_input_np, delex_para_input, delex_para_input_np, u_len, prev_dial_act_input
def _convert_input(self, encoded_input): u_input_np = pad_sequences([encoded_input], cfg.max_ts, padding='post', truncating='pre').transpose((1, 0)) u_input = cuda_(Variable(torch.from_numpy(u_input_np).long())) u_len = np.array([len(encoded_input)]) db_found = self.reader._degree_vec_mapping(1) degree_input_np = np.array([db_found]) degree_input = cuda_( Variable(torch.from_numpy(degree_input_np).float())) return u_input, u_input_np, u_len, degree_input
def greedy_decode(self, pz_dec_outs, u_enc_out, m_tm1, u_input_np, last_hidden, degree_input, bspan_index): decoded = [] bspan_index_np = pad_sequences(bspan_index).transpose((1, 0)) for t in range(self.max_ts): proba, last_hidden, _ = self.m_decoder(pz_dec_outs, u_enc_out, u_input_np, m_tm1, degree_input, last_hidden, bspan_index_np) mt_proba, mt_index = torch.topk(proba, 1) # [B,1] mt_index = mt_index.data.view(-1) decoded.append(mt_index.clone()) for i in range(mt_index.size(0)): if mt_index[i] >= cfg.vocab_size: mt_index[i] = 2 # unk m_tm1 = cuda_(Variable(mt_index).view(1, -1)) decoded = torch.stack(decoded, dim=0).transpose(0, 1) decoded = list(decoded) return [list(_) for _ in decoded]
def train(): def prepare_input(batch): src_ids, label = batch res = {} res['src'] = src_ids res['label'] = label return res # Set parameters: # ngram_range = 2 will add bi-grams features ngram_range = 2 max_features = 20000 maxlen = 400 batch_size = 32 embedding_dims = 50 epochs = 5 print('Loading data...') all_data = reader.raw_data(num_words=max_features) x_train, y_train, x_test, y_test = all_data print(len(x_train), 'train sequences') print(len(x_test), 'test sequences') print('Average train sequence length: {}'.format( np.mean(list(map(len, x_train)), dtype=int))) print('Average test sequence length: {}'.format( np.mean(list(map(len, x_test)), dtype=int))) if ngram_range > 1: print('Adding {}-gram features'.format(ngram_range)) # Create set of unique n-gram from the training set. ngram_set = set() for input_list in x_train: for i in range(2, ngram_range + 1): set_of_ngram = create_ngram_set(input_list, ngram_value=i) ngram_set.update(set_of_ngram) # Dictionary mapping n-gram token to a unique integer. # Integer values are greater than max_features in order # to avoid collision with existing features. start_index = max_features + 1 token_indice = {v: k + start_index for k, v in enumerate(ngram_set)} indice_token = {token_indice[k]: k for k in token_indice} # max_features is the highest integer that could be found in the dataset. max_features = np.max(list(indice_token.keys())) + 1 # Augmenting x_train and x_test with n-grams features x_train = add_ngram(x_train, token_indice, ngram_range) x_test = add_ngram(x_test, token_indice, ngram_range) print('Average train sequence length: {}'.format( np.mean(list(map(len, x_train)), dtype=int))) print('Average test sequence length: {}'.format( np.mean(list(map(len, x_test)), dtype=int))) print('Pad sequences (samples x time)') x_train = reader.pad_sequences(x_train, maxlen=maxlen) x_test = reader.pad_sequences(x_test, maxlen=maxlen) print('x_train shape:', x_train.shape) print('x_test shape:', x_test.shape) all_data = x_train, y_train, x_test, y_test print('Build model...') model = BaseModel(max_features=max_features) loss, acc = model.build_graph() main_program = fluid.default_main_program() inference_program = fluid.default_main_program().clone(for_test=True) optimizer = fluid.optimizer.Adam(0.01) optimizer.minimize(loss) place = fluid.CPUPlace() exe = Executor(place) exe.run(framework.default_startup_program()) for epoch_id in range(epochs): start_time = time.time() print("epoch id", epoch_id) train_data_iter = reader.get_data_iter(all_data, batch_size) total_loss = 0 total_acc = 0 batch_id = 0 for batch in train_data_iter: input_data_feed = prepare_input(batch) fetch_outs = exe.run(feed=input_data_feed, fetch_list=[loss.name, acc.name], use_program_cache=False) cost_train = np.array(fetch_outs[0]) acc_train = np.array(fetch_outs[1]) total_loss += cost_train total_acc += acc_train if batch_id > 0 and batch_id % 10 == 0: print("current loss: %.3f, current acc: %.3f for step %d" % (total_loss, total_acc * 0.1, batch_id)) total_loss = 0.0 total_acc = 0.0 batch_id += 1 test_data_iter = reader.get_data_iter(all_data, batch_size, mode='test') all_acc = [] for batch in test_data_iter: input_data_feed = prepare_input(batch) fetch_outs = exe.run(program=inference_program, feed=input_data_feed, fetch_list=[loss.name, acc.name], use_program_cache=False) all_acc.append(fetch_outs[1]) all_acc = np.array(all_acc).astype("float32") print("test acc: %.3f" % all_acc.mean())
def _convert_batch(self, py_batch): kw_ret = {} x = None gt_y = None if self.cfg.network == 'classification': state_vector = py_batch[ 'state_vector'] #list of array (batch_size, 1, vector_size) batch_size = len(state_vector) np_x = np.stack(state_vector, axis=0) #(batch_size, 1, vector_size) np_x = np.squeeze(np_x, axis=1) #(batch_size, vector_size) np_gt_y = np.zeros((batch_size, self.cfg.output_size), dtype=float) #(batch_size, output_size) for batch_id, idx_list in enumerate(py_batch['act_slot_idx_list']): for idx in idx_list: np_gt_y[batch_id, idx] = 1. x = cuda_(Variable(torch.from_numpy(np_x).float()), self.cfg) gt_y = cuda_(Variable(torch.from_numpy(np_gt_y).float()), self.cfg) elif 'seq2seq' in self.cfg.network: user_np = pad_sequences(py_batch['user_act_seq'], self.cfg.user_max_ts, padding='post', truncating='post').transpose((1, 0)) last_agent_np = pad_sequences(py_batch['last_agent_act_seq'], self.cfg.agent_max_ts, padding='post', truncating='post').transpose((1, 0)) current_slot_np = pad_sequences(py_batch['current_slot_seq'], self.cfg.current_slot_max_ts, padding='post', truncating='post').transpose( (1, 0)) # (seqlen, batchsize) agent_np = pad_sequences(py_batch['agent_act_seq'], self.cfg.agent_max_ts, padding='post', truncating='post').transpose((1, 0)) user_len = np.array(py_batch['user_len']) last_agent_len = np.array(py_batch['last_agent_len']) current_slot_len = np.array(py_batch['current_slot_len']) agent_len = np.array(py_batch['agent_len']) kb_turn_np = np.array(py_batch['kb_turn_vector']).transpose( 1, 0, 2) kw_ret['user_np'] = user_np #seqlen, batchsize kw_ret['last_agent_np'] = last_agent_np #seqlen, batchsize kw_ret['current_slot_np'] = current_slot_np #seqlen, batchsize kw_ret['agent_np'] = agent_np #seqlen, batchsize kw_ret['user_len'] = user_len #batchsize kw_ret['last_agent_len'] = last_agent_len #batchsize kw_ret['current_slot_len'] = current_slot_len #batchsize kw_ret['agent_len'] = agent_len #batchsize kw_ret['kb_turn'] = cuda_( Variable(torch.from_numpy(kb_turn_np).float()), self.cfg) #1, batch_size, kb_turn_size kw_ret['last_agent'] = cuda_( Variable(torch.from_numpy(last_agent_np).long()), self.cfg) #seqlen, batchsize kw_ret['current_slot'] = cuda_( Variable(torch.from_numpy(current_slot_np).long()), self.cfg) #seqlen, batchsize x = cuda_(Variable(torch.from_numpy(user_np).long()), self.cfg) #seqlen, batchsize gt_y = cuda_(Variable(torch.from_numpy(agent_np).long()), self.cfg) #seqlen, batchsize elif 'cas' in self.cfg.network: user_np = pad_sequences(py_batch['user_act_seq'], self.cfg.user_max_ts, padding='post', truncating='post').transpose((1, 0)) last_agent_np = pad_sequences(py_batch['last_agent_act_seq'], self.cfg.agent_max_ts, padding='post', truncating='post').transpose((1, 0)) current_slot_np = pad_sequences(py_batch['current_slot_seq'], self.cfg.current_slot_max_ts, padding='post', truncating='post').transpose( (1, 0)) # (seqlen, batchsize) current_user_request_np = pad_sequences( py_batch['current_user_request_seq'], self.cfg.current_singleslot_max_ts, padding='post', truncating='post').transpose((1, 0)) # (seqlen, batchsize) current_user_inform_np = pad_sequences( py_batch['current_user_inform_seq'], self.cfg.current_singleslot_max_ts, padding='post', truncating='post').transpose((1, 0)) # (seqlen, batchsize) current_agent_request_np = pad_sequences( py_batch['current_agent_request_seq'], self.cfg.current_singleslot_max_ts, padding='post', truncating='post').transpose((1, 0)) # (seqlen, batchsize) current_agent_propose_np = pad_sequences( py_batch['current_agent_propose_seq'], self.cfg.current_singleslot_max_ts, padding='post', truncating='post').transpose((1, 0)) # (seqlen, batchsize) user_len = np.array(py_batch['user_len']) last_agent_len = np.array(py_batch['last_agent_len']) current_slot_len = np.array(py_batch['current_slot_len']) current_user_request_len = np.array( py_batch['current_user_request_len']) current_user_inform_len = np.array( py_batch['current_user_inform_len']) current_agent_request_len = np.array( py_batch['current_agent_request_len']) current_agent_propose_len = np.array( py_batch['current_agent_propose_len']) kb_turn_np = np.array(py_batch['kb_turn_vector']).transpose( 1, 0, 2) cas_continue_np = np.concatenate( py_batch['cas_continue'], axis=1) #seqlen, batchsize, continuesize cas_act_np = np.concatenate(py_batch['cas_act'], axis=1) #seqlen, batchsize, actsize cas_slot_np = np.concatenate(py_batch['cas_slot'], axis=1) #seqlen, batchsize, slotsize cas_continue_go_np = np.concatenate(py_batch['cas_continue_go'], axis=1) cas_act_go_np = np.concatenate(py_batch['cas_act_go'], axis=1) cas_slot_go_np = np.concatenate(py_batch['cas_slot_go'], axis=1) cas_continue_list_np = np.array( py_batch['cas_continue_list']).transpose( (1, 0)) # seqlen, batchsize cas_act_list_np = np.array(py_batch['cas_act_list']).transpose( (1, 0)) #seqlen, batchsize kw_ret['user_len'] = user_len #batchsize kw_ret['last_agent_len'] = last_agent_len #batchsize kw_ret['current_slot_len'] = current_slot_len #batchsize kw_ret[ 'current_user_request_len'] = current_user_request_len # batchsize kw_ret[ 'current_user_inform_len'] = current_user_inform_len # batchsize kw_ret[ 'current_agent_request_len'] = current_agent_request_len # batchsize kw_ret[ 'current_agent_propose_len'] = current_agent_propose_len # batchsize kw_ret['kb_turn'] = cuda_( Variable(torch.from_numpy(kb_turn_np).float()), self.cfg) #1, batch_size, kb_turn_size kw_ret['last_agent'] = cuda_( Variable(torch.from_numpy(last_agent_np).long()), self.cfg) #seqlen, batchsize kw_ret['current_slot'] = cuda_( Variable(torch.from_numpy(current_slot_np).long()), self.cfg) #seqlen, batchsize kw_ret['current_user_request'] = cuda_( Variable(torch.from_numpy(current_user_request_np).long()), self.cfg) kw_ret['current_user_inform'] = cuda_( Variable(torch.from_numpy(current_user_inform_np).long()), self.cfg) kw_ret['current_agent_request'] = cuda_( Variable(torch.from_numpy(current_agent_request_np).long()), self.cfg) kw_ret['current_agent_propose'] = cuda_( Variable(torch.from_numpy(current_agent_propose_np).long()), self.cfg) kw_ret['continue_go'] = cuda_( Variable(torch.from_numpy(cas_continue_go_np).float()), self.cfg) kw_ret['act_go'] = cuda_( Variable(torch.from_numpy(cas_act_go_np).float()), self.cfg) kw_ret['slot_go'] = cuda_( Variable(torch.from_numpy(cas_slot_go_np).float()), self.cfg) kw_ret['cas_act'] = cuda_( Variable(torch.from_numpy(cas_act_np).float()), self.cfg) kw_ret['cas_continue'] = cuda_( Variable(torch.from_numpy(cas_continue_np).float()), self.cfg) cas_continue_list = cuda_( Variable(torch.from_numpy(cas_continue_list_np).long()), self.cfg) cas_act_list = cuda_( Variable(torch.from_numpy(cas_act_list_np).long()), self.cfg) cas_slot = cuda_(Variable(torch.from_numpy(cas_slot_np).float()), self.cfg) x = cuda_(Variable(torch.from_numpy(user_np).long()), self.cfg) #seqlen, batchsize gt_y = (cas_continue_list, cas_act_list, cas_slot) else: assert () return x, gt_y, kw_ret
def _convert_batch(self, py_batch, prev_z_py=None): kw_ret = {} requested_7_np = np.stack(py_batch['requested_7'], axis=0).transpose() requested_7_np = requested_7_np[:, :, np.newaxis] # 7, batchsize, 1 response_7_np = np.stack(py_batch['response_7'], axis=0).transpose() response_7_np = response_7_np[:, :, np.newaxis] # 7, batchsize, 1 requestable_key = py_batch['requestable_key'] # (batchsize, 7) keys requestable_slot = py_batch['requestable_slot'] # (batchsize, 7) slots requestable_key_np = pad_sequences(requestable_key, len(requestable_key[0]), padding='post', truncating='post').transpose((1, 0)) requestable_slot_np = pad_sequences(requestable_slot, len(requestable_slot[0]), padding='post', truncating='post').transpose( (1, 0)) kw_ret['requestable_key_np'] = requestable_key_np kw_ret['requestable_slot_np'] = requestable_slot_np kw_ret['requestable_key'] = cuda_( Variable(torch.from_numpy(requestable_key_np).long())) kw_ret['requestable_slot'] = cuda_( Variable(torch.from_numpy(requestable_slot_np).long())) kw_ret['requested_7'] = cuda_( Variable(torch.from_numpy(requested_7_np).float())) kw_ret['response_7'] = cuda_( Variable(torch.from_numpy(response_7_np).float())) u_input_py = py_batch['user'] u_len_py = py_batch['u_len'] if cfg.prev_z_method == 'concat' and prev_z_py is not None: for i in range(len(u_input_py)): eob = self.reader.vocab.encode('EOS_Z2') if eob in prev_z_py[i] and prev_z_py[i].index(eob) != len( prev_z_py[i]) - 1: idx = prev_z_py[i].index(eob) u_input_py[i] = prev_z_py[i][:idx + 1] + u_input_py[i] else: u_input_py[i] = prev_z_py[i] + u_input_py[i] u_len_py[i] = len(u_input_py[i]) for j, word in enumerate(prev_z_py[i]): if word >= cfg.vocab_size: prev_z_py[i][j] = 2 # unk elif cfg.prev_z_method == 'separate' and prev_z_py is not None: for i in range(len(prev_z_py)): eob = self.reader.vocab.encode('EOS_Z2') if eob in prev_z_py[i] and prev_z_py[i].index(eob) != len( prev_z_py[i]) - 1: idx = prev_z_py[i].index(eob) prev_z_py[i] = prev_z_py[i][:idx + 1] for j, word in enumerate(prev_z_py[i]): if word >= cfg.vocab_size: prev_z_py[i][j] = 2 # unk prev_z_input_np = pad_sequences(prev_z_py, cfg.max_ts, padding='post', truncating='pre').transpose((1, 0)) prev_z_len = np.array([len(_) for _ in prev_z_py]) prev_z_input = cuda_( Variable(torch.from_numpy(prev_z_input_np).long())) kw_ret['prev_z_len'] = prev_z_len kw_ret['prev_z_input'] = prev_z_input kw_ret['prev_z_input_np'] = prev_z_input_np degree_input_np = np.array(py_batch['degree']) u_input_np = pad_sequences(u_input_py, cfg.max_ts, padding='post', truncating='pre').transpose((1, 0)) m_input_np = pad_sequences(py_batch['response'], cfg.max_ts, padding='post', truncating='post').transpose((1, 0)) r_input_np = pad_sequences(py_batch['requested'], cfg.req_length, padding='post', truncating='post').transpose( (1, 0)) # (seqlen, batchsize) k_input_np = pad_sequences(py_batch['constraint_key'], len(py_batch['constraint_key'][0]), padding='post', truncating='post').transpose((1, 0)) flat_constraint_value = [] num_k = k_input_np.shape[0] for b in py_batch['constraint_value']: for k in b: flat_constraint_value.append(k) flat_i_input_np = pad_sequences(flat_constraint_value, cfg.inf_length, padding='post', truncating='post') i_input_np = [] i_k_input_np = [] for idx, k in enumerate(flat_i_input_np): i_k_input_np.append(k) if (idx + 1) % num_k == 0: i_input_np.append(np.asarray(i_k_input_np)) i_k_input_np = [] i_input_np = np.asarray(i_input_np) # (batchsize, key_size, seqlen) u_len = np.array(u_len_py) m_len = np.array(py_batch['m_len']) degree_input = cuda_( Variable(torch.from_numpy(degree_input_np).float())) u_input = cuda_(Variable(torch.from_numpy(u_input_np).long())) m_input = cuda_(Variable(torch.from_numpy(m_input_np).long())) r_input = cuda_(Variable(torch.from_numpy(r_input_np).long())) k_input = cuda_(Variable(torch.from_numpy(k_input_np).long())) i_input = cuda_(Variable(torch.from_numpy(i_input_np).long())) i_input = i_input.permute(1, 2, 0) z_input = [] for k_i_input in i_input: z_input.append(k_i_input) z_input = torch.cat(z_input, dim=0) z_input_np = z_input.cpu().data.numpy() kw_ret['z_input_np'] = z_input_np return u_input, u_input_np, z_input, m_input, m_input_np, u_len, m_len, \ degree_input, k_input, i_input, r_input, kw_ret, py_batch['constraint_eos']
def interact(self): def z2degree(gen_z): gen_bspan = self.reader.vocab.sentence_decode(gen_z, eos='EOS_Z2') constraint_request = gen_bspan.split() constraints = constraint_request[:constraint_request.index('EOS_Z1')] if 'EOS_Z1' \ in constraint_request else constraint_request for j, ent in enumerate(constraints): constraints[j] = ent.replace('_', ' ') degree = self.reader.db_search(constraints) degree_input_list = self.reader._degree_vec_mapping(len(degree)) degree_input = cuda_( Variable(torch.Tensor(degree_input_list).unsqueeze(0))) return degree, degree_input self.m.eval() print('Start interaction.') kw_ret = dict({'func': z2degree}) while True: usr = input('usr: '******'END': break usr_words = usr.split() + ['EOS_U'] u_len = np.array([len(usr_words)]) usr_indices = self.reader.vocab.sentence_encode(usr_words) u_input_np = np.array(usr_indices)[:, np.newaxis] u_input = cuda_(Variable(torch.from_numpy(u_input_np).long())) m_idx, z_idx, _ = self.m(mode='test', degree_input=None, z_input=None, u_input=u_input, u_input_np=u_input_np, u_len=u_len, m_input=None, m_input_np=None, m_len=None, turn_states=None, **kw_ret) degree = kw_ret.get('degree') venue = random.sample(degree, 1)[0] if degree else dict() l = [self.reader.vocab.decode(_) for _ in m_idx[0]] if 'EOS_M' in l: l = l[:l.index('EOS_M')] l_origin = [] for word in l: if 'SLOT' in word: word = word[:-5] if word in venue.keys(): value = venue[word] if value != '?': l_origin.append(value.replace(' ', '_')) else: l_origin.append(word) sys = ' '.join(l_origin) print('sys:', sys) if cfg.prev_z_method == 'separate': eob = self.reader.vocab.encode('EOS_Z2') if eob in z_idx[0] and z_idx[0].index(eob) != len( z_idx[0]) - 1: idx = z_idx[0].index(eob) z_idx[0] = z_idx[0][:idx + 1] for j, word in enumerate(z_idx[0]): if word >= cfg.vocab_size: z_idx[0][j] = 2 #unk prev_z_input_np = pad_sequences(z_idx, cfg.max_ts, padding='post', truncating='pre').transpose( (1, 0)) prev_z_len = np.array([len(_) for _ in z_idx]) prev_z_input = cuda_( Variable(torch.from_numpy(prev_z_input_np).long())) kw_ret['prev_z_len'] = prev_z_len kw_ret['prev_z_input'] = prev_z_input kw_ret['prev_z_input_np'] = prev_z_input_np