from abc import abstractmethod import torch import numpy as np from torch.optim import AdamW, lr_scheduler from src.config.config_setup import build_model, get_dataloader from monai.losses import DiceCELoss, DiceLoss import torch.nn as nn from src.utils.util import save_checkpoint import time import os import torch.distributed as dist from torch.cuda import amp import torchio as tio class Trainer_basic(object): def __init__(self, args, logger): self.args = args self.logger = logger a = time.time() use_small = True if self.args.use_small_dataset else False self.train_data, self.val_data = get_dataloader(args, split='train', use_small=use_small), get_dataloader(args, split='val', use_small=use_small) if self.args.use_sam3d_turbo: self.sam = build_model(args, checkpoint='../src/ckpt/sam_med3d_turbo.pth') else: self.sam = build_model(args) if self.args.ddp: self.sam = self.sam.module self.best_dice, self.best_epoch, self.start_epoch = 0, 0, 0 self.pooling_layer = nn.AvgPool3d((self.args.boundary_kernel_size, self.args.boundary_kernel_size, 1), stride=1, padding=(int((self.args.boundary_kernel_size - 1) / 2), int((self.args.boundary_kernel_size - 1) / 2), 0)).cuda() self.setup() print('dataloaders are created, models are loaded, and others are set, spent {} for rank {}' .format(round(time.time() - a, 2), self.args.rank)) def run(self): self.scaler = amp.GradScaler() for epoch_num in range(self.start_epoch, self.args.max_epoch): self.sam.train() if self.args.ddp: # dist.barrier() # set a barrier until all processes are at same point self.train_data.sampler.set_epoch(epoch_num) self.train(epoch_num) if self.args.ddp and self.args.rank == 0: print('doing validation on rank=0') current_mean_dice = self.validate(epoch_num) if self.args.data != 'lits' else self.validate_sliding_window(epoch_num) else: current_mean_dice = self.validate(epoch_num) if self.args.data != 'lits' else self.validate_sliding_window(epoch_num) # https://medium.com/codex/a-comprehensive-tutorial-to-pytorch-distributeddataparallel-1f4b42bb1b51 # if self.args.ddp: # dist.barrier() self.save_model(current_mean_dice, epoch_num) @abstractmethod def forward(self, model, image, label, iter_nums, train, return_each_iter): pass def train(self, epoch_num): loss_summary = [] for idx, (image, label, image_path) in enumerate(self.train_data): self.optimizer.zero_grad() # increase speed based on gradient accumulation # my_context = self.sam.no_sync if self.args.rank != -1 and idx % self.args.accumulation_steps != 0 else nullcontext # with my_context(): image, label = image.to(self.args.device), label.to(self.args.device) with amp.autocast(): loss, _ = self.forward(self.sam, image, label, iter_nums=self.args.iter_nums, train=True) loss_summary.append(loss.detach().cpu().numpy()) self.scaler.scale(loss).backward() self.scaler.unscale_(self.optimizer) torch.nn.utils.clip_grad_norm_(self.sam.parameters(), 1.0) self.scaler.step(self.optimizer) self.scaler.update() print('epoch: {}/{}, iter: {}/{}'.format(epoch_num, self.args.max_epoch, idx, len(self.train_data)) + ": loss:" + str(round(loss_summary[-1].flatten()[0], 4)) + ": rank:" + str(self.args.rank)) self.logger.info( 'epoch: {}/{}, iter: {}/{}'.format(epoch_num, self.args.max_epoch, idx, len(self.train_data)) + ": loss:" + str(round(loss_summary[-1].flatten()[0], 4)) + ": rank:" + str(self.args.rank)) print('current lr: {}'.format(self.optimizer.param_groups[0]["lr"])) # If the first iteration creates NaN gradients (e.g. due to a high scaling factor and thus gradient overflow), # the optimizer.step() will be skipped and you might get this warning. self.update_lr(epoch_num, warm_up=self.args.warm_up) self.logger.info("- Train metrics: " + str(np.mean(loss_summary))) def validate_sliding_window(self, epoch_num): self.sam.eval() with torch.no_grad(): dice_list = [] for idx, batch in enumerate(self.val_data): if isinstance(batch, (list, tuple)) and len(batch) >= 2: subject_dict, image_path = batch[0], batch[1] else: raise ValueError("Unexpected validation batch format for lits dataset") if subject_dict['label']['data'][0].sum() <= 0: self.logger.info(image_path, 'label volume too small, and it has been skipped for validation') continue mean_dice = 0 subject = tio.Subject(image=tio.ScalarImage(tensor=subject_dict['image']['data'][0].float(), affine=subject_dict['image']['affine'][0]), label=tio.LabelMap(tensor=subject_dict['label']['data'][0].float(), affine=subject_dict['label']['affine'][0])) grid_sampler = tio.inference.GridSampler(subject, 128, 16) patch_loader = torch.utils.data.DataLoader(grid_sampler, batch_size=1) aggregator = tio.inference.GridAggregator(grid_sampler) masks_final = torch.zeros([self.args.iter_nums, len(patch_loader), 128, 128, 128]) location_list = [] for idx_patch, patches_batch in enumerate(patch_loader): image, label = patches_batch['image'][tio.DATA].to(self.args.device), patches_batch['label'][tio.DATA].to(self.args.device) locations = patches_batch[tio.LOCATION] if torch.count_nonzero(label) == 0: print('found empty patch') masks = torch.zeros([self.args.iter_nums, 1, 128, 128, 128]) else: _, masks = self.forward(self.sam, image, label, iter_nums=self.args.iter_nums, train=False, return_each_iter=True) print(masks.shape) masks_final[:, idx_patch, :] = masks.squeeze(1) location_list.append(locations) mean_dice_sub_list = [] for iter_num in range(self.args.iter_nums): for l_i in range(0, len(location_list)): location = location_list[l_i] a = masks_final[iter_num, l_i, :].unsqueeze(0).unsqueeze(0) mask = a aggregator.add_batch(mask, location) masks_iter_final = aggregator.get_output_tensor() mean_dice_sub_list.append(self.get_dice_score(torch.sigmoid(masks_iter_final), subject.label.data)) mean_dice_sub = np.mean(mean_dice_sub_list) mean_dice += mean_dice_sub dice_list.append(mean_dice) print(mean_dice_sub) self.logger.info( 'epoch: {}/{}, iter: {}/{}'.format(epoch_num, self.args.max_epoch, idx, len(self.val_data)) + ' subject: ' + str(image_path) + ' mean dice over clicks:' + str(mean_dice) + ' stich left and right side (total size): ' + str(label.size(1))) self.logger.info("- Val metrics mean dice: " + str(np.mean(dice_list))) return dice_list def validate(self, epoch_num): self.sam.eval() device = self.args.device with torch.no_grad(): dice_list = [] for idx, (image, label, image_path, _) in enumerate(self.val_data): mean_dice = 0 image, label = image.to(device), label.to(device) #with amp.autocast(): if self.args.data == 'kits' and image.size(1) > 1: label_final, masks_final = torch.zeros([1, 1, int(image.size(2) * 2), image.size(3), image.size(4)]), torch.zeros([self.args.iter_nums, 1, int(image.size(2) * 2), image.size(3), image.size(4)]) for channel_num in range(image.size(1)): _, masks = self.forward(self.sam, image[:, channel_num, :].unsqueeze(1), label[:, channel_num, :].unsqueeze(1), iter_nums=self.args.iter_nums, train=False, return_each_iter=True) start_point, end_pont = 0 + channel_num * image.size(2), image.size(2) + channel_num * image.size(2) masks_final[:, 0, start_point: end_pont, :] = masks[:, 0, :] label_final[0, 0, start_point: end_pont, :] = label[0, channel_num, :] mean_dice_sub_list = [] for iter_num in range(self.args.iter_nums): mean_dice_sub_list.append(self.get_dice_score(torch.sigmoid(masks_final[iter_num]), label_final[0])) mean_dice_sub = np.mean(mean_dice_sub_list) else: mean_dice_sub, masks = self.forward(self.sam, image, label, iter_nums=self.args.iter_nums, train=False) mean_dice += mean_dice_sub dice_list.append(mean_dice) print(mean_dice_sub) self.logger.info( 'epoch: {}/{}, iter: {}/{}'.format(epoch_num, self.args.max_epoch, idx, len(self.val_data)) + ' subject: ' + str(image_path) + ' mean dice over clicks:' + str(mean_dice) + ' stich left and right side (total size): ' + str(label.size(1))) self.logger.info("- Val metrics mean dice: " + str(np.mean(dice_list))) return dice_list def calculate_loss(self, mask, prev_masks, pred_dice, label, labels_input, iter_num, inter=False): mask_probs, prev_masks_prob = torch.sigmoid(mask), torch.sigmoid(prev_masks) seg_edge = abs(label - self.pooling_layer(label)) mask_edge = abs(mask_probs - self.pooling_layer(mask_probs)) edge_number = torch.count_nonzero(mask_edge) + 1 pred_dice_score_loss = 0 for batch_index in range(mask.size(0)): target_dice = 1 - self.loss_validation(mask[batch_index].unsqueeze(0), label[batch_index].unsqueeze(0))[0,0,0,0,0] target_dice = torch.tensor([target_dice])[0].to(self.args.device) pred_dice_score_loss += self.loss_boundary(pred_dice[batch_index], target_dice) * 1 loss = self.loss_segmentation(mask, label) + self.loss_boundary(mask_edge, seg_edge) * 10 loss = loss + pred_dice_score_loss return loss def get_dice_score(self, prev_masks, label, batch=False): def compute_dice(mask_pred, mask_gt): mask_threshold = 0.5 mask_pred = (mask_pred > mask_threshold) mask_gt = (mask_gt > 0) volume_sum = mask_gt.sum() + mask_pred.sum() if volume_sum == 0: return np.NaN volume_intersect = (mask_gt & mask_pred).sum() return 2 * volume_intersect / volume_sum pred_masks = (prev_masks > 0.5) true_masks = (label > 0) dice_list = [] for i in range(true_masks.shape[0]): dice_list.append(compute_dice(pred_masks[i], true_masks[i])) if batch: return dice_list else: return (sum(dice_list) / len(dice_list)).item() def save_model(self, current_dice, epoch_num): is_best = False if np.mean(current_dice) > self.best_dice: self.best_dice = np.mean(current_dice) self.best_epoch = epoch_num is_best = True if not self.args.ddp or (self.args.ddp and self.args.rank == 0): save_checkpoint({"epoch": epoch_num + 1, "best_val_loss": self.best_dice, "model_state_dict": self.sam.state_dict(), "optimizer": self.optimizer.state_dict(), "lr_scheduler": self.lr_scheduler.state_dict(), }, is_best=is_best, checkpoint=self.args.save_dir) self.logger.info("- Val metrics best mean dice: {} at epoch {} " .format(self.best_dice, self.best_epoch)) def setup(self): self.setup_loss() self.setup_optimizier() self.setup_scheduler() if self.args.resume: if self.args.ddp: dist.barrier() checkpoint = 'best.pth.tar' if self.args.resume_best else 'last.pth.tar' ckpt = torch.load(os.path.join(self.args.save_dir, checkpoint)) self.start_epoch = ckpt["epoch"] self.best_epoch = self.start_epoch self.best_dice = ckpt["best_val_loss"] self.sam.load_state_dict(ckpt["model_state_dict"], strict=True) self.optimizer.load_state_dict(ckpt["optimizer"]) #self.lr_scheduler.load_state_dict(ckpt['lr_scheduler'])lr_scheduler_regular self.lr_scheduler_regular.load_state_dict(ckpt['lr_scheduler']) self.logger.info(f"Resume training from epoch {self.start_epoch}!") del ckpt torch.cuda.empty_cache() def setup_loss(self): self.loss_boundary = nn.MSELoss() self.mse_none = nn.MSELoss(reduction='none') self.loss_segmentation = DiceCELoss(sigmoid=True, squared_pred=True, reduction='mean') self.loss_Dice = DiceLoss(sigmoid=True) self.loss_validation = DiceLoss(sigmoid=True, reduction='none') self.l1 = nn.L1Loss() self.inter_loss = DiceCELoss(sigmoid=True, squared_pred=True, reduction='mean') def setup_optimizier(self): self.optimizer = AdamW([ {'params': self.sam.image_encoder.parameters()}, {'params': self.sam.prompt_encoder.parameters()}, {'params': self.sam.mask_decoder.parameters()}, ], lr=self.args.lr) def setup_scheduler(self): if self.args.lr_scheduler == 'linear': self.lr_scheduler_regular = lr_scheduler.LinearLR(self.optimizer, start_factor=1.0, end_factor=0.01, total_iters=500) else: self.lr_scheduler_regular = lr_scheduler.ExponentialLR(self.optimizer, gamma=0.98) if self.args.warm_up: self.linear_warmup_scheduler = lr_scheduler.LinearLR(self.optimizer, start_factor=0.01, end_factor=1.0, total_iters=10) def update_lr(self, epoch, warmup_epoch=10, warm_up=False): if warm_up: if epoch < warmup_epoch: self.lr_scheduler = self.linear_warmup_scheduler else: self.lr_scheduler = self.lr_scheduler_regular else: self.lr_scheduler = self.lr_scheduler_regular self.lr_scheduler.step()