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
