def train(self, epoch):
"""
Train one epoch for auxnet
:param epoch: index of epoch
"""
top1_error = utils.AverageMeter()
top1_loss = utils.AverageMeter()
top5_error = utils.AverageMeter()
iters = len(self.train_loader)
self.update_lr(epoch)
# Switch to train mode
self.model.train()
start_time = time.time()
end_time = start_time
for i, (images, labels) in enumerate(self.train_loader):
start_time = time.time()
data_time = start_time - end_time
if self.settings.n_gpus == 1:
images = images.cuda()
labels = labels.cuda()
# forward
output, loss = self.forward(images, labels)
self.backward(loss)
# compute loss and error rate
single_error, single_loss, single5_error = utils.compute_singlecrop_error(
outputs=output, labels=labels,
loss=loss, top5_flag=True)
top1_error.update(single_error, images.size(0))
top1_loss.update(single_loss, images.size(0))
top5_error.update(single5_error, images.size(0))
end_time = time.time()
iter_time = end_time - start_time
if i % self.settings.print_frequency == 0:
utils.print_result(epoch, self.settings.n_epochs, i + 1,
iters, self.lr, data_time, iter_time,
single_error,
single_loss,
mode="Train",
logger=self.logger)
if self.tensorboard_logger is not None:
self.tensorboard_logger.scalar_summary('train_top1_error', top1_error.avg, self.run_count)
self.tensorboard_logger.scalar_summary('train_top5_error', top5_error.avg, self.run_count)
self.tensorboard_logger.scalar_summary('train_loss', top1_loss.avg, self.run_count)
self.tensorboard_logger.scalar_summary("lr", self.lr, self.run_count)
self.logger.info("|===>Training Error: {:.4f} Loss: {:.4f}, Top5 Error: {:.4f}"
.format(top1_error.avg, top1_loss.avg, top5_error.avg))
return top1_error.avg, top1_loss.avg, top5_error.avg
def val(self, epoch):
"""
Validation
"""
top1_error = utils.AverageMeter()
top1_loss = utils.AverageMeter()
top5_error = utils.AverageMeter()
self.pruned_model.eval()
iters = len(self.val_loader)
start_time = time.time()
end_time = start_time
with torch.no_grad():
for i, (images, labels) in enumerate(self.val_loader):
start_time = time.time()
data_time = start_time - end_time
if self.settings.n_gpus == 1:
images = images.cuda()
labels = labels.cuda()
output, loss = self.forward(images, labels)
single_error, single_loss, single5_error = utils.compute_singlecrop_error(
outputs=output, loss=loss,
labels=labels, top5_flag=True)
top1_error.update(single_error, images.size(0))
top1_loss.update(single_loss, images.size(0))
top5_error.update(single5_error, images.size(0))
end_time = time.time()
iter_time = end_time - start_time
if i % self.settings.print_frequency == 0:
utils.print_result(
epoch, self.settings.n_epochs, i + 1,
iters, self.lr, data_time, iter_time,
single_error, single_loss,
top5error=single5_error,
mode="Validation",
logger=self.logger)
self.scalar_info['network_wise_fine_tune_val_top1_error'] = top1_error.avg
self.scalar_info['network_wise_fine_tune_val_top5_error'] = top5_error.avg
self.scalar_info['network_wise_fine_tune_val_loss'] = top1_loss.avg
if self.tensorboard_logger is not None:
for tag, value in self.scalar_info.items():
self.tensorboard_logger.scalar_summary(tag, value, self.run_count)
self.scalar_info = {}
self.run_count += 1
self.logger.info(
"|===>Validation Error: {:.4f} Loss: {:.4f}, Top5 Error: {:.4f}".format(top1_error.avg, top1_loss.avg,
top5_error.avg))
return top1_error.avg, top1_loss.avg, top5_error.avg
def val(self, epoch):
"""
Validation
:param epoch: index of epoch
"""
top1_error = utils.AverageMeter()
top1_loss = utils.AverageMeter()
top5_error = utils.AverageMeter()
self.model.eval()
iters = len(self.val_loader)
start_time = time.time()
end_time = start_time
with torch.no_grad():
for i, (images, labels) in enumerate(self.val_loader):
start_time = time.time()
data_time = start_time - end_time
if self.settings.n_gpus == 1:
images = images.cuda()
labels = labels.cuda()
output, loss = self.forward(images, labels)
# compute loss and error rate
single_error, single_loss, single5_error = utils.compute_singlecrop_error(
outputs=output, labels=labels,
loss=loss, top5_flag=True)
top1_error.update(single_error, images.size(0))
top1_loss.update(single_loss, images.size(0))
top5_error.update(single5_error, images.size(0))
end_time = time.time()
iter_time = end_time - start_time
if i % self.settings.print_frequency == 0:
utils.print_result(epoch, self.settings.n_epochs, i + 1,
iters, self.lr, data_time, iter_time,
single_error,
single_loss,
mode="Validation",
logger=self.logger)
if self.tensorboard_logger is not None:
self.tensorboard_logger.scalar_summary("val_top1_error", top1_error.avg, self.run_count)
self.tensorboard_logger.scalar_summary("val_top5_error", top5_error.avg, self.run_count)
self.tensorboard_logger.scalar_summary("val_loss", top1_loss.avg, self.run_count)
self.run_count += 1
self.logger.info("|===>Testing Error: {:.4f} Loss: {:.4f}, Top5 Error: {:.4f}"
.format(top1_error.avg, top1_loss.avg, top5_error.avg))
return top1_error.avg, top1_loss.avg, top5_error.avg
def val(self, epoch):
"""
Validation
:param epoch: index of epoch
"""
top1_error = []
top5_error = []
top1_loss = []
num_segments = len(self.segments)
for i in range(num_segments):
self.segments[i].eval()
self.aux_fc[i].eval()
top1_error.append(utils.AverageMeter())
top5_error.append(utils.AverageMeter())
top1_loss.append(utils.AverageMeter())
iters = len(self.val_loader)
start_time = time.time()
end_time = start_time
with torch.no_grad():
for i, (images, labels, _) in enumerate(self.val_loader, start=1):
start_time = time.time()
data_time = start_time - end_time
if self.settings.n_gpus == 1:
images = images.cuda()
labels = labels.cuda()
outputs, losses = self.auxnet_forward(images, labels)
# compute loss and error rate
single_error, single_loss, single5_error = utils.compute_singlecrop_error(
outputs=outputs, labels=labels,
loss=losses, top5_flag=True)
for j in range(num_segments):
top1_error[j].update(single_error[j], images.size(0))
top5_error[j].update(single5_error[j], images.size(0))
top1_loss[j].update(single_loss[j], images.size(0))
end_time = time.time()
iter_time = end_time - start_time
if i % self.settings.print_frequency == 0:
utils.print_result(epoch, self.settings.n_epochs, i + 1,
iters, self.lr, data_time, iter_time,
single_error,
single_loss,
mode="Validation",
logger=self.logger)
top1_error_list, top1_loss_list, top5_error_list = self._convert_results(
top1_error=top1_error, top1_loss=top1_loss, top5_error=top5_error)
if self.logger is not None:
for i in range(num_segments):
self.tensorboard_logger.scalar_summary(
"auxnet_val_top1_error_{:d}".format(i), top1_error[i].avg, self.run_count)
self.tensorboard_logger.scalar_summary(
"auxnet_val_top5_error_{:d}".format(i), top5_error[i].avg, self.run_count)
self.tensorboard_logger.scalar_summary(
"auxnet_val_loss_{:d}".format(i), top1_loss[i].avg, self.run_count)
self.run_count += 1
self.logger.info("|===>Validation Error: {:4f}/{:4f}, Loss: {:4f}".format(
top1_error[-1].avg, top5_error[-1].avg, top1_loss[-1].avg))
return top1_error_list, top1_loss_list, top5_error_list
def train(self, epoch):
"""
Train one epoch for auxnet
:param epoch: index of epoch
"""
iters = len(self.train_loader)
self.update_lr(epoch)
top1_error = []
top5_error = []
top1_loss = []
num_segments = len(self.segments)
for i in range(num_segments):
self.segments[i].train() # each segment and fc are treated as a model
self.aux_fc[i].train()
top1_error.append(utils.AverageMeter())
top5_error.append(utils.AverageMeter())
top1_loss.append(utils.AverageMeter())
start_time = time.time()
end_time = start_time
for i, (images, labels, _) in enumerate(self.train_loader, start=1):
start_time = time.time()
data_time = start_time - end_time
if self.settings.n_gpus == 1:
images = images.cuda()
labels = labels.cuda()
# forward
outputs, losses = self.auxnet_forward(images, labels)
# backward
for j in range(len(self.seg_optimizer)):
self.auxnet_backward_for_loss_i(losses[j], j)
# compute loss and error rate
single_error, single_loss, single5_error = utils.compute_singlecrop_error(
outputs=outputs, labels=labels,
loss=losses, top5_flag=True)
for j in range(num_segments):
top1_error[j].update(single_error[j], images.size(0))
top5_error[j].update(single5_error[j], images.size(0))
top1_loss[j].update(single_loss[j], images.size(0))
end_time = time.time()
iter_time = end_time - start_time
if i % self.settings.print_frequency == 0:
utils.print_result(epoch, self.settings.n_epochs, i + 1,
iters, self.lr, data_time, iter_time,
single_error,
single_loss,
mode="Train",
logger=self.logger)
top1_error_list, top1_loss_list, top5_error_list = self._convert_results(
top1_error=top1_error, top1_loss=top1_loss, top5_error=top5_error)
if self.logger is not None:
for i in range(num_segments):
self.tensorboard_logger.scalar_summary(
"auxnet_train_top1_error_{:d}".format(i), top1_error[i].avg,
self.run_count)
self.tensorboard_logger.scalar_summary(
"auxnet_train_top5_error_{:d}".format(i), top5_error[i].avg,
self.run_count)
self.tensorboard_logger.scalar_summary(
"auxnet_train_loss_{:d}".format(i), top1_loss[i].avg, self.run_count)
self.tensorboard_logger.scalar_summary("lr", self.lr, self.run_count)
self.logger.info("|===>Training Error: {:4f}/{:4f}, Loss: {:4f}".format(
top1_error[-1].avg, top5_error[-1].avg, top1_loss[-1].avg))
return top1_error_list, top1_loss_list, top5_error_list
def train(self, epoch):
"""
training
"""
top1_error = utils.AverageMeter()
top1_loss = utils.AverageMeter()
top5_error = utils.AverageMeter()
iters = len(self.train_loader)
self.update_lr(epoch)
# switch to train mode
self.pruned_model.train()
start_time = time.time()
end_time = start_time
for i, (images, labels) in enumerate(self.train_loader):
start_time = time.time()
data_time = start_time - end_time
if self.settings.n_gpus == 1:
images = images.cuda()
labels = labels.cuda()
output, loss = self.forward(images, labels)
self.backward(loss)
single_error, single_loss, single5_error = utils.compute_singlecrop(
outputs=output, labels=labels,
loss=loss, top5_flag=True, mean_flag=True)
top1_error.update(single_error, images.size(0))
top1_loss.update(single_loss, images.size(0))
top5_error.update(single5_error, images.size(0))
end_time = time.time()
iter_time = end_time - start_time
utils.print_result(
epoch, self.settings.network_wise_n_epochs, i + 1,
iters, self.network_wise_lr, data_time, iter_time,
single_error,
single_loss, top5error=single5_error,
mode="Train",
logger=self.logger)
self.scalar_info['network_wise_fine_tune_train_top1_error'] = top1_error.avg
self.scalar_info['network_wise_fine_tune_train_top5_error'] = top5_error.avg
self.scalar_info['network_wise_fine_tune_train_loss'] = top1_loss.avg
self.scalar_info['network_wise_fine_tune_lr'] = self.network_wise_lr
if self.tensorboard_logger is not None:
for tag, value in list(self.scalar_info.items()):
self.tensorboard_logger.scalar_summary(tag, value, self.run_count)
self.scalar_info = {}
self.logger.info(
"|===>Training Error: {:.4f} Loss: {:.4f}, Top5 Error: {:.4f}".format(top1_error.avg, top1_loss.avg,
top5_error.avg))
return top1_error.avg, top1_loss.avg, top5_error.avg
def train(self, epoch, index):
"""
train
:param epoch: index of epoch
:param index: index of segment
"""
iters = len(self.train_loader)
self.update_lr(epoch)
top1_error = []
top5_error = []
top1_loss = []
num_segments = len(self.pruned_segments)
for i in range(num_segments):
self.pruned_segments[i].train()
if i != index and i != num_segments - 1:
self.aux_fc[i].eval()
else:
self.aux_fc[i].train()
top1_error.append(utils.AverageMeter())
top5_error.append(utils.AverageMeter())
top1_loss.append(utils.AverageMeter())
start_time = time.time()
end_time = start_time
for i, (images, labels) in enumerate(self.train_loader):
start_time = time.time()
data_time = start_time - end_time
if self.settings.n_gpus == 1:
images = images.cuda()
labels = labels.cuda()
# forward
outputs, losses = self.forward(images, labels)
# backward
self.backward(losses, index)
# compute loss and error rate
single_error, single_loss, single5_error = utils.compute_singlecrop(
outputs=outputs, labels=labels,
loss=losses, top5_flag=True, mean_flag=True)
for j in range(num_segments):
top1_error[j].update(single_error[j], images.size(0))
top5_error[j].update(single5_error[j], images.size(0))
top1_loss[j].update(single_loss[j], images.size(0))
end_time = time.time()
iter_time = end_time - start_time
utils.print_result(epoch, self.settings.segment_wise_n_epochs, i + 1,
iters, self.segment_wise_lr, data_time, iter_time,
single_error,
single_loss,
mode="Train",
logger=self.logger)
top1_error_list, top1_loss_list, top5_error_list = self._convert_results(
top1_error=top1_error, top1_loss=top1_loss, top5_error=top5_error)
if self.logger is not None:
for i in range(num_segments):
self.tensorboard_logger.scalar_summary(
"segment_wise_fine_tune_train_top1_error_{:d}".format(i), top1_error[i].avg,
self.run_count)
self.tensorboard_logger.scalar_summary(
"segment_wise_fine_tune_train_top5_error_{:d}".format(i), top5_error[i].avg,
self.run_count)
self.tensorboard_logger.scalar_summary(
"segment_wise_fine_tune_train_loss_{:d}".format(i), top1_loss[i].avg, self.run_count)
self.tensorboard_logger.scalar_summary("segment_wise_fine_tune_lr", self.segment_wise_lr, self.run_count)
self.logger.info("|===>Training Error: {:4f}/{:4f}, Loss: {:4f}".format(
top1_error[-1].avg, top5_error[-1].avg, top1_loss[-1].avg))
return top1_error_list, top1_loss_list, top5_error_list
