def test(test_loader, model, criterion, model_type):
model.eval()
# Prepare value counters and timers
batch_time, losses = AverageMeter(), AverageMeter()
end = time.time()
c = 0
for i, (X_masked, Mask, Y_unmasked) in enumerate(test_loader):
X_masked = X_masked.permute(0, 3, 2, 1)
Mask = Mask.permute(0, 3, 2, 1)
Y_unmasked = Y_unmasked.permute(0, 3, 2, 1)
if use_gpu:
X_masked, Mask, Y_unmasked = X_masked.cuda(), Mask.cuda(
), Y_unmasked.cuda()
X_masked = X_masked.float()
Mask = Mask.float()
Y_unmasked = Y_unmasked.float()
if model_type == 'PartialConv':
output = model((X_masked, Mask))
else:
output = model(X_masked)
loss = criterion(output, Y_unmasked)
losses.update(loss.item(), X_masked.size(0))
# Save images to file
for j in range(10):
img1 = output[j]
img2 = X_masked[j]
save_name = 'img-{}.jpg'.format(c)
if model_type == 'PartialConv':
save_image(img1, "PredictedOutput_PartialConv/" + save_name)
else:
save_image(img1, "PredictedOutput_VanillaCNN/" + save_name)
save_image(img2, "InputImage/" + save_name)
c += 1
# Record time to do forward passes and save images
batch_time.update(time.time() - end)
end = time.time()
# Print model accuracy -- in the code below, val refers to both value and validation
if i % 10 == 9:
print(model_type + ' Testing: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
i, len(test_loader), batch_time=batch_time, loss=losses))
print('Finished testing.')
def trainCNN(train_loader, model, criterion, optimizer, epoch):
print('Starting Training Epoch {}'.format(epoch))
model.train()
# Prepare value counters and timers
batch_time, losses = AverageMeter(), AverageMeter()
end = time.time()
for i, (x, y) in enumerate(train_loader):
x = x.unsqueeze(1)
y = y.unsqueeze(1)
# x = x.permute(0, 3, 1, 2)
# y = y.permute(0, 3, 1, 2)
# Use GPU if available
if use_gpu:
x, y = x.cuda(), y.cuda()
# Run Forward Pass
output_y = model(x)
# print(y)
# print(output_y)
# break
loss = criterion(output_y, y)
losses.update(loss.item(), x.size(0))
# Compute gradient and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Record time to do backward and forward passes
batch_time.update(time.time() - end)
end = time.time()
# Print model accuracy
if i % 5 == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
loss=losses))
print('Finished training epoch {}'.format(epoch))
return losses.avg
def validation(valid_loader, model, criterion, epoch, model_type):
model.eval()
# Prepare value counters and timers
batch_time, losses = AverageMeter(), AverageMeter()
end = time.time()
for i, (X_masked, Mask, Y_unmasked) in enumerate(valid_loader):
X_masked = X_masked.permute(0, 3, 2, 1)
Mask = Mask.permute(0, 3, 2, 1)
Y_unmasked = Y_unmasked.permute(0, 3, 2, 1)
if use_gpu:
X_masked, Mask, Y_unmasked = X_masked.cuda(), Mask.cuda(
), Y_unmasked.cuda()
X_masked = X_masked.float()
Mask = Mask.float()
Y_unmasked = Y_unmasked.float()
if model_type == 'PartialConv':
output = model((X_masked, Mask))
else:
output = model(X_masked)
loss = criterion(output, Y_unmasked)
losses.update(loss.item(), X_masked.size(0))
# Record time to do forward passes and save images
batch_time.update(time.time() - end)
end = time.time()
# Print model accuracy -- in the code below, val refers to both value and validation
if i % 10 == 0:
print(model_type + 'Validate: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
i,
len(valid_loader),
batch_time=batch_time,
loss=losses))
print('Finished validation.')
return losses.avg
def train(train_loader, model, criterion, optimizer, epoch, model_type):
print('Starting training epoch {}'.format(epoch))
model.train()
batch_time, losses = AverageMeter(), AverageMeter()
for i, (X_masked, Mask, Y_unmasked) in enumerate(train_loader):
X_masked = X_masked.permute(0, 3, 2, 1)
Mask = Mask.permute(0, 3, 2, 1)
Y_unmasked = Y_unmasked.permute(0, 3, 2, 1)
if use_gpu:
X_masked, Mask, Y_unmasked = X_masked.cuda(), Mask.cuda(
), Y_unmasked.cuda()
X_masked = X_masked.float()
Mask = Mask.float()
Y_unmasked = Y_unmasked.float()
if model_type == 'PartialConv':
output = model((X_masked, Mask))
else:
output = model(X_masked)
loss = criterion(output, Y_unmasked)
losses.update(loss.item(), X_masked.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Print model accuracy -- in the code below, val refers to value, not validation
if i % 20 == 0:
print(model_type + ' Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
loss=losses))
print('Finished training epoch {}'.format(epoch))
def eval_epoch(self, loader, args, writer):
"""
Test the model using the given data loader
"""
batch_time = AverageMeter()
losses = AverageMeter()
criterion = nn.NLLLoss()
# switch to evaluate mode
self.eval()
step = 0 * len(loader)
total = 0
correct = 0
with torch.no_grad():
end = time.time()
for i, (x_batch, y_batch) in enumerate(loader):
x_batch = x_batch.to(self.device)
y_batch = y_batch.to(self.device)
prediction = self.forward(x_batch)
loss = criterion(prediction, y_batch)
_, predicted = torch.max(prediction.data, 1)
total += y_batch.size(0)
correct += (predicted == y_batch).sum().item()
# measure accuracy and record loss
losses.update(loss.item(), args.batch_size)
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0 or i == len(loader) - 1:
writer.add_scalar('eval/loss', losses.val, step + i)
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
i,
len(loader) - 1,
batch_time=batch_time,
loss=losses),
flush=True)
print('Accuracy of the network on the test images: {accuracy:.4f}%'.
format(accuracy=100 * correct / total))
def validate(val_loader,
model,
criterion,
save_images,
epoch,
user_input=False):
model.eval()
# Prepare value counters and timers
batch_time, data_time, losses = AverageMeter(), AverageMeter(
), AverageMeter()
end = time.time()
already_saved_images = False
for i, (input_gray, input_ab, target,
input_ab_mean) in enumerate(val_loader):
data_time.update(time.time() - end)
# Use GPU
if use_gpu:
input_gray, input_ab, target, input_ab_mean = input_gray.cuda(
), input_ab.cuda(), target.cuda(), input_ab_mean.cuda()
# Run model and record loss
output_ab = model(input_gray) # throw away class predictions
loss = criterion(output_ab, input_ab)
losses.update(loss.item(), input_gray.size(0))
# Save val images to file
if save_images and not already_saved_images:
already_saved_images = True
for j in range(min(len(output_ab),
10)): # save at most 10 images
save_path = {
'grayscale':
'../blue_cis6930/rishab.lokray/outputs/gray/',
'colorized':
'../blue_cis6930/rishab.lokray/outputs/color/'
}
save_name = 'img-{}-epoch-{}.jpg'.format(
i * val_loader.batch_size + j, epoch)
to_rgb(input_gray[j].cpu(),
ab_input=output_ab[j].detach().cpu(),
save_path=save_path,
save_name=save_name)
# Record time to do forward passes and save images
batch_time.update(time.time() - end)
end = time.time()
# Print model accuracy -- in the code below, val refers to both value and validation
print('Validate: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
i, len(val_loader), batch_time=batch_time, loss=losses))
print('Finished validation.')
return losses.avg
def evaluate(loader, model, criterion, epoch, writer):
batch_time = AverageMeter()
losses = AverageMeter()
# switch to evaluate mode
model.eval()
step = epoch * len(loader)
with torch.no_grad():
end = time.time()
for i, (img, speed, target, mask) in enumerate(loader):
img = img.cuda(args.gpu, non_blocking=True)
speed = speed.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
mask = mask.cuda(args.gpu, non_blocking=True)
branches_out, pred_speed = model(img, speed)
mask_out = branches_out * mask
branch_loss = criterion(mask_out, target) * 4
speed_loss = criterion(pred_speed, speed)
loss = args.branch_weight * branch_loss + \
args.speed_weight * speed_loss
# measure accuracy and record loss
losses.update(loss.item(), args.batch_size)
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0 or i == len(loader):
writer.add_scalar('eval/loss', losses.val, step+i)
output_log(
'Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
.format(
i, len(loader), batch_time=batch_time,
loss=losses), logging)
return losses.avg
def train(train_loader, model, criterion, optimizer, epoch):
print('Starting training epoch {}'.format(epoch))
model.train()
# Prepare value counters and timers
batch_time, data_time, losses = AverageMeter(), AverageMeter(
), AverageMeter()
end = time.time()
for i, (input_gray, input_ab, target,
input_ab_mean) in enumerate(train_loader):
# Use GPU if available
if use_gpu:
input_gray, input_ab, target, input_ab_mean = input_gray.cuda(
), input_ab.cuda(), target.cuda(), input_ab_mean.cuda()
# Record time to load data (above)
data_time.update(time.time() - end)
print("USEGPu", use_gpu)
print(type(input_gray))
print(type(input_ab_mean))
# Run forward pass
output_ab = model(input_gray)
loss = criterion(output_ab, input_ab_mean)
losses.update(loss.item(), input_gray.size(0))
# Compute gradient and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Record time to do forward and backward passes
batch_time.update(time.time() - end)
end = time.time()
# Print model accuracy -- in the code below, val refers to value, not validation
if i % 5 == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
data_time=data_time,
loss=losses))
print('Finished training epoch {}'.format(epoch))
return loss
def validate(val_loader, model, criterion):
model.eval()
all_acc = []
all_acc_top5 = []
all_loss = []
if args.model == "Elastic_InceptionV3":
for ix in range((num_outputs - 1)):
all_loss.append(AverageMeter())
all_acc.append(AverageMeter())
all_acc_top5.append(AverageMeter())
else:
for ix in range(num_outputs):
all_loss.append(AverageMeter())
all_acc.append(AverageMeter())
all_acc_top5.append(AverageMeter())
for i, (input, target) in enumerate(val_loader):
target = target.cuda(async=True)
input_var = torch.autograd.Variable(input)
target_var = torch.autograd.Variable(target)
losses = 0
outputs = model(input_var)
with torch.no_grad():
for ix in range(len(outputs)):
loss = criterion(outputs[ix], target_var)
all_loss[ix].update(loss.item(), input.size(0))
losses += loss
prec1 = accuracy(outputs[ix].data, target)
all_acc[ix].update(prec1[0].data[0].item(), input.size(0))
# top 5 accuracy
prec5 = accuracy(outputs[ix].data, target, topk=(5, ))
all_acc_top5[ix].update(prec5[0].data[0].item(), input.size(0))
accs = []
ls = []
accs_top5 = []
for i, j, k in zip(all_acc, all_loss, all_acc_top5):
accs.append(float(100 - i.avg))
ls.append(j.avg)
accs_top5.append(float(100 - k.avg))
print("validation top 5 error: ", accs_top5)
return accs, ls, accs_top5
def validate(val_loader,
model,
criterion,
save_images,
epoch,
user_input=False):
model.eval()
# Prepare value counters and timers
batch_time, data_time, losses = AverageMeter(), AverageMeter(
), AverageMeter()
end = time.time()
already_saved_images = False
for i, (input_gray, input_ab, target,
input_ab_mean) in enumerate(val_loader):
data_time.update(time.time() - end)
# Use GPU
if use_gpu:
input_gray, input_ab, target, input_ab_mean = input_gray.cuda(
), input_ab.cuda(), target.cuda(), input_ab_mean.cuda()
# Run model and record loss
output_ab = model(input_gray) # throw away class predictions
loss = criterion(output_ab, input_ab_mean)
losses.update(loss.item(), input_gray.size(0))
# Record time to do forward passes and save images
batch_time.update(time.time() - end)
end = time.time()
# Print model accuracy -- in the code below, val refers to both value and validation
print('Validate: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
i, len(val_loader), batch_time=batch_time, loss=losses))
print('Finished validation.')
return losses.avg
def train(loader, model, optimizer, epoch, writer):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
iou = AverageMeter() # semantic IoU
iou_c = AverageMeter() # contour IoU
iou_m = AverageMeter() # marker IoU
print_freq = config['train'].getfloat('print_freq')
only_contour = config['contour'].getboolean('exclusive')
weight_map = config['param'].getboolean('weight_map')
model_name = config['param']['model']
with_contour = config.getboolean(model_name, 'branch_contour')
with_marker = config.getboolean(model_name, 'branch_marker')
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Sets the module in training mode.
model.train()
end = time.time()
n_step = len(loader)
for i, data in enumerate(loader):
# measure data loading time
data_time.update(time.time() - end)
# split sample data
inputs = data['image'].to(device)
labels = data['label'].to(device)
labels_c = data['label_c'].to(device)
labels_m = data['label_m'].to(device)
# get loss weight
weights = None
if weight_map and 'weight' in data:
weights = data['weight'].to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward step
outputs = model(inputs)
if with_contour and with_marker:
outputs, outputs_c, outputs_m = outputs
elif with_contour:
outputs, outputs_c = outputs
# compute loss
if only_contour:
loss = contour_criterion(outputs, labels_c)
else:
# weight_criterion equals to segment_criterion if weights is none
loss = focal_criterion(outputs, labels, weights)
if with_contour:
loss += focal_criterion(outputs_c, labels_c, weights)
if with_marker:
loss += focal_criterion(outputs_m, labels_m, weights)
# compute gradient and do backward step
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
# measure accuracy and record loss
# NOT instance-level IoU in training phase, for better speed & instance separation handled in post-processing
losses.update(loss.item(), inputs.size(0))
if only_contour:
batch_iou = iou_mean(outputs, labels_c)
else:
batch_iou = iou_mean(outputs, labels)
iou.update(batch_iou, inputs.size(0))
if with_contour:
batch_iou_c = iou_mean(outputs_c, labels_c)
iou_c.update(batch_iou_c, inputs.size(0))
if with_marker:
batch_iou_m = iou_mean(outputs_m, labels_m)
iou_m.update(batch_iou_m, inputs.size(0))
# log to summary
#step = i + epoch * n_step
#writer.add_scalar('training/loss', loss.item(), step)
#writer.add_scalar('training/batch_elapse', batch_time.val, step)
#writer.add_scalar('training/batch_iou', iou.val, step)
#writer.add_scalar('training/batch_iou_c', iou_c.val, step)
#writer.add_scalar('training/batch_iou_m', iou_m.val, step)
if (i + 1) % print_freq == 0:
print(
'Epoch: [{0}][{1}/{2}]\t'
'Time: {batch_time.avg:.2f} (io: {data_time.avg:.2f})\t'
'Loss: {loss.val:.4f} (avg: {loss.avg:.4f})\t'
'IoU: {iou.avg:.3f} (Coutour: {iou_c.avg:.3f}, Marker: {iou_m.avg:.3f})\t'
.format(
epoch, i, n_step, batch_time=batch_time,
data_time=data_time, loss=losses, iou=iou, iou_c=iou_c, iou_m=iou_m
)
)
# end of loop, dump epoch summary
writer.add_scalar('training/epoch_loss', losses.avg, epoch)
writer.add_scalar('training/epoch_iou', iou.avg, epoch)
writer.add_scalar('training/epoch_iou_c', iou_c.avg, epoch)
writer.add_scalar('training/epoch_iou_m', iou_m.avg, epoch)
return iou.avg # return epoch average iou
c = cfg.getfloat('default', 'c')
lag = cfg.getint('default', 'lag')
data_src = cfg.get('default', 'data_src')
log_src = cfg.get('default', 'log_src')
# Dataset
dataset = IndexDataset(os.path.join(data_src, 'futures', 'train'), lag)
dataloader = DataLoader(dataset, shuffle=False, batch_size=1)
# Models
ddrl = DDRL(lag)
# Tools
optimizer = torch.optim.Adam(ddrl.parameters())
reward_meter = AverageMeter(epochs, len(dataloader))
# Training Phase
for e in range(epochs):
with tqdm(total=len(dataloader)) as progress_bar:
for i, (returns, fragments) in enumerate(dataloader):
# Computing actions by using FDDR
delta = ddrl(fragments).double().squeeze(-1)
# Computing reward
pad_delta = F.pad(delta, [1, 0])
delta_diff = (pad_delta[:, 1:] - pad_delta[:, :-1])
reward = torch.sum(delta * returns - c * torch.abs(delta_diff))
# Updating FDDR
optimizer.zero_grad()
def validate(args, epoch, model, loader, criterion, logger):
steps = len(loader)
local_loss = AverageMeter()
local_acc = AverageMeter()
local_recall = AverageMeter()
aver_loss = AverageMeter()
aver_acc = AverageMeter()
aver_recall = AverageMeter()
model.eval()
if args.verbose:
logger.info("Validating")
with torch.no_grad():
for i, (images, targets) in enumerate(loader, start=1):
if args.gpu is not None:
images = images.cuda(args.gpu, non_blocking=True)
targets = targets.cuda(args.gpu, non_blocking=True)
outputs = model(images)
if args.multi:
outputs = torch.sigmoid(outputs)
loss = criterion(outputs, targets)
if args.multi:
precision, recall = calculate_metrics(
outputs.detach().cpu().numpy(),
targets.detach().cpu().numpy(), args.threshold)
else:
precision = accuracy(outputs, targets)[0].item()
recall = precision
local_loss.update(loss.item(), images.size(0))
local_acc.update(precision, images.size(0))
local_recall.update(recall, images.size(0))
if args.distributed:
running_metrics = torch.FloatTensor(
[loss.item(), precision, recall]).cuda(args.gpu)
running_metrics /= args.world_size
dist.all_reduce(running_metrics, op=dist.ReduceOp.SUM)
aver_loss.update(running_metrics[0].item())
aver_acc.update(running_metrics[1].item())
aver_recall.update(running_metrics[2].item())
else:
aver_loss.update(loss.item(), images.size(0))
aver_acc.update(precision, images.size(0))
aver_recall.update(recall, images.size(0))
if args.verbose and i % args.log_interval == 0:
logger.info("Epoch: [{}] [{}]/[{}]({:.2%}) "
"Loss: {:.4f} / {:.4f} / {:.4f} "
"Acc: {:.2f} / {:.2f} / {:.2f} "
"Recall: {:.2f} / {:.2f} / {:.2f}".format(
epoch, i, steps, i / steps, loss,
local_loss.avg, aver_loss.avg, precision,
local_acc.avg, aver_acc.avg, recall,
local_recall.avg, aver_recall.avg))
return aver_loss.avg, aver_acc.avg, aver_recall.avg
# streamer.transform('./Data/futures/train', './Data/fuzzy_futures/train')
# Dataset
train_dataset = FuzzyIndexDataset(
os.path.join(data_src, 'fuzzy_futures', 'train'), lag)
train_dataloader = DataLoader(train_dataset, shuffle=False, batch_size=1)
test_dataset = FuzzyIndexDataset(
os.path.join(data_src, 'fuzzy_futures', 'test'), lag)
test_dataloader = DataLoader(test_dataset, shuffle=False, batch_size=1)
# Models
fddr = FDDR(lag, fuzzy_degree)
# Tools
optimizer = torch.optim.Adam(fddr.parameters())
train_reward_meter = AverageMeter(epochs, len(train_dataloader))
test_reward_meter = AverageMeter(epochs, len(test_dataloader))
# Training Phase
for e in range(epochs):
with tqdm(total=len(train_dataloader), ncols=130) as progress_bar:
fddr.train()
for i, (returns, fragments, mean, var) in enumerate(train_dataloader):
# Computing actions by using FDDR
delta = fddr(fragments, running_mean=mean,
running_var=var).double().squeeze(-1)
# Computing reward
pad_delta = F.pad(delta, [1, 0])
delta_diff = (pad_delta[:, 1:] - pad_delta[:, :-1])
reward = torch.sum(delta * returns - c * torch.abs(delta_diff))
def train(train_loader, model, criterion, optimizer, epoch, print_freq):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to train mode
model.train()
#model.apply(freeze_bn)
dslen = len(train_loader)
end = time.time()
for k, (input, target) in enumerate(train_loader):
if epoch < args.warm:
warmup_scheduler.step()
# measure data loading time
if True:
data_time.update(time.time() - end)
target = target.cuda(non_blocking=True)
input = input.cuda(non_blocking=True)
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec[0].item(), input.size(0))
top5.update(prec[1].item(), input.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if 'mean' in args.weight:
model.apply(meanweigh) #(model)
n_iter = (epoch) * len(train_loader) + k
if n_iter == 1:
os.system('nvidia-smi')
if n_iter % print_freq == 1 and epoch < args.start_epoch + 5:
print('Epoch: [{0}][{1}/{2}]\t'
'LR: {3:.5f}\t'
'Time {batch_time.avg:.3f}\t'
'Data {data_time.avg:.3f}\t'
'LossEpoch {loss.avg:.4f}\t'
'Prec@1 {top1.avg:.3f}\t'
'Prec@5 {top5.avg:.3f}\t'.format(
epoch,
n_iter,
dslen,
optimizer.param_groups[0]['lr'],
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
top5=top5),
flush=True)
batch_time.reset()
data_time.reset()
losses.reset()
top1.reset()
top5.reset()
#validatetrain(val_loader, model, criterion)
elif k == dslen - 1:
model.apply(inspect_bn)
print('Epoch: [{0}][{1}/{2}]\t'
'LR: {3:.5f}\t'
'Time {batch_time.avg:.3f}\t'
'Data {data_time.avg:.3f}\t'
'LossEpoch {loss.avg:.4f}\t'
'Prec@1 {top1.avg:.3f}\t'
'Prec@5 {top5.avg:.3f}\t'.format(
epoch,
n_iter,
dslen,
optimizer.param_groups[0]['lr'],
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
top5=top5),
flush=True)
def validatetrain(val_loader, model, criterion):
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
model.eval()
for i, (input, target) in enumerate(val_loader):
target = target.cuda(non_blocking=True)
input = input.cuda(non_blocking=True)
with torch.no_grad():
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec[0].item(), input.size(0))
top5.update(prec[1].item(), input.size(0))
model.train()
print(' *TRAINMODE Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}'.format(
top1=top1, top5=top5))
def validate(val_loader, model, criterion, print_freq, colorization=False):
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
for i, (input, target) in enumerate(val_loader):
# target = target.cuda()
# input = input.cuda()
input = input.to(device, dtype=torch.float32)
target = target.to(device, dtype=torch.float32)
if colorization:
input = transforms.Resize(500)(input)
target = transforms.Resize(500)(target)
input = input.repeat(1,3,1,1)
with torch.no_grad():
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
losses.update(loss.item(), input.size(0))
if not colorization:
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
top1.update(prec1, input.size(0))
top5.update(prec5, input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if not colorization:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i, len(val_loader), batch_time=batch_time, loss=losses,
top1=top1, top5=top5))
else:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
i, len(val_loader), batch_time=batch_time, loss=losses))
return losses.avg, top1.avg, top5.avg
def validate(val_loader, model, criterion, print_freq):
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
for i, (input, target) in enumerate(val_loader):
target = target.cuda(async=True)
input = input.cuda(async=True)
with torch.no_grad():
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % print_freq == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i,
len(val_loader),
batch_time=batch_time,
loss=losses,
top1=top1,
top5=top5))
print(' * Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}'.format(top1=top1,
top5=top5))
return top1.avg, top5.avg
def train(train_loader, model, criterion, optimizer, epoch):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
errors = AverageMeter()
# switch to train mode
model.train()
end = time()
for i, s in enumerate(train_loader):
if len(s) == 5:
data, label, mid, leng, quat = s
else:
data, label, mid, leng = s
# measure data loading time
data_time.update(time() - end)
batch_size = data.size(0)
input_var = torch.autograd.Variable(data.cuda().float())
# input_quat_var = torch.autograd.Variable(quat.cuda())
target_var = torch.autograd.Variable(label.cuda())
output = model(input_var)
# record loss
# leng is voxel length
leng = leng * (NUM_VOXEL / NUM_GT_SIZE)
mid = mid - leng.repeat(1, 3) * (NUM_GT_SIZE / 2 - 0.5)
leng = leng.repeat(1, JOINT_LEN * 3)
base = mid.repeat(1, JOINT_LEN)
for j in range(len(output)):
output[j] = (output[j].mul(leng.cuda())).add(base.cuda())
loss = criterion(output[0], target_var)
for k in range(1, nSTACK):
loss += criterion(output[k], target_var)
losses.update(loss.item() / batch_size, 1)
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
err_t = float(mean_error(output[-1].cpu(), label)[0])
# print err_t
errors.update(err_t, batch_size)
# measure elapsed time
batch_time.update(time() - end)
end = time()
if i % args.print_freq == 0:
print(
'Epoch: [{0}][{1}/{2}]\t'
'Acc {err_t.val:.2f} ({err_t.avg:.2f})\t'
'Loss {loss.val:.2f} ({loss.avg:.2f})\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
err_t=errors))
return losses.avg, errors.avg
def train_iters(self):
# Initialize search module
searcher = GreedySearchDecoder(self.encoder,
self.decoder, self.device)
start = time.time()
nepoch_no_imprv = 0
self.train_loss = AverageMeter()
total_loss = []
total_bleu = []
total_rouge_l = []
total_rouge_1 = []
total_rouge_2 = []
self.best_bleu = .0
for epoch in tqdm(range(self.num_epoch)):
# Ensure dropout layers are in train mode
self.encoder.train()
self.decoder.train()
print_loss_total = 0
epoch_loss = []
for i_train, batch in enumerate(self.train_loader):
src_input = batch.src[0]
per_input = batch.per[0]
src_length = batch.src[1]
trg_input = batch.trg[0][:, :-1]
trg_length = batch.trg[1]
max_target_lenght = max([len(ele) for ele in trg_input.tolist()])
max_src_lenght = max([len(ele) for ele in src_input.tolist()])
loss = self.train(src_input, trg_input, per_input, self.encoder,
self.decoder, self.encoder_optimizer, self.decoder_optimizer, self.criterion, max_target_lenght)
self.train_loss.update(loss)
epoch_loss.append(loss)
print_loss_total += loss
total_loss.append(np.average(epoch_loss))
######################################################################
# Run the overfitting
# ~~~~~~~~~~~~~~
if (epoch % self.evaluate_every == 0) and (epoch != 0):
# Ensure dropout layers are in evaluation mode
self.encoder.eval()
self.decoder.eval()
self.val_bleu = AverageMeter()
self.val_rouge_1 = AverageMeter()
self.val_rouge_2 = AverageMeter()
self.val_rouge_l = AverageMeter()
epoch_bleu = []
epoch_rouge_l = []
epoch_rouge_1 = []
epoch_rouge_2 = []
print("evaluating")
for i, batch in enumerate(self.val_loader):
src_input = batch.src[0]
per_input = batch.per[0]
trg_output = batch.trg[0][:,:]
preds = []
for src_input_, per_input_ in zip(src_input, per_input):
lengths = []
ctr = 0
for ele in src_input_:
if ele == self.PAD_word:
break
ctr += 1
lengths.append(ctr)
src_input_ = torch.LongTensor([src_input_.tolist()]).transpose(0,1).to(self.device)
per_input_ = torch.LongTensor([per_input_.tolist()]).transpose(0,1).to(self.device)
lengths = torch.tensor(lengths).to(self.device)
#trg_output_ = torch.LongTensor([trg_output_.tolist()]).transpose(0,1).to(self.device)
pred, scores = searcher(src_input_, per_input_, lengths, self.max_length, self.trg_soi)
preds.append(pred)
# Compute BLEU and ROUGFE score and Loss
pred_sents = []
trg_sents = []
pred_STR = []
trg_STR = []
print(trg_output.t().size())
for j in range(trg_output.t().size()[1]):
pred_sent = self.get_sentence(tensor2np(preds[j]), 'trg')
trg_sent = self.get_sentence(tensor2np(trg_output[j]), 'trg')
pred_sents.append(pred_sent)
pred_STR.append(" ".join(pred_sent))
trg_sents.append(trg_sent)
trg_STR.append(" ".join(trg_sent))
rouge = Rouge()
hyps, refs = map(list, zip(*[[d[0], d[1]] for d in [pred_STR, trg_STR]]))
rouge_scores = rouge.get_scores(hyps, refs, avg=True)
bleu_score = get_bleu(pred_sents, trg_sents)
epoch_bleu.append(bleu_score)
epoch_rouge_1.append(rouge_scores["rouge-1"]["f"])
epoch_rouge_2.append(rouge_scores["rouge-2"]["f"])
epoch_rouge_l.append(rouge_scores["rouge-l"]["f"])
self.val_bleu.update(bleu_score)
self.val_rouge_1.update(rouge_scores["rouge-1"]["f"])
self.val_rouge_2.update(rouge_scores["rouge-2"]["f"])
self.val_rouge_l.update(rouge_scores["rouge-l"]["f"])
total_bleu.append(np.average(epoch_bleu))
total_rouge_1.append(np.average(epoch_rouge_1))
total_rouge_2.append(np.average(epoch_rouge_2))
total_rouge_l.append(np.average(epoch_rouge_l))
print('epochs: ' + str(epoch))
print('average train loss: ' + str(self.train_loss.avg))
print('average validation bleu score: ' + str(self.val_bleu.avg))
print('average validation rouge-l score: ' + str(self.val_rouge_l.avg))
# early stopping
# Save model if bleu score is higher than the best
if self.best_bleu < self.val_bleu.avg:
self.best_bleu = self.val_bleu.avg
checkpoint = {
'encoder': self.encoder,
'decoder': self.decoder,
'epoch': epoch
}
torch.save(checkpoint, self.log_path + '/Model_e%d_bleu%.3f.pt' % (epoch, self.val_bleu.avg))
else:
nepoch_no_imprv += 1
if nepoch_no_imprv >= self.nepoch_no_imprv:
print("- early stopping {} epochs without " \
"improvement".format(nepoch_no_imprv))
break
pandas_bleu = pd.DataFrame.from_dict({"bleu_validation": total_bleu})
pandas_loss = pd.DataFrame.from_dict({"loss_train": total_loss})
pandas_rouge_1 = pd.DataFrame.from_dict({"rouge_1_val": total_rouge_1})
pandas_rouge_2 = pd.DataFrame.from_dict({"rouge_2_val": total_rouge_2})
pandas_rouge_l = pd.DataFrame.from_dict({"rouge_l_val": total_rouge_l})
pandas_loss.to_csv("./loss_train.csv", sep="\t", index=False)
pandas_bleu.to_csv("./blue_validation.csv", sep="\t", index=False)
pandas_rouge_1.to_csv("./rouge_1_validation.csv", sep="\t", index=False)
pandas_rouge_2.to_csv("./rouge_2_validation.csv", sep="\t", index=False)
pandas_rouge_l.to_csv("./rouge_l_validation.csv", sep="\t", index=False)
c = cfg.getfloat('default', 'c')
lag = cfg.getint('default', 'lag')
data_src = cfg.get('default', 'data_src')
log_src = cfg.get('default', 'log_src')
# Dataset
dataset = IndexDataset(os.path.join(data_src, 'futures', 'train'), lag)
dataloader = DataLoader(dataset, shuffle=False, batch_size=1)
# Models
drl = DRL(lag)
# Tools
optimizer = torch.optim.Adam(drl.parameters())
reward_meter = AverageMeter(epochs, len(dataloader))
# Training Phase
for e in range(epochs):
with tqdm(total=len(dataloader)) as progress_bar:
for i, (returns, fragments) in enumerate(dataloader):
# Computing actions by using FDDR
delta = drl(fragments).double().squeeze(-1)
# Computing reward
pad_delta = F.pad(delta, [1, 0])
delta_diff = (pad_delta[:, 1:] - pad_delta[:, :-1])
reward = torch.sum(delta * returns - c * torch.abs(delta_diff))
# Updating FDDR
optimizer.zero_grad()
def train(train_loader, model, criterion, optimizers, epoch):
model.train()
lr = None
all_acc = []
all_acc_top5 = []
all_loss = []
for ix in range(num_outputs):
all_loss.append(AverageMeter())
all_acc.append(AverageMeter())
all_acc_top5.append(AverageMeter())
LOG("==> train ", logFile)
# print("num_outputs: ", num_outputs)
for i, (input, target) in enumerate(train_loader):
# print("input: ", input, input.shape)
# print("target: ", target, target.shape)
# bp_1
if args.backpropagation == 1:
# LOG("enter backpropagation method : " + str(args.backpropagation) +"\n", logFile)
target = target.cuda(async=True)
input_var = torch.autograd.Variable(input)
target_var = torch.autograd.Variable(target)
for ix in range(num_outputs):
outputs = model(input_var)
#
optimizers[ix].zero_grad()
loss = criterion(outputs[ix], target_var)
loss.backward()
optimizers[ix].step()
# optimizer.zero_grad()
# if ix == (num_outputs - 1):
# loss.backward()
# else:
# loss.backward(retain_graph=True)
# optimizer.step()
all_loss[ix].update(loss.item(), input.size(0))
# top 1 accuracy
prec1 = accuracy(outputs[ix].data, target)
all_acc[ix].update(prec1[0].data[0].item(), input.size(0))
# # top 5 accuracy
prec5 = accuracy(outputs[ix].data, target, topk=(5, ))
# print("prec top 5-1: ", prec5)
# print("prec top 5-2: ", prec5[0])
# print("prec top 5-3: ", prec5[0].data[0].item())
all_acc_top5[ix].update(prec5[0].data[0].item(), input.size(0))
# elif args.backpropagation == 2:
# # LOG("enter backpropagation method : " + str(args.backpropagation) +"\n", logFile)
# # bp_2
# for ix in range(num_outputs):
# target = target.cuda(async=True)
# input_var = torch.autograd.Variable(input)
# target_var = torch.autograd.Variable(target)
# optimizer.zero_grad()
# outputs = model(input_var)
# loss = criterion(outputs[ix], target_var)
# loss.backward()
# optimizer.step()
# all_loss[ix].update(loss.item(), input.size(0))
# # top 1 accuracy
# prec1 = accuracy(outputs[ix].data, target)
# all_acc[ix].update(prec1[0].data[0].item(), input.size(0))
# # top 5 accuracy
# prec5 = accuracy(outputs[ix].data, target, topk=(5,))
# all_acc_top5[ix].update(prec5[0].data[0].item(), input.size(0))
# elif args.backpropagation == 3:
# # LOG("enter backpropagation method : " + str(args.backpropagation) +"\n", logFile)
# # bp_3
# target = target.cuda(async=True)
# input_var = torch.autograd.Variable(input)
# target_var = torch.autograd.Variable(target)
# optimizer.zero_grad()
# outputs = model(input_var)
# losses = 0
# for ix in range(len(outputs)):
# # print("outputs[ix]: ", outputs[ix])
# loss = criterion(outputs[ix], target_var)
# losses += loss
# all_loss[ix].update(loss.item(), input.size(0))
# # top 1 accuracy
# prec1 = accuracy(outputs[ix].data, target)
# all_acc[ix].update(prec1[0].data[0].item(), input.size(0))
# # top 5 accuracy
# prec5 = accuracy(outputs[ix].data, target, topk=(5,))
# all_acc_top5[ix].update(prec5[0].data[0].item(), input.size(0))
# # losses = losses/len(outputs)
# losses.backward()
# optimizer.step()
else:
NotImplementedError
accs = []
accs_top5 = []
ls = []
for i, j, k in zip(all_acc, all_loss, all_acc_top5):
accs.append(float(100 - i.avg))
ls.append(j.avg)
accs_top5.append(float(100 - k.avg))
try:
lr = float(str(optimizers[-1]).split("\n")[-5].split(" ")[-1])
except:
lr = 100
print("train epoch top 5 error: ", accs_top5)
return accs, ls, lr, accs_top5
def valid(loader, model, epoch, writer, n_step):
iou = AverageMeter() # semantic IoU
iou_c = AverageMeter() # contour IoU
iou_m = AverageMeter() # marker IoU
losses = AverageMeter()
only_contour = config['contour'].getboolean('exclusive')
weight_map = config['param'].getboolean('weight_map')
model_name = config['param']['model']
with_contour = config.getboolean(model_name, 'branch_contour')
with_marker = config.getboolean(model_name, 'branch_marker')
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Sets the model in evaluation mode.
model.eval()
for i, data in enumerate(loader):
# get the inputs
inputs = data['image'].to(device)
labels = data['label'].to(device)
labels_c = data['label_c'].to(device)
labels_m = data['label_m'].to(device)
# get loss weight
weights = None
if weight_map and 'weight' in data:
weights = data['weight'].to(device)
# forward step
outputs = model(inputs)
if with_contour and with_marker:
outputs, outputs_c, outputs_m = outputs
elif with_contour:
outputs, outputs_c = outputs
# compute loss
if only_contour:
loss = contour_criterion(outputs, labels_c)
else:
# weight_criterion equals to segment_criterion if weights is none
loss = focal_criterion(outputs, labels, weights)
if with_contour:
loss += focal_criterion(outputs_c, labels_c, weights)
if with_marker:
loss += focal_criterion(outputs_m, labels_m, weights)
# measure accuracy and record loss (Non-instance level IoU)
losses.update(loss.item(), inputs.size(0))
if only_contour:
batch_iou = iou_mean(outputs, labels_c)
else:
batch_iou = iou_mean(outputs, labels)
iou.update(batch_iou, inputs.size(0))
if with_contour:
batch_iou_c = iou_mean(outputs_c, labels_c)
iou_c.update(batch_iou_c, inputs.size(0))
if with_marker:
batch_iou_m = iou_mean(outputs_m, labels_m)
iou_m.update(batch_iou_m, inputs.size(0))
# end of loop, dump epoch summary
writer.add_scalar('CV/epoch_loss', losses.avg, epoch)
writer.add_scalar('CV/epoch_iou', iou.avg, epoch)
writer.add_scalar('CV/epoch_iou_c', iou_c.avg, epoch)
writer.add_scalar('CV/epoch_iou_m', iou_m.avg, epoch)
print(
'Epoch: [{0}]\t\tcross-validation\t'
'Loss: N/A (avg: {loss.avg:.4f})\t'
'IoU: {iou.avg:.3f} (Coutour: {iou_c.avg:.3f}, Marker: {iou_m.avg:.3f})\t'
.format(
epoch, loss=losses, iou=iou, iou_c=iou_c, iou_m=iou_m
)
)
return iou.avg # return epoch average iou
def validate(val_loader, model, criterion, print_freq, epoch):
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
# model.apply(unfreeze_bn)
for i, (input, target) in enumerate(val_loader):
target = target.cuda(non_blocking=True)
input = input.cuda(non_blocking=True)
with torch.no_grad():
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec[0].item(), input.size(0))
top5.update(prec[1].item(), input.size(0))
# measure elapsed time
if i % print_freq == 0:
print('Test: [{0}][{1}/{2}]\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
epoch,
i,
len(val_loader),
loss=losses,
top1=top1,
top5=top5))
n_iter = (epoch) * len(train_loader) + i + 1
# if args.record:
# writer.add_scalar('Test/Average loss', losses.val, n_iter)
# writer.add_scalar('Test/Accuracy', top1.val, n_iter)
model.train()
f_loss.write('\n epoch {} test with loss {:.4f} \n'.format(
epoch, losses.avg))
f_acc.write('\n epoch {} test with top1 {:.3f} and top5 {:.3f} \n'.format(
epoch, top1.avg, top5.avg))
print(' * Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}'.format(top1=top1,
top5=top5))
return top1.avg, top5.avg
def test(args, model, device, test_loader):
if test_loader.dataset.train:
print("test on validation set\r\n")
else:
print("test on test set\r\n")
# validate
model.eval()
# test_loss = 0
# correct = 0
# num_samples = 0
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
with torch.no_grad():
for data in test_loader:
inputs, labels = data[0].to(device), data[1].to(device)
outputs = model(inputs)
test_loss = criterion(outputs, labels).item()
# pred = outputs.argmax(dim=1, keepdim=True)
# correct += pred.eq(labels.view_as(pred)).sum().item()
# # _, pred = torch.max(outputs, 1)
# # correct += (pred == labels).sum().item()
# num_samples += pred.size(0)
prec1, prec5 = accuracy(outputs, labels, topk=(1, 5))
losses.update(test_loss, labels.size(0))
top1.update(prec1[0], labels.size(0))
top5.update(prec5[0], labels.size(0))
print(
'\nTest set: Average loss: {:.4f}, Accuracy: Prec@1:{}/{} ({:.2f}%) Prec@5:{}/{} ({:.2f}%)\n'
.format(losses.avg, top1.sum // 100, top1.count, top1.avg,
top5.sum // 100, top1.count, top5.avg))
return top1.avg, top5.avg
def train(train_loader, model, criterion, optimizer, epoch, print_freq, colorization=False,scheduler=None):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
global cur_itrs
# switch to train mode
model.train()
end = time.time()
for i, (input, target) in enumerate(train_loader):
cur_itrs+=1
# measure data loading time
data_time.update(time.time() - end)
# if torch.cuda.is_available():
# target = target.cuda()
# input = input.cuda()
target = target.to(device, dtype=torch.float32)
input = input.to(device, dtype=torch.float32)
if colorization:
input = transforms.Resize(500)(input)
target = transforms.Resize(500)(target)
input = input.repeat(1,3,1,1)
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
losses.update(loss.item(), input.size(0))
if not colorization:
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
top1.update(prec1, input.size(0))
top5.update(prec5, input.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
if scheduler:
scheduler.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % print_freq == 0:
if not colorization:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})\t'.format(
epoch, i, len(train_loader), batch_time=batch_time,
data_time=data_time, loss=losses, top1=top1, top5=top5))
else:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch, i, len(train_loader), batch_time=batch_time,
data_time=data_time, loss=losses))
# return loss, top1, top5 corresponding to each epoch
return losses.avg, top1.avg, top5.avg
class Trainer(object):
def __init__(self, train_loader, val_loader, test_loader, vocabs, args):
self.use_cuda = True
self.max_length = args.max_len
# Data Loader
self.train_loader = train_loader
self.val_loader = val_loader
self.test_loader = test_loader
# Hyper-parameters
self.lr = args.lr
self.grad_clip = args.grad_clip
self.embed_dim = args.embed_dim
self.hidden_dim = args.hidden_dim
self.num_layer = args.num_layer
self.dropout = args.dropout
self.attn_model = args.attn_model
self.decoder_lratio = args.decoder_lratio
self.teacher_forcing= args.teacher_forcing
self.nepoch_no_imprv= args.early_stoping
self.evaluate_every = args.evaluate_every
# Training setting
self.batch_size = args.batch_size
self.num_epoch = args.num_epoch
self.iter_per_epoch = len(train_loader)
USE_CUDA = torch.cuda.is_available()
self.device = torch.device("cuda" if USE_CUDA else "cpu")
ARRUMAR BUILD
self.build_model(vocabs)
self.log_path = os.path.join('./logs/' + args.log)
def build_model(self, vocabs):
self.src_vocab = vocabs['src_vocab']
self.trg_vocab = vocabs['trg_vocab']
self.per_vocab = vocabs['per_vocab']
self.src_inv_vocab = vocabs['src_inv_vocab']
self.trg_inv_vocab = vocabs['trg_inv_vocab']
self.per_inv_vocab = vocabs['per_inv_vocab']
self.trg_soi = self.trg_vocab[SOS_WORD]
self.PAD_word = self.src_vocab[PAD_WORD]
self.src_nword = len(self.src_vocab)
self.trg_nword = len(self.trg_vocab)
self.per_nword = len(self.per_vocab)
print('Building encoder and decoder ...')
# Initialize word embeddings
embedding_trg = nn.Embedding(self.trg_nword, self.embed_dim)
embedding_src = nn.Embedding(self.src_nword, self.embed_dim)
embedding_per = nn.Embedding(self.per_nword, 600)
#if loadFilename:
w_trg = get_word_embeddings(600, "./data/embeddings/pt.txt", self.trg_vocab)
w_src = get_word_embeddings(600, "./data/embeddings/pt.txt", self.src_vocab)
embedding_trg.from_pretrained(torch.FloatTensor(w_trg))
embedding_src.from_pretrained(torch.FloatTensor(w_src))
# Initialize encoder & decoder models
self.encoder = EncoderRNN(self.hidden_dim, embedding_src, embedding_per, self.num_layer, self.dropout)
self.decoder = LuongAttnDecoderRNN(self.attn_model, embedding_trg, self.hidden_dim, self.trg_nword, self.num_layer, self.dropout)
if self.use_cuda:
self.encoder = self.encoder.cuda()
self.decoder = self.decoder.cuda()
# set the criterion and optimizer
self.encoder_optimizer = optim.Adam(filter(lambda x: x.requires_grad, self.encoder.parameters()),
lr=self.lr)
self.decoder_optimizer = optim.Adam(filter(lambda x: x.requires_grad, self.decoder.parameters()),
lr=self.lr * self.decoder_lratio)
self.criterion = nn.NLLLoss()
print(self.encoder)
print(self.decoder)
print(self.criterion)
print(self.encoder_optimizer)
print(self.decoder_optimizer)
def get_mask(self, output_batch):
#pad value is one
mask = binaryMatrix(output_batch, self.PAD_word)
mask = torch.ByteTensor(mask)
return mask
def get_sentence(self, sentence, side):
def _eos_parsing(sentence):
if EOS_WORD in sentence:
return sentence[:sentence.index(EOS_WORD) + 1]
else:
return sentence
# index sentence to word sentence
if side == 'trg':
sentence = [self.trg_inv_vocab[x] for x in sentence]
else:
sentence = [self.src_inv_vocab[x] for x in sentence]
return _eos_parsing(sentence)
return torch.LongTensor(pad_vector)
def train(self, input_variable, target_variable, per_variable, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion,
max_length):
# Zero gradients
encoder_optimizer.zero_grad()
decoder_optimizer.zero_grad()
lengths = []
for input_ in input_variable:
ctr = 0
for ele in input_:
if ele == self.PAD_word:
break
ctr += 1
lengths.append(ctr)
mask = self.get_mask(target_variable)
# Set device options
input_variable = input_variable.t().to(self.device)
per_variable = per_variable.t().to(self.device)
lengths = torch.tensor(lengths).to(self.device)
target_variable = target_variable.t().to(self.device)
mask = mask.t().to(self.device)
"""
temos que checar o tamanhoo dp padding e fazer o padding na mão...
RuntimeError: Expected
hidden
size(2, 40, 100), got(2, 3, 100)
"""
# Initialize variables
loss = 0
print_losses = []
n_totals = 0
# Forward pass through encoder
encoder_outputs, encoder_hidden = encoder(input_variable, lengths, per_variable)
# Create initial decoder input (start with SOS tokens for each sentence)
decoder_input = torch.LongTensor([[self.trg_soi for _ in range(target_variable.size()[1])]])
decoder_input = decoder_input.to(self.device)
# Set initial decoder hidden state to the encoder's final hidden state
decoder_hidden = encoder_hidden[:decoder.n_layers]
# Determine if we are using teacher forcing this iteration
use_teacher_forcing = True if random.random() < self.teacher_forcing else False
# Forward batch of sequences through decoder one time step at a time
if use_teacher_forcing:
for t in range(max_length):
decoder_output, decoder_hidden = decoder(
decoder_input, decoder_hidden, encoder_outputs
)
# Teacher forcing: next input is current target
decoder_input = target_variable[t].view(1, -1)
# Calculate and accumulate loss
mask_loss, nTotal = maskNLLLoss(decoder_output, target_variable[t], mask[t], self.device)
loss += mask_loss
print_losses.append(mask_loss.item() * nTotal)
n_totals += nTotal
else:
for t in range(max_length):
decoder_output, decoder_hidden = decoder(
decoder_input, decoder_hidden, encoder_outputs
)
# No teacher forcing: next input is decoder's own current output
_, topi = decoder_output.topk(1)
decoder_input = torch.LongTensor([[topi[i][0] for i in range(batch_size)]])
decoder_input = decoder_input.to(self.device)
# Calculate and accumulate loss
mask_loss, nTotal = maskNLLLoss(decoder_output, target_variable[t], mask[t], self.device)
loss += mask_loss
print_losses.append(mask_loss.item() * nTotal)
n_totals += nTotal
# Perform backpropatation
loss.backward()
# Clip gradients: gradients are modified in place
_ = torch.nn.utils.clip_grad_norm_(encoder.parameters(), self.grad_clip)
_ = torch.nn.utils.clip_grad_norm_(decoder.parameters(), self.grad_clip)
# Adjust model weights
encoder_optimizer.step()
decoder_optimizer.step()
return sum(print_losses) / n_totals
def train_iters(self):
# Initialize search module
searcher = GreedySearchDecoder(self.encoder,
self.decoder, self.device)
start = time.time()
nepoch_no_imprv = 0
self.train_loss = AverageMeter()
total_loss = []
total_bleu = []
total_rouge_l = []
total_rouge_1 = []
total_rouge_2 = []
self.best_bleu = .0
for epoch in tqdm(range(self.num_epoch)):
# Ensure dropout layers are in train mode
self.encoder.train()
self.decoder.train()
print_loss_total = 0
epoch_loss = []
for i_train, batch in enumerate(self.train_loader):
src_input = batch.src[0]
per_input = batch.per[0]
src_length = batch.src[1]
trg_input = batch.trg[0][:, :-1]
trg_length = batch.trg[1]
max_target_lenght = max([len(ele) for ele in trg_input.tolist()])
max_src_lenght = max([len(ele) for ele in src_input.tolist()])
loss = self.train(src_input, trg_input, per_input, self.encoder,
self.decoder, self.encoder_optimizer, self.decoder_optimizer, self.criterion, max_target_lenght)
self.train_loss.update(loss)
epoch_loss.append(loss)
print_loss_total += loss
total_loss.append(np.average(epoch_loss))
######################################################################
# Run the overfitting
# ~~~~~~~~~~~~~~
if (epoch % self.evaluate_every == 0) and (epoch != 0):
# Ensure dropout layers are in evaluation mode
self.encoder.eval()
self.decoder.eval()
self.val_bleu = AverageMeter()
self.val_rouge_1 = AverageMeter()
self.val_rouge_2 = AverageMeter()
self.val_rouge_l = AverageMeter()
epoch_bleu = []
epoch_rouge_l = []
epoch_rouge_1 = []
epoch_rouge_2 = []
print("evaluating")
for i, batch in enumerate(self.val_loader):
src_input = batch.src[0]
per_input = batch.per[0]
trg_output = batch.trg[0][:,:]
preds = []
for src_input_, per_input_ in zip(src_input, per_input):
lengths = []
ctr = 0
for ele in src_input_:
if ele == self.PAD_word:
break
ctr += 1
lengths.append(ctr)
src_input_ = torch.LongTensor([src_input_.tolist()]).transpose(0,1).to(self.device)
per_input_ = torch.LongTensor([per_input_.tolist()]).transpose(0,1).to(self.device)
lengths = torch.tensor(lengths).to(self.device)
#trg_output_ = torch.LongTensor([trg_output_.tolist()]).transpose(0,1).to(self.device)
pred, scores = searcher(src_input_, per_input_, lengths, self.max_length, self.trg_soi)
preds.append(pred)
# Compute BLEU and ROUGFE score and Loss
pred_sents = []
trg_sents = []
pred_STR = []
trg_STR = []
print(trg_output.t().size())
for j in range(trg_output.t().size()[1]):
pred_sent = self.get_sentence(tensor2np(preds[j]), 'trg')
trg_sent = self.get_sentence(tensor2np(trg_output[j]), 'trg')
pred_sents.append(pred_sent)
pred_STR.append(" ".join(pred_sent))
trg_sents.append(trg_sent)
trg_STR.append(" ".join(trg_sent))
rouge = Rouge()
hyps, refs = map(list, zip(*[[d[0], d[1]] for d in [pred_STR, trg_STR]]))
rouge_scores = rouge.get_scores(hyps, refs, avg=True)
bleu_score = get_bleu(pred_sents, trg_sents)
epoch_bleu.append(bleu_score)
epoch_rouge_1.append(rouge_scores["rouge-1"]["f"])
epoch_rouge_2.append(rouge_scores["rouge-2"]["f"])
epoch_rouge_l.append(rouge_scores["rouge-l"]["f"])
self.val_bleu.update(bleu_score)
self.val_rouge_1.update(rouge_scores["rouge-1"]["f"])
self.val_rouge_2.update(rouge_scores["rouge-2"]["f"])
self.val_rouge_l.update(rouge_scores["rouge-l"]["f"])
total_bleu.append(np.average(epoch_bleu))
total_rouge_1.append(np.average(epoch_rouge_1))
total_rouge_2.append(np.average(epoch_rouge_2))
total_rouge_l.append(np.average(epoch_rouge_l))
print('epochs: ' + str(epoch))
print('average train loss: ' + str(self.train_loss.avg))
print('average validation bleu score: ' + str(self.val_bleu.avg))
print('average validation rouge-l score: ' + str(self.val_rouge_l.avg))
# early stopping
# Save model if bleu score is higher than the best
if self.best_bleu < self.val_bleu.avg:
self.best_bleu = self.val_bleu.avg
checkpoint = {
'encoder': self.encoder,
'decoder': self.decoder,
'epoch': epoch
}
torch.save(checkpoint, self.log_path + '/Model_e%d_bleu%.3f.pt' % (epoch, self.val_bleu.avg))
else:
nepoch_no_imprv += 1
if nepoch_no_imprv >= self.nepoch_no_imprv:
print("- early stopping {} epochs without " \
"improvement".format(nepoch_no_imprv))
break
pandas_bleu = pd.DataFrame.from_dict({"bleu_validation": total_bleu})
pandas_loss = pd.DataFrame.from_dict({"loss_train": total_loss})
pandas_rouge_1 = pd.DataFrame.from_dict({"rouge_1_val": total_rouge_1})
pandas_rouge_2 = pd.DataFrame.from_dict({"rouge_2_val": total_rouge_2})
pandas_rouge_l = pd.DataFrame.from_dict({"rouge_l_val": total_rouge_l})
pandas_loss.to_csv("./loss_train.csv", sep="\t", index=False)
pandas_bleu.to_csv("./blue_validation.csv", sep="\t", index=False)
pandas_rouge_1.to_csv("./rouge_1_validation.csv", sep="\t", index=False)
pandas_rouge_2.to_csv("./rouge_2_validation.csv", sep="\t", index=False)
pandas_rouge_l.to_csv("./rouge_l_validation.csv", sep="\t", index=False)
def train_epoch(self, loader, args, epoch, optimizer, writer):
"""
Train for a single epoch
"""
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
criterion = torch.nn.NLLLoss()
self.train()
end = time.time()
step = epoch * len(loader)
for i, (x_batch, y_batch) in enumerate(loader):
data_time.update(time.time() - end)
x_batch = x_batch.to(self.device)
y_batch = y_batch.to(self.device)
prediction = self.forward(x_batch)
loss = criterion(prediction, y_batch)
losses.update(loss.item(), args.batch_size)
optimizer.zero_grad()
loss.backward()
optimizer.step()
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0 or i == len(loader) - 1:
writer.add_scalar('train/loss', losses.val, step + i)
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
i,
len(loader) - 1,
batch_time=batch_time,
data_time=data_time,
loss=losses),
flush=True)
def test(test_loader, model, criterion):
batch_time = AverageMeter()
losses = AverageMeter()
errors = AverageMeter()
# switch to evaluate mode
model.eval()
end = time()
result = np.empty(shape=(0, JOINT_POS_LEN), dtype=np.float32)
label_full = np.empty(shape=(0, JOINT_POS_LEN), dtype=np.float32)
for i, s in enumerate(test_loader):
if len(s) == 5:
data, label, mid, leng, quat = s
else:
data, label, mid, leng = s
# measure data loading time
batch_size = data.size(0)
input_var = data.cuda().float()
target_var = label.cuda()
output = model(input_var)
# record loss
leng = leng.cuda() * (NUM_VOXEL / NUM_GT_SIZE)
base = mid.cuda() - leng.repeat(1, 3) * (NUM_GT_SIZE / 2 - 0.5)
leng = leng.repeat(1, JOINT_LEN * 3)
base = base.repeat(1, JOINT_LEN)
for j in range(len(output)):
output[j] = (output[j].mul(leng)).add(base)
loss = criterion(output[0], target_var)
for k in range(1, nSTACK):
loss += criterion(output[k], target_var)
losses.update(loss.item() / batch_size, 1)
output = output[-1].cpu().detach()
# quat = quat.numpy().reshape(-1,IMU_NUM,4)
# joints = label.reshape(-1,JOINT_LEN,3)[0]
# es_joints = output.reshape(-1,JOINT_LEN,3)[0]
# print joints[10]
# right_forearm = quaternion.from_float_array(quat[0][Bone.R_UpArm])
# vec = np.array([152.6,0,0],dtype=np.float32)
# diff_gt = joints[Joint.RightArm]-joints[Joint.RightShoulder]
# diff_es = joints[Joint.RightArm]-es_joints[Joint.RightShoulder]
# diff = quaternion.rotate_vectors(right_forearm,vec).astype(np.float32)
# print diff, joints[10]-joints[9]
# diff_gt = (diff-diff_gt).norm(2)
# diff_es = (diff-diff_es).norm(2)
# diff = diff.norm(2)
r = mean_error(output, label)
err_t = float(r[0])
# print err_t,diff_gt,diff_es, 'es',r[1].item(),r[1]-diff_es
# if err_t>50:
# from visualization import plot_voxel_label
# print i,err_t
# data = data[0]
# data[data<1] = 0
# plot_voxel_label(data,(label[0]-base.cpu())/(leng.cpu()/(NUM_VOXEL/NUM_GT_SIZE)))
# plot_voxel_label(data,(output[0]-base.cpu())/(leng.cpu()/(NUM_VOXEL/NUM_GT_SIZE)))
errors.update(err_t, batch_size)
# measure elapsed time
batch_time.update(time() - end)
end = time()
if i % TEST_PRINT == 0:
print(
'[{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.5f} ({loss.avg:.5f})\t'
'acc_in_t {err_t.val:.3f} ({err_t.avg:.3f})'.format(
i,
len(test_loader),
batch_time=batch_time,
loss=losses,
err_t=errors))
# measure accuracy
result = np.append(result, output.numpy(), axis=0)
label_full = np.append(label_full, label.numpy(), axis=0)
return result, label_full, errors.avg
def train(train_loader, model, criterion, optimizer, epoch, print_freq):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to train mode
model.train()
end = time.time()
for i, (input, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
target = target.cuda(async=True)
input = input.cuda(async=True)
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % print_freq == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})\t'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
top5=top5))
