import os import torch import logging import torch.backends.cudnn as cudnn import apex from datetime import datetime from tensorboardX import SummaryWriter from lib.Network import Network from utils.dataset import get_loader from utils.utils import adjust_lr, dice_coef, structure_loss, plot_image def train(train_loader, model, optimizer, epoch, save_path, writer): """ train function """ model.train() loss_all = 0 epoch_step = 0 dices = 0.0 # dice num = 0 total_step = len(train_loader) try: for i, (images, gts) in enumerate(train_loader, start=1): images = images.cuda() gts = gts.cuda() preds = model(images) loss = structure_loss(preds, gts) # Training dice num += images.shape[0] preds_ = preds.sigmoid().detach().squeeze().data.cpu().numpy() preds_ = (preds_ - preds_.min()) / (preds_.max() - preds_.min() + 1e-8) preds_ = (preds_ >= 0.5) gts_ = gts.squeeze().cpu().data.numpy() dice = dice_coef(preds_, gts_) dices += (dice * images.shape[0]) optimizer.zero_grad() with apex.amp.scale_loss(loss, optimizer) as scale_loss: scale_loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() epoch_step += 1 loss_all += loss.item() if i % 200 == 0 or i == total_step or i == 1: print('{}|| Epoch [{:03d}/{:03d}], Step [{:04d}/{:04d}], Total_loss: {:.4f}'. format(datetime.now(), epoch, opt.epoch, i, total_step, loss.data)) logging.info( '[Train Info]:Epoch [{:03d}/{:03d}], Step [{:04d}/{:04d}], Total_loss: {:.4f}'.format( epoch, opt.epoch, i, total_step, loss.data)) # TensorboardX-Loss writer.add_scalars('Loss_Statistics', {'Loss_total': loss.data}, global_step=i) epoch_avg_dice = dices / num epoch_avg_loss = loss_all / epoch_step except KeyboardInterrupt: print('Keyboard Interrupt: save model and exit.') if not os.path.exists(save_path): os.makedirs(save_path) torch.save(model.state_dict(), os.path.join(save_path, 'Net_epoch_{}.pth'.format(epoch + 1))) print('Save checkpoints successfully!') raise return epoch_avg_loss, epoch_avg_dice def val(test_loader, model): """ validation function """ model.eval() total_num = 0 losses = 0.0 dices = 0.0 num = 0 with torch.no_grad(): for i, (image, gt) in enumerate(test_loader): image, gt = image.cuda(), gt.cuda() pred = model(image) loss_total = structure_loss(pred, gt) loss = loss_total.item() losses += loss * image.shape[0] num += image.shape[0] pred_ = pred.squeeze().sigmoid().data.cpu().numpy() pred_ = (pred_ - pred_.min()) / (pred_.max() - pred_.min() + 1e-8) pred_ = (pred_ >= 0.5) gt_ = gt.squeeze().cpu().data.numpy() dice = dice_coef(pred_, gt_) dices += (dice * image.shape[0]) epoch_avg_dice = dices / num epoch_avg_loss = losses / num return epoch_avg_loss, epoch_avg_dice def main(args): # build the model model = Network(mode=args.mode, ratio=args.ratio_list).cuda() if args.load is not None: model.load_state_dict(torch.load(args.load)) print('load model from ', args.load) optimizer = torch.optim.Adam(model.parameters(), args.lr) model, optimizer = apex.amp.initialize(model, optimizer, opt_level='O1') save_path = os.path.join(args.save_path, 'unet', datetime.now().strftime("%Y%m%d-%H%M%S")) print(save_path) os.makedirs(os.path.join(save_path, 'weight'), exist_ok=True) os.makedirs(os.path.join(save_path, 'logs'), exist_ok=True) os.makedirs(os.path.join(save_path, 'summary'), exist_ok=True) # load data print('Load dataset.......') train_loader = get_loader(batchsize = args.batchsize, trainsize = args.trainsize, file=args.train_file, mode='train') val_loader = get_loader(batchsize = args.vbatchsize, trainsize = args.trainsize, file=args.val_file, mode='valid') # logging logging.basicConfig(filename=os.path.join(save_path, 'logs', 'unet.log'), format='[%(asctime)s-%(filename)s-%(levelname)s:%(message)s]', level=logging.INFO, filemode='a', datefmt='%Y-%m-%d %I:%M:%S %p') logging.info("Network-Train") logging.info('Dataset: train: {}; val: {}'.format(args.train_file, args.val_file)) logging.info('Config: epoch: {}; lr: {}; batchsize: {}; trainsize: {}; decay_rate: {}; decay_epoch: {}; load: {}; ' 'save_path: {}'.format(args.epoch, args.lr, args.batchsize, args.trainsize, args.decay_rate, args.decay_epoch, args.load, save_path)) logging.info('ratio: {}'.format(args.ratio)) writer = SummaryWriter(os.path.join(save_path,'summary')) epoch_losses = [] epoch_dices = [] epoch_val_losses = [] epoch_val_dices = [] best_dice = 0 best_epoch = 1 print("Start train......") for epoch in range(1, args.epoch+1): cur_lr = adjust_lr(optimizer, args.lr, epoch, args.decay_rate, args.decay_epoch) writer.add_scalar('learning_rate', cur_lr, global_step=epoch) # Train loss_t, dice_t = train(train_loader, model, optimizer, epoch, os.path.join(save_path, 'weight'), writer) epoch_losses.append(loss_t) epoch_dices.append(dice_t) logging.info('[Train Info]: Epoch [{:03d}/{:03d}], Loss_AVG: {:.4f}, Train_Dice: {:.4f}'.format(epoch, args.epoch+1, loss_t, dice_t)) writer.add_scalar('Loss-epoch', loss_t, global_step=epoch) # Validation loss_v, dice_v = val(val_loader, model) epoch_val_losses.append(loss_v) epoch_val_dices.append(dice_v) writer.add_scalar('Dice', torch.tensor(dice_v), global_step=epoch) if dice_v > best_dice: best_dice = dice_v best_epoch = epoch torch.save(model.state_dict(), f"{save_path}/weight/Net_epoch{epoch}_bestdice{best_dice:.4f}.pth") print('Save bestmae state_dict successfully! Best epoch:{}.'.format(epoch)) print('Epoch: {}, Dice: {}, bestDice: {}, bestEpoch: {}'.format(epoch, dice_v, best_dice, best_epoch)) logging.info( '[Val Info]:Epoch:{} bestEpoch:{}, bestDice: {}, Val_Dice: {}, Val_Loss: {}'.format(epoch, best_epoch, best_dice, dice_v, loss_v)) plot_image(os.path.join(save_path,'logs'), epoch_losses, epoch_dices, epoch_val_losses, epoch_val_dices) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser() parser.add_argument('--train_file', type=str, default='/data2/sod_data/train_sample_half.lst', help='train list') parser.add_argument('--val_file', type=str, default='/data2/sod_data/val_sample_half.lst', help='val list') parser.add_argument('--epoch', type=int, default=100, help='epoch number') parser.add_argument('--lr', type=float, default=1e-4, help='learning rate') parser.add_argument('--batchsize', type=int, default=16, help='training batch size') parser.add_argument('--vbatchsize', type=int, default=16, help='validing batch size') parser.add_argument('--trainsize', type=list, default=[224, 256, 288, 320, 352, 384] , help='training dataset size of resize') parser.add_argument('--decay_rate', type=float, default=0.1, help='decay rate of learning rate') parser.add_argument('--decay_epoch', type=int, default=50, help='every n epochs decay learning rate') parser.add_argument('--load', type=str, default=None, help='train from checkpoints') parser.add_argument('--save_path', type=str, default='../train_output', help='the path to save model, figure and log') parser.add_argument('--mode', type=str, default='ori', help='optional modes: ori, curvature, and entropy') parser.add_argument('--ratio_list', type=list, default=[0.5, 0.5], help='Selection ratio from shallow to deep layers') opt = parser.parse_args() print(opt) # set the device for training os.environ["CUDA_VISIBLE_DEVICES"] = "0" cudnn.benchmark = True main(opt)