def train_model(model, lr, epochs, train_loader, val_loader, patience):
optimizer = Adagrad(model.parameters(), lr)
criterion = nn.MSELoss()
best_rmse = 100
rounds_no_imporve = 0
for epoch in range(epochs):
for users, items, x, y in train_loader:
y_pred = model(users, items, x)
loss = criterion(y_pred.reshape(-1), y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
logging.info('Last train loss: {0:.3f}'.format(
loss.detach().cpu().numpy().tolist()))
with torch.no_grad():
errors = np.array([])
for users, items, x, y in val_loader:
y_pred = model(users, items, x)
group_errors = (y_pred - y).reshape(-1).cpu().numpy()
errors = np.concatenate([errors, group_errors])
rmse = (errors**2).mean()**0.5
logging.info('Test RMSE: {0:.3f}'.format(rmse))
if rmse < best_rmse:
best_rmse = rmse
rounds_no_imporve = 0
else:
rounds_no_imporve += 1
if rounds_no_imporve >= patience:
return model
return model
def demo_pytorch_vae_mnist(hidden_sizes=[200, 200],
latent_dim=5,
distribution_type='bernoulli',
minibatch_size=20,
checkpoints=100,
n_epochs=20):
cp = Checkpoints(checkpoints)
model = VAEModel(
encoder=make_mlp_encoder(visible_dim=784,
hidden_sizes=hidden_sizes,
latent_dim=latent_dim),
decoder=make_mlp_decoder(latent_dim=latent_dim,
hidden_sizes=hidden_sizes,
visible_dim=784,
dist_type=distribution_type),
latent_dim=latent_dim,
)
# optimizer = Adam(params = model.parameters())
# optimizer = RMSprop(params = model.parameters())
# optimizer = Adamax(params = model.parameters())
optimizer = Adagrad(params=model.parameters())
# optimizer = SGD(lr=0.001, params = model.parameters())
train_loader = torch.utils.data.DataLoader(datasets.MNIST(
'../data',
train=True,
download=True,
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=minibatch_size,
shuffle=True)
for epoch in range(n_epochs):
for batch_idx, (x, y) in enumerate(train_loader):
epoch_pt = epoch + batch_idx / len(train_loader)
optimizer.zero_grad()
loss = -model.elbo(x.flatten(1)).sum()
loss.backward()
optimizer.step()
rate = measure_global_rate('training')
if cp():
print(f'Mean Rate at Epoch {epoch_pt:.2g}: {rate:.3g}iter/s')
z_samples = model.prior().sample((64, ))
x_dist = model.decode(z_samples)
dbplot(x_dist.mean.reshape(-1, 28, 28),
'Sample Means',
title=f'Sample Means at epoch {epoch_pt:.2g}')
def fit(self, seq_list: List, objective='cross_entropy',
print_freq=1000, num_epochs=10, sgd_kwargs={}):
''' train LSTM using DataLoader
Parameters
----------
seq_list : list
each element corresponds to a sequence
objective : str
objective function
print_freq : int
how frequently loss is printed
num_epochs : int
the number of training epochs
sgd_kwargs : dict
keywords fed into SGD
'''
if objective == 'cross_entropy':
criterion = nn.CrossEntropyLoss()
elif objective == 'mse':
criterion = nn.MSELoss()
elif objective == 'nll': # nll stands for negative log-likelihood
criterion = nn.NLLLoss()
else:
raise NotImplementedError
optimizer = Adagrad(self.parameters(), **sgd_kwargs)
i = 0
running_loss = 0
for epoch in range(num_epochs):
for each_idx in range(0, len(seq_list), self.batch_size):
each_seq = torch.stack(
seq_list[each_idx:each_idx + self.batch_size], dim=1)
seq = Variable(each_seq, requires_grad=False)
optimizer.zero_grad()
pred_seq = self.forward(seq[:-1])
loss = criterion(pred_seq, seq[:-1])
loss.backward()
optimizer.step()
self.init_hidden()
# print statistics
running_loss += loss.data[0]
i += 1
if i % print_freq == print_freq-1:
print('epoch: {}\t total examples: {}\t loss: {}'.format(
epoch + 1, i + 1, running_loss / print_freq))
running_loss = 0.0
print('Finished Training')
def train(inputs, outputs, model, l1, l2, lr=1e-5, epochs=10000):
criterion = torch.nn.CrossEntropyLoss()
optimizer = Adagrad(model.parameters(), lr=lr)
log = []
for _ in range(epochs):
prediction = model(inputs)
acc = tn((prediction.max(1)[1] == outputs).float().mean())
original_loss = criterion(prediction, outputs)
penalty = model.penalty(l1, l2)
error = original_loss + penalty
optimizer.zero_grad()
error.backward()
log.append(
(tn(original_loss), tn(penalty), tn(get_sparsity(model)), acc))
optimizer.step()
return np.array(log)
def train(self, device):
set_random_seed()
self.loaded_data.negative_sample()
# Compose Graph NN
gnn_channel = GNNChannel(self.sr_ent_num, self.tg_ent_num, self.dim,
self.layer_num, self.drop_out, self.channels)
self.gnn_channel = gnn_channel
gnn_channel.to(device)
gnn_channel.train()
# Prepare optimizer
optimizer = Adagrad(filter(lambda p: p.requires_grad,
gnn_channel.parameters()),
lr=self.learning_rate,
weight_decay=self.l2_regularization)
criterion = AlignLoss(self.margin_gamma)
best_hit_at_1 = 0
best_epoch_num = 0
for epoch_num in range(1, self.epoch_num + 1):
gnn_channel.train()
optimizer.zero_grad()
sr_seed_hid, tg_seed_hid, _, _ = gnn_channel.forward(
self.loaded_data.train_sr_ent_seeds,
self.loaded_data.train_tg_ent_seeds)
loss = criterion(sr_seed_hid, tg_seed_hid)
loss.backward()
optimizer.step()
if epoch_num % self.nega_sample_freq == 0:
if str(self.directory).find('DWY100k') >= 0:
self.loaded_data.negative_sample()
else:
self.negative_sample()
hit_at_1 = self.evaluate(epoch_num,
gnn_channel,
print_info=False,
device=device)
if hit_at_1 > best_hit_at_1:
best_hit_at_1 = hit_at_1
best_epoch_num = epoch_num
print('Model best Hit@1 on valid set is %.2f at %d epoch.' %
(best_hit_at_1, best_epoch_num))
return best_hit_at_1, best_epoch_num
def train(inputs, outputs, model, l1, l2, lr=1e-5, epochs=10000):
criterion = torch.nn.MSELoss()
optimizer = Adagrad(model.parameters(), lr=lr)
# Everyone starts the same way
for p in model.parameters():
# p.data.fill_(1.0)
pass
log = []
for _ in range(epochs):
original_loss = criterion(model(inputs), outputs)
penalty = model.penalty(l1, l2)
error = original_loss + penalty
optimizer.zero_grad()
error.backward()
log.append((tn(original_loss), tn(penalty), tn(get_sparsity(model))))
optimizer.step()
return np.array(log)
def run(dim, ds, epochs, attempts, lrs, reg_coef):
losses = pd.DataFrame(columns=['lr', 'epoch', 'attempt', 'loss'])
total_epochs = len(lrs) * len(attempts) * len(epochs)
with tqdm(total=total_epochs, desc='lr = NA, attempt = NA, epoch = NA, loss = NA', unit='epochs',
ncols=140) as pbar:
for lr in lrs:
for attempt in attempts:
x = torch.empty(dim, requires_grad=True, dtype=torch.double)
torch.nn.init.normal_(x)
opt = Adagrad([x], lr=lr)
for epoch in epochs:
train_loss = 0
for X, y in DataLoader(ds, shuffle=True, batch_size=1):
opt.zero_grad()
if y.item() == 0:
score = -torch.dot(X[0, :], x)
else:
score = torch.dot(X[0, :], x)
loss = torch.log1p(torch.exp(score)) + (reg_coef / 2) * torch.dot(x, x)
loss.backward()
train_loss += loss.item()
opt.step()
train_loss /= len(ds)
losses = losses.append(pd.DataFrame.from_dict(
{'loss': [train_loss],
'epoch': [epoch],
'lr': [lr],
'attempt': [attempt]}), sort=True)
pbar.update()
pbar.set_description(desc=f'lr = {lr}, attempt = {attempt}, epoch = {epoch}, loss = {train_loss}')
return losses
class Trainer:
def __init__(self, config):
self.config = config
self.step = 0
self.vocab = Vocab(config.vocab_file, config.vocab_size)
self.train_data = CNNDMDataset('train', config.data_path, config,
self.vocab)
self.validate_data = CNNDMDataset('val', config.data_path, config,
self.vocab)
# self.model = Model(config).to(device)
# self.optimizer = None
self.setup(config)
def setup(self, config):
model = Model(config)
checkpoint = None
if config.train_from != '':
logging('Train from %s' % config.train_from)
checkpoint = torch.load(config.train_from, map_location='cpu')
model.load_state_dict(checkpoint['model'])
self.step = checkpoint['step']
self.model = model.to(device)
self.optimizer = Adagrad(model.parameters(),
lr=config.learning_rate,
initial_accumulator_value=config.initial_acc)
if checkpoint is not None:
self.optimizer.load_state_dict(checkpoint['optimizer'])
def train_one(self, batch):
config = self.config
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, config, device)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, device)
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
step_losses = []
for di in range(max_dec_len):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
return loss
def train(self):
config = self.config
train_loader = DataLoader(self.train_data,
batch_size=config.batch_size,
shuffle=True,
collate_fn=Collate())
running_avg_loss = 0
self.model.train()
for e in range(config.train_epoch):
for batch in train_loader:
self.step += 1
self.optimizer.zero_grad()
loss = self.train_one(batch)
loss.backward()
clip_grad_norm_(self.model.parameters(), config.max_grad_norm)
self.optimizer.step()
#print(loss.item())
running_avg_loss = calc_running_avg_loss(
loss.item(), running_avg_loss)
if self.step % config.report_every == 0:
logging("Step %d Train loss %.3f" %
(self.step, running_avg_loss))
if self.step % config.validate_every == 0:
self.validate()
if self.step % config.save_every == 0:
self.save(self.step)
if self.step % config.test_every == 0:
pass
@torch.no_grad()
def validate(self):
self.model.eval()
validate_loader = DataLoader(self.validate_data,
batch_size=self.config.batch_size,
shuffle=False,
collate_fn=Collate())
losses = []
for batch in validate_loader:
loss = self.train_one(batch)
losses.append(loss.item())
self.model.train()
ave_loss = sum(losses) / len(losses)
logging('Validate loss : %f' % ave_loss)
def save(self, step):
state = {
'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'step': step
}
save_path = os.path.join(self.config.model_path, 'model_s%d.pt' % step)
logging('Saving model step %d to %s...' % (step, save_path))
torch.save(state, save_path)
class VAE(BaseEstimator, TransformerMixin):
"""
:param decoder: Address neural network in decoder. Possible values are
bernoulli and gaussian.
"""
def __init__(self,
nohiddens: int = 400,
nolatents: int = 20,
nosamples: int = 1,
noepochs: int = 15,
batch_size: int = 100,
show_every: int = 100,
decoder: str = 'bernoulli',
outdir: str = 'output/'):
super(BaseEstimator, self).__init__()
makedirs(outdir, exist_ok=True)
self.noinputs = None
self.nohiddens = nohiddens
self.nolatents = nolatents
self.nosamples = nosamples
self.noepochs = noepochs
self.batch_size = batch_size
self.show_every = show_every
self.outdir = outdir
if decoder == 'bernoulli':
self.fit = self.__fit_bernoulli
elif decoder == 'gaussian':
self.fit = self.__fit_gaussian
else:
raise ValueError(f'Unknown decoder type: "{decoder}".')
self.logger = getLogger(__name__)
self.model = None
self.opt = None
def fit(self, X):
"""Method fit is overloaded during construction of VAE estimator. See
constructor for details.
"""
def transform(self, X: Tensor) -> LatentVariable:
latvar = LatentVariable(self.model, *self.model.encode(X))
return latvar
def inverse_transform(self, X: Tensor) -> Tensor:
origin = self.model.decode(X)
if isinstance(origin, tuple):
return origin[0]
else:
return origin
def __fit(self, dataset: Tensor, model: VAEBase):
it = DataLoader(dataset, batch_size=self.batch_size, shuffle=True)
dur = self.noepochs * ceil(len(dataset) / self.batch_size)
history = History(zeros(dur), zeros(dur), zeros(dur), zeros(dur),
zeros(dur))
hooks = CombinedHook()
hooks.add(LossHook)
hooks.add(RekonstruktHook, dataset[:10, :])
hooks.add(LatentSamplerHook, self.nolatents)
hooks.prehook(self, history)
self.model = model
self.noinputs = model.noinputs
self.opt = Adagrad(self.model.parameters(), lr=0.01) # See Section 5.
for epoch in range(self.noepochs):
for i, x in enumerate(it):
self.opt.zero_grad()
# Apply model in the following steps:
# (a) encode datapoint into latent space;
# (b) sample points from latent space;
# (c) decode sampled points from latent space.
mu, logsigma2 = self.model.encode(x)
z = self.model.sample(mu, logsigma2)
X = self.model.decode(z)
# Estimate KL-divergence and reconstruction error (RE).
kl = self.model.kl(mu, logsigma2)
re = self.model.re(x, X)
# Do error backpropagation.
loss = kl + re
loss.backward()
self.opt.step()
# Aggregation runtime statistics.
history.append(epoch=epoch,
batch=i,
kl=float(kl / self.batch_size),
re=float(re / self.batch_size))
if i % self.show_every == 0:
hooks.hook(self, history)
# Print status before exit.
hooks.posthook(self, history)
# Return itself for calls chaining.
return self
def __fit_bernoulli(self, dataset: Tensor):
params = self.get_params()
params['noinputs'] = dataset.shape[1]
model = VAEBernoulliDecoder(**params)
return self.__fit(dataset, model)
def __fit_gaussian(self, dataset: Tensor):
params = self.get_params()
params['noinputs'] = dataset.shape[1]
model = VAEGaussianDecoder(**params)
return self.__fit(dataset, model)
class trainW2V:
""" To train a word2vec model on a text obtained from pubmed scraping. """
def __init__(self, text, windowSize=5, negWords=15, embedDim=200, vocabSize=None,
nOccur=10, phMinCount=5, phThresh=10, phDepth=2,
wInit='scaled-uniform', epochs=50, batchSize= 1024,
optimizer='SGD', lr=0.01, patience=5, epsilon=1e-5, raw=False,
tShuff=False, saveFreq=-1, restoreBest=True, outPath='./'):
""" Args:
text (nested list): input text as list of sentences.
windowSize (int): size of the context window.
negWords (int): number of negative words used in training.
embedDim (int): dimensionality of the embedded space (default 200).
vocabSize (int): size of the the vocabulary (default None)
nOccur (int): minimum number of occurrencies to keep a word in the dictionary,
can be overwritten by vocabSiz (default 10).
phMinCount (int): minimum number of occurrences to keep a phrase (default 5).
phThresh (float): minimum score to keep a phrase (default 10).
phDepth (int): number of recursions during phrase search (1 = bi-grams, default 2).
wInit (string): distribution from which to draw initial node weights (only 'scaled-uniform'
and 'xavier' are currently available, default 'scaled-uniform').
epochs (int): number of epochs (default 50).
batchSize (int): size of batches (default 1024).
optimizer (str): optimizer choice, 'SGD' amd 'Adagrad' only
(default 'SGD').
lr (float): learning rage (default .01).
patience (int): early stop patience (default 5).
epsilon (float): early stop epsilon (default 1e-5).
raw (bool): if True clean the input text (default True).
tShuff (bool): shuffle training set at each epoch (default false).
saveFreq (int): frequency of model checkpoints, if < 0 don't save checkpoints (default -1).
restoreBest (bool): restore and save best model by early stopping.
outPath (string): path to directory where to save the trained models.
"""
""" Set up training dataset and batches. """
self.trainDs = textDataset(text, windowSize, negWords, vocabSize=vocabSize, nOccur=nOccur,
phMinCount=phMinCount, phThresh=phThresh, phDepth=phDepth, raw=raw)
self.trainBatch = DataLoader(self.trainDs, batch_size = batchSize, shuffle = tShuff)
""" Set up model """
self.model = skipGram(int(self.trainDs.wDict.shape[0]), embedDim, wInit)
""" Send model to GPU if available. """
if torch.cuda.is_available():
self.model.cuda()
self.epochs = epochs
if optimizer == 'SGD':
# no momentum allowed with sparse matrices :(
self.optimizer = SGD(self.model.parameters(), lr=lr)
elif optimizer == 'Adagrad':
self.optimizer = Adagrad(self.model.parameters(), lr=lr)
else:
print ('ERROR: '+optimizer+' is not available, please select SGD or Adagrad.')
sys.exit(1)
self.losses = []
""" Set up early stopping. """
self.earlStop = EarlyStopping(patience=patience, epsilon=epsilon, keepBest=True)
self.restoreBest = restoreBest
self.saveFreq = saveFreq
if self.saveFreq < 0:
self.saveFreq = self.epochs + 1
self.outPath = outPath
if not os.path.exists(self.outPath):
os.makedirs(self.outPath)
def train(self):
""" Run the training of the model. """
for epoch in tqdm(range(self.epochs), desc='Epoch'):
pBarB = tqdm(enumerate(self.trainBatch), total=len(self.trainBatch), desc='Batch')
for batchNum, batch in pBarB:
wordBatch = batch[0]
contBatch = batch[1]
negaBatch = batch[2]
""" Move batches to GPU if available. """
if torch.cuda.is_available():
wordBatch = wordBatch.cuda()
contBatch = contBatch.cuda()
negaBatch = negaBatch.cuda()
""" Core of training. """
self.optimizer.zero_grad()
loss = self.model(wordBatch, contBatch, negaBatch)
loss.backward()
self.optimizer.step()
pBarB.set_postfix({'loss' : '{:.5f}'.format(loss.item())})
""" Store loss. """
self.losses.append(loss.item())
""" Save checkpoint model every n-th epoch. """
if epoch > 0 and epoch%self.saveFreq == 0:
self.saveModel(name='_{:d}_{:.5f}'.format(epoch,loss))
""" Early stop check. """
self.earlStop(loss, self.model)
if self.earlStop.earlyStop:
print('Limit loss improvement reached, stopping the training.')
break
""" Restore and save best model. """
if self.restoreBest:
self.model = self.earlStop.bestModel
def saveModel(self, name):
""" Saves any model and its dictionary.
Args:
name (string): file name.
"""
torch.save({'model_state_dict': self.model.state_dict(),
'word_to_ix': self.trainDs.wDict['word'].to_dict()
},
os.path.join(self.outPath, 'model_'+name+'.pt'))
def getEmbedded(self):
""" Returns the embedding layer weights, equivalent to the word vectors in
the embedded space.
Returns:
(numpy array): the embedding layer weights.
"""
return self.model.getEmbedded()
class Train(object):
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path,
self.vocab,
mode='train',
batch_size=config.batch_size,
single_pass=False)
time.sleep(5)
if not os.path.exists(config.log_root):
os.mkdir(config.log_root)
self.model_dir = os.path.join(config.log_root, 'train_model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.train_log = os.path.join(config.log_root, 'train_log')
if not os.path.exists(self.train_log):
os.mkdir(self.train_log)
self.summary_writer = tf.summary.FileWriter(self.train_log)
def save_model(self, running_avg_loss, iter, mode):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
if mode == 'train':
save_model_dir = self.model_dir
else:
best_model_dir = os.path.join(config.log_root, 'best_model')
if not os.path.exists(best_model_dir):
os.mkdir(best_model_dir)
save_model_dir = best_model_dir
if len(os.listdir(save_model_dir)) > 0:
shutil.rmtree(save_model_dir)
time.sleep(2)
os.mkdir(save_model_dir)
train_model_path = os.path.join(save_model_dir,
'model_best_%d' % (iter))
torch.save(state, train_model_path)
return train_model_path
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc,
weight_decay=config.L2_loss)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
# encoder_outputs shape = (batch_size, max_seq_len, 2*hidden_size)
# encoder_feature shape = (batch_size*max_seq_len, 2*hidden_size)
# encoder_hidden[0] shape = (batch, 2, hidden_size)
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
# s_t_1[0] shape = (1, batch_size, hidden_size)
s_t_1 = self.model.reduce_state(encoder_hidden)
'''
print('Actual enc_batch:')
en_words = [self.vocab._id_to_word[idx] for idx in enc_batch[0].numpy()]
print(en_words)
print('Actual de_batch:')
de_words = [self.vocab._id_to_word[idx] for idx in dec_batch[0].numpy()]
print(de_words)
print('Actual tar_batch:')
tar_words = [self.vocab._id_to_word[idx] for idx in target_batch[0].numpy()]
print(tar_words)
'''
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
min_val_loss = np.inf
while iter < n_iters:
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
self.summary_writer, iter)
iter += 1
if iter % config.print_interval == 0:
tf.logging.info(
'steps %d, seconds for %d batch: %.2f , loss: %f, min_val_loss: %f'
% (iter, config.print_interval, time.time() - start, loss,
min_val_loss))
start = time.time()
if iter % config.save_model_iter == 0:
self.summary_writer.flush()
model_file_path = self.save_model(running_avg_loss,
iter,
mode='train')
tf.logging.info('Evaluate the model %s at validation set....' %
model_file_path)
evl_model = Evaluate(model_file_path)
val_avg_loss = evl_model.run_eval()
if val_avg_loss < min_val_loss:
min_val_loss = val_avg_loss
best_model_file_path = self.save_model(running_avg_loss,
iter,
mode='eval')
tf.logging.info('Save best model at %s' %
best_model_file_path)
class Train(object):
def __init__(self, model_file_path=None):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path,
self.vocab,
mode='train',
batch_size=config.batch_size,
single_pass=False)
time.sleep(15)
if not model_file_path:
train_dir = os.path.join(config.log_root,
'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.mkdir(train_dir)
else:
train_dir = re.sub('/model/model.*', '', model_file_path)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.summary_writer = tf.summary.create_file_writer(train_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(
self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
# self.optimizer = Adam(params)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def f(self, x, alpha):
# # 1 - x ** alpha
# k = utils.EPOCH / (utils.MAX_EPOCH / 2) - 1
# return k * x + (1 - k)/2
return 1 - x**alpha
def get_loss_mask(self, src, tgt, absts, alpha=config.alpha):
loss_mask = []
for i in range(len(src)):
# debug('src[i]',src[i])
# debug('tgt[i]',src[i])
# cnt = 0
# tgt_i = [t for t in tgt[i] if t != 1]
# src_i = set([s for s in src[i] if s != 1])
# debug('src_i',src_i)
# m = [t for t in tgt_i if t not in src_i ]
# # for token in tgt_i:
# # if token not in src_i:
# # cnt += 1
# cnt = len(m)
# abst = round(cnt / len(tgt_i),4)
abst = absts[i]
loss_factor = self.f(abst, alpha)
loss_mask.append(loss_factor)
return torch.Tensor(loss_mask).cuda()
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
# debug(batch.original_articles[0])
# debug(batch.original_abstracts[0])
loss_mask = self.get_loss_mask(enc_batch, dec_batch, batch.absts)
# debug('loss_mask',loss_mask)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage, tau = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
# debug('enc_batch',enc_batch.size())
# debug('dec_batch',dec_batch.size())
# debug('final_dist', final_dist.size())
# debug('target',target)
# debug('gold_probs',gold_probs)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
# debug('step_loss_before',step_loss)
# debug('config.loss_mask',config.loss_mask)
if config.loss_mask:
step_loss = step_loss * loss_mask
# pass
# debug('step_loss_after',step_loss)
step_losses.append(step_loss)
if config.DEBUG:
# break
pass
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
if not config.DEBUG:
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item(), tau
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
start_iter = iter
while iter < n_iters:
batch = self.batcher.next_batch()
loss, tau = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
self.summary_writer, iter)
iter += 1
if config.DEBUG:
debug('iter', iter)
if iter - start_iter > config.BREAK_POINT:
break
if iter % 100 == 0:
self.summary_writer.flush()
print_interval = 100
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' %
(iter, print_interval, time.time() - start, loss))
if config.adaptive_sparsemax:
print('tau + eps', [
round(e[0], 4)
for e in (tau +
config.eps).detach().cpu().numpy().tolist()
])
start = time.time()
if iter % 5000 == 0:
self.save_model(running_avg_loss, iter)
class Train(object):
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path, self.vocab, mode='train',
batch_size=config.batch_size, single_pass=False)
time.sleep(15)
train_dir = os.path.join(config.log_root, 'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.summary_writer = tf.summary.FileWriter(train_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(params, lr=initial_lr, initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path, map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
s_t_1_origin = s_t_1
batch_size = batch.batch_size
step_losses = []
sample_idx = []
sample_log_probs = Variable(torch.zeros(batch_size))
baseline_idx = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing, shape [batch_size]
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(y_t_1, s_t_1,
encoder_outputs,
encoder_feature,
enc_padding_mask, c_t_1,
extra_zeros,
enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1, target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage), 1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
# sample
if di == 0: # use decoder input[0], which is <BOS>
sample_t_1 = dec_batch[:, di]
s_t_sample = s_t_1_origin
c_t_sample = Variable(torch.zeros((batch_size, 2 * config.hidden_dim)))
final_dist, s_t_sample, c_t_sample, attn_dist, p_gen, next_coverage = self.model.decoder(sample_t_1,
s_t_sample,
encoder_outputs,
encoder_feature,
enc_padding_mask,
c_t_sample,
extra_zeros,
enc_batch_extend_vocab,
coverage, di)
# according to final_dist to sample
# change sample_t_1
dist = torch.distributions.Categorical(final_dist)
sample_t_1 = Variable(dist.sample())
# record sample idx
sample_idx.append(sample_t_1) # tensor list
# compute sample probability
sample_log_probs += torch.log(
final_dist.gather(1, sample_t_1.view(-1, 1))) # gather value along axis=1. given index
# baseline
if di == 0: # use decoder input[0], which is <BOS>
baseline_t_1 = dec_batch[:, di]
s_t_sample = s_t_1_origin
c_t_sample = Variable(torch.zeros((batch_size, 2 * config.hidden_dim)))
final_dist, s_t_baseline, c_t_baseline, attn_dist, p_gen, next_coverage = self.model.decoder(baseline_t_1,
s_t_baseline,
encoder_outputs,
encoder_feature,
enc_padding_mask,
c_t_baseline,
extra_zeros,
enc_batch_extend_vocab,
coverage, di)
# according to final_dist to get baseline
# change baseline_t_1
baseline_t_1 = torch.autograd.Variable(final_dist.max(1)) # get max value along axis=1
# record baseline probability
baseline_idx.append(baseline_t_1)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
# according to sample_idx and baseline_idx to compute RL loss
# map sample/baseline_idx to string
# compute rouge score
# compute loss
sample_idx = torch.stack(sample_idx, dim=1).squeeze() # expect shape (batch_size, seq_len)
baseline_idx = torch.stack(baseline_idx, dim=1).squeeze()
rl_loss = torch.zeros(batch_size)
for i in range(sample_idx.shape[0]): # each example in a batch
sample_y = data.outputids2words(sample_idx[i], self.vocab,
(batch.art_oovs[i] if config.pointer_gen else None))
baseline_y = data.outputids2words(baseline_idx[i], self.vocab,
(batch.art_oovs[i] if config.pointer_gen else None))
true_y = batch.original_abstracts[i]
sample_score = rouge_l_f(sample_y, true_y)
baseline_score = rouge_l_f(baseline_y, true_y)
sample_score = Variable(sample_score)
baseline_score = Variable(baseline_score)
rl_loss[i] = baseline_score - sample_score
rl_loss = rl_loss * sample_log_probs
gamma = 0.9984
loss = (1 - gamma) * loss + gamma * rl_loss
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(), config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
while iter < n_iters:
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss, self.summary_writer, iter)
iter += 1
if iter % 100 == 0:
self.summary_writer.flush()
print_interval = 1000
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' % (iter, print_interval,
time.time() - start, loss))
start = time.time()
if iter % 5000 == 0:
self.save_model(running_avg_loss, iter)
class Train:
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path,
self.vocab,
mode='train',
batch_size=config.batch_size,
single_pass=False)
time.sleep(15)
train_dir = os.path.join(config.log_root,
'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.summary_writer = tf.summary.FileWriter(train_dir)
def save_model(self, moving_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': moving_avg_loss
}
model_save_path = os.path.join(
self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.do_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
# 在训练到某个epoch，需要切换到coverage结构，因此需要使用新的optimizer状态。此处控制切换时机。
if not config.do_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, context_v, coverage = \
get_encoder_variables(batch, use_cuda)
# dec_lens_var：一个batch的decoder目标序列长度
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_decoder_variables(batch, use_cuda)
self.optimizer.zero_grad()
if 0 in enc_lens:
print('=================')
print(enc_batch.shape)
print(enc_lens)
print(enc_batch)
print('=================')
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
d_hc = self.model.reduce_state(encoder_hidden) # decoder初始h，c
step_losses = []
# for step in tqdm.tqdm(range(min(max_dec_len, config.max_dec_steps))):
for step in range(min(max_dec_len, config.max_dec_steps)):
d_inp = dec_batch[:, step] # Teacher forcing
final_dist, d_hc, context_v, attn_dist, p_gen, next_coverage = self.model.decoder(
d_inp, d_hc, encoder_outputs, encoder_feature,
enc_padding_mask, context_v, extra_zeros,
enc_batch_extend_vocab, coverage, step)
target = target_batch[:, step]
# gather每一步target id的预测概率
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.do_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1) # encoder的累计分布作为损失，见原论文
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, step]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
iter, moving_avg_loss = self.setup_train(model_file_path)
start = time.time()
pbar = tqdm.tqdm(total=n_iters)
while iter < n_iters:
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch)
moving_avg_loss = calc_moving_avg_loss(loss, moving_avg_loss,
self.summary_writer, iter)
iter += 1
pbar.update(1)
if iter % 100 == 0:
self.summary_writer.flush()
print_interval = 100
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' %
(iter, print_interval, time.time() - start, loss))
start = time.time()
if iter % 5000 == 0:
self.save_model(moving_avg_loss, iter)
pbar.close()
class Train(object):
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path, self.vocab, mode='train',
batch_size=config.batch_size, single_pass=False)
time.sleep(15)
stamp = time.strftime("%Y%m%d_%H%M%S", time.localtime())
train_dir = os.path.join(config.log_root, 'train_{}'.format(stamp))
if not os.path.exists(train_dir):
os.makedirs(train_dir)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.summary_writer = tf.compat.v1.summary.FileWriter(train_dir)
def save_model(self, running_avg_loss, iter_step):
"""保存模型"""
state = {
'iter': iter_step,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
stamp = time.strftime("%Y%m%d_%H%M%S", time.localtime())
model_save_path = os.path.join(self.model_dir, 'model_{}_{}'.format(iter_step, stamp))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
"""模型初始化或加载、初始化迭代次数、损失、优化器"""
# 初始化模型
self.model = Model(model_file_path)
# 模型参数的列表
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr # lr_coverage和lr二选一
# 定义优化器
self.optimizer = Adagrad(params, lr=initial_lr, initial_accumulator_value=config.adagrad_init_acc)
# 初始化迭代次数和损失
start_iter, start_loss = 0, 0
# 如果传入的已存在的模型路径，加载模型继续训练
if model_file_path is not None:
state = torch.load(model_file_path, map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if USE_CUDA:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.to(DEVICE)
return start_iter, start_loss
def train_one_batch(self, batch):
"""
训练一个batch，返回该batch的loss。
enc_batch: torch.Size([16, 400]), 16篇文章的编码，不足400词的用pad的编码补足, oov词汇用0编码；
enc_padding_mask: torch.Size([16, 400]), 对应pad的位置为0，其余为1；
enc_lens: numpy.ndarray, 列表内每个元素表示每篇article的单词数；
enc_batch_extend_vocab:torch.Size([16, 400]), 16篇文章的编码;oov词汇用超过词汇表的编码；
extra_zeros: torch.Size([16, 文章oov词汇数量]) zero tensor;
c_t_1: torch.Size([16, 512]) zero tensor;
coverage: Variable(torch.zeros(batch_size, max_enc_seq_len)) if is_coverage==True else None;coverage模式时后续有值
----------------------------------------
dec_batch: torch.Size([16, 100]) 摘要编码含有开始符号编码以及PAD；
dec_padding_mask: torch.Size([16, 100]) 对应pad的位置为0，其余为1；
max_dec_len: 标量，摘要词语数量，不包含pad
dec_lens_var: torch.Size([16] 摘要词汇数量
target_batch: torch.Size([16, 100]) 目标摘要编码含有STOP符号编码以及PAD
"""
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch)
# 暂时未理解extra_zeros含义
self.optimizer.zero_grad()
"""
# 记得修改Batch类添加vocab属性
print("模型输入文章编码:", "*"*100)
print("enc_batch:", enc_batch, enc_batch.size())
print("enc_batch[-1]:", enc_batch[-1])
# print("batch._id_to_word:", batch.vocab._id_to_word)
print("enc_batch[-1]原文:", [batch.vocab.id2word(idx) for idx in enc_batch[-1].cpu().numpy()])
print("-"*50)
print("enc_padding_mask:", enc_padding_mask, enc_padding_mask.size())
print("-"*50)
print("enc_lens:", enc_lens, enc_lens.shape)
print("-"*50)
print("enc_batch_extend_vocab", enc_batch_extend_vocab, enc_batch_extend_vocab.size())
print("enc_batch_extend_vocab[-1]:", enc_batch_extend_vocab[-1])
print("enc_batch_extend_vocab[-1]的原文:", [batch.vocab.id2word(idx) if idx<50000 else '[UNK]+{}'.format(idx-50000) for idx in enc_batch_extend_vocab[-1].cpu().numpy()])
print("-"*50)
print("extra_zeros:", extra_zeros, extra_zeros.size())
print("-"*50)
print("c_t_1:", c_t_1, c_t_1.size())
print("-"*50)
print("coverage:", coverage)
print("*"*100)
print("模型输入摘要编码，包括源和目标：", "*"*100)
print("dec_batch:", dec_batch, dec_batch.size())
print("dec_batch[0]:", dec_batch[0])
# print("batch._id_to_word:", batch.vocab._id_to_word)
print("dec_batch[0]原文:", [batch.vocab.id2word(idx) for idx in dec_batch[0].cpu().numpy()])
print("-"*50)
print("dec_padding_mask:", dec_padding_mask, dec_padding_mask.size())
print("-"*50)
print("max_dec_len:", max_dec_len)
print("-"*50)
print("dec_lens_var", dec_lens_var, dec_lens_var.size())
print("-"*50)
print("target_batch:", target_batch, target_batch.size())
print("-"*50)
print("target_batch[0]:", target_batch[0], target_batch[0].size())
print("target_batch[0]的原文:", [batch.vocab.id2word(idx) if idx<50000 else '[UNK]+{}'.format(idx-50000) for idx in target_batch[0].cpu().numpy()])
print("*"*100)
input("任意键继续>>>")
"""
# [B, max(seq_lens), 2*hid_dim], [B*max(seq_lens), 2*hid_dim], tuple([2, B, hid_dim], [2, B, hid_dim])
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden) # (h,c) = ([3, B, hid_dim], [3, B, hid_dim])
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # 摘要的一个单词，batch里的每个句子的同一位置的单词编码
# print("y_t_1:", y_t_1, y_t_1.size())
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(y_t_1, s_t_1,
encoder_outputs,
encoder_feature,
enc_padding_mask, c_t_1,
extra_zeros,
enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di] # 摘要的下一个单词的编码
# print("target-iter:", target, target.size())
# print("final_dist:", final_dist, final_dist.size())
# input("go on>>")
# final_dist 是词汇表每个单词的概率，词汇表是扩展之后的词汇表，也就是大于预设的50_000
gold_probs = torch.gather(final_dist, 1, target.unsqueeze(1)).squeeze() # 取出目标单词的概率gold_probs
step_loss = -torch.log(gold_probs + config.eps) # 最大化gold_probs，也就是最小化step_loss（添加负号）
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage), 1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(), config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
# 训练设置，包括
iter_step, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
while iter_step < n_iters:
# 获取下一个batch数据
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss, self.summary_writer, iter_step)
iter_step += 1
if iter_step % 100 == 0:
self.summary_writer.flush()
# print_interval = 1000
if iter_step % 100 == 0:
# lr = self.optimizer.state_dict()['param_groups'][0]['lr']
logging.info('steps %d, seconds for %d steps: %.2f, loss: %f' % (iter_step, 10,
time.time() - start, loss))
start = time.time()
# 50000次迭代就保存一下模型
if iter_step % 50000 == 0:
logging.info("model saved = {}/{}".format(int(iter_step / 50000) + 1, int(config.max_iterations/50000) + 1))
self.save_model(running_avg_loss, iter_step)
class WeightedHolE(nn.Module):
def __init__(self, *args, **kwargs):
super(WeightedHolE, self).__init__()
# self.add_hyperparam('rparam', kwargs.pop('rparam', 0.0))
self.learning_rate = kwargs.get('lr', _DEF_LEARNING_RATE)
entity_dim, _, relation_dim = args[0]
embed_dim = args[1]
self._max_epochs = kwargs.get('max_epochs', _DEF_MAX_EPOCHS)
init_relations = kwargs.get('init_relations')
if init_relations is not None:
self.R = nn.Parameter(init_relations)
else:
self.R = nn.Parameter(torch.FloatTensor(relation_dim, embed_dim).uniform_(-.1,.1))
self.R.my_name = 'R'
self.R.grad = torch.zeros_like(self.R)
pretrained_ent = kwargs.get('pretrained_entities')
if pretrained_ent is not None:
self.E = nn.Parameter(pretrained_ent)
else:
self.E = nn.Parameter(torch.FloatTensor(entitiy_dim, embed_dim).uniform_(-.1,.1))
self.E.my_name = 'E'
self.E.grad = torch.zeros_like(self.E)
self.loss_function = nn.SoftMarginLoss(reduction='sum')
self.optim = Adagrad(list(self.parameters()), lr=self.learning_rate)
def forward(self, xs, ys, minibatch_size):
for loss, grads in self._optim(list(zip(xs, ys)), minibatch_size):
yield loss, grads
def _optim(self, xys, minibatch_size):
for self._epoch in range(1, self._max_epochs+1):
self.loss = 0
self.optim.zero_grad()
self.train()
# shuffle training examples
indices = list(range(len(xys)))
shuffle(indices)
# store epoch for callback
self.epoch_start = timeit.default_timer()
# process mini-batches
lower_iter, upper_iter = count(0, minibatch_size), count(minibatch_size, minibatch_size)
for lower, upper in zip(lower_iter, upper_iter):
# select indices for current batch
if lower >= len(indices):
break
batch_examples = [xys[idx] for idx in indices[lower:upper]]
triples,ys = zip(*batch_examples)
ss,ps,os = zip(*triples)
ss,ps,os,ys=torch.LongTensor(ss), torch.LongTensor(ps), torch.LongTensor(os), torch.FloatTensor(ys)
yscores = self._scores(ss, ps, os) # see Holographic Embeddings, eq. 2
self.loss = self.loss_function(yscores, ys)
print('loss', self.loss)
fs = -(ys * torch.sigmoid(-yscores)).unsqueeze(1)
entity_grad, entity_idxs = self._fn_Entity_Grad(yscores, ss, os, ps, fs)
relation_grad, relation_idxs = self._fn_Relation_Grad(yscores, ss, os, ps, fs)
#print('grad rel', relation_grads.shape, torch.sum(relation_grads))
for param in self.parameters():
if param.my_name == 'R':
self.R.grad = relation_grad
if param.my_name == 'E':
for col,row_grads in zip(entity_idxs, entity_grad): # FIXME use index_put_
self.E.grad[col] = row_grads
self.optim.step()
#batch_loss, batch_grads = self._process_batch(bxys)
#yield batch_loss, batch_grads
def _fn_Entity_Grad(self, yscores, ss, os, ps, fs):
sparse_indices, Sm, n = grad_sum_matrix(torch.cat((ss, os)))
combined = torch.cat((fs * ccorr(self.R[ps], self.E[os]),
fs * cconv(self.E[ss], self.R[ps])),
dim=0)
grads = torch.mm(Sm, combined) / n.unsqueeze(1)
return grads, sparse_indices
def _fn_Relation_Grad(self, yscores, ss, os, ps, fs):
sparse_indices, Sm, n = grad_sum_matrix(ps)
grads = torch.mm(Sm, fs * ccorr(self.E[ss], self.E[os])) / n
return grads, sparse_indices
def _scores(self, ss, ps, os):
return torch.sum(self.R[ps] * ccorr(self.E[ss], self.E[os]), dim=1)
def _update(self, g, idx=None):
self.p2[idx] += g * g
H = np.maximum(np.sqrt(self.p2[idx]), 1e-7)
self.param[idx] -= self.learning_rate * g / H
class TrainSeq2Seq(object):
def __init__(self, is_word_level=False, is_combined=False, alpha=0.3):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
# self.batcher = Batcher(config.train_data_path, self.vocab, mode='train',
# batch_size=config.batch_size, single_pass=False)
self.dataset = DailyMailDataset("train", self.vocab)
#time.sleep(15)
self.is_word_level = is_word_level
self.is_combined = is_combined
self.alpha = alpha
if is_word_level:
print("Using Word Level Policy Gradient")
elif is_combined:
print("Using Combined Policy Gradient w/ alpha = ", alpha)
else:
print("Using Sentence Level Policy Gradient")
train_dir = './train_dumps'
# train_dir = './train_dumps'
if not os.path.exists(train_dir):
#print('create dict')
os.mkdir(train_dir)
self.model_dir = os.path.join(
train_dir, 'dumps_model_{:%m_%d_%H_%M}'.format(datetime.now()))
if not os.path.exists(self.model_dir):
#print('create folder')
os.mkdir(self.model_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(
self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
torch.save(state, model_save_path)
return model_save_path
def setup(self, seqseq_model, model_file_path):
self.model = seqseq_model
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
#self.optimizer = Adam(params, lr=initial_lr)
start_iter, start_loss = 0, 0
if model_file_path is not None:
print("Loading checkpoint .... ")
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if config.use_gpu:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch_nll(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, config.use_gpu)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, config.use_gpu)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
def train_nll(self, n_iters, iter, running_avg_loss):
start = time.time()
while iter < n_iters:
batch = self.batcher.next_batch()
loss = self.train_one_batch_nll(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
iter)
print("Iteration:", iter, " loss:", loss, " Running avg loss:",
running_avg_loss)
iter += 1
print_interval = 1000
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' %
(iter, print_interval, time.time() - start, loss))
start = time.time()
if iter % 1000 == 0:
self.save_model(running_avg_loss, iter)
def train_pg(self,
n_iters,
start_iter,
start_running_avg_loss,
start_pg_losses,
start_run_avg_losses,
num_epochs=50):
"""
The generator is trained using policy gradients, using the reward from the discriminator.
Training is done for num_batches batches.
"""
dataloader = DataLoader(self.dataset,
batch_size=config.batch_size,
shuffle=True,
num_workers=1,
collate_fn=create_batch_collate(
self.vocab, config.batch_size))
# pg_batcher = Batcher(config.train_data_path, self.vocab, mode='train',
# batch_size=config.batch_size, single_pass=False)
#
# time.sleep(15)
start = time.time()
running_avg_loss = start_running_avg_loss
pg_losses = start_pg_losses
run_avg_losses = start_run_avg_losses
iteration = start_iter
for epoch in range(num_epochs):
print("Epoch :", epoch + 1)
for batch in dataloader:
iteration += 1
loss = self.train_one_batch_pg(batch)
running_avg_loss = calc_running_avg_loss(
loss, running_avg_loss, iteration)
print("Iteration:", iteration, " PG loss:", loss,
" Running avg loss:", running_avg_loss)
pg_losses.append(loss)
run_avg_losses.append(running_avg_loss)
print_interval = 10
if iteration % print_interval == 0:
print(
'steps %d, seconds for %d batch: %.2f , loss: %f' %
(iteration, print_interval, time.time() - start, loss))
start = time.time()
if iteration % 10 == 0:
# Dump model and losses
model_file_path = self.save_model(running_avg_loss,
iteration)
pickle.dump(
pg_losses,
open(
os.path.join(
self.model_dir,
'train_pg_losses_{}.p'.format(iteration)),
'wb'))
pickle.dump(
run_avg_losses,
open(
os.path.join(
self.model_dir,
'train_run_avg_losses_{}.p'.format(iteration)),
'wb'))
# Run eval
eval_processor = Evaluate_pg(
model_file_path,
is_word_level=self.is_word_level,
is_combined=self.is_combined,
alpha=self.alpha)
eval_losses = eval_processor.run_eval(
self.model_dir, iteration)
# Check if we should stop
avg_eval_loss = np.mean(eval_losses)
if running_avg_loss < avg_eval_loss:
print("Stopping at iteration {}".format(iteration))
break
def compute_policy_grads_using_rewards(self, sentence_rewards,
word_rewards, sentence_losses,
word_losses, word_to_sent_ind):
if self.is_combined:
pg_losses = [[(self.alpha * word_reward + (1 - self.alpha) *
sentence_rewards[i][word_to_sent_ind[i][j]]) *
word_losses[i][j]
for j, word_reward in enumerate(abstract_rewards)
if j < len(word_to_sent_ind[i])]
for i, abstract_rewards in enumerate(word_rewards)]
pg_losses = [sum(pg) for pg in pg_losses]
elif self.is_word_level:
pg_losses = [[
word_reward * word_losses[i][j]
for j, word_reward in enumerate(abstract_rewards)
if j < len(word_to_sent_ind[i])
] for i, abstract_rewards in enumerate(word_rewards)]
pg_losses = [sum(pg) for pg in pg_losses]
else:
pg_losses = [[
rs * sentence_losses[ri][rsi] for rsi, rs in enumerate(r)
] for ri, r in enumerate(sentence_rewards)]
pg_losses = [sum(pg) for pg in pg_losses]
return pg_losses
def compute_pg_loss(self, orig, pred, sentence_losses, split_predictions,
word_losses, word_to_sent_ind):
sentence_rewards = None
word_rewards = None
# First compute the rewards
if not self.is_word_level or self.is_combined:
sentence_rewards = get_sentence_rewards(orig, pred)
if self.is_word_level or self.is_combined:
word_rewards = get_word_level_rewards(orig, split_predictions)
pg_losses = self.compute_policy_grads_using_rewards(
sentence_rewards=sentence_rewards,
word_rewards=word_rewards,
sentence_losses=sentence_losses,
word_losses=word_losses,
word_to_sent_ind=word_to_sent_ind)
return pg_losses
def compute_batched_sentence_loss(self, word_losses, orig, pred):
orig_sum = []
new_pred = []
pred_sum = []
sentence_losses = []
# Convert the original sum as one single string per article
for i in range(len(orig)):
orig_sum.append(' '.join(map(str, orig[i])))
new_pred.append([])
pred_sum.append([])
sentence_losses.append([])
batch_sent_indices = []
for i in range(len(pred)):
sentence = []
sentence = pred[i]
losses = word_losses[i]
sentence_indices = []
count = 0
while len(sentence) > 0:
try:
idx = sentence.index(".")
except ValueError:
idx = len(sentence)
sentence_indices.extend([count for _ in range(idx)])
if count > 0:
new_pred[i].append(new_pred[i][count - 1] +
sentence[:idx + 1])
else:
new_pred[i].append(sentence[:idx + 1])
sentence_losses[i].append(sum(losses[:idx + 1]))
sentence = sentence[idx + 1:]
losses = losses[idx + 1:]
count += 1
batch_sent_indices.append(sentence_indices)
for i in range(len(pred)):
for j in range(len(new_pred[i])):
pred_sum[i].append(' '.join(map(str, new_pred[i][j])))
pg_losses = self.compute_pg_loss(orig_sum,
pred_sum,
sentence_losses,
split_predictions=pred,
word_losses=word_losses,
word_to_sent_ind=batch_sent_indices)
return pg_losses
def train_one_batch_pg(self, batch):
batch_size = batch.batch_size
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, config.use_gpu)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, config.use_gpu)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
step_losses = []
output_ids = []
# Begin with START symbol
y_t_1 = torch.ones(batch_size, dtype=torch.long) * self.vocab.word2id(
data.START_DECODING)
if config.use_gpu:
y_t_1 = y_t_1.cuda()
for _ in range(batch_size):
output_ids.append([])
step_losses.append([])
for di in range(min(max_dec_len, config.max_dec_steps)):
#y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps) # NLL
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
# Move on to next token
_, idx = torch.max(final_dist, 1)
idx = idx.reshape(batch_size, -1).squeeze()
y_t_1 = idx
for i, pred in enumerate(y_t_1):
if not pred.item() == data.PAD_TOKEN:
output_ids[i].append(pred.item())
for i, loss in enumerate(step_loss):
step_losses[i].append(step_loss[i])
# Obtain the original and predicted summaries
original_abstracts = batch.original_abstracts_sents
predicted_abstracts = [
data.outputids2words(ids, self.vocab, None) for ids in output_ids
]
# Compute the batched loss
batched_losses = self.compute_batched_sentence_loss(
step_losses, original_abstracts, predicted_abstracts)
#batched_losses = Variable(batched_losses, requires_grad=True)
losses = torch.stack(batched_losses)
losses = losses / dec_lens_var
loss = torch.mean(losses)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
class Trainer:
def __init__(self, config):
self.config = config
self.device = config['device']
self.step = 0
if os.path.exists('../vocab.pt'):
self.vocab = torch.load('../vocab.pt')
else:
self.vocab = Vocab(config['vocab_file'], config['vocab_size'])
torch.save(self.vocab, '../vocab.pt')
self.train_data = CNNDMDataset('train', config['data_path'], config,
self.vocab)
self.validate_data = CNNDMDataset('val', config['data_path'], config,
self.vocab)
self.setup(config)
def setup(self, config):
self.model = Model(config).to(config['device'])
self.optimizer = Adagrad(self.model.parameters(),
lr=config['learning_rate'],
initial_accumulator_value=0.1)
# self.optimizer = Adam(self.model.parameters(),lr = config['learning_rate'],betas = config['betas'])
checkpoint = None
if config[
'train_from'] != '': # Counter在两次mostCommon间, 相同频率的元素可能以不同的次序输出...!
logging('Train from %s' % config['train_from'])
checkpoint = torch.load(config['train_from'], map_location='cpu')
self.model.load_state_dict(checkpoint['model'])
self.step = checkpoint['step']
self.vocab = checkpoint['vocab']
self.optimizer.load_state_dict(checkpoint['optimizer'])
# print('State dict parameters:')
# for n in model.state_dict().keys():
# print(n)
#self.optimizer = Adam(self.model.parameters(),lr = config['learning_rate'],betas = config['betas'])
def train_one(self, batch):
""" coverage not implemented """
config = self.config
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros = \
get_input_from_batch(batch, config, self.device)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, self.device)
pred = self.model(enc_batch, dec_batch, enc_padding_mask,
dec_padding_mask, enc_batch_extend_vocab,
extra_zeros)
# >>>>>>>> DEBUG Session <<<<<<<<<
# print("ENC\n")
# print(enc_batch)
# print("DEC\n")
# print(dec_batch)
# print("TGT\n")
# print(target_batch)
# print("ENCP\n")
# print(enc_padding_mask)
# print("DECP\n")
# print(dec_padding_mask)
# encs = [self.vocab.id2word(int(v)) for v in enc_batch[:, 0]]
# decs = [self.vocab.id2word(int(v)) for v in dec_batch[:, 0]]
# print(' '.join(encs))
# print(' '.join(decs))
#print(pred.max(dim=-1)[1][:,0]) #
#loss = self.model.nll_loss(pred, target_batch, dec_lens_var)
loss = self.model.label_smoothing_loss(pred, target_batch)
return loss
def train(self):
config = self.config
train_loader = DataLoader(self.train_data,
batch_size=config['batch_size'],
shuffle=True,
collate_fn=Collate())
running_avg_loss = 0
self.model.train()
for _ in range(config['train_epoch']):
for batch in train_loader:
self.step += 1
loss = self.train_one(batch)
running_avg_loss = calc_running_avg_loss(
loss.item(), running_avg_loss)
loss.div(float(config['gradient_accum'])).backward()
if self.step % config[
'gradient_accum'] == 0: # gradient accumulation
clip_grad_norm_(self.model.parameters(),
config['max_grad_norm'])
self.optimizer.step()
self.optimizer.zero_grad()
if self.step % config['report_every'] == 0:
logging("Step %d Train loss %.3f" %
(self.step, running_avg_loss))
if self.step % config['save_every'] == 0:
self.save()
if self.step % config['validate_every'] == 0:
self.validate()
@torch.no_grad()
def validate(self):
self.model.eval()
validate_loader = DataLoader(self.validate_data,
batch_size=self.config['batch_size'],
shuffle=False,
collate_fn=Collate())
losses = []
for batch in tqdm(validate_loader):
loss = self.train_one(batch)
losses.append(loss.item())
self.model.train()
ave_loss = sum(losses) / len(losses)
logging('Validate loss : %f' % ave_loss)
def save(self):
state = {
'model': self.model.state_dict(),
'optimizer': self.optimizer.state_dict(),
'step': self.step,
'vocab': self.vocab
}
save_path = os.path.join(self.config['model_path'],
'model_s%d.pt' % self.step)
logging('Saving model step %d to %s...' % (self.step, save_path))
torch.save(state, save_path)
class Train(object):
def __init__(self):
if config.is_hierarchical:
raise Exception("Hierarchical PGN-AMI not supported!")
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.pad_id = self.vocab.word2id(PAD_TOKEN)
self.start_id = self.vocab.word2id(START_DECODING)
self.stop_id = self.vocab.word2id(STOP_DECODING)
self.print_interval = config.print_interval
train_dir = config.train_dir
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = train_dir
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(self.model_dir,
'iter{}.pt'.format(iter))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, ami_data, idx):
# enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
# get_ami_input_from_batch(batch, use_cuda)
# dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
# get_ami_output_from_batch(batch, use_cuda)
enc_pack, dec_pack = get_a_batch(ami_data,
idx,
self.vocab,
config.batch_size,
config.max_enc_steps,
config.max_dec_steps,
self.start_id,
self.stop_id,
self.pad_id,
sum_type='short',
use_cuda=use_cuda)
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = enc_pack
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = dec_pack
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state.forward1(encoder_hidden)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder.forward1(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
clip_grad_norm_(self.model.encoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
sys.stdout.flush()
ami_data = load_ami_data('train')
valid_data = load_ami_data('valid')
# make the training data 100
random.shuffle(valid_data)
ami_data.extend(valid_data[:6])
valid_data = valid_data[6:]
num_batches = len(ami_data)
idx = 0
# validation & stopping
best_valid_loss = 1000000000
stop_counter = 0
while iter < n_iters:
if idx == 0:
print("shuffle training data")
random.shuffle(ami_data)
loss = self.train_one_batch(ami_data, idx)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
iter)
iter += 1
idx += config.batch_size
if idx == num_batches: idx = 0
if iter % self.print_interval == 0:
print("[{}] iter {}, loss: {:.5f}".format(
str(datetime.now()), iter, loss))
sys.stdout.flush()
if iter % config.save_every == 0:
self.save_model(running_avg_loss, iter)
if iter % config.eval_every == 0:
valid_loss = self.run_eval(valid_data)
print("valid_loss = {:.5f}".format(valid_loss))
if valid_loss < best_valid_loss:
stop_counter = 0
best_valid_loss = valid_loss
print("VALID better")
else:
stop_counter += 1
print(
"VALID NOT better, counter = {}".format(stop_counter))
if stop_counter == config.stop_after:
print("Stop training")
return
print("Finished training!")
def eval_one_batch(self, eval_data, idx):
enc_pack, dec_pack = get_a_batch(eval_data,
idx,
self.vocab,
1,
config.max_enc_steps,
config.max_dec_steps,
self.start_id,
self.stop_id,
self.pad_id,
sum_type='short',
use_cuda=use_cuda)
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = enc_pack
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = dec_pack
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state.forward1(encoder_hidden)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder.forward1(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist,
dim=1,
index=target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_step_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_step_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
return loss.data.item()
def run_eval(self, eval_data):
running_avg_loss, iter = 0, 0
batch_losses = []
num_batches = len(eval_data)
print("valid data size = {}".format(num_batches))
for idx in range(num_batches):
loss = self.eval_one_batch(eval_data, idx)
batch_losses.append(loss)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
iter)
print("#", end="")
sys.stdout.flush()
print()
avg_loss = sum(batch_losses) / len(batch_losses)
return avg_loss
class Train(object):
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path,
self.vocab,
mode='train',
batch_size=config.batch_size,
single_pass=False)
time.sleep(15)
train_dir = os.path.join(config.log_root,
'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.summary_writer = tf.summary.FileWriter(train_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(
self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
while iter < n_iters:
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
self.summary_writer, iter)
iter += 1
if iter % 100 == 0:
self.summary_writer.flush()
print_interval = 50
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' %
(iter, print_interval, time.time() - start, loss))
start = time.time()
if iter % 5000 == 0:
self.save_model(running_avg_loss, iter)
class Train(object):
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path, self.vocab, mode='train',
batch_size=config.batch_size, single_pass=False)
# print("MODE MUST BE train")
# time.sleep(15)
self.print_interval = config.print_interval
train_dir = config.train_dir
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = train_dir
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
# self.summary_writer = tf.compat.v1.summary.FileWriter(train_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(self.model_dir, 'iter{}.pt'.format(iter))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(params, lr=initial_lr, initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path, map_location= lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
if not config.is_hierarchical:
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(enc_batch, enc_lens)
s_t_1 = self.model.reduce_state.forward1(encoder_hidden)
else:
stop_id = self.vocab.word2id('.')
pad_id = self.vocab.word2id('[PAD]')
enc_sent_pos = get_sent_position(enc_batch, stop_id, pad_id)
dec_sent_pos = get_sent_position(dec_batch, stop_id, pad_id)
encoder_outputs, encoder_feature, encoder_hidden, sent_enc_outputs, sent_enc_feature, sent_enc_hidden, sent_enc_padding_mask, sent_lens, seq_lens2 = \
self.model.encoder(enc_batch, enc_lens, enc_sent_pos)
s_t_1, sent_s_t_1 = self.model.reduce_state(encoder_hidden, sent_enc_hidden)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
if not config.is_hierarchical:
# start = datetime.now()
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder.forward1(y_t_1, s_t_1,
encoder_outputs, encoder_feature, enc_padding_mask, c_t_1,
extra_zeros, enc_batch_extend_vocab,
coverage, di)
# print('NO HIER Time: ',datetime.now() - start)
# import pdb; pdb.set_trace()
else:
# start = datetime.now()
max_doc_len = enc_batch.size(1)
final_dist, sent_s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(y_t_1, sent_s_t_1,
encoder_outputs, encoder_feature, enc_padding_mask, seq_lens2,
sent_s_t_1, sent_enc_outputs, sent_enc_feature, sent_enc_padding_mask,
sent_lens, max_doc_len,
c_t_1, extra_zeros, enc_batch_extend_vocab, coverage, di)
# print('DO HIER Time: ',datetime.now() - start)
# import pdb; pdb.set_trace()
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1, target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage), 1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses/dec_lens_var
loss = torch.mean(batch_avg_loss)
# start = datatime.now()
loss.backward()
# print('{} HIER Time: {}'.format(config.is_hierarchical ,datetime.now() - start))
# import pdb; pdb.set_trace()
clip_grad_norm_(self.model.encoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(), config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
sys.stdout.flush()
# data_path = "lib/data/batches_train.vocab50000.batch16.pk.bin"
# with open(data_path, 'rb') as f:
# stored_batches = pickle.load(f, encoding="bytes")
# print("loaded data: {}".format(data_path))
# num_batches = len(stored_batches)
while iter < n_iters:
batch = self.batcher.next_batch()
# batch_id = iter%num_batches
# batch = stored_batches[batch_id]
loss = self.train_one_batch(batch)
# running_avg_loss = calc_running_avg_loss(loss, running_avg_loss, self.summary_writer, iter)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss, iter)
iter += 1
# if iter % 100 == 0:
# self.summary_writer.flush()
if iter % self.print_interval == 0:
print("[{}] iter {}, loss: {:.5f}".format(str(datetime.now()), iter, loss))
sys.stdout.flush()
if iter % config.save_every == 0:
self.save_model(running_avg_loss, iter)
print("Finished training!")
class Train(object):
def __init__(self, opt):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path,
self.vocab,
mode='train',
batch_size=config.batch_size,
single_pass=False)
time.sleep(15)
train_dir = os.path.join(config.log_root,
'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.opt = opt
self.summary_writer = tf.summary.FileWriter(train_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(
self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
# 训练设置，包括
if self.opt.load_model != None:
model_file_path = os.path.join(self.model_dir, self.opt.load_model)
else:
model_file_path = None
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
if self.opt.train_mle == "yes":
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros,
enc_batch_extend_vocab, coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(
torch.min(attn_dist, coverage), 1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
mle_loss = torch.mean(batch_avg_loss)
else:
mle_loss = get_cuda(torch.FloatTensor([0]))
# --------------RL training-----------------------------------------------------
if self.opt.train_rl == "yes": # perform reinforcement learning training
# multinomial sampling
sample_sents, RL_log_probs = self.train_batch_RL(
encoder_outputs,
encoder_hidden,
enc_padding_mask,
encoder_feature,
enc_batch_extend_vocab,
extra_zeros,
c_t_1,
batch.art_oovs,
coverage,
greedy=False)
with torch.autograd.no_grad():
# greedy sampling
greedy_sents, _ = self.train_batch_RL(encoder_outputs,
encoder_hidden,
enc_padding_mask,
encoder_feature,
enc_batch_extend_vocab,
extra_zeros,
c_t_1,
batch.art_oovs,
coverage,
greedy=True)
sample_reward = self.reward_function(sample_sents,
batch.original_abstracts)
baseline_reward = self.reward_function(greedy_sents,
batch.original_abstracts)
# if iter%200 == 0:
# self.write_to_file(sample_sents, greedy_sents, batch.original_abstracts, sample_reward, baseline_reward, iter)
rl_loss = -(
sample_reward - baseline_reward
) * RL_log_probs # Self-critic policy gradient training (eq 15 in https://arxiv.org/pdf/1705.04304.pdf)
rl_loss = torch.mean(rl_loss)
batch_reward = torch.mean(sample_reward).item()
else:
rl_loss = get_cuda(torch.FloatTensor([0]))
batch_reward = 0
#loss.backward()
(self.opt.mle_weight * mle_loss +
self.opt.rl_weight * rl_loss).backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return mle_loss.item(), batch_reward
def train_batch_RL(self, encoder_outputs, encoder_hidden, enc_padding_mask,
encoder_feature, enc_batch_extend_vocab, extra_zeros,
c_t_1, article_oovs, coverage, greedy):
'''Generate sentences from decoder entirely using sampled tokens as input. These sentences are used for ROUGE evaluation
Args
:param enc_out: Outputs of the encoder for all time steps (batch_size, length_input_sequence, 2*hidden_size)
:param enc_hidden: Tuple containing final hidden state & cell state of encoder. Shape of h & c: (batch_size, hidden_size)
:param enc_padding_mask: Mask for encoder input; Tensor of size (batch_size, length_input_sequence) with values of 0 for pad tokens & 1 for others
:param ct_e: encoder context vector for time_step=0 (eq 5 in https://arxiv.org/pdf/1705.04304.pdf)
:param extra_zeros: Tensor used to extend vocab distribution for pointer mechanism
:param enc_batch_extend_vocab: Input batch that stores OOV ids
:param article_oovs: Batch containing list of OOVs in each example
:param greedy: If true, performs greedy based sampling, else performs multinomial sampling
Returns:
:decoded_strs: List of decoded sentences
:log_probs: Log probabilities of sampled words
'''
s_t_1 = self.model.reduce_state(
encoder_hidden) # Decoder hidden states
y_t_1 = get_cuda(
torch.LongTensor(len(encoder_outputs)).fill_(
self.vocab.word2id(data.START_DECODING))
) # Input to the decoder #Used for intra-temporal attention (section 2.1 in https://arxiv.org/pdf/1705.04304.pdf)
inds = [] # Stores sampled indices for each time step
decoder_padding_mask = [
] # 存储生成样本的填充掩码 Stores padding masks of generated samples
log_probs = [] # Stores log probabilites of generated samples
mask = get_cuda(
torch.LongTensor(len(encoder_outputs)).fill_(1)
) # Values that indicate whether [STOP] token has already been encountered; 1 => Not encountered, 0 otherwise
for t in range(config.max_dec_steps):
probs, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, t)
if greedy is False:
multi_dist = Categorical(probs) # 根据概率分布进行采样
y_t_1 = multi_dist.sample() # perform multinomial sampling
log_prob = multi_dist.log_prob(y_t_1)
log_probs.append(log_prob)
else:
_, y_t_1 = torch.max(
probs, dim=1
) # 取概率最大的词 #perform greedy sampling
y_t_1 = y_t_1.detach()
inds.append(y_t_1)
mask_t = get_cuda(torch.zeros(len(encoder_outputs))
) # Padding mask of batch for current time step
mask_t[
mask ==
1] = 1 # If [STOP] is not encountered till previous time step, mask_t = 1 else mask_t = 0
mask[
(mask == 1) +
(y_t_1 == self.vocab.word2id(data.STOP_DECODING)) ==
2] = 0 # If [STOP] is not encountered till previous time step and current word is [STOP], make mask = 0
decoder_padding_mask.append(mask_t)
is_oov = (y_t_1 >= config.vocab_size
).long() # Mask indicating whether sampled word is OOV
y_t_1 = (1 - is_oov) * y_t_1 + (is_oov) * self.vocab.word2id(
data.UNKNOWN_TOKEN) # Replace OOVs with [UNK] token
inds = torch.stack(inds, dim=1)
decoder_padding_mask = torch.stack(decoder_padding_mask, dim=1)
if greedy is False: # If multinomial based sampling, compute log probabilites of sampled words
log_probs = torch.stack(log_probs, dim=1)
log_probs = log_probs * decoder_padding_mask # Not considering sampled words with padding mask = 0
lens = torch.sum(decoder_padding_mask,
dim=1) # Length of sampled sentence
log_probs = torch.sum(
log_probs, dim=1
) / lens # (bs,) #compute normalizied log probability of a sentence
decoded_strs = []
for i in range(len(encoder_outputs)):
id_list = inds[i].cpu().numpy()
oovs = article_oovs[i]
S = data.outputids2words(
id_list, self.vocab,
oovs) # Generate sentence corresponding to sampled words
try:
end_idx = S.index(data.STOP_DECODING)
S = S[:end_idx]
except ValueError:
S = S
if len(
S
) < 2: # If length of sentence is less than 2 words, replace it with "xxx"; Avoids setences like "." which throws error while calculating ROUGE
S = ["xxx"]
S = " ".join(S)
decoded_strs.append(S)
return decoded_strs, log_probs
def reward_function(self, decoded_sents, original_sents):
rouge = Rouge()
try:
scores = rouge.get_scores(decoded_sents, original_sents)
except Exception:
print(
"Rouge failed for multi sentence evaluation.. Finding exact pair"
)
scores = []
for i in range(len(decoded_sents)):
try:
score = rouge.get_scores(decoded_sents[i],
original_sents[i])
except Exception:
print("Error occured at:")
print("decoded_sents:", decoded_sents[i])
print("original_sents:", original_sents[i])
score = [{"rouge-1": {"p": 0.0}}]
scores.append(score[0])
rouge_l_p1 = [score["rouge-1"]["p"] for score in scores]
rouge_l_p1 = get_cuda(torch.FloatTensor(rouge_l_p1))
return rouge_l_p1
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
while iter < n_iters:
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
self.summary_writer, iter)
iter += 1
if iter % 50 == 0:
self.summary_writer.flush()
print_interval = 50
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' %
(iter, print_interval, time.time() - start, loss))
start = time.time()
if iter % 100 == 0:
self.save_model(running_avg_loss, iter)
dtype=torch.float64).cuda()
else:
loss_weights = torch.tensor(cfg.LOSS_WEIGHTS, dtype=torch.float64)
model.train()
optimizer = Adagrad(model.parameters(),
lr=cfg.LEARNING_RATE,
weight_decay=cfg.WEIGHT_DECAY)
for epoch in range(cfg.MAX_EPOCHS):
train_loss = 0
for _iter in tqdm(range(cfg.EPOCH_ITERS)):
batch_iterator = iter(dataloader)
# zero the gradient buffers
optimizer.zero_grad()
(gt, patch_2, patch_3) = next(batch_iterator)
# Use CUDA if possible
if torch.cuda.device_count():
gt = gt.cuda()
patch_2 = patch_2.cuda()
patch_3 = patch_3.cuda()
else:
gt = gt
patch_2 = patch_2
patch_3 = patch_3
softmax_scores = model.forward(patch_2=Variable(patch_2),
patch_3=Variable(patch_3))
class Train(object):
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path,
self.vocab,
mode='train',
batch_size=config.batch_size,
single_pass=False)
time.sleep(15)
train_dir = os.path.join(config.ouput_root,
'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.makedirs(train_dir)
self.checkpoint_dir = os.path.join(train_dir, 'checkpoints')
if not os.path.exists(self.checkpoint_dir):
os.makedirs(self.checkpoint_dir)
self.train_summary_writer = tf.summary.create_file_writer(
os.path.join(train_dir, 'log', 'train'))
self.eval_summary_writer = tf.summary.create_file_writer(
os.path.join(train_dir, 'log', 'eval'))
def save_model(self, model_path, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
torch.save(state, model_path)
def setup_train(self, model_file_path=None):
self.model = Model(device, model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.to(device)
return start_iter, start_loss
def train_one_batch(self, batch, forcing_ratio=1):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, device)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, device)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
step_losses = []
y_t_1_hat = None
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di]
# decide the next input
if di == 0 or random.random() < forcing_ratio:
x_t = y_t_1 # teacher forcing, use label from last time step as input
else:
# use embedding of UNK for all oov word
y_t_1_hat[y_t_1_hat > self.vocab.size()] = self.vocab.word2id(
UNKNOWN_TOKEN)
x_t = y_t_1_hat.flatten(
) # use prediction from last time step as input
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
x_t, s_t_1, encoder_outputs, encoder_feature, enc_padding_mask,
c_t_1, extra_zeros, enc_batch_extend_vocab, coverage, di)
_, y_t_1_hat = final_dist.data.topk(1)
target = target_batch[:, di].unsqueeze(1)
step_loss = cal_NLLLoss(target, final_dist)
if config.is_coverage: # if not using coverge, keep coverage=None
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage),
1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
step_mask = dec_padding_mask[:,
di] # padding in target should not count into loss
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
def train(self, n_iters, init_model_path=None):
iter, avg_loss = self.setup_train(init_model_path)
start = time.time()
cnt = 0
best_model_path = None
min_eval_loss = float('inf')
while iter < n_iters:
s = config.forcing_ratio
k = config.decay_to_0_iter
x = iter
nere_zero = 0.0001
if config.forcing_decay_type:
if x >= config.decay_to_0_iter:
forcing_ratio = 0
elif config.forcing_decay_type == 'linear':
forcing_ratio = s * (k - x) / k
elif config.forcing_decay_type == 'exp':
p = pow(nere_zero, 1 / k)
forcing_ratio = s * (p**x)
elif config.forcing_decay_type == 'sig':
r = math.log((1 / nere_zero) - 1) / k
forcing_ratio = s / (1 + pow(math.e, r * (x - k / 2)))
else:
raise ValueError('Unrecognized forcing_decay_type: ' +
config.forcing_decay_type)
else:
forcing_ratio = config.forcing_ratio
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch, forcing_ratio=forcing_ratio)
model_path = os.path.join(self.checkpoint_dir,
'model_step_%d' % (iter + 1))
avg_loss = calc_avg_loss(loss, avg_loss)
if (iter + 1) % config.print_interval == 0:
with self.train_summary_writer.as_default():
tf.summary.scalar(name='loss', data=loss, step=iter)
self.train_summary_writer.flush()
logger.info('steps %d, took %.2f seconds, train avg loss: %f' %
(iter + 1, time.time() - start, avg_loss))
start = time.time()
if config.eval_interval is not None and (
iter + 1) % config.eval_interval == 0:
start = time.time()
logger.info("Start Evaluation on model %s" % model_path)
eval_processor = Evaluate(self.model, self.vocab)
eval_loss = eval_processor.run_eval()
logger.info(
"Evaluation finished, took %.2f seconds, eval loss: %f" %
(time.time() - start, eval_loss))
with self.eval_summary_writer.as_default():
tf.summary.scalar(name='eval_loss',
data=eval_loss,
step=iter)
self.eval_summary_writer.flush()
if eval_loss < min_eval_loss:
logger.info(
"This is the best model so far, saving it to disk.")
min_eval_loss = eval_loss
best_model_path = model_path
self.save_model(model_path, eval_loss, iter)
cnt = 0
else:
cnt += 1
if cnt > config.patience:
logger.info(
"Eval loss doesn't drop for %d straight times, early stopping.\n"
"Best model: %s (Eval loss %f: )" %
(config.patience, best_model_path, min_eval_loss))
break
start = time.time()
elif (iter + 1) % config.save_interval == 0:
self.save_model(model_path, avg_loss, iter)
iter += 1
else:
logger.info(
"Training finished, best model: %s, with train loss %f: " %
(best_model_path, min_eval_loss))
class Train(object):
def __init__(self):
#config("print.vocab_path ",config.vocab_path)
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path,
self.vocab,
mode='train',
batch_size=config.batch_size,
single_pass=False)
time.sleep(15)
train_dir = os.path.join(config.log_root,
'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.summary_writer = tf.summary.FileWriter(train_dir)
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(
self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
#print("params : ",params)
#print("params collection is completed....")
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(
params,
lr=initial_lr,
initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
#### Loading state where the training stopped earlier use that to train for future epoches ####
if model_file_path is not None:
state = torch.load(model_file_path,
map_location=lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
###### Making into GPU/server accessable Variables #####
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
########### Below Two lines of code is for just initialization of Encoder and Decoder sizes,vocab, lenghts etc : ######
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
#print("train_one_batch function ......")
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(
enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(
encoder_hidden
) ### Here initially encoder final hiddenstate==decoder first/prev word at timestamp=0
#print("s_t_1 : ",len(s_t_1),s_t_1[0].shape,s_t_1[1].shape)
#print("steps.....")
#print("max_dec_len = ",max_dec_len)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
############ Traing [ Teacher Forcing ] ###########
y_t_1 = dec_batch[:, di] # Teacher forcing
#print("y_t_1 : ",len(y_t_1))
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(
y_t_1, s_t_1, encoder_outputs, encoder_feature,
enc_padding_mask, c_t_1, extra_zeros, enc_batch_extend_vocab,
coverage, di)
#print("attn_dist : ",len(attn_dist),attn_dist[0].shape)
#print("final_dist : ",len(final_dist),final_dist[0].shape) ############## vocab_Size
target = target_batch[:, di]
#print("target = ",len(target))
gold_probs = torch.gather(final_dist, 1,
target.unsqueeze(1)).squeeze()
step_loss = -torch.log(
gold_probs + config.eps
) #################################################### Eqn_6
if config.is_coverage:
step_coverage_loss = torch.sum(
torch.min(attn_dist, coverage),
1) ###############################Eqn_13a
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss ###############################Eqn_13b
coverage = next_coverage
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses / dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(),
config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(),
config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
print("trainIters__Started___model_file_path is : ", model_file_path)
iter, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
print("Max iteration : n_iters = ", n_iters)
print("going to start running iter NO : ", iter)
print("\n******************************\n")
while iter < n_iters:
print("\n###################################\n")
print("iter : ", iter)
batch = self.batcher.next_batch()
print("batch data loading : ", batch)
loss = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss,
self.summary_writer, iter)
print("running_avg_loss : ", running_avg_loss)
iter += 1
if iter % 100 == 0: ##100
self.summary_writer.flush()
print_interval = 100 #1000
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' %
(iter, print_interval, time.time() - start, loss))
start = time.time()
if iter % 500 == 0: ##5000
self.save_model(running_avg_loss, iter)
class Train(object):
def __init__(self):
self.vocab = Vocab(config.vocab_path, config.vocab_size)
self.batcher = Batcher(config.train_data_path, self.vocab, mode='train',
batch_size=config.batch_size, single_pass=False)
time.sleep(15)
train_dir = os.path.join(config.log_root, 'train_%d' % (int(time.time())))
if not os.path.exists(train_dir):
os.mkdir(train_dir)
self.model_dir = os.path.join(train_dir, 'model')
if not os.path.exists(self.model_dir):
os.mkdir(self.model_dir)
self.summary_writer = tf.summary.FileWriter(train_dir)
self.last_good_model_save_path = None
def save_model(self, running_avg_loss, iter):
state = {
'iter': iter,
'encoder_state_dict': self.model.encoder.state_dict(),
'decoder_state_dict': self.model.decoder.state_dict(),
'reduce_state_dict': self.model.reduce_state.state_dict(),
'optimizer': self.optimizer.state_dict(),
'current_loss': running_avg_loss
}
model_save_path = os.path.join(self.model_dir, 'model_%d_%d' % (iter, int(time.time())))
# save the path to the last model that was not nan
if (not math.isnan(running_avg_loss)):
self.last_good_model_save_path = model_save_path
torch.save(state, model_save_path)
def setup_train(self, model_file_path=None):
self.model = Model(model_file_path)
self.last_good_model_save_path = model_file_path
params = list(self.model.encoder.parameters()) + list(self.model.decoder.parameters()) + \
list(self.model.reduce_state.parameters())
initial_lr = config.lr_coverage if config.is_coverage else config.lr
self.optimizer = Adagrad(params, lr=initial_lr, initial_accumulator_value=config.adagrad_init_acc)
start_iter, start_loss = 0, 0
if model_file_path is not None:
state = torch.load(model_file_path, map_location= lambda storage, location: storage)
start_iter = state['iter']
start_loss = state['current_loss']
if not config.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if use_cuda:
for state in self.optimizer.state.values():
for k, v in state.items():
if torch.is_tensor(v):
state[k] = v.cuda()
return start_iter, start_loss
def train_one_batch(self, batch):
enc_batch, enc_padding_mask, enc_lens, enc_batch_extend_vocab, extra_zeros, c_t_1, coverage = \
get_input_from_batch(batch, use_cuda)
dec_batch, dec_padding_mask, max_dec_len, dec_lens_var, target_batch = \
get_output_from_batch(batch, use_cuda)
self.optimizer.zero_grad()
encoder_outputs, encoder_feature, encoder_hidden = self.model.encoder(enc_batch, enc_lens)
s_t_1 = self.model.reduce_state(encoder_hidden)
step_losses = []
for di in range(min(max_dec_len, config.max_dec_steps)):
y_t_1 = dec_batch[:, di] # Teacher forcing
final_dist, s_t_1, c_t_1, attn_dist, p_gen, next_coverage = self.model.decoder(y_t_1, s_t_1,
encoder_outputs, encoder_feature, enc_padding_mask, c_t_1,
extra_zeros, enc_batch_extend_vocab,
coverage, di)
target = target_batch[:, di]
gold_probs = torch.gather(final_dist, 1, target.unsqueeze(1)).squeeze()
step_loss = -torch.log(gold_probs + config.eps)
if config.is_coverage:
step_coverage_loss = torch.sum(torch.min(attn_dist, coverage), 1)
step_loss = step_loss + config.cov_loss_wt * step_coverage_loss
coverage = next_coverage
# calculate copy loss
vocab_zero = Variable(torch.zeros(self.model.decoder.vocab_dist_.shape, dtype=torch.float))
if use_cuda:
vocab_zero = vocab_zero.cuda()
if extra_zeros is not None:
vocab_zero = torch.cat([vocab_zero, extra_zeros], 1)
attn_dist_ = (1 - p_gen) * attn_dist
attn_expanded = vocab_zero.scatter_add(1, enc_batch_extend_vocab, attn_dist_)
vocab_zero[:, self.vocab.word2id('[UNK]')] = 1.0
# Not sure whether we want to add loss for the extra vocab indices
#vocab_zero[:, config.vocab_size:] = 1.0
y_unk_neg = 1.0 - vocab_zero
copyloss=torch.bmm(y_unk_neg.unsqueeze(1), attn_expanded.unsqueeze(2))
# add copy loss with lambda 2 weight
step_loss = step_loss + config.copy_loss_wt * copyloss
step_mask = dec_padding_mask[:, di]
step_loss = step_loss * step_mask
step_losses.append(step_loss)
sum_losses = torch.sum(torch.stack(step_losses, 1), 1)
batch_avg_loss = sum_losses/dec_lens_var
loss = torch.mean(batch_avg_loss)
loss.backward()
self.norm = clip_grad_norm_(self.model.encoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.decoder.parameters(), config.max_grad_norm)
clip_grad_norm_(self.model.reduce_state.parameters(), config.max_grad_norm)
self.optimizer.step()
return loss.item()
def trainIters(self, n_iters, model_file_path=None):
iter, running_avg_loss = self.setup_train(model_file_path)
start = time.time()
while iter < n_iters:
batch = self.batcher.next_batch()
loss = self.train_one_batch(batch)
running_avg_loss = calc_running_avg_loss(loss, running_avg_loss, self.summary_writer, iter)
iter += 1
if (math.isnan(running_avg_loss)):
print('Found a nan loss return. Restarting the training at {}' \
.format(self.last_good_model_save_path))
iter, running_avg_loss = self.setup_train(self.last_good_model_save_path)
start = time.time()
if iter % 100 == 0:
self.summary_writer.flush()
print_interval = 1000
if iter % print_interval == 0:
print('steps %d, seconds for %d batch: %.2f , loss: %f' % (iter, print_interval,
time.time() - start, loss))
start = time.time()
if iter % 1000 == 0:
self.save_model(running_avg_loss, iter)
