|
|
import numpy as np |
|
|
from light_training.dataloading.dataset import get_train_val_test_loader_from_train |
|
|
import torch |
|
|
import torch.nn as nn |
|
|
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.files_helper import save_new_model_and_delete_last |
|
|
from monai.losses.dice import DiceLoss |
|
|
set_determinism(123) |
|
|
import os |
|
|
import argparse |
|
|
|
|
|
def func(m, epochs): |
|
|
return np.exp(-10*(1- m / epochs)**2) |
|
|
|
|
|
class BraTSTrainer(Trainer): |
|
|
def __init__( |
|
|
self, |
|
|
env_type, |
|
|
max_epochs, |
|
|
batch_size, |
|
|
device="cpu", |
|
|
val_every=1, |
|
|
num_gpus=1, |
|
|
logdir="./logs/", |
|
|
roi_size=(128, 128, 128), |
|
|
augmentation=True, |
|
|
train_process=18, |
|
|
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, |
|
|
train_process=train_process, |
|
|
) |
|
|
self.window_infer = SlidingWindowInferer(roi_size=list(roi_size), sw_batch_size=1, overlap=0.5) |
|
|
self.augmentation = augmentation |
|
|
from model_segmamba.segmamba import SegMamba |
|
|
|
|
|
self.model = SegMamba(in_chans=4, |
|
|
out_chans=4, |
|
|
depths=[2,2,2,2], |
|
|
feat_size=[48, 96, 192, 384]) |
|
|
|
|
|
self.patch_size = list(roi_size) |
|
|
self.best_mean_dice = 0.0 |
|
|
self.ce = nn.CrossEntropyLoss() |
|
|
self.mse = nn.MSELoss() |
|
|
self.train_process = train_process |
|
|
self.model_save_path = os.path.join(logdir, "model") |
|
|
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.cross = nn.CrossEntropyLoss() |
|
|
|
|
|
def training_step(self, batch): |
|
|
image, label = self.get_input(batch) |
|
|
|
|
|
pred = self.model(image) |
|
|
|
|
|
loss = self.cross(pred, label) |
|
|
|
|
|
self.log("training_loss", loss, step=self.global_step) |
|
|
|
|
|
return loss |
|
|
|
|
|
def convert_labels(self, labels): |
|
|
|
|
|
result = [(labels == 1) | (labels == 3), (labels == 1) | (labels == 3) | (labels == 2), labels == 3] |
|
|
|
|
|
return torch.cat(result, dim=1).float() |
|
|
|
|
|
|
|
|
def get_input(self, batch): |
|
|
image = batch["data"] |
|
|
label = batch["seg"] |
|
|
|
|
|
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) |
|
|
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) |
|
|
|
|
|
output = output.argmax(dim=1) |
|
|
|
|
|
output = output[:, None] |
|
|
output = self.convert_labels(output) |
|
|
|
|
|
label = label[:, None] |
|
|
label = self.convert_labels(label) |
|
|
|
|
|
output = output.cpu().numpy() |
|
|
target = label.cpu().numpy() |
|
|
|
|
|
dices = [] |
|
|
|
|
|
c = 3 |
|
|
for i in range(0, 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 |
|
|
|
|
|
tc, wt, et = dices[0].mean(), dices[1].mean(), dices[2].mean() |
|
|
|
|
|
print(f"dices is {tc, wt, et}") |
|
|
|
|
|
mean_dice = (tc + wt + et) / 3 |
|
|
|
|
|
self.log("tc", tc, step=self.epoch) |
|
|
self.log("wt", wt, step=self.epoch) |
|
|
self.log("et", et, 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(self.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(self.model_save_path, |
|
|
f"final_model_{mean_dice:.4f}.pt"), |
|
|
delete_symbol="final_model") |
|
|
|
|
|
|
|
|
if (self.epoch + 1) % 100 == 0: |
|
|
torch.save(self.model.state_dict(), os.path.join(self.model_save_path, f"tmp_model_ep{self.epoch}_{mean_dice:.4f}.pt")) |
|
|
|
|
|
print(f"mean_dice is {mean_dice}") |
|
|
|
|
|
def _parse_csv_ints(s: str, n: int): |
|
|
parts = [p.strip() for p in s.split(",") if p.strip()] |
|
|
if len(parts) != n: |
|
|
raise ValueError(f"expect {n} integers like '128,128,128', got: {s}") |
|
|
return [int(x) for x in parts] |
|
|
|
|
|
|
|
|
def _parse_augmentation(s: str): |
|
|
s = str(s).strip().lower() |
|
|
if s in {"true", "1", "yes", "y"}: |
|
|
return True |
|
|
if s in {"false", "0", "no", "n"}: |
|
|
return False |
|
|
|
|
|
|
|
|
return s |
|
|
|
|
|
|
|
|
def main(): |
|
|
parser = argparse.ArgumentParser(description="SegMamba BraTS2023 training.") |
|
|
parser.add_argument("--data_dir", type=str, default="./data/fullres/train", help="Preprocessed data directory (contains *.npz).") |
|
|
parser.add_argument("--logdir", type=str, default="./logs/segmamba", help="Log/checkpoint directory.") |
|
|
parser.add_argument("--env", type=str, default="pytorch", choices=["pytorch", "DDP", "ddp"], help="Training environment.") |
|
|
parser.add_argument("--max_epoch", type=int, default=1000) |
|
|
parser.add_argument("--batch_size", type=int, default=2) |
|
|
parser.add_argument("--val_every", type=int, default=2) |
|
|
parser.add_argument("--num_gpus", type=int, default=1) |
|
|
parser.add_argument("--device", type=str, default="cuda:0", help="Device for single GPU; DDP will use LOCAL_RANK.") |
|
|
parser.add_argument("--roi_size", type=str, default="128,128,128", help="Patch/ROI size, e.g. '128,128,128'.") |
|
|
parser.add_argument("--augmentation", type=str, default="true", help="true/false/nomirror/onlymirror/onlyspatial") |
|
|
parser.add_argument("--train_process", type=int, default=18, help="Number of augmentation worker processes (per rank).") |
|
|
parser.add_argument("--master_port", type=int, default=17759) |
|
|
|
|
|
parser.add_argument("--not_call_launch", action="store_true", help=argparse.SUPPRESS) |
|
|
args, _ = parser.parse_known_args() |
|
|
|
|
|
roi_size = _parse_csv_ints(args.roi_size, 3) |
|
|
augmentation = _parse_augmentation(args.augmentation) |
|
|
|
|
|
trainer = BraTSTrainer( |
|
|
env_type=args.env, |
|
|
max_epochs=args.max_epoch, |
|
|
batch_size=args.batch_size, |
|
|
device=args.device, |
|
|
logdir=args.logdir, |
|
|
val_every=args.val_every, |
|
|
num_gpus=args.num_gpus, |
|
|
master_port=args.master_port, |
|
|
training_script=__file__, |
|
|
roi_size=roi_size, |
|
|
augmentation=augmentation, |
|
|
train_process=args.train_process, |
|
|
) |
|
|
|
|
|
train_ds, val_ds, test_ds = get_train_val_test_loader_from_train(args.data_dir) |
|
|
trainer.train(train_dataset=train_ds, val_dataset=val_ds) |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
main() |
|
|
|
