def main():
random.seed(0)
d = Driver()
t = Transport(d, isServer=False)
services = Services(t)
s = services.getService(TEST_ADDRESS)
for i in itertools.count(1):
#totalFrags = random.randrange(1, 2**16 - 1)
totalFrags = random.randrange(1, 500)
#totalFrags = 1000
requestBuffer = Buffer(
['a' * t.dataPerFragment() for j in range(totalFrags)])
responseBuffer = Buffer()
start = gettime()
r = t.clientSend(s, requestBuffer, responseBuffer)
r.getReply()
elapsedNs = gettime() - start
resp = responseBuffer.getRange(0, responseBuffer.getTotalLength())
req = requestBuffer.getRange(0, requestBuffer.getTotalLength())
assert len(req) == len(resp), (len(req), len(resp), req[:10],
resp[:10], req[-10:], resp[-10:])
assert req == resp, (req, resp)
print
print "Message %d with %d frags OK in %dms" % (i, totalFrags,
elapsedNs / 1000000)
d.stat()
def main():
random.seed(0)
d = Driver()
t = Transport(d, isServer=False)
services = Services(t)
s = services.getService(TEST_ADDRESS)
for i in itertools.count(1):
#totalFrags = random.randrange(1, 2**16 - 1)
totalFrags = random.randrange(1, 500)
#totalFrags = 1000
requestBuffer = Buffer(['a' * t.dataPerFragment() for j in range(totalFrags)])
responseBuffer = Buffer()
start = gettime()
r = t.clientSend(s, requestBuffer, responseBuffer)
r.getReply()
elapsedNs = gettime() - start
resp = responseBuffer.getRange(0, responseBuffer.getTotalLength())
req = requestBuffer.getRange(0, requestBuffer.getTotalLength())
assert len(req) == len(resp), (len(req), len(resp), req[:10], resp[:10],
req[-10:], resp[-10:])
assert req == resp, (req, resp)
print
print "Message %d with %d frags OK in %dms" % (i, totalFrags,
elapsedNs / 1000000)
d.stat()
def train(train_set,
langs,
embedding_size=600,
learning_rate=0.01,
iter_time=10,
batch_size=32,
get_loss=GET_LOSS,
save_model=SAVE_MODEL,
encoder_style=ENCODER_STYLE,
use_model=USE_MODEL):
"""The training procedure."""
# Set the timer
start = time.time()
# Initialize the model
emb = docEmbedding(langs['rt'].n_words, langs['re'].n_words,
langs['rm'].n_words, embedding_size)
emb.init_weights()
if encoder_style == 'LIN':
encoder = EncoderLIN(embedding_size, emb)
elif encoder_style == 'BiLSTM':
encoder = EncoderBiLSTM(embedding_size, emb)
else:
encoder = EncoderRNN(embedding_size, emb)
decoder = AttnDecoderRNN(embedding_size, langs['summary'].n_words)
if use_cuda:
emb.cuda()
encoder.cuda()
decoder.cuda()
if use_model is not None:
encoder = load_model(encoder, use_model[0])
decoder = load_model(decoder, use_model[1])
# Choose optimizer
loss_optimizer = optim.Adagrad(list(encoder.parameters()) +
list(decoder.parameters()),
lr=learning_rate,
lr_decay=0,
weight_decay=0)
# decoder_optimizer = optim.Adagrad(decoder.parameters(), lr=learning_rate, lr_decay=0, weight_decay=0)
criterion = nn.NLLLoss()
total_loss = 0
iteration = 0
for epo in range(1, iter_time + 1):
print("Epoch #%d" % (epo))
# Get data
train_iter = data_iter(train_set, batch_size=batch_size)
for dt in train_iter:
iteration += 1
data, idx_data = get_batch(dt)
rt, re, rm, summary = idx_data
# Add paddings
rt = addpaddings(rt)
re = addpaddings(re)
rm = addpaddings(rm)
summary = addpaddings(summary)
rt = Variable(torch.LongTensor(rt), requires_grad=False)
re = Variable(torch.LongTensor(re), requires_grad=False)
rm = Variable(torch.LongTensor(rm), requires_grad=False)
# For Decoding
summary = Variable(torch.LongTensor(summary), requires_grad=False)
if use_cuda:
rt, re, rm, summary = rt.cuda(), re.cuda(), rm.cuda(
), summary.cuda()
# Get the average loss on the sentences
loss = sentenceloss(rt, re, rm, summary, encoder, decoder,
loss_optimizer, criterion, embedding_size,
encoder_style)
total_loss += loss
# Print the information and save model
if iteration % get_loss == 0:
print("Time {}, iter {}, avg loss = {:.4f}".format(
gettime(start), iteration, total_loss / get_loss))
total_loss = 0
if epo % save_model == 0:
torch.save(encoder.state_dict(),
"{}_encoder_{}".format(OUTPUT_FILE, iteration))
torch.save(decoder.state_dict(),
"{}_decoder_{}".format(OUTPUT_FILE, iteration))
print("Save the model at iter {}".format(iteration))
return encoder, decoder
def train(train_set,
langs,
embedding_size=EMBEDDING_SIZE,
learning_rate=LR,
batch_size=BATCH_SIZE,
get_loss=GET_LOSS,
grad_clip=GRAD_CLIP,
encoder_style=ENCODER_STYLE,
decoder_style=DECODER_STYLE,
to_copy=TOCOPY,
epoch_time=EPOCH_TIME,
layer_depth=LAYER_DEPTH,
max_length=MAX_LENGTH,
max_sentence=MAX_SENTENCES,
save_model=SAVE_MODEL,
output_file=OUTPUT_FILE,
iter_num=iterNum,
pretrain=PRETRAIN):
"""The training procedure."""
# # Test arg parser (For Debugging)
# print("embedding_size={}, learning_rate={}, batch_size={}, get_loss={}, grad_clip={},\
# encoder_style={}, decoder_style={}, max_length={},\
# max_sentece={}, save_model={}, output_file={}, to_copy={},\
# epoch={}, layer_depth={}, iter num={}, pretrain={}".format(
# embedding_size, learning_rate, batch_size, get_loss, grad_clip,
# encoder_style, decoder_style, max_length, max_sentece, save_model, output_file,
# to_copy, epoch_time, layer_depth, iter_num, pretrain))
# Set the timer
start = time.time()
# Initialize the model
emb = docEmbedding(langs['rt'].n_words, langs['re'].n_words,
langs['rm'].n_words, embedding_size)
emb.init_weights()
# Choose encoder style
if encoder_style == 'LIN':
encoder = EncoderLIN(embedding_size, emb)
elif encoder_style == 'BiLSTM':
encoder = EncoderBiLSTM(embedding_size, emb, n_layers=layer_depth)
elif encoder_style == 'BiLSTMMax':
encoder = EncoderBiLSTMMaxPool(embedding_size,
emb,
n_layers=layer_depth)
elif encoder_style == 'HierarchicalBiLSTM':
encoder_args = {
"hidden_size": embedding_size,
"local_embed": emb,
"n_layers": layer_depth
}
encoder = HierarchicalBiLSTM(**encoder_args)
elif encoder_style == 'HierarchicalLIN':
encoder_args = {"hidden_size": embedding_size, "local_embed": emb}
encoder = HierarchicalLIN(**encoder_args)
else:
# initialize hierarchical encoder rnn, (both global and local)
encoder_args = {
"hidden_size": embedding_size,
"local_embed": emb,
"n_layers": layer_depth
}
encoder = HierarchicalRNN(**encoder_args)
# Choose decoder style and training function
if decoder_style == 'HierarchicalRNN':
decoder = HierarchicalDecoder(embedding_size,
langs['summary'].n_words,
n_layers=layer_depth,
copy=to_copy)
train_func = Hierarchical_seq_train
else:
decoder = AttnDecoderRNN(embedding_size,
langs['summary'].n_words,
n_layers=layer_depth,
copy=to_copy)
train_func = Plain_seq_train
if use_cuda:
emb.cuda()
encoder.cuda()
decoder.cuda()
# Choose optimizer
loss_optimizer = optim.Adagrad(list(encoder.parameters()) +
list(decoder.parameters()),
lr=learning_rate,
lr_decay=0,
weight_decay=0)
# loss_optimizer = optim.Adam(list(encoder.parameters()) + list(decoder.parameters()),
# lr=learning_rate)
# Load pre-train model
use_model = None
if pretrain is not None and iter_num is not None:
use_model = [
'./models/' + pretrain + '_' + s + '_' + str(iter_num)
for s in ['encoder', 'decoder', 'optim']
]
if use_model is not None:
encoder = load_model(encoder, use_model[0])
decoder = load_model(decoder, use_model[1])
loss_optimizer.load_state_dict(torch.load(use_model[2]))
print("Load Pretrain Model {}".format(use_model))
else:
print("Not use Pretrain Model")
criterion = nn.NLLLoss()
# Build up the model
model = Seq2Seq(encoder, decoder, train_func, criterion, embedding_size,
langs)
# print(encoder)
# print(decoder)
# print(loss_optimizer)
total_loss = 0
iteration = 0
for epo in range(1, epoch_time + 1):
# Start of an epoch
print("Epoch #%d" % (epo))
# Get data
train_iter = data_iter(train_set, batch_size=batch_size)
for dt in train_iter:
iteration += 1
data, idx_data = get_batch(dt)
rt, re, rm, summary = idx_data
# Debugging: check the input triplets
# show_triplets(data[0][0])
# Add paddings
rt = addpaddings(rt)
re = addpaddings(re)
rm = addpaddings(rm)
# For summary paddings, if the model is herarchical then pad between sentences
# If the batch_size is 1 then we don't need to do sentence padding
if decoder_style == 'HierarchicalRNN' and batch_size != 1:
summary = add_sentence_paddings(summary)
else:
summary = addpaddings(summary)
rt = Variable(torch.LongTensor(rt), requires_grad=False)
re = Variable(torch.LongTensor(re), requires_grad=False)
rm = Variable(torch.LongTensor(rm), requires_grad=False)
# For Decoding
summary = Variable(torch.LongTensor(summary), requires_grad=False)
if use_cuda:
rt, re, rm, summary = rt.cuda(), re.cuda(), rm.cuda(
), summary.cuda()
# Zero the gradient
loss_optimizer.zero_grad()
model.train()
# calculate loss of "a batch of input sequence"
loss = sequenceloss(rt, re, rm, summary, model)
# Backpropagation
loss.backward()
torch.nn.utils.clip_grad_norm(
list(model.encoder.parameters()) +
list(model.decoder.parameters()), grad_clip)
loss_optimizer.step()
# Get the average loss on the sentences
target_length = summary.size()[1]
if float(torch.__version__[:3]) > 0.3:
total_loss += loss.item()
else:
total_loss += loss.data[0]
# Print the information and save model
if iteration % get_loss == 0:
print("Time {}, iter {}, Seq_len:{}, avg loss = {:.4f}".format(
gettime(start), iteration, target_length,
total_loss / get_loss))
total_loss = 0
if epo % save_model == 0:
torch.save(encoder.state_dict(),
"models/{}_encoder_{}".format(output_file, iteration))
torch.save(decoder.state_dict(),
"models/{}_decoder_{}".format(output_file, iteration))
torch.save(loss_optimizer.state_dict(),
"models/{}_optim_{}".format(output_file, iteration))
print("Save the model at iter {}".format(iteration))
return model.encoder, model.decoder
def train(train_set,
langs,
embedding_size=600,
learning_rate=0.01,
iter_time=10,
batch_size=32,
get_loss=GET_LOSS,
save_model=SAVE_MODEL,
encoder_style=ENCODER_STYLE,
decoder_style=DECODER_STYLE,
use_model=USE_MODEL):
"""The training procedure."""
# Set the timer
start = time.time()
encoder, decoder, loss_optimizer, train_func = model_initialization(
encoder_style, decoder_style, langs, embedding_size, learning_rate,
use_model)
criterion = nn.NLLLoss()
# Build up the model
model = Seq2Seq(encoder, decoder, train_func, None, criterion,
embedding_size, langs)
# print(encoder)
# print(decoder)
# print(loss_optimizer)
total_loss = 0
iteration = 0
for epo in range(1, iter_time + 1):
# Start of an epoch
print("Epoch #%d" % (epo))
# Get data
train_iter = data_iter(train_set, batch_size=batch_size)
for dt in train_iter:
iteration += 1
data, idx_data = get_batch(dt)
print(idx_data)
rt, re, rm, summary = idx_data
# Debugging: check the input triplets
# show_triplets(data[0][0])
# Add paddings
rt = addpaddings(rt)
re = addpaddings(re)
rm = addpaddings(rm)
# For summary paddings, if the model is herarchical then pad between sentences
if decoder_style == 'HierarchicalRNN':
summary = add_sentence_paddings(summary)
else:
summary = addpaddings(summary)
rt = Variable(torch.LongTensor(rt), requires_grad=False)
re = Variable(torch.LongTensor(re), requires_grad=False)
rm = Variable(torch.LongTensor(rm), requires_grad=False)
# DEBUG:
if torch.sum(rm == 3).item() == 0:
print('skip')
continue
# For Decoding
summary = Variable(torch.LongTensor(summary), requires_grad=False)
if use_cuda:
rt, re, rm, summary = rt.cuda(), re.cuda(), rm.cuda(
), summary.cuda()
# Zero the gradient
loss_optimizer.zero_grad()
model.train()
# calculate loss of "a batch of input sequence"
loss = sequenceloss(rt, re, rm, summary, model)
# Backpropagation
loss.backward()
torch.nn.utils.clip_grad_norm(
list(model.encoder.parameters()) +
list(model.decoder.parameters()), GRAD_CLIP)
loss_optimizer.step()
# Get the average loss on the sentences
target_length = summary.size()[1]
if float(torch.__version__[:3]) > 0.3:
total_loss += loss.item()
else:
total_loss += loss.data[0]
# Print the information and save model
if iteration % get_loss == 0:
print("Time {}, iter {}, Seq_len:{}, avg loss = {:.4f}".format(
gettime(start), iteration, target_length,
total_loss / get_loss))
total_loss = 0
if epo % save_model == 0:
torch.save(encoder.state_dict(),
"models/{}_encoder_{}".format(OUTPUT_FILE, iteration))
torch.save(decoder.state_dict(),
"models/{}_decoder_{}".format(OUTPUT_FILE, iteration))
torch.save(loss_optimizer.state_dict(),
"models/{}_optim_{}".format(OUTPUT_FILE, iteration))
print("Save the model at iter {}".format(iteration))
return model.encoder, model.decoder
def train(train_set,
langs,
embedding_size=600,
learning_rate=0.01,
iter_time=10,
batch_size=32,
get_loss=GET_LOSS,
save_model=SAVE_MODEL,
encoder_style=ENCODER_STYLE,
decoder_style=DECODER_STYLE,
use_model=USE_MODEL):
"""The training procedure."""
# Set the timer
start = time.time()
# Initialize the model
emb = docEmbedding(langs['rt'].n_words, langs['re'].n_words,
langs['rm'].n_words, embedding_size)
emb.init_weights()
# Choose encoder style
# TODO:: Set up a choice for hierarchical or not
if encoder_style == 'LIN':
encoder = EncoderLIN(embedding_size, emb)
elif encoder_style == 'BiLSTM':
encoder = EncoderBiLSTM(embedding_size, emb)
elif encoder_style == 'BiLSTMMax':
encoder = EncoderBiLSTMMaxPooling(embedding_size, emb)
elif encoder_style == 'HierarchicalBiLSTM':
encoder_args = {"hidden_size": embedding_size, "local_embed": emb}
encoder = HierarchicalBiLSTM(**encoder_args)
elif encoder_style == 'HierarchicalLIN':
encoder_args = {"hidden_size": embedding_size, "local_embed": emb}
encoder = HierarchicalLIN(**encoder_args)
else:
# initialize hierarchical encoder rnn, (both global and local)
encoder_args = {"hidden_size": embedding_size, "local_embed": emb}
encoder = HierarchicalEncoderRNN(**encoder_args)
# Choose decoder style and training function
if decoder_style == 'HierarchicalRNN':
decoder = HierarchicalDecoder(embedding_size, langs['summary'].n_words)
train_func = Hierarchical_seq_train
else:
decoder = AttnDecoderRNN(embedding_size, langs['summary'].n_words)
train_func = Plain_seq_train
if use_cuda:
emb.cuda()
encoder.cuda()
decoder.cuda()
# Choose optimizer
loss_optimizer = optim.Adagrad(list(encoder.parameters()) +
list(decoder.parameters()),
lr=learning_rate,
lr_decay=0,
weight_decay=0)
# loss_optimizer = optim.Adam(list(encoder.parameters()) + list(decoder.parameters()),
# lr=learning_rate)
if use_model is not None:
encoder = load_model(encoder, use_model[0])
decoder = load_model(decoder, use_model[1])
loss_optimizer.load_state_dict(torch.load(use_model[2]))
criterion = nn.NLLLoss()
# Build up the model
model = Seq2Seq(encoder, decoder, train_func, criterion, embedding_size,
langs)
# print(encoder)
# print(decoder)
# print(loss_optimizer)
total_loss = 0
iteration = 0
for epo in range(1, iter_time + 1):
# Start of an epoch
print("Epoch #%d" % (epo))
# Get data
train_iter = data_iter(train_set, batch_size=batch_size)
for dt in train_iter:
iteration += 1
data, idx_data = get_batch(dt)
rt, re, rm, summary = idx_data
# Debugging: check the input triplets
# show_triplets(data[0][0])
# Add paddings
rt = addpaddings(rt)
re = addpaddings(re)
rm = addpaddings(rm)
# For summary paddings, if the model is herarchical then pad between sentences
if decoder_style == 'HierarchicalRNN':
summary = add_sentence_paddings(summary)
else:
summary = addpaddings(summary)
rt = Variable(torch.LongTensor(rt), requires_grad=False)
re = Variable(torch.LongTensor(re), requires_grad=False)
rm = Variable(torch.LongTensor(rm), requires_grad=False)
# For Decoding
summary = Variable(torch.LongTensor(summary), requires_grad=False)
if use_cuda:
rt, re, rm, summary = rt.cuda(), re.cuda(), rm.cuda(
), summary.cuda()
# Zero the gradient
loss_optimizer.zero_grad()
model.train()
# calculate loss of "a batch of input sequence"
loss = sequenceloss(rt, re, rm, summary, model)
# Backpropagation
loss.backward()
torch.nn.utils.clip_grad_norm(
list(model.encoder.parameters()) +
list(model.decoder.parameters()), GRAD_CLIP)
loss_optimizer.step()
# Get the average loss on the sentences
target_length = summary.size()[1]
if float(torch.__version__[:3]) > 0.3:
total_loss += loss.item()
else:
total_loss += loss.data[0]
# Print the information and save model
if iteration % get_loss == 0:
print("Time {}, iter {}, Seq_len:{}, avg loss = {:.4f}".format(
gettime(start), iteration, target_length,
total_loss / get_loss))
total_loss = 0
if epo % save_model == 0:
torch.save(encoder.state_dict(),
"models/{}_encoder_{}".format(OUTPUT_FILE, iteration))
torch.save(decoder.state_dict(),
"models/{}_decoder_{}".format(OUTPUT_FILE, iteration))
torch.save(loss_optimizer.state_dict(),
"models/{}_optim_{}".format(OUTPUT_FILE, iteration))
print("Save the model at iter {}".format(iteration))
return model.encoder, model.decoder
def plot_alg1(Table, gatealloc, puckallock):
narrow_count = 0
wide_count = 0
total_narrow_count = 0
total_wide_count = 0
for puck in Table['Puck'].dict:
tp = util.bt(Table['Puck'][puck]['plane_type'])
if tp == 'N': total_narrow_count += 1
else: total_wide_count += 1
for puck, gate in puckallock.items():
if not gate: continue
tp = util.bt(Table['Puck'][puck]['plane_type'])
if tp == 'N': narrow_count += 1
else: wide_count += 1
plt.figure()
plt.bar([0, 1], [wide_count, narrow_count],
color='rb',
tick_label=['Wide', 'Narrow'],
align='center')
plt.text(0, wide_count, '{}'.format(wide_count), fontsize=15)
plt.text(1, narrow_count, '{}'.format(narrow_count), fontsize=15)
plt.ylabel(u'数量')
plt.savefig("output/alg1-1.pdf", bbox_inches='tight')
plt.figure()
plt.bar([0, 1],
[wide_count / total_wide_count, narrow_count / total_narrow_count],
color='rb',
tick_label=['Wide', 'Narrow'],
align='center')
plt.text(0,
wide_count / total_wide_count * 1.01,
'{}'.format(wide_count / total_wide_count),
fontsize=15)
plt.text(1,
narrow_count / total_narrow_count * 1.01,
'{:.3f}'.format(narrow_count / total_narrow_count),
fontsize=15)
plt.ylabel(u'比例')
plt.savefig("output/alg1-2.pdf", bbox_inches='tight')
plt.show()
T_count = 0
S_count = 0
T_time = 0
S_time = 0
start_date = datetime.datetime(2018, 1, 20)
end_date = datetime.datetime(2018, 1, 21)
ztime = datetime.time(0, 0, 0)
start_time = util.gettime(start_date, ztime)
end_time = util.gettime(end_date, ztime)
for gate, pks in gatealloc.items():
if len(pks) == 0: continue
for pk in pks:
sdate = (Table['Puck'][pk]['in_date'])
stime = (Table['Puck'][pk]['in_time'])
edate = (Table['Puck'][pk]['out_date'])
etime = (Table['Puck'][pk]['out_time'])
st = util.gettime(sdate, stime)
et = util.gettime(edate, etime)
if st < start_time: t = et - start_time
elif et > end_time: t = end_time - st
else: t = et - st
h = Table['Gate'][gate]['hall']
if h == 'T':
T_count += 1
T_time += t
elif h == 'S':
S_count += 1
S_time += t
else:
print('Error hall:', h)
T_time = T_time / (24 * 60) / T_count
S_time = S_time / (24 * 60) / S_count
plt.figure()
plt.bar([0, 1], [T_count, S_count],
color='rb',
tick_label=['T', 'S'],
align='center')
plt.text(0, T_count, '{}'.format(T_count), fontsize=15)
plt.text(1, S_count, '{}'.format(S_count), fontsize=15)
plt.ylabel(u'数量')
plt.savefig("output/alg1-3.pdf", bbox_inches='tight')
plt.figure()
plt.bar([0, 1], [T_time, S_time],
color='rb',
tick_label=['T', 'S'],
align='center')
plt.text(0, T_time * 1.01, '{:.2f}'.format(T_time), fontsize=15)
plt.text(1, S_time * 1.01, '{:.2f}'.format(S_time), fontsize=15)
plt.ylabel(u'平均使用率')
plt.savefig("output/alg1-4.pdf", bbox_inches='tight')
def train(train_set,
langs,
embedding_size=EMBEDDING_SIZE,
learning_rate=LR,
batch_size=BATCH_SIZE,
get_loss=GET_LOSS,
grad_clip=GRAD_CLIP,
encoder_style=ENCODER_STYLE,
decoder_style=DECODER_STYLE,
to_copy=TOCOPY,
epoch_time=EPOCH_TIME,
layer_depth=LAYER_DEPTH,
max_length=MAX_LENGTH,
max_sentence=MAX_SENTENCES,
save_model=SAVE_MODEL,
output_file=OUTPUT_FILE,
iter_num=iterNum,
pretrain=PRETRAIN):
start = time.time()
emb = docEmbedding(langs['rt'].n_words, langs['re'].n_words,
langs['rm'].n_words, embedding_size)
emb.init_weights()
encoder_args = {
"hidden_size": embedding_size,
"local_embed": emb,
"n_layers": layer_depth
}
encoder = HierarchicalRNN(**encoder_args)
if decoder_style == 'HierarchicalRNN':
decoder = HierarchicalDecoder(embedding_size,
langs['summary'].n_words,
n_layers=layer_depth,
copy=to_copy)
train_func = Hierarchical_seq_train
else:
decoder = AttnDecoderRNN(embedding_size,
langs['summary'].n_words,
n_layers=layer_depth,
copy=to_copy)
train_func = Plain_seq_train
if use_cuda:
emb.cuda()
encoder.cuda()
decoder.cuda()
loss_optimizer = optim.Adagrad(list(encoder.parameters()) +
list(decoder.parameters()),
lr=learning_rate,
lr_decay=0,
weight_decay=0)
use_model = None
if pretrain is not None and iter_num is not None:
use_model = [
'./models/' + pretrain + '_' + s + '_' + str(iter_num)
for s in ['encoder', 'decoder', 'optim']
]
if use_model is not None:
encoder = load_model(encoder, use_model[0])
decoder = load_model(decoder, use_model[1])
loss_optimizer.load_state_dict(torch.load(use_model[2]))
print("Load Pretrain Model {}".format(use_model))
else:
print("Not use Pretrain Model")
criterion = nn.NLLLoss()
model = Seq2Seq(encoder, decoder, train_func, criterion, embedding_size,
langs)
total_loss = 0
iteration = 0
for epo in range(1, epoch_time + 1):
print("Epoch #%d" % (epo))
train_iter = data_iter(train_set, batch_size=batch_size)
for dt in train_iter:
iteration += 1
data, idx_data = get_batch(dt)
rt, re, rm, summary = idx_data
rt = addpaddings(rt)
re = addpaddings(re)
rm = addpaddings(rm)
if decoder_style == 'HierarchicalRNN' and batch_size != 1:
summary = add_sentence_paddings(summary)
else:
summary = addpaddings(summary)
rt = Variable(torch.LongTensor(rt), requires_grad=False)
re = Variable(torch.LongTensor(re), requires_grad=False)
rm = Variable(torch.LongTensor(rm), requires_grad=False)
summary = Variable(torch.LongTensor(summary), requires_grad=False)
if use_cuda:
rt, re, rm, summary = rt.cuda(), re.cuda(), rm.cuda(
), summary.cuda()
loss_optimizer.zero_grad()
model.train()
loss = sequenceloss(rt, re, rm, summary, model)
loss.backward()
torch.nn.utils.clip_grad_norm(
list(model.encoder.parameters()) +
list(model.decoder.parameters()), grad_clip)
loss_optimizer.step()
target_length = summary.size()[1]
if float(torch.__version__[:3]) > 0.3:
total_loss += loss.item() / target_length
else:
total_loss += loss.data[0] / target_length
if iteration % get_loss == 0:
print("Time {}, iter {}, Seq_len:{}, avg loss = {:.4f}".format(
gettime(start), iteration, target_length,
total_loss / get_loss))
total_loss = 0
if epo % save_model == 0:
torch.save(encoder.state_dict(),
"models/{}_encoder_{}".format(output_file, iteration))
torch.save(decoder.state_dict(),
"models/{}_decoder_{}".format(output_file, iteration))
torch.save(loss_optimizer.state_dict(),
"models/{}_optim_{}".format(output_file, iteration))
print("Save the model at iter {}".format(iteration))
return model.encoder, model.decoder
