def read(self, utt_j): # transformation emb_j = tanh(self.Wemb_backup[utt_j, :]) # 1st convolution wh1_j = self.convolution(emb_j, self.Wcv1_backup, mode='np') if self.pool[0]: # max pooling wh1_j = max_pool(wh1_j, (3, 1), ignore_border=False) wh1_j = tanh(wh1_j) # 2nd convolution wh2_j = self.convolution(wh1_j, self.Wcv2_backup, mode='np') if self.pool[1]: # max pooling wh2_j = max_pool(wh2_j, (3, 1), ignore_border=False) wh2_j = tanh(wh2_j) if self.level >= 3: # 3rd convolution and pooling wh3_j = self.convolution(wh2_j, self.Wcv3_backup, mode='np') if self.pool[2]: # max pooling wh3_j = max_pool(wh3_j, (3, 1), ignore_border=False) # average pooling wh3_j = tanh(np.sum(wh3_j, axis=0)) else: # level < 3 wh3_j = None if self.pool == (True, True, True): return None, wh3_j else: return np.concatenate([wh1_j, wh2_j], axis=1), wh3_j
def decide(self, belief_t, degree_t, intent_t, masked_source_t, masked_target_t, forced_sample=None): # prepare belief state vector belief_t = np.concatenate(belief_t, axis=0) # sample how many actions n = 1 # forced sampling if forced_sample != None: z_t = [forced_sample] prob_t = None # different sampling mode elif self.sample_mode == 'posterior' and masked_target_t != None: # training time, sample from posterior z_t, prob_t = self._sample_from_posterior( belief_t, degree_t, intent_t, masked_source_t, masked_target_t) elif self.sample_mode == 'prior': # testing time, sample from prior z_t, prob_t = self._sample_from_prior(belief_t, degree_t, intent_t) # state representation hidden_t = tanh(np.dot(belief_t, self.Ws1_backup) + np.dot(degree_t, self.Ws2_backup) + np.dot(intent_t, self.Ws3_backup)) # put sample into decoder to decode hidden_t = np.multiply(sigmoid(self.Wd2_backup[z_t, :] + self.bd1_backup), hidden_t) hidden_t = np.repeat(hidden_t, n, axis=0) actEmb_t = tanh(np.dot( np.concatenate([tanh(self.Wd1_backup[z_t, :]), hidden_t], axis=1), self.Wd3_backup)) return actEmb_t, z_t, prob_t
def read(self, s_j): # hidden layers to be stored h = [np.zeros(self.dih)] c_tm1 = np.zeros(self.dih) # forward encoder for w_t in s_j: # lstm step in_t = sigmoid( self.Wemb_backup[w_t] ) bundle_t = np.dot(in_t, self.iWgate_backup) +\ np.dot(h[-1],self.iUgate_backup) ig = sigmoid(bundle_t[:self.dih]) fg = sigmoid(bundle_t[self.dih:self.dih*2]+self.bf_backup) og = sigmoid(bundle_t[self.dih*2:self.dih*3]) cx_t= tanh(bundle_t[self.dih*3:]) # compute cell activation and hidden layer c_t = np.multiply(ig,cx_t) + \ np.multiply(fg,c_tm1) h_t = np.multiply(og,tanh(c_t)) # store current step vectors h.append(h_t) c_tm1 = c_t return np.array(h)[-1]
def _gen(self,node): # input word embedding wv_t = sigmoid(self.Wemb_np[node.wordid,:]) # attention b_t = np.zeros((node.sv.shape[0])) for j in range(node.sv.shape[0]): b_t[j] = np.dot(tanh(np.dot( np.concatenate([wv_t,node.h,node.sv[j]],axis=0), self.Wha_np)),self.Vha_np) b_t = softmax(b_t) sv_emb_t = np.dot(b_t,node.sv) da_emb_t = tanh( node.a+sv_emb_t ) # compute ig, fg, og together and slice it gates_t = np.dot( np.concatenate([wv_t,node.h,da_emb_t],axis=0), self.Wgate_np) ig = sigmoid(gates_t[:self.dh]) fg = sigmoid(gates_t[self.dh:self.dh*2]) og = sigmoid(gates_t[self.dh*2:self.dh*3]) cx_t= tanh( gates_t[self.dh*3:] ) # update lstm internal state c_t = np.multiply(ig,cx_t) + np.multiply(fg,node.c) # obtain new hiddne layer h_t = np.multiply(og,tanh(c_t)) # compute output distribution target word prob o_t = softmax( np.dot(h_t,self.Who_np) ) # make sure we won't sample unknown word o_t[0] = 0.0 selected_words = np.argsort(o_t)[::-1][:self.beamwidth].tolist() # return results return selected_words, o_t[selected_words], c_t, h_t
def read(self,utt_j): # transformation emb_j = tanh( self.Wemb_backup[utt_j,:] ) # 1st convolution wh1_j = self.convolution(emb_j,self.Wcv1_backup,mode='np') if self.pool[0]: # max pooling wh1_j = max_pool(wh1_j,(3,1),ignore_border=False) wh1_j = tanh(wh1_j) # 2nd convolution wh2_j = self.convolution(wh1_j, self.Wcv2_backup,mode='np') if self.pool[1]: # max pooling wh2_j = max_pool(wh2_j,(3,1),ignore_border=False) wh2_j = tanh(wh2_j) if self.level>=3: # 3rd convolution and pooling wh3_j = self.convolution(wh2_j, self.Wcv3_backup,mode='np') if self.pool[2]: # max pooling wh3_j = max_pool(wh3_j,(3,1),ignore_border=False) # average pooling wh3_j = tanh(np.sum(wh3_j,axis=0)) else: # level < 3 wh3_j = None if self.pool==(True,True,True): return None, wh3_j else: return np.concatenate([wh1_j,wh2_j],axis=1), wh3_j
def _gen(self, node): # input word embedding wv_t = sigmoid(self.Wemb_np[node.wordid, :]) # compute ig, fg, og together and slice it gates_t = np.dot(np.concatenate([wv_t, node.h, node.sv], axis=0), self.Wgate_np) ig = sigmoid(gates_t[:self.dh]) fg = sigmoid(gates_t[self.dh:self.dh * 2]) og = sigmoid(gates_t[self.dh * 2:self.dh * 3]) # compute reading rg rg = sigmoid( np.dot(np.concatenate([wv_t, node.h, node.sv], axis=0), self.Wrgate_np)) # compute proposed cell value cx_t = np.tanh( np.dot(np.concatenate([wv_t, node.h], axis=0), self.Wcx_np)) # update DA 1-hot vector sv_t = np.multiply(rg, node.sv) # update lstm internal state c_t = np.multiply(ig, cx_t) + \ np.multiply(fg, node.c) + \ tanh(np.dot(np.concatenate([node.a, sv_t], axis=0), self.Wfc_np)) # obtain new hiddne layer h_t = np.multiply(og, tanh(c_t)) # compute output distribution target word prob o_t = softmax(np.dot(h_t, self.Who_np)) # make sure we won't sample unknown word o_t[0] = 0.0 selected_words = np.argsort(o_t)[::-1][:self.beamwidth].tolist() # return results return selected_words, o_t[selected_words], sv_t, c_t, h_t
def _gen(self, node): # input word embedding wv_t = sigmoid(self.Wemb_np[node.wordid, :]) # attention b_t = np.zeros((node.sv.shape[0])) for j in range(node.sv.shape[0]): b_t[j] = np.dot( tanh( np.dot(np.concatenate([wv_t, node.h, node.sv[j]], axis=0), self.Wha_np)), self.Vha_np) b_t = softmax(b_t) sv_emb_t = np.dot(b_t, node.sv) da_emb_t = tanh(node.a + sv_emb_t) # compute ig, fg, og together and slice it gates_t = np.dot(np.concatenate([wv_t, node.h, da_emb_t], axis=0), self.Wgate_np) ig = sigmoid(gates_t[:self.dh]) fg = sigmoid(gates_t[self.dh:self.dh * 2]) og = sigmoid(gates_t[self.dh * 2:self.dh * 3]) cx_t = tanh(gates_t[self.dh * 3:]) # update lstm internal state c_t = np.multiply(ig, cx_t) + np.multiply(fg, node.c) # obtain new hiddne layer h_t = np.multiply(og, tanh(c_t)) # compute output distribution target word prob o_t = softmax(np.dot(h_t, self.Who_np)) # make sure we won't sample unknown word o_t[0] = 0.0 selected_words = np.argsort(o_t)[::-1][:self.beamwidth].tolist() # return results return selected_words, o_t[selected_words], c_t, h_t
def decide(self,belief_t, degree_t, intent_t, masked_source_t, masked_target_t, forced_sample=None): # prepare belief state vector belief_t = np.concatenate(belief_t,axis=0) # sample how many actions n = 1 # forced sampling if forced_sample!=None: z_t = [forced_sample] prob_t = None # different sampling mode elif self.sample_mode=='posterior' and masked_target_t!=None: # training time, sample from posterior z_t, prob_t = self._sample_from_posterior( belief_t, degree_t, intent_t, masked_source_t, masked_target_t) elif self.sample_mode=='prior': # testing time, sample from prior z_t, prob_t = self._sample_from_prior(belief_t, degree_t, intent_t) # state representation hidden_t = tanh(np.dot(belief_t,self.Ws1_backup)+ np.dot(degree_t,self.Ws2_backup)+ np.dot(intent_t,self.Ws3_backup) ) # put sample into decoder to decode hidden_t = np.multiply(sigmoid(self.Wd2_backup[z_t,:]+self.bd1_backup),hidden_t) hidden_t = np.repeat(hidden_t,n,axis=0) actEmb_t = tanh(np.dot( np.concatenate([tanh(self.Wd1_backup[z_t,:]),hidden_t],axis=1), self.Wd3_backup)) return actEmb_t, z_t, prob_t
def _gen(self,node): # input word embedding wv_t = sigmoid(self.Wemb_np[node.wordid,:]) # compute ig, fg, og together and slice it gates_t = np.dot( np.concatenate( [wv_t,node.h,node.sv],axis=0),self.Wgate_np) ig = sigmoid(gates_t[:self.dh]) fg = sigmoid(gates_t[self.dh:self.dh*2]) og = sigmoid(gates_t[self.dh*2:self.dh*3]) # compute reading rg rg = sigmoid(np.dot(np.concatenate( [wv_t,node.h,node.sv],axis=0),self.Wrgate_np)) # compute proposed cell value cx_t= np.tanh(np.dot(np.concatenate( [wv_t,node.h],axis=0),self.Wcx_np)) # update DA 1-hot vector sv_t = np.multiply(rg,node.sv) # update lstm internal state c_t = np.multiply(ig,cx_t) +\ np.multiply(fg,node.c)+\ tanh(np.dot(np.concatenate([node.a,sv_t],axis=0),self.Wfc_np)) # obtain new hiddne layer h_t = np.multiply(og,tanh(c_t)) # compute output distribution target word prob o_t = softmax( np.dot(h_t,self.Who_np) ) # make sure we won't sample unknown word o_t[0] = 0.0 selected_words = np.argsort(o_t)[::-1][:self.beamwidth].tolist() # return results return selected_words, o_t[selected_words], sv_t, c_t, h_t
def read(self, s_j): # hidden layers to be stored h = [np.zeros(self.dih)] c_tm1 = np.zeros(self.dih) # forward encoder for w_t in s_j: # lstm step in_t = sigmoid(self.Wemb_backup[w_t]) bundle_t = np.dot(in_t, self.iWgate_backup) + \ np.dot(h[-1], self.iUgate_backup) ig = sigmoid(bundle_t[:self.dih]) fg = sigmoid(bundle_t[self.dih:self.dih * 2] + self.bf_backup) og = sigmoid(bundle_t[self.dih * 2:self.dih * 3]) cx_t = tanh(bundle_t[self.dih * 3:]) # compute cell activation and hidden layer c_t = np.multiply(ig, cx_t) + \ np.multiply(fg, c_tm1) h_t = np.multiply(og, tanh(c_t)) # store current step vectors h.append(h_t) c_tm1 = c_t return np.array(h)[-1]
def decide(self, belief_t, degree_t, intent_t, ohidden_tjm1, wemb_tj): # embed degree_t = tanh(np.dot(degree_t,self.Ws2_backup)) intent_t = tanh(np.dot(intent_t,self.Ws3_backup)) # score bias score_t=np.dot(ohidden_tjm1,self.Wa1_backup)+\ np.dot(wemb_tj, self.Wa2_backup)+\ np.dot(belief_t,self.Wa3_backup) # attention mechanism atten_t= softmax(np.dot(sigmoid(score_t),self.Va1_backup)) actEmb = tanh(np.dot(atten_t,belief_t)+degree_t+intent_t) return np.expand_dims(actEmb,axis=0)
def decide(self, belief_t, degree_t, intent_t, ohidden_tjm1, wemb_tj): # embed degree_t = tanh(np.dot(degree_t, self.Ws2_backup)) intent_t = tanh(np.dot(intent_t, self.Ws3_backup)) # score bias score_t=np.dot(ohidden_tjm1,self.Wa1_backup)+\ np.dot(wemb_tj, self.Wa2_backup)+\ np.dot(belief_t,self.Wa3_backup) # attention mechanism atten_t = softmax(np.dot(sigmoid(score_t), self.Va1_backup)) actEmb = tanh(np.dot(atten_t, belief_t) + degree_t + intent_t) return np.expand_dims(actEmb, axis=0)
def _sample_from_posterior(self, belief_t, degree_t, intent_t, masked_source_t, masked_target_t): # Posterior # response encoding target_intent_t = bidirectional_read(self.tfEncoder, self.tbEncoder, masked_target_t) source_intent_t = bidirectional_read(self.sfEncoder, self.sbEncoder, masked_source_t) # posterior parameterisation q_logit_t = np.dot( tanh( np.dot(belief_t, self.Wq1_backup) + np.dot(degree_t, self.Wq2_backup) + np.dot(source_intent_t, self.Wq3_backup) + np.dot(target_intent_t, self.Wq4_backup)), self.Wq5_backup) # sampling from a scaled posterior sortedIndex = np.argsort(q_logit_t)[::-1][:self.topN] topN_posterior_t = softmax(q_logit_t[sortedIndex]) z_t = sortedIndex[np.argmax( np.random.multinomial(n=1, pvals=topN_posterior_t))] #z_t = sortedIndex[0] z_t = np.expand_dims(z_t, axis=0) print sortedIndex[:3] print softmax(q_logit_t)[sortedIndex][:3] print 'Posterior : %s' % sortedIndex print 'probability: %s' % topN_posterior_t return z_t, softmax(q_logit_t)
def decide(self, belief_t, degree_t, intent_t): # numpy function called during test time belief_t = np.concatenate(belief_t, axis=0) return np.expand_dims(tanh( np.dot(belief_t, self.Ws1_backup) + np.dot(degree_t, self.Ws2_backup) + np.dot(intent_t, self.Ws3_backup)), axis=0)
def decide(self, belief_t, degree_t, intent_t): # numpy function called during test time belief_t = np.concatenate(belief_t,axis=0) return np.expand_dims( tanh( np.dot(belief_t,self.Ws1_backup)+ np.dot(degree_t,self.Ws2_backup)+ np.dot(intent_t,self.Ws3_backup) ),axis=0)
def _sample_from_posterior(self, belief_t, degree_t, intent_t, masked_source_t, masked_target_t): # Posterior # response encoding target_intent_t = bidirectional_read( self.tfEncoder, self.tbEncoder, masked_target_t) source_intent_t = bidirectional_read( self.sfEncoder, self.sbEncoder, masked_source_t) # posterior parameterisation q_logit_t = np.dot(tanh( np.dot(belief_t,self.Wq1_backup)+ np.dot(degree_t,self.Wq2_backup)+ np.dot(source_intent_t,self.Wq3_backup)+ np.dot(target_intent_t,self.Wq4_backup)), self.Wq5_backup ) # sampling from a scaled posterior sortedIndex = np.argsort(q_logit_t)[::-1][:self.topN] topN_posterior_t= softmax(q_logit_t[sortedIndex]) z_t = sortedIndex[ np.argmax( np.random.multinomial(n=1, pvals=topN_posterior_t)) ] #z_t = sortedIndex[0] z_t = np.expand_dims(z_t,axis=0) print sortedIndex[:3] print softmax(q_logit_t)[sortedIndex][:3] print 'Posterior : %s' % sortedIndex print 'probability: %s' % topN_posterior_t return z_t, softmax(q_logit_t)
def _decideBelief(self,belief_t): # belief vectors beliefs_t = [] bn = 0 for bvec in belief_t: size = bvec.shape[0] beliefs_t.append( tanh(np.dot(bvec,self.Ws1_backup[bn:bn+size,:]))) bn += size beliefs_t = np.concatenate(np.expand_dims(beliefs_t,axis=0),axis=0) return beliefs_t
def _decideBelief(self, belief_t): # belief vectors beliefs_t = [] bn = 0 for bvec in belief_t: size = bvec.shape[0] beliefs_t.append(tanh(np.dot(bvec, self.Ws1_backup[bn:bn + size, :]))) bn += size beliefs_t = np.concatenate(np.expand_dims(beliefs_t, axis=0), axis=0) return beliefs_t
def _sample_from_prior(self, belief_t, degree_t, intent_t): # prior parameterisarion hidden_t = tanh(np.dot(belief_t, self.Ws1_backup) + np.dot(degree_t, self.Ws2_backup) + np.dot(intent_t, self.Ws3_backup)) p_logit_t = np.dot( tanh(np.dot(hidden_t, self.Wp1_backup) + self.bp1_backup), self.Wp2_backup) # sampling from prior sortedIndex = np.argsort(p_logit_t)[::-1][:self.topN] topN_prior_t = softmax(p_logit_t[sortedIndex]) z_t = sortedIndex[np.argmax(np.random.multinomial(n=1, pvals=topN_prior_t))] z_t = np.expand_dims(z_t, axis=0) # choose the top N samples print 'Sample : %s' % z_t print 'Prior dist.: %s' % sortedIndex print 'probability: %s' % topN_prior_t print return z_t, softmax(p_logit_t)
def _sample_from_prior(self, belief_t, degree_t, intent_t): # prior parameterisarion hidden_t = tanh(np.dot(belief_t,self.Ws1_backup)+ np.dot(degree_t,self.Ws2_backup)+ np.dot(intent_t,self.Ws3_backup) ) p_logit_t = np.dot( tanh(np.dot(hidden_t,self.Wp1_backup)+self.bp1_backup), self.Wp2_backup) # sampling from prior sortedIndex = np.argsort(p_logit_t)[::-1][:self.topN] topN_prior_t= softmax(p_logit_t[sortedIndex]) z_t = sortedIndex[ np.argmax( np.random.multinomial(n=1, pvals=topN_prior_t)) ] z_t = np.expand_dims(z_t,axis=0) # choose the top N samples print 'Sample : %s' % z_t print 'Prior dist.: %s' % sortedIndex print 'probability: %s' % topN_prior_t print return z_t, softmax(p_logit_t)
def _forwardpass(self, n, intent_t, belief_vec_t, degree_t, actEmb_t, scoreTable): # forward pass in_j = sigmoid(self.Wemb_backup[n.wordid]) # action embedding if self.ply == 'attention': actEmb_tj = self.policy.decide(belief_vec_t, degree_t, intent_t, n.h, in_j)[0] else: # fixed action embedding actEmb_tj = actEmb_t # syntatic memory cell and gate # compute i, f, o, c together and slice it bundle_j = np.dot(in_j, self.oWgate_backup) + \ np.dot(n.h, self.oUgate_backup) bundle_aj = np.dot(actEmb_tj, self.Wzh_backup) # input gate ig = sigmoid(bundle_j[:self.doh] + bundle_aj[:self.doh] + self.b_backup[:self.doh]) # use forget bias or not fg = sigmoid(bundle_j[self.doh:self.doh * 2] + bundle_aj[self.doh:self.doh * 2] + self.b_backup[self.doh:self.doh * 2]) # output gate og = sigmoid(bundle_j[self.doh * 2:self.doh * 3] + bundle_aj[self.doh * 2:self.doh * 3] + self.b_backup[self.doh * 2:self.doh * 3]) # proposed memory cell # reading gate, memory cell, hidden layer if self.struct == 'lstm_cond': # reading gate control signal rg = sigmoid(bundle_j[self.doh * 4:self.doh * 5] + bundle_aj[self.doh * 4:self.doh * 5] + self.b_backup[self.doh * 3:]) cx_j = tanh(bundle_j[self.doh * 3:self.doh * 4]) oc_j = np.multiply(ig, cx_j) + \ np.multiply(fg, n.c) + \ np.multiply(rg, tanh(bundle_aj[self.doh * 3:self.doh * 4])) oh_j = np.multiply(og, tanh(oc_j)) o_j = softmax(np.dot(oh_j, self.Who_backup)) elif self.struct == 'lstm_mix': # two signals rg = sigmoid(bundle_j[self.doh * 4:self.doh * 5] + bundle_aj[self.doh * 4:self.doh * 5] + self.b_backup[self.doh * 3:]) cx_j = tanh(bundle_j[self.doh * 3:self.doh * 4]) oc_j = np.multiply(ig, cx_j) + \ np.multiply(fg, n.c) oh_j = np.multiply(og, tanh(oc_j)) + \ np.multiply(rg, tanh(bundle_aj[self.doh * 3:self.doh * 4])) o_j = softmax(np.dot(oh_j, self.Who_backup)) elif self.struct == 'lstm_lm': # lm style cx_j = tanh(bundle_j[self.doh * 3:self.doh * 4] + bundle_aj[self.doh * 3:self.doh * 4]) oc_j = np.multiply(ig, cx_j) + \ np.multiply(fg, n.c) oh_j = np.multiply(og, tanh(oc_j)) o_j = softmax(np.dot(oh_j, self.Who_backup)) else: sys.exit('[ERROR]: Unseen decoder structure ' + self.struct) # compute output distribution, logp, and sample # make sure we won't sample unknown word o_j[0] = 0.0 selected_words = np.argsort(o_j)[::-1][:self.beamwidth] # expand nodes and add additional reward nextnodes = [] for wid in selected_words: # ignore <unk> token # loglikelihood of current word logp = np.log10(o_j[wid]) # update record for new node new_record = deepcopy(n.record) if new_record['s'].has_key(wid): new_record['s'][wid] += 1 if new_record['v'].has_key(wid): new_record['v'][wid] += 1 # create new node and score it node = BeamSearchNode(oh_j, oc_j, n, wid, \ n.logp + logp, n.leng + 1, new_record) # store nodes nextnodes.append( \ (-node.eval(self.repeat_penalty, self.token_reward, \ scoreTable, self.alpha), node)) return nextnodes
def _forwardpass(self, n, intent_t, belief_vec_t, degree_t, actEmb_t, scoreTable): # forward pass in_j = sigmoid( self.Wemb_backup[n.wordid] ) # action embedding if self.ply=='attention': actEmb_tj = self.policy.decide(belief_vec_t, degree_t, intent_t, n.h, in_j)[0] else: # fixed action embedding actEmb_tj = actEmb_t # syntatic memory cell and gate # compute i, f, o, c together and slice it bundle_j = np.dot(in_j,self.oWgate_backup) +\ np.dot(n.h, self.oUgate_backup) bundle_aj= np.dot(actEmb_tj,self.Wzh_backup) # input gate ig = sigmoid( bundle_j[:self.doh]+ bundle_aj[:self.doh]+ self.b_backup[:self.doh]) # use forget bias or not fg = sigmoid( bundle_j[self.doh:self.doh*2]+ bundle_aj[self.doh:self.doh*2]+ self.b_backup[self.doh:self.doh*2]) # output gate og = sigmoid( bundle_j[self.doh*2:self.doh*3]+ bundle_aj[self.doh*2:self.doh*3]+ self.b_backup[self.doh*2:self.doh*3]) # proposed memory cell # reading gate, memory cell, hidden layer if self.struct=='lstm_cond': # reading gate control signal rg = sigmoid( bundle_j[self.doh*4:self.doh*5]+ bundle_aj[self.doh*4:self.doh*5]+ self.b_backup[self.doh*3:]) cx_j = tanh(bundle_j[self.doh*3:self.doh*4]) oc_j = np.multiply(ig,cx_j)+\ np.multiply(fg,n.c)+\ np.multiply(rg,tanh(bundle_aj[self.doh*3:self.doh*4])) oh_j = np.multiply(og,tanh(oc_j)) o_j = softmax( np.dot(oh_j, self.Who_backup) ) elif self.struct=='lstm_mix':# two signals rg = sigmoid( bundle_j[self.doh*4:self.doh*5]+ bundle_aj[self.doh*4:self.doh*5]+ self.b_backup[self.doh*3:]) cx_j = tanh(bundle_j[self.doh*3:self.doh*4]) oc_j = np.multiply(ig,cx_j)+\ np.multiply(fg,n.c) oh_j = np.multiply(og,tanh(oc_j))+\ np.multiply(rg,tanh(bundle_aj[self.doh*3:self.doh*4])) o_j = softmax( np.dot(oh_j, self.Who_backup) ) elif self.struct=='lstm_lm': # lm style cx_j = tanh( bundle_j[self.doh*3:self.doh*4]+ bundle_aj[self.doh*3:self.doh*4]) oc_j = np.multiply(ig,cx_j)+\ np.multiply(fg,n.c) oh_j = np.multiply(og,tanh(oc_j)) o_j = softmax( np.dot(oh_j, self.Who_backup) ) else: sys.exit('[ERROR]: Unseen decoder structure '+self.struct) # compute output distribution, logp, and sample # make sure we won't sample unknown word o_j[0] = 0.0 selected_words = np.argsort(o_j)[::-1][:self.beamwidth] # expand nodes and add additional reward nextnodes = [] for wid in selected_words: # ignore <unk> token # loglikelihood of current word logp = np.log10(o_j[wid]) # update record for new node new_record = deepcopy(n.record) if new_record['s'].has_key(wid): new_record['s'][wid] += 1 if new_record['v'].has_key(wid): new_record['v'][wid] += 1 # create new node and score it node = BeamSearchNode(oh_j,oc_j,n,wid,\ n.logp+logp,n.leng+1,new_record) # store nodes nextnodes.append( \ (-node.eval(self.repeat_penalty,self.token_reward,\ scoreTable,self.alpha), node)) return nextnodes