import os import numpy as np import json, time from functools import partial import nibabel as nb import torch from scipy.ndimage import zoom from torch.utils.tensorboard import SummaryWriter from torch.cuda.amp import GradScaler, autocast #native AMP import torch.nn.parallel import torch.distributed as dist import torch.multiprocessing as mp import torch.utils.data.distributed from monai.transforms.transform import MapTransform import sys from os import environ import os import sys os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3,4,5,6,7" from monai.inferers import sliding_window_inference # from monai.data import DataLoader, Dataset from monai.losses import DiceLoss, DiceCELoss from monai.metrics import DiceMetric from monai.utils.enums import MetricReduction from monai.data import load_decathlon_datalist from monai.transforms import AsDiscrete,Activations,Compose from monai import transforms, data from monai_trainer import AMDistributedSampler, run_training from optimizers.lr_scheduler import WarmupCosineSchedule,LinearWarmupCosineAnnealingLR from networks.unetr import UNETR from networks.swin3d_unetr import SwinUNETR from networks.swin3d_unetrv2 import SwinUNETR as SwinUNETR_v2 import warnings warnings.filterwarnings("ignore") import argparse parser = argparse.ArgumentParser(description='5fold cross val') parser.add_argument('--syn',action='store_true') parser.add_argument('--fold', default=0, type=int) parser.add_argument('--checkpoint', default=None) parser.add_argument('--logdir', default=None) parser.add_argument('--save_checkpoint', action='store_true') parser.add_argument('--max_epochs', default=3000, type=int) parser.add_argument('--batch_size', default=1, type=int) parser.add_argument('--optim_lr', default=4e-4, type=float) parser.add_argument('--optim_name', default='adamw', type=str) parser.add_argument('--reg_weight', default=1e-5, type=float) parser.add_argument('--noamp', action='store_true') #experimental parser.add_argument('--val_every', default=200, type=int) parser.add_argument('--val_overlap', default=0.5, type=float) parser.add_argument('--cache_rate', default=0.5, type=float) parser.add_argument('--distributed', action='store_true') #distributed multi gpu parser.add_argument('--world_size', default=1, type=int, help='number of nodes for distributed training') parser.add_argument('--rank', default=0, type=int, help='node rank for distributed training') parser.add_argument('--dist-url', default='tcp://127.0.0.1:23457', type=str, help='url used to set up distributed training') parser.add_argument('--dist-backend', default='nccl', type=str, help='distributed backend') parser.add_argument('--workers', default=4, type=int) parser.add_argument('--model_name', default='unet', type=str) parser.add_argument('--swin_type', default='base', type=str) parser.add_argument('--tumor_type', default='tumor', type=str) parser.add_argument('--organ_type', default='liver', type=str) parser.add_argument('--organ_model', default='liver', type=str) parser.add_argument('--diff_model', default=None, type=str) parser.add_argument('--ddim_ts', default=50, type=int) parser.add_argument('--fg_thresh', default=10, type=int) parser.add_argument('--healthy_num', default=400, type=int) parser.add_argument('--healthy_seed', default=0, type=int) #segmentation flex params parser.add_argument('--seg_block', default='basic_pre', type=str) parser.add_argument('--seg_num_blocks', default = '1,2,2,4', type=str) parser.add_argument('--seg_base_filters', default=16, type=int) parser.add_argument('--seg_relu', default='relu', type=str) parser.add_argument('--seg_lastnorm_init_zero', action='store_true') parser.add_argument('--seg_mode', default=1, type=int) parser.add_argument('--seg_use_se', action='store_true') parser.add_argument('--seg_norm_name', default='instancenorm', type=str) parser.add_argument('--seg_noskip', action='store_true') parser.add_argument('--seg_aug_mode', default=0, type=int) parser.add_argument('--seg_aug_noflip', action='store_true') parser.add_argument('--seg_norm_mode', default=0, type=int) parser.add_argument('--seg_crop_mode', default=0, type=int) #unetr params parser.add_argument('--pos_embedd', default='conv', type=str) parser.add_argument('--norm_name', default='instance', type=str) parser.add_argument('--num_steps', default=40000, type=int) parser.add_argument('--eval_num', default=500, type=int) parser.add_argument('--warmup_steps', default=500, type=int) parser.add_argument('--num_heads', default=16, type=int) parser.add_argument('--mlp_dim', default=3072, type=int) parser.add_argument('--hidden_size', default=768, type=int) parser.add_argument('--in_channels', default=1, type=int) parser.add_argument('--out_channels', default=3, type=int) parser.add_argument('--num_classes', default=3, type=int) parser.add_argument('--res_block', action='store_true') parser.add_argument('--conv_block', action='store_true') parser.add_argument('--roi_x', default=96, type=int) parser.add_argument('--roi_y', default=96, type=int) parser.add_argument('--roi_z', default=96, type=int) parser.add_argument('--dropout_rate', default=0.0, type=float) parser.add_argument('--decay', default=1e-5, type=float) parser.add_argument('--lrdecay', action='store_true') parser.add_argument('--amp', action='store_true') parser.add_argument('--amp_scale', action='store_true') parser.add_argument('--opt_level', default='O2', type=str) parser.add_argument('--opt', default='adamw', type=str) parser.add_argument('--lrschedule', default='warmup_cosine', type=str) parser.add_argument('--warmup_epochs', default=100, type=int) parser.add_argument('--resume_ckpt', action='store_true') parser.add_argument('--pretrained_dir', default=None, type=str) parser.add_argument('--data_root', default=None, type=str) parser.add_argument('--healthy_data_root', default=None, type=str) parser.add_argument('--datafold_dir', default=None, type=str) parser.add_argument('--cache_num', default=200, type=int) parser.add_argument("--version", type=int, choices=[1, 2, 3], required=True, help="Specify the version of the model (1, 2, or 3).") parser.add_argument('--use_pretrained', action='store_true') import numpy as np class RandCropByPosNegLabeld_select(transforms.RandCropByPosNegLabeld): def __init__(self, keys, label_key, spatial_size, pos=1.0, neg=1.0, num_samples=1, image_key=None, image_threshold=0.0, allow_missing_keys=True, fg_thresh=0): super().__init__(keys=keys, label_key=label_key, spatial_size=spatial_size, pos=pos, neg=neg, num_samples=num_samples, image_key=image_key, image_threshold=image_threshold, allow_missing_keys=allow_missing_keys) self.fg_thresh = fg_thresh def R2voxel(self, R): return (4/3) * np.pi * (R)**3 def check_shape_and_fix(self, image, label): """Ensure label matches the shape of the image, resize/pad the label if necessary.""" # Convert image and label from numpy arrays to PyTorch tensors if necessary if isinstance(image, np.ndarray): image = torch.from_numpy(image) if isinstance(label, np.ndarray): label = torch.from_numpy(label) if image.shape != label.shape: target_shape = image.shape[1:] # (D, H, W) label = torch.nn.functional.interpolate(label.unsqueeze(0), size=target_shape, mode='nearest').squeeze(0) if image.is_cuda: # Ensure the tensor is on the CPU before converting to numpy image = image.cpu() if label.is_cuda: label = label.cpu() image = image.numpy() # Convert back to NumPy array label = label.numpy() return image, label def __call__(self, data): d = dict(data) data_name = d['name'] data_text = d['text'] d.pop('name') d['image'], d['label'] = self.check_shape_and_fix(d['image'], d['label']) if data_text != "": flag = 0 valid_crop_found = False d_crop = None while flag <= 30: flag += 1 d_crop = super().__call__(d) pixel_num = (d_crop[0]['label'] > 0).sum() if pixel_num > self.R2voxel(self.fg_thresh): valid_crop_found = True break elif flag > 5 and pixel_num > self.R2voxel(max(self.fg_thresh - 5, 5)): valid_crop_found = True break elif flag > 10 and pixel_num > self.R2voxel(max(self.fg_thresh - 10, 5)): valid_crop_found = True break elif flag > 15 and pixel_num > self.R2voxel(max(self.fg_thresh - 15, 5)): valid_crop_found = True break elif flag > 20 and pixel_num > self.R2voxel(max(self.fg_thresh - 20, 5)): valid_crop_found = True break elif flag > 25 and pixel_num > self.R2voxel(max(self.fg_thresh - 25, 5)): valid_crop_found = True break if not valid_crop_found: print(f"Warning: Could not find a valid crop after {flag} attempts.") else: d_crop = super().__call__(d) d_crop[0]['name'] = data_name return d_crop class LoadImage_train(MapTransform): def __init__(self, organ_type): self.reader_image_label = transforms.LoadImaged(keys=["image", "label"]) self.reader_label = transforms.LoadImaged(keys=["label"]) self.reader_image = transforms.LoadImaged(keys=["image"]) self.organ_type = organ_type def __call__(self, data): d = dict(data) data_name = d['name'] d['text'] = d.get('text', '') if self.organ_type == 'kidney': if 'BDMAP' not in data_name: d = self.reader_image_label(d) d['label'][d['label'] == 3] = 1 else: d = self.reader_image(d) left_label_path, right_label_path = d['label'] d_left = self.reader_label({'label': left_label_path}) d_right = self.reader_label({'label': right_label_path}) left_label = d_left['label'] right_label = d_right['label'] if left_label.ndim == 4: left_label = left_label[0] if right_label.ndim == 4: right_label = right_label[0] combined_label = (left_label > 0) | (right_label > 0) combined_label = combined_label.astype(np.int16) d['label'] = combined_label label_meta_dict = d_left.get('label_meta_dict', {}).copy() if 'affine' in d_right.get('label_meta_dict', {}): label_meta_dict['affine'] = d_right['label_meta_dict']['affine'] d['label_meta_dict'] = label_meta_dict else: d = self.reader_image_label(d) return d class LoadImage_val(transforms.LoadImaged): def __init__(self, keys, *args,**kwargs, ): super().__init__(keys) def __call__(self, data): d = dict(data) data_name = d['name'] d = super().__call__(d) d['label'][d['label']==3] = 1 return d def _get_transform(args): train_transform = transforms.Compose( [ LoadImage_train(args.organ_type), transforms.AddChanneld(keys=["image", "label"]), transforms.Orientationd(keys=["image", "label"], axcodes="RAS"), transforms.Spacingd(keys=["image", "label"], pixdim=(1.0, 1.0, 1.0), mode=("bilinear", "nearest")), transforms.ScaleIntensityRanged( keys=["image"], a_min=-175, a_max=250, b_min=0.0, b_max=1.0, clip=True, ), transforms.SpatialPadd(keys=["image", "label"], mode=["minimum", "constant"], spatial_size=[96, 96, 96]), RandCropByPosNegLabeld_select( keys=["image", "label", "name"], label_key="label", spatial_size=(96, 96, 96), pos=1, neg=1, num_samples=1, image_key="image", image_threshold=0, fg_thresh = args.fg_thresh, ), transforms.RandFlipd(keys=["image", "label"], prob=0.2, spatial_axis=0), transforms.RandFlipd(keys=["image", "label"], prob=0.2, spatial_axis=1), transforms.RandFlipd(keys=["image", "label"], prob=0.2, spatial_axis=2), transforms.RandRotate90d(keys=["image", "label"], prob=0.2, max_k=3), transforms.RandScaleIntensityd(keys="image", factors=0.1, prob=0.15), transforms.RandShiftIntensityd(keys="image", offsets=0.1, prob=0.15), transforms.ToTensord(keys=["image", "label"]), ] ) val_transform = transforms.Compose( [ LoadImage_val(keys=["image", "label", "organ_pseudo"]), transforms.AddChanneld(keys=["image", "label", "organ_pseudo"]), transforms.Orientationd(keys=["image", "label", "organ_pseudo"], axcodes="RAS"), transforms.Spacingd(keys=["image", "label", "organ_pseudo"], pixdim=(1.0, 1.0, 1.0), mode=("bilinear", "nearest", "nearest")), transforms.ScaleIntensityRanged(keys=["image"], a_min=-175, a_max=250, b_min=0.0, b_max=1.0, clip=True), transforms.SpatialPadd(keys=["image", "label", "organ_pseudo"], mode=["minimum", "constant", "constant"], spatial_size=[96, 96, 96]), transforms.ToTensord(keys=["image", "label", "organ_pseudo"]), ] ) return train_transform, val_transform def main(): args = parser.parse_args() args.amp = not args.noamp print("MAIN Argument values:") for k, v in vars(args).items(): print(k, '=>', v) print('-----------------') if args.distributed: args.ngpus_per_node = torch.cuda.device_count() print('Found total gpus', args.ngpus_per_node) args.world_size = args.ngpus_per_node * args.world_size mp.spawn(main_worker, nprocs=args.ngpus_per_node, args=(args,)) else: # Simply call main_worker function main_worker(gpu=0, args=args) def main_worker(gpu, args): if args.distributed: torch.multiprocessing.set_start_method('fork', force=True) #in new Pytorch/python labda functions fail to pickle with spawn np.set_printoptions(formatter={'float': '{: 0.3f}'.format}, suppress=True) args.gpu = gpu if args.distributed: args.rank = args.rank * args.ngpus_per_node + gpu dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size, rank=args.rank) torch.cuda.set_device(args.gpu) #use this default device (same as args.device if not distributed) torch.backends.cudnn.benchmark = True print(args.rank, ' gpu', args.gpu) if args.rank==0: print('Batch size is:', args.batch_size, 'epochs', args.max_epochs) roi_size = [args.roi_x, args.roi_y, args.roi_z] inf_size = [args.roi_x, args.roi_y, args.roi_z] data_root = args.data_root healthy_data_root = args.healthy_data_root datafold_dir = args.datafold_dir fold = args.fold tumor_type = args.tumor_type organ_type = args.organ_type if organ_type == 'liver': args.fg_thresh = 30 elif organ_type == 'pancreas': args.fg_thresh = 15 elif organ_type == 'kidney': args.fg_thresh = 25 train_transform, val_transform = _get_transform(args) ## NETWORK if (args.model_name is None) or args.model_name == 'unet': from monai.networks.nets import UNet model = UNet( spatial_dims=3, in_channels=1, out_channels=3, channels=(16, 32, 64, 128, 256), strides=(2, 2, 2, 2), num_res_units=2, ) elif args.model_name == 'swinunetr': if args.swin_type == 'tiny': feature_size=12 elif args.swin_type == 'small': feature_size=24 elif args.swin_type == 'base': feature_size=48 model = SwinUNETR_v2(in_channels=1, out_channels=3, img_size=(96, 96, 96), feature_size=feature_size, patch_size=2, depths=[2, 2, 2, 2], num_heads=[3, 6, 12, 24], window_size=[7, 7, 7]) if args.use_pretrained: pretrained_add = 'model_swinvit.pt' model.load_from(weights=torch.load(pretrained_add)) print('Use pretrained ViT weights from: {}'.format(pretrained_add)) elif args.model_name == 'nnunet': from monai.networks.nets import DynUNet from dynunet_pipeline.create_network import get_kernels_strides from dynunet_pipeline.task_params import deep_supr_num task_id = 'custom' kernels, strides = get_kernels_strides(task_id) model = DynUNet( spatial_dims=3, in_channels=1, out_channels=3, kernel_size=kernels, strides=strides, upsample_kernel_size=strides[1:], norm_name="instance", deep_supervision=False, deep_supr_num=deep_supr_num[task_id], ) else: raise ValueError('Unsupported model ' + str(args.model_name)) if args.resume_ckpt: model_dict = torch.load(args.pretrained_dir) model.load_state_dict(model_dict['state_dict']) print('Use pretrained weights') dice_loss = DiceCELoss(to_onehot_y=True, softmax=True, squared_pred=True, smooth_nr=0, smooth_dr=1e-6) post_label = AsDiscrete(to_onehot=True, n_classes=args.num_classes) post_pred = AsDiscrete(argmax=True, to_onehot=True, n_classes=args.num_classes) val_channel_names=['val_liver_dice', 'val_tumor_dice'] print('Crop size', roi_size) # Initialize empty lists to store your data train_img = [] train_lbl = [] train_name = [] train_text = [] train_txt = os.path.join(datafold_dir, 'real_{}_train_{}.txt'.format(tumor_type, fold)) for line in open(train_txt): tokens = line.strip().split() name = tokens[1].split('.')[0] if 'BDMAP' in name: ct_path = tokens[0] if 'kidney' in tokens[1]: organ_label_path = [tokens[1], tokens[2]] text = ' '.join(tokens[3:]) train_img.append(os.path.join(healthy_data_root, ct_path)) train_lbl.append([os.path.join(healthy_data_root, lbl) for lbl in organ_label_path]) train_name.append(name) train_text.append(text) else: organ_label_path = tokens[1] text = ' '.join(tokens[2:]) train_img.append(os.path.join(healthy_data_root, ct_path)) train_lbl.append(os.path.join(healthy_data_root, organ_label_path)) train_name.append(name) train_text.append(text) else: ct_path = tokens[0] organ_tumor_label_path = tokens[1] text = '' train_img.append(os.path.join(data_root, ct_path)) train_lbl.append(os.path.join(data_root, organ_tumor_label_path)) train_name.append(name) train_text.append(text) data_dicts_train = [{'image': image, 'label': label, 'name': name, 'text': text} for image, label, name, text in zip(train_img, train_lbl, train_name, train_text)] print('train len {}'.format(len(data_dicts_train))) val_img = [] val_lbl = [] val_name = [] val_pseudo_lbl = [] val_txt = os.path.join(datafold_dir, 'real_{}_val_{}.txt'.format(tumor_type, fold)) for line in open(val_txt): tokens = line.strip().split() ct_path = tokens[0] organ_tumor_label_path = tokens[1] name = os.path.basename(organ_tumor_label_path).split('.')[0] val_img.append(os.path.join(data_root, ct_path)) val_lbl.append(os.path.join(data_root, organ_tumor_label_path)) val_name.append(name) val_pseudo_lbl.append('../organ_pseudo_swin_new/{}/{}/'.format(organ_type, os.path.basename(organ_tumor_label_path))) data_dicts_val = [{'image': image, 'label': label, 'organ_pseudo': organ_pseudo, 'name': name} for image, label, organ_pseudo, name in zip(val_img, val_lbl, val_pseudo_lbl, val_name)] print('val len {}'.format(len(data_dicts_val))) val_shape_dict = {} for d in data_dicts_val: imagepath = d["image"] imagename = imagepath.split('/')[-1] imgnb = nb.load(imagepath) val_shape_dict[imagename] = [imgnb.shape[0], imgnb.shape[1], imgnb.shape[2]] train_ds = data.CacheDataset(data=data_dicts_train, transform=train_transform, cache_rate=args.cache_rate) train_sampler = AMDistributedSampler(train_ds) if args.distributed else None train_loader = data.DataLoader(train_ds, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, sampler=train_sampler, pin_memory=True) print(len(train_ds)) print(args.batch_size) for i, batch_data in enumerate(train_loader): data_names = batch_data['name'] print(f"Batch {i}: {data_names}") val_ds = data.Dataset(data=data_dicts_val, transform=val_transform) val_sampler = AMDistributedSampler(val_ds, shuffle=False) if args.distributed else None val_loader = data.DataLoader(val_ds, batch_size=1, shuffle=False, num_workers=args.workers//2, sampler=val_sampler, pin_memory=True) model_inferer = partial( sliding_window_inference, roi_size=inf_size, sw_batch_size=1, predictor=model, overlap=args.val_overlap, mode='gaussian' ) pytorch_total_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print('Total parameters count', pytorch_total_params) best_acc = 0 start_epoch = 0 if args.checkpoint is not None: checkpoint = torch.load(args.checkpoint, map_location='cpu') from collections import OrderedDict new_state_dict = OrderedDict() for k, v in checkpoint['state_dict'].items(): new_state_dict[k.replace('backbone.','')] = v # load params model.load_state_dict(new_state_dict, strict=False) if 'epoch' in checkpoint: start_epoch = checkpoint['epoch'] if 'best_acc' in checkpoint: best_acc = checkpoint['best_acc'] print("=> loaded checkpoint '{}' (epoch {}) (bestacc {})".format(args.checkpoint, start_epoch, best_acc)) model.cuda(args.gpu) if args.distributed: torch.cuda.set_device(args.gpu) if args.norm_name=='batch': model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model) model.cuda(args.gpu) #?? model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu], output_device=args.gpu, find_unused_parameters=True) if args.optim_name == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=args.optim_lr, weight_decay=args.reg_weight) elif args.optim_name == 'adamw': optimizer = torch.optim.AdamW(model.parameters(), lr=args.optim_lr, weight_decay=args.reg_weight) elif args.optim_name=='sgd': optimizer = torch.optim.SGD(model.parameters(), lr=args.optim_lr, momentum=0.99, nesterov=True, weight_decay=args.reg_weight) #momentum 0.99, nestorov=True, following nnUnet else: raise ValueError('Unsupported optim_name' + str(args.optim_name)) if args.lrschedule == 'warmup_cosine': scheduler = LinearWarmupCosineAnnealingLR( optimizer, warmup_epochs=args.warmup_epochs, max_epochs=args.max_epochs ) elif args.lrschedule == 'cosine_anneal': scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.max_epochs) if args.checkpoint is not None: scheduler.step(epoch=start_epoch) else: scheduler = None accuracy = run_training(model=model, train_loader=train_loader, val_loader=val_loader, optimizer=optimizer, loss_func=dice_loss, args=args, model_inferer=model_inferer, scheduler=scheduler, start_epoch=start_epoch, val_channel_names=val_channel_names, val_shape_dict=val_shape_dict, post_label=post_label, post_pred=post_pred, val_acc_max = best_acc) return accuracy if __name__ == '__main__': main()