File size: 7,537 Bytes
b4d7ac8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 |
import numpy as np
from light_training.dataloading.dataset import get_train_val_test_loader_from_train
# from dataset.brats_data_utils_resample128 import get_loader_brats
import torch
import torch.nn as nn
# from ddim_seg.basic_unet import BasicUNet
from monai.networks.nets.unetr import UNETR
from monai.networks.nets.swin_unetr import SwinUNETR
from monai.inferers import SlidingWindowInferer
from light_training.evaluation.metric import dice
from light_training.trainer import Trainer
from monai.utils import set_determinism
from light_training.utils.lr_scheduler import LinearWarmupCosineAnnealingLR
from light_training.utils.files_helper import save_new_model_and_delete_last
from models.uent2d import UNet2D
from models.uent3d import UNet3D
from monai.networks.nets.segresnet import SegResNet
# from ddim_seg.unet3d import DiffusionUNet
# from ddim_seg.ddim import DDIM
# from ddim_seg.nnunet3d_raw import Generic_UNet
# from ddim_seg.basic_unet_denose import BasicUNetDe
# from ddim_seg.basic_unet import BasicUNetEncoder
from models.transbts.TransBTS_downsample8x_skipconnection import TransBTS
import argparse
from monai.losses.dice import DiceLoss
# from light_training.model.bit_diffusion import decimal_to_bits, bits_to_decimal
# from guided_diffusion.gaussian_diffusion import get_named_beta_schedule, ModelMeanType, ModelVarType,LossType
# from guided_diffusion.respace import SpacedDiffusion, space_timesteps
# from guided_diffusion.resample import UniformSampler
set_determinism(123)
import os
from scipy import ndimage
os.environ["CUDA_VISIBLE_DEVICES"] = "6,7"
data_dir = "./data/fullres/train"
logdir = f"./logs_gpu4/diffunet_ep2000"
model_save_path = os.path.join(logdir, "model")
# augmentation = "nomirror"
augmentation = True
env = "pytorch"
max_epoch = 2000
batch_size = 2
val_every = 2
num_gpus = 1
device = "cuda:0"
roi_size = [128, 128, 128]
def get_edge_points(img):
"""
get edge points of a binary segmentation result
"""
dim = len(img.shape)
if (dim == 2):
strt = ndimage.generate_binary_structure(2, 1)
else:
strt = ndimage.generate_binary_structure(3, 1)
ero = ndimage.binary_erosion(img, strt)
edge = np.asarray(img, np.uint8) - np.asarray(ero, np.uint8)
return edge
def edge_3d(image_3d):
# image_3d = torch.from_numpy(image_3d)
b, c, d, h, w = image_3d.shape
image_3d = image_3d[:, 0] > 0
return_edge = []
for i in range(image_3d.shape[0]):
return_edge.append(get_edge_points(image_3d[i])[None,])
return_edge = np.concatenate(return_edge, axis=0)
return return_edge
class BraTSTrainer(Trainer):
def __init__(self, env_type, max_epochs, batch_size, device="cpu", val_every=1, num_gpus=1, logdir="./logs/", master_ip='localhost', master_port=17750, training_script="train.py"):
super().__init__(env_type, max_epochs, batch_size, device, val_every, num_gpus, logdir, master_ip, master_port, training_script)
self.window_infer = SlidingWindowInferer(roi_size=roi_size,
sw_batch_size=1,
overlap=0.5)
self.augmentation = augmentation
from models.nnunet_denoise_ddp_infer.get_unet3d_denoise_uncer_edge import DiffUNet
self.model = DiffUNet(1, 10, 3, 1, bta=True)
self.patch_size = roi_size
self.best_mean_dice = 0.0
self.ce = nn.CrossEntropyLoss()
self.mse = nn.MSELoss()
self.train_process = 20
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=1e-2, weight_decay=3e-5,
momentum=0.99, nesterov=True)
self.scheduler_type = "poly"
self.bce = nn.BCEWithLogitsLoss()
self.dice_loss = DiceLoss(sigmoid=True)
self.cross = nn.CrossEntropyLoss()
def training_step(self, batch):
image, label = self.get_input(batch)
pred, pred_edge = self.model(image, label)
loss_edge = self.cross(pred_edge, label)
loss_seg = self.cross(pred, label)
self.log("loss_seg", loss_seg, step=self.global_step)
self.log("loss_edge", loss_edge, step=self.global_step)
loss = loss_edge + loss_seg
return loss
def get_input(self, batch):
image = batch["data"]
label = batch["seg"]
# label = self.convert_labels(label)
# label = label.float()
label = label[:, 0].long()
return image, label
def cal_metric(self, gt, pred, voxel_spacing=[1.0, 1.0, 1.0]):
if pred.sum() > 0 and gt.sum() > 0:
d = dice(pred, gt)
# hd95 = metric.binary.hd95(pred, gt)
return np.array([d, 50])
elif gt.sum() == 0 and pred.sum() == 0:
return np.array([1.0, 50])
else:
return np.array([0.0, 50])
def validation_step(self, batch):
image, label = self.get_input(batch)
output = self.model(image, ddim=True)
# output = output > 0
output = output.argmax(dim=1)
output = output.cpu().numpy()
target = label.cpu().numpy()
dices = []
c = 10
for i in range(1, c):
pred_c = output == i
target_c = target == i
cal_dice, _ = self.cal_metric(target_c, pred_c)
dices.append(cal_dice)
return dices
def validation_end(self, val_outputs):
dices = val_outputs
dices_mean = []
c = 9
for i in range(0, c):
dices_mean.append(dices[i].mean())
mean_dice = sum(dices_mean) / len(dices_mean)
self.log("0", dices_mean[0], step=self.epoch)
self.log("1", dices_mean[1], step=self.epoch)
self.log("2", dices_mean[2], step=self.epoch)
self.log("3", dices_mean[3], step=self.epoch)
self.log("4", dices_mean[4], step=self.epoch)
self.log("5", dices_mean[5], step=self.epoch)
self.log("6", dices_mean[6], step=self.epoch)
self.log("7", dices_mean[7], step=self.epoch)
self.log("8", dices_mean[8], step=self.epoch)
self.log("mean_dice", mean_dice, step=self.epoch)
if mean_dice > self.best_mean_dice:
self.best_mean_dice = mean_dice
save_new_model_and_delete_last(self.model,
os.path.join(model_save_path,
f"best_model_{mean_dice:.4f}.pt"),
delete_symbol="best_model")
save_new_model_and_delete_last(self.model,
os.path.join(model_save_path,
f"final_model_{mean_dice:.4f}.pt"),
delete_symbol="final_model")
print(f"mean_dice is {mean_dice}")
if __name__ == "__main__":
trainer = BraTSTrainer(env_type=env,
max_epochs=max_epoch,
batch_size=batch_size,
device=device,
logdir=logdir,
val_every=val_every,
num_gpus=num_gpus,
master_port=17759,
training_script=__file__)
train_ds, val_ds, test_ds = get_train_val_test_loader_from_train(data_dir)
trainer.train(train_dataset=train_ds, val_dataset=val_ds)
|