def validate(loader, trainer):
trainer.eval()
total_loss = 0.0
total_pred_loss = 0.0
total_reg_loss = 0.0
for i, batch in enumerate(loader, 1):
review, target = custom_collate(batch, vocab, args.cuda)
if args.aspect == 'aspect1':
target = target[:, 0]
if args.aspect == 'aspect2':
target = target[:, 1]
if args.aspect == 'aspect3':
target = target[:, 2]
trainer(review, target)
loss = trainer.loss.data[0]
pred_loss = trainer.pred_loss.data[0]
reg_loss = trainer.reg_loss.data[0]
delta = loss - total_loss
total_loss += (delta / i)
delta = pred_loss - total_pred_loss
total_pred_loss += (delta / i)
delta = reg_loss - total_reg_loss
total_reg_loss += (delta / i)
# print("validated one batch")
return total_loss, total_pred_loss, total_reg_loss
def validate(loader, trainer, criterion):
trainer.eval()
total_loss = 0.0
for i, batch in enumerate(loader, 1):
review, target = custom_collate(batch, vocab, args.cuda)
pred = activation(trainer(review))
loss = criterion(pred, target).data[0]
delta = loss - total_loss
total_loss += (delta / i)
return total_loss
def train(loader, trainer, criterion, optimizer):
trainer.train()
total_loss = 0.0
for t, batch in enumerate(loader, 1):
review, target = custom_collate(batch, vocab, args.cuda)
pred = activation(trainer(review))
loss = criterion(pred, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
#print("trained one batch")
delta = loss.data[0] - total_loss
total_loss += (delta / t)
return total_loss
def train(loader, trainer, optimizer):
trainer.train()
total_loss = 0.0
total_pred_loss = 0.0
total_reg_loss = 0.0
for i, batch in enumerate(loader, 1):
reviews, target = custom_collate(batch, vocab, args.cuda)
if args.aspect == 'aspect1':
target = target[:, 0]
if args.aspect == 'aspect2':
target = target[:, 1]
if args.aspect == 'aspect3':
target = target[:, 2]
loss = trainer(reviews, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss, pred_loss, reg_loss = trainer.loss.data[
0], trainer.pred_loss.data[0], trainer.reg_loss.data[0]
delta = loss - total_loss
total_loss += (delta / i)
delta = pred_loss - total_pred_loss
total_pred_loss += (delta / i)
delta = reg_loss - total_reg_loss
total_reg_loss += (delta / i)
#print("trained one batch")
gc.collect()
return total_loss, total_pred_loss, total_reg_loss
def main():
global vocab, args
lowest_loss = 100 # arbitrary high number as upper bound for loss
# Check for GPU
args = parser.parse_args()
args.cuda = torch.cuda.is_available()
# Set Seed
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# Set-up data
if args.remote:
train_path = '/home/paulusm/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + args.mode + '.txt.gz'
val_path = '/home/paulusm/data/beer_reviews/' + 'reviews.' + args.aspect + '.heldout.' + args.mode + '.txt.gz'
embd_path = '/home/paulusm/data/beer_reviews/' + 'review+wiki.filtered.200.txt.gz'
word_path = '/home/paulusm/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + 'words.txt.gz'
else:
train_path = '/Users/Max/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + args.mode + '.txt.gz'
val_path = '/Users/Max/data/beer_reviews/' + 'reviews.' + args.aspect + '.heldout.' + args.mode + '.txt.gz'
embd_path = '/Users/Max/data/beer_reviews/' + 'review+wiki.filtered.200.txt.gz'
word_path = '/Users/Max/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + 'words.txt.gz'
# Set-up vocabulary
vocab = Vocabulary()
vocab.loadPretrained(embd_path)
vocab.setStops()
vocab.loadCorpus(word_path)
vocab.updateEmbedding()
vocab.setCuda(args.cuda)
# Set up datasets and -loader
train_set = BeerDataset(train_path)
val_set = BeerDataset(val_path)
kwargs = {'num_workers': 0, 'pin_memory': True} if args.cuda else {}
my_collate = custom_collate(vocab, args.cuda)
train_loader = torch.utils.data.DataLoader(train_set,
collate_fn=my_collate,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
val_loader = torch.utils.data.DataLoader(val_set,
collate_fn=my_collate,
batch_size=args.batch_size,
**kwargs)
# Network parameters
EMBD_DIM = 200
KERNEL_DIM = 200
HIDDEN_DIM = 500
ENC_DIM = 200
TARGET_DIM = 3 if args.aspect in set(['all', 'short']) else 1
# Conventional trainer
trainer = ChunkTrainer(EMBD_DIM, HIDDEN_DIM, KERNEL_DIM, ENC_DIM,
TARGET_DIM)
trainer.activation = nn.Sigmoid()
trainer.reg = args.reg
trainer.reg_mean = args.reg_mean
if args.cuda:
trainer.cuda()
print("created trainer")
# Set-up optimizer
params = [{
'params': vocab.EmbeddingBag.parameters()
}, {
'params': trainer.parameters()
}]
optimizer = torch.optim.Adam(params, lr=args.lr)
### Loop
for epoch in range(args.epochs):
adjust_learning_rate(optimizer, epoch)
train(train_loader, trainer, optimizer)
loss, pred_loss, reg_loss = validate(val_loader, trainer)
log(epoch, loss, pred_loss, reg_loss)
print("logged")
is_best = pred_loss < lowest_loss
lowest_loss = min(pred_loss, lowest_loss)
save = {
'epoch:': epoch + 1,
'embedding': vocab.EmbeddingBag.state_dict(),
'model': 'marginal_chunk Trainer',
'state_dict': trainer.state_dict(),
'lowest_loss': lowest_loss,
'optimizer': optimizer.state_dict()
}
save_checkpoint(save, is_best)
print("saved a checkpoint")
print('*' * 20, 'SUCCESS', '*' * 20)
def main():
global vocab, args
lowest_loss = 100 # arbitrary high number as upper bound for loss
# Check for GPU
args = parser.parse_args()
args.cuda = torch.cuda.is_available()
# Set Seed
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# Set-up data
if args.remote:
train_path = '/home/paulusm/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + args.mode + '.txt.gz'
val_path = '/home/paulusm/data/beer_reviews/' + 'reviews.' + args.aspect + '.heldout.' + args.mode + '.txt.gz'
embd_path = '/home/paulusm/data/beer_reviews/' + 'review+wiki.filtered.200.txt.gz'
word_path = '/home/paulusm/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + 'words.txt.gz'
else:
train_path = '/Users/Max/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + args.mode + '.txt.gz'
val_path = '/Users/Max/data/beer_reviews/' + 'reviews.' + args.aspect + '.heldout.' + args.mode + '.txt.gz'
embd_path = '/Users/Max/data/beer_reviews/' + 'review+wiki.filtered.200.txt.gz'
word_path = '/Users/Max/data/beer_reviews/' + 'reviews.' + args.aspect + '.train.' + 'words.txt.gz'
# Set-up vocabulary
vocab = Vocabulary()
vocab.loadPretrained(embd_path)
vocab.setStops()
vocab.loadCorpus(word_path)
vocab.updateEmbedding()
vocab.setCuda(args.cuda)
print('set up vocabulary')
# Set up datasets and -loader
train_set = BeerDataset(train_path, vocab)
val_set = BeerDataset(val_path, vocab)
kwargs = {'num_workers': 0, 'pin_memory': True} if args.cuda else {}
my_collate = custom_collate(vocab, args.cuda)
train_loader = torch.utils.data.DataLoader(train_set,
collate_fn=my_collate,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
val_loader = torch.utils.data.DataLoader(train_set,
collate_fn=my_collate,
batch_size=args.batch_size,
**kwargs)
# Network parameters
EMBD_DIM = 200
KERNEL_DIM = 200
HIDDEN_DIM = 500
ENC_DIM = 200
TARGET_DIM = 3 if args.aspect in set(['all', 'short']) else 1
# Conventional trainer
trainer = ChunkTrainer(EMBD_DIM, HIDDEN_DIM, KERNEL_DIM, ENC_DIM,
TARGET_DIM)
trainer.activation = nn.Sigmoid()
trainer.reg = args.reg
trainer.reg_mean = args.reg_mean
print("created trainer")
# Set-up optimizer
params = [{
'params': vocab.EmbeddingBag.parameters()
}, {
'params': trainer.parameters()
}]
optimizer = torch.optim.Adam(params, lr=args.lr)
### Loop
for epoch in range(args.epochs):
for t, batch in enumerate(train_loader):
pass