import numpy as np
import matplotlib.pyplot as plt
from starter_code.utils import load_volume

axial_slices = []
coronal_slices = []
sagittal_slices = []


for case_id in range(0, 300):
    case_str = f"{case_id:05d}"
    volume = load_volume(case_str)
    vol_shape = volume.shape

    axial_slices.append(vol_shape[0])
    coronal_slices.append(vol_shape[1])
    sagittal_slices.append(vol_shape[2])

highest_axial = max(axial_slices)
lowest_axial = min(axial_slices)
average_axial = np.mean(axial_slices)

highest_case = axial_slices.index(highest_axial)
lowest_case = axial_slices.index(lowest_axial)

print(f"Highest number of axial slices: {highest_axial} (Case ID: {highest_case:05d})")
print(f"Lowest number of axial slices: {lowest_axial} (Case ID: {lowest_case:05d})")
print(f"Average number of axial slices: {average_axial:.2f}")

cases = np.arange(1, 301)

plt.figure(figsize=(12, 6))
plt.scatter(cases, axial_slices, label="Axial Slices", color="blue", s=10)
plt.scatter(cases, coronal_slices, label="Coronal Slices", color="green", s=10)
plt.scatter(cases, sagittal_slices, label="Sagittal Slices", color="red", s=10)

plt.xlabel("Case ID")
plt.ylabel("Number of Slices")
plt.title("Number of Slices in Each Plane Across Cases")
plt.legend()
plt.grid(True)
plt.show()

Highest number of axial slices: 1059 (Case ID: 00151)
Lowest number of axial slices: 29 (Case ID: 00061)
Average number of axial slices: 217.21

from pathlib import Path
import nibabel as nib
import numpy as np
import matplotlib.pyplot as plt
from starter_code.utils import load_case, load_volume

case = 78
vol, seg = load_case(case)

vol = vol.get_fdata()
seg = seg.get_fdata()

vol_hus = []
seg_hus = []
for i in range(vol.shape[0]):
    for j in range(vol.shape[1]):
        for k in range(vol.shape[2]):
            vol_hus.append(vol[i, j, k])
            seg_hus.append(seg[i, j, k])

plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.hist(vol_hus, color='blue', edgecolor='black')
plt.title('Image HU Distribution')
plt.xlabel('HU')
plt.ylabel('Frequency')

plt.subplot(1, 2, 2)
plt.hist(seg_hus, color='red', edgecolor='black')
plt.title('Mask HU Distribution')
plt.xlabel('HU')
plt.ylabel('Frequency')

plt.tight_layout()
plt.show()

import torch
import numpy as np
import cv2
from pathlib import Path
from scipy.ndimage import zoom
from starter_code.utils import load_case, load_volume
import nibabel as nib
from torch.utils.data import Dataset, DataLoader

#constants
TARGET_VOXEL_SPACING = [3.22, 1.62, 1.62]
DEFAULT_HU_MAX = 304
DEFAULT_HU_MIN = -79
DEFAULT_SLICE_SIZE = 512
DEFAULT_PLANE = "axial"
DATASET_START = 0
DATASET_END = 300

#auxillary functions for preprocessing
def resample(image, original_spacing, target_spacing=TARGET_VOXEL_SPACING):
    # Compute zoom factor
    resize_factor = np.array(original_spacing) / np.array(target_spacing)
    resampled_image = zoom(image, resize_factor, mode='nearest')
    return resampled_image

def restrict_hu(image, hu_min=DEFAULT_HU_MIN, hu_max=DEFAULT_HU_MAX):
    # Clip at max and min values if specified
    restrict_image = np.clip(image, hu_min, hu_max)
    return restrict_image

def z_score(image):
    mean = np.mean(image)
    std = np.std(image)
    z_score_image = (image - mean) / std
    return z_score_image

def trans_to_2d(image, plane=DEFAULT_PLANE):
    plane = plane.lower()

    plane_opts = ["axial", "coronal", "sagittal"]
    if plane not in plane_opts:
        raise ValueError((
            "Plane \"{}\" not understood. "
            "Must be one of the following\n\n\t{}\n"
        ).format(plane, plane_opts))

    if plane == plane_opts[0]:
        slices = [image[i, :, :] for i in range(image.shape[0])]

    if plane == plane_opts[1]:
        slices = [image[:, i, :] for i in range(image.shape[1])]

    if plane == plane_opts[2]:
        slices = [image[:, :, i] for i in range(image.shape[2])]

    return slices

def resize(slices):
    resized_slices = [cv2.resize(s, (DEFAULT_SLICE_SIZE, DEFAULT_SLICE_SIZE)) for s in slices]
    return resized_slices


# the main function to be called.
def preprocess(case_id, hu_min=DEFAULT_HU_MIN, hu_max=DEFAULT_HU_MAX):
    vol, seg = load_case(case_id)

    # splitting up cases
    if case_id < 210:
        vol, seg = load_case(case_id)
        seg_present = True
    else:
        vol = load_volume(case_id)
        seg_present = False

    # voxel spacing and resampling
    vol_spacing = nib.affines.voxel_sizes(vol.affine)
    vol = resample(vol.get_fdata(), vol_spacing)

    # restrict hu and apply z_score normalisation to VOLUME ONLY
    vol = restrict_hu(vol, hu_min, hu_max)
    vol = z_score(vol)

    # transform to 2D slices and resize
    vol_slices = resize(trans_to_2d(vol))
    vol_tensors = [torch.tensor(vol_slice, dtype=torch.float32).unsqueeze(0) for vol_slice in vol_slices]

    # If segmentation is available, process it
    if seg_present:
        seg = resample(seg.get_fdata(), vol_spacing)
        seg_slices = resize(trans_to_2d(seg))
        seg_tensors = [torch.tensor(seg_slice, dtype=torch.long).unsqueeze(0) for seg_slice in seg_slices]
        return vol_tensors, seg_tensors
    else:
        return vol_tensors, []

# preprocess images with segmentations
for batch in range(0, 21):
    print(f'Preprocessing train set {batch} ... ', end = '')

    all_vol_tensors = []
    all_seg_tensors = []

    for cid in range(10*batch, 10*(batch+1)):
        if cid != 160:
            vol_tensors, seg_tensors = preprocess(cid)
            all_vol_tensors.extend(vol_tensors)
            all_seg_tensors.extend(seg_tensors)

    train_set = KidneyDataset(all_vol_tensors, all_seg_tensors)
    output_path = Path("preprocessed_data")
    if not output_path.exists():
        output_path.mkdir()
    output_path = output_path / 'train_set_{}'.format(batch)
    torch.save(train_set, output_path)
    print(f'Finished. The number of samples: {len(train_set)}')

# preprocess images without segmentations
for batch in range(21, 30):
    print(f'Preprocessing test set {batch} ... ', end = '')

    test_set = []

    for cid in range(10*batch, 10*(batch+1)):
        vol_tensors, seg_tensors = preprocess(cid)
        test_set.extend(vol_tensors)

    output_path = Path("preprocessed_data")
    if not output_path.exists():
        output_path.mkdir()
    output_path = output_path / 'test_set_{}'.format(batch)
    torch.save(test_set, output_path)
    print(f'Finished. The number of samples: {len(test_set)}')

# UNet imports
import torch
import torchvision.transforms.functional as TF
from pathlib import Path
from torch import optim, nn
from torch.utils.data import Dataset, DataLoader, random_split
from tqdm import tqdm

# Hyperparameters and paths
LEARNING_RATE = 2e-4
EPOCHS = 10
BATCH_COUNT = 2 # 2 training sets
VAL_BATCH_COUNT = [19] # 1 validation set
TEST_SET = 20 # For calculating Dice Score
DATA_PATH = Path() / "preprocessed_data"

# Model components for the convolution, downsampling and upsampling
class DoubleConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace = True),
            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace = True),
        )

    def forward(self, x):
        return self.conv(x)

class DownSample(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.conv = DoubleConv(in_channels, out_channels)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)

    def forward(self, x):
        down = self.conv(x)
        p = self.pool(down)

        return down, p

class UpSample(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.up = nn.ConvTranspose2d(in_channels, in_channels//2, kernel_size=2, stride=2)
        self.conv = DoubleConv(in_channels, out_channels)

    def forward(self, x1, x2):
        x1 = self.up(x1)
        x = torch.cat([x1, x2], 1)
        return self.conv(x)

# The UNet model itself as per the described architecture
class UNet(nn.Module):
    def __init__(self, in_channels, num_classes):
        super().__init__()
        self.dc1 = DownSample(in_channels, 64)
        self.dc2 = DownSample(64, 128)
        self.dc3 = DownSample(128, 256)
        self.dc4 = DownSample(256, 512)

        self.bn = DoubleConv(512, 1024)

        self.uc1 = UpSample(1024, 512)
        self.uc2 = UpSample(512, 256)
        self.uc3 = UpSample(256, 128)
        self.uc4 = UpSample(128, 64)

        self.output = nn.Conv2d(in_channels=64, out_channels=num_classes, kernel_size=1)

    def forward(self, x):
        down1, p1 = self.dc1(x)
        down2, p2 = self.dc2(p1)
        down3, p3 = self.dc3(p2)
        down4, p4 = self.dc4(p3)

        bn = self.bn(p4)

        up1 = self.uc1(bn, down4)
        up2 = self.uc2(up1, down3)
        up3 = self.uc3(up2, down2)
        up4 = self.uc4(up3, down1)

        output = self.output(up4)
        return output

# Initialisation, optimiser and loss function
device = "cuda" if torch.cuda.is_available() else "cpu"
model = UNet(in_channels = 1, num_classes = 1).to(device)
optimiser = optim.AdamW(model.parameters(), lr = LEARNING_RATE)
criterion = nn.BCEWithLogitsLoss()

# Dataset definition
class KidneyDataset(Dataset):
    def __init__(self, volumes, masks):
        self.volumes = volumes
        self.masks = masks

    def __len__(self):
        return len(self.volumes)

    def __getitem__(self, idx):
        return self.volumes[idx], self.masks[idx]

# Storage of loss for graphing
loss_over_time = []
val_loss_over_time = []

test_path = DATA_PATH / "train_set_{}".format(TEST_SET)
test_dataset = torch.load(test_path, map_location=device, weights_only=False)
test_data = DataLoader(test_dataset, batch_size=1, shuffle=True)
val_data_count = len(test_data)

# Training Loop
for epoch in range(EPOCHS):
    model.train()

    validation_loss = 0
    training_loss = 0
    data_count = 0

    # Training
    for batch_index in range(BATCH_COUNT):
        train_path = DATA_PATH / "train_set_{}".format(batch_index)
        train_dataset = torch.load(train_path, map_location=device, weights_only=False)
        train_data = DataLoader(train_dataset, batch_size=1, shuffle=True)
        batch_loss = 0
        data_count += len(train_data)

        for images, masks in tqdm(train_data):
            images = images.float().to(device)
            masks = masks.float().to(device)

            outputs = model(images)
            loss = criterion(outputs, masks)
            optimiser.zero_grad()
            loss.backward()
            optimiser.step()
            batch_loss += loss.item()

        training_loss += batch_loss

    # Validation
    with torch.no_grad():
        model.eval()

        for images, masks in (test_data):
            images = images.float().to(device)
            masks = masks.float().to(device)

            outputs = model(images)
            validation_loss += criterion(outputs, masks)

    # Adding Results
    epoch_val_loss = validation_loss / val_data_count
    val_loss_over_time.append(epoch_val_loss)
    epoch_loss = training_loss / data_count
    loss_over_time.append(epoch_loss)
    torch.cuda.empty_cache()

    torch.save(model.state_dict(), f'Unet_epoch_{}.pth'.format(epoch+1)) # Save the model!
    print(f"EPOCH {epoch+1} TRAINING LOSS: {epoch_loss:.5f} VALIDATION LOSS: {epoch_val_loss:.5f}")

import matplotlib.pyplot as plt
epochs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
manual_loss = [0.07790, 0.01756, 0.01182, 0.00088, 0.00692, 0.00634, 0.00476, 0.00268, 0.00088, 0.00434]
manual_val = [0.02410, 0.02727, 0.01491, 0.01820, 0.01988, 0.01701, 0.01860, 0.01562, 0.01900, 0.01923]
plt.plot(epochs, manual_loss, label="Training Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.plot(epochs, manual_val, label="Validation Loss")
plt.legend(loc="best")

def dice_coefficient(prediction, target, epsilon=1e-07):
    prediction_copy = prediction.clone()

    # Floor/Ceil the probabilities to 0 and 1
    prediction_copy[prediction_copy < 0] = 0
    prediction_copy[prediction_copy > 0] = 1

    intersection = abs(torch.sum(prediction_copy * target))
    union = abs(torch.sum(prediction_copy) + torch.sum(target))
    dice = (2. * intersection + epsilon) / (union + epsilon)

    return dice

with torch.no_grad():
    model.eval()
    total_dc = 0
    for images, masks in tqdm(test_data):
        images = images.float().to(device)
        masks = masks.float().to(device)

        outputs = model(images)
        dc = dice_coefficient(outputs, masks)
        total_dc += dc.item()

    val_dc = total_dc / val_data_count
    print(val_dc)

import os

import torch
from torch.utils.data import Dataset

from sklearn.model_selection import train_test_split

import nibabel as nib
import numpy as np

class Batch(Dataset):
    def __init__(self, volumes, segmentations):

        ct_image = torch.stack([t.squeeze(0) for t in volumes])
        seg_image = torch.stack([t.squeeze(0) for t in segmentations])

        self.volumes = ct_image
        self.masks = seg_image

    def __len__(self):
        return len(self.volumes.shape[0])

    def __getitem__(self):
        return self.volumes, self.masks

    def get(self):
        return self.volumes, self.masks

    def getVolume(self) -> torch.Tensor:
        return self.volumes

    def getMask(self) -> torch.Tensor:
        return self.masks

class Image(Dataset):
    def __init__(self, volumes: torch.Tensor, segmentations: torch.Tensor):
        self.volumes = volumes
        self.masks = segmentations

    def __len__(self):
        return len(self.volumes)

    def __getitem__(self):
        return self.volumes, self.masks

    def getVolume(self) -> torch.Tensor:
        return self.volumes

    def getMask(self) -> torch.Tensor:
        return self.masks

# data implementation for the KiTS19 dataset
class KiTS19Dataset(Dataset):
    def __init__(self, data_dir="", split_ratio=0.8, train="true", old=None, batch_size=1):
        if isinstance(old, KiTS19Dataset):
            self.data_dir = old.data_dir
            self.case_ids = old.case_ids
            self.train = old.train;
            self.train_ids = old.train_ids
            self.test_ids = old.test_ids
            self.batch_size = old.batch_size
            # self.entry = old.entry;
        else:
            self.data_dir = data_dir
            self.case_ids = self.get_cases()  # List of case IDs to load
            self.train = train;
            train_ids, test_ids = train_test_split(self.case_ids, train_size=split_ratio, random_state=42)
            self.train_ids = train_ids if train else test_ids
            self.test_ids = test_ids
            self.batch_size = batch_size
            # self.loadset()

    def loadset(self):
        if self.train:
            ids = self.train_ids
        else:
            ids = self.test_ids

        s = list()
        ct_buffer = []
        seg_buffer = []
        for id in ids:
            image = self.load_case_idx(id)
            ct_image = image.getVolume()
            seg_image = image.getMask()

            ct_buffer = ct_buffer + ct_image
            seg_buffer = seg_buffer + seg_image

            start_idx = 0
            while start_idx + self.batch_size <= len(ct_buffer):
                s.append(Batch(ct_buffer[:self.batch_size], seg_buffer[:self.batch_size]))
                del ct_buffer[:self.batch_size]
                del seg_buffer[:self.batch_size]

        self.entry = s

        for idx, i in enumerate(self.entry):
            save_path = os.path.dirname(os.path.abspath(__file__)) + '\\slices\\' + f"slice_{idx}"
            torch.save(i, save_path)

    def __len__(self):
        if self.train:
            return len(self.train_ids)
        else:
            return len(self.test_ids)

    def __getitem__(self, idx):
        data = self.load_case_idx(idx)
        ct_image, seg_image = data.get()

        ct_image = ct_image.unsqueeze(0)
        # print(data)
        # ct_image = data.getVolume()
        # seg_image = data.getMask()

        return ct_image, seg_image

    def load_case_idx(self, case_id: int):
        # Construct the case directory name
        # Format the file name according to the case_id
        file_name = f"slice_{case_id}"
        file_path = os.path.join(self.data_dir, file_name)

        # Check if the file exists
        if not os.path.exists(file_path):
            raise FileNotFoundError(f"File {file_name} not found in directory {self.data_dir}.")

        # Load and return the contents of the tensor file
        try:
            data = torch.load(file_path)
            return data
        except Exception as e:
            raise RuntimeError(f"Error loading file {file_name}: {e}")

    def _find_case_files(self):
        """Find all files in the format case_xxxxx.pt and return the list of paths and case numbers."""
        case_files = []
        case_numbers = []
        self.data_dir = os.path.dirname(os.path.dirname(__file__)) + self.data_dir
        print(self.data_dir)
        # Traverse the directory to find files matching the format
        for root, _, files in os.walk(self.data_dir):
            for file in files:
                if file.startswith("slice_"):
                    # Extract case number
                    case_number = file.split("_")[1].split(".")[0]
                    case_files.append(os.path.join(root, file))
                    case_numbers.append(case_number)

        return case_files, case_numbers

    def _check_keys_in_tensor(self, file_path):
        """Check if a tensor file contains 'volumes' and 'segmentations' keys."""
        try:
            data = torch.load(file_path)
            if isinstance(data, dict) and "volumes" in data and "segmentations" in data:
                return True
            return False
        except Exception as e:
            print(f"Error loading {file_path}: {e}")
            return False

    def get_cases(self):
        """Main function to find case files and check for specific keys."""
        case_files, case_numbers = self._find_case_files()
        print(f"Found {len(case_files)} slice files.")
        full_cases = []
        other_cases = []
        # Check each file for the required keys
        for file_path, case_number in zip(case_files, case_numbers):
            full_cases.append(case_number)
        return full_cases

    def train(self):
        self.train = True;

    def test(self):
        self.train = False;
        # self.entry = self.loadset()

    def target_mean(self):
        if self.train:
            target_ids = self.train_ids
        else:
            target_ids = self.test_ids

        ms = []
        for i in target_ids:
            data = self.load_case_idx(i)
            target = data.getMask()
            ml = []
            for j in target:
                m = np.mean(j.cpu().numpy())
                ml.append(m)

            m = np.mean(ml)
            ms.append(m)
        return np.mean(ms)


# modified code, from https://github.com/mattmacy/vnet.pytorch

import torch
import torch.nn as nn
import torch.nn.functional as F


def passthrough(x, **kwargs):
    return x

def ELUCons(elu, nchan):
    if elu:
        return nn.ELU(inplace=True)
    else:
        return nn.PReLU(nchan)

# normalization between sub-volumes is necessary
# for good performance

class ContBatchNorm3d(nn.modules.batchnorm._BatchNorm):
    def _check_input_dim(self, input):
        if input.dim() != 5:
            raise ValueError('expected 5D input (got {}D input)'
                             .format(input.dim()))

    def forward(self, input):
        self._check_input_dim(input)
        return F.batch_norm(
            input, self.running_mean, self.running_var, self.weight, self.bias,
            True, self.momentum, self.eps)

class LUConv(nn.Module):
    def __init__(self, nchan, elu):
        super(LUConv, self).__init__()
        self.relu1 = ELUCons(elu, nchan)
        self.conv1 = nn.Conv3d(nchan, nchan, kernel_size=5, padding=2)
        self.bn1 = ContBatchNorm3d(nchan)

    def forward(self, x):
        out = self.relu1(self.bn1(self.conv1(x)))
        return out

def _make_nConv(nchan, depth, elu):
    layers = []
    for _ in range(depth):
        layers.append(LUConv(nchan, elu))
    return nn.Sequential(*layers)

class InputTransition(nn.Module):
    def __init__(self, outChans, elu):
        super(InputTransition, self).__init__()
        self.conv1 = nn.Conv3d(1, 16, kernel_size=5, padding=2)
        self.bn1 = ContBatchNorm3d(16)
        self.relu1 = ELUCons(elu, 16)

    def forward(self, x):
        # do we want a PRELU here as well?
        out = self.bn1(self.conv1(x))
        # split input in to 16 channels
        x16 = torch.cat((x, x, x, x, x, x, x, x,
                         x, x, x, x, x, x, x, x), 0)
        out = self.relu1(torch.add(out, x16))
        return out

class DownTransition(nn.Module):
    def __init__(self, inChans, nConvs, elu, dropout=False):
        super(DownTransition, self).__init__()
        outChans = 2*inChans
        self.down_conv = nn.Conv3d(inChans, outChans, kernel_size=1, stride=1)
        self.bn1 = ContBatchNorm3d(outChans)
        self.do1 = passthrough
        self.relu1 = ELUCons(elu, outChans)
        self.relu2 = ELUCons(elu, outChans)
        if dropout:
            self.do1 = nn.Dropout3d()
        self.ops = _make_nConv(outChans, nConvs, elu)

    def forward(self, x):
        down = self.relu1(self.bn1(self.down_conv(x)))
        out = self.do1(down)
        out = self.ops(out)
        out = self.relu2(torch.add(out, down))
        return out


class UpTransition(nn.Module):
    def __init__(self, inChans, outChans, nConvs, elu, dropout=False):
        super(UpTransition, self).__init__()
        self.up_conv = nn.ConvTranspose3d(inChans, outChans // 2, kernel_size=1, stride=1)
        self.bn1 = ContBatchNorm3d(outChans // 2)
        self.do1 = passthrough
        self.do2 = nn.Dropout3d()
        self.relu1 = ELUCons(elu, outChans // 2)
        self.relu2 = ELUCons(elu, outChans)
        if dropout:
            self.do1 = nn.Dropout3d()
        self.ops = _make_nConv(outChans, nConvs, elu)

    def forward(self, x, skipx):
        out = self.do1(x)
        skipxdo = self.do2(skipx)
        out = self.relu1(self.bn1(self.up_conv(out)))
        xcat = torch.cat((out, skipxdo), 1)
        out = self.ops(xcat)
        out = self.relu2(torch.add(out, xcat))
        return out


class OutputTransition(nn.Module):
    def __init__(self, inChans, elu, nll):
        super(OutputTransition, self).__init__()
        self.conv1 = nn.Conv3d(inChans, 2, kernel_size=5, padding=2)
        self.bn1 = ContBatchNorm3d(2)
        self.conv2 = nn.Conv3d(2, 2, kernel_size=1)
        self.relu1 = ELUCons(elu, 2)
        if nll:
            self.softmax = F.log_softmax
        else:
            self.softmax = F.softmax

    def forward(self, x):
        # convolve 32 down to 2 channels
        out = self.relu1(self.bn1(self.conv1(x)))
        out = self.conv2(out)
        # make channels the last axis
        out = out.permute(0, 2, 3, 4, 1).contiguous()
        # flatten
        out = out.view(out.numel() // 2, 2)
        out = self.softmax(out)
        # treat channel 0 as the predicted output
        return out


class VNet(nn.Module):
    # the number of convolutions in each layer corresponds
    # to what is in the actual prototxt, not the intent
    def __init__(self, elu=True, nll=False):
        super(VNet, self).__init__()
        self.in_tr = InputTransition(16, elu)
        self.down_tr32 = DownTransition(16, 1, elu)
        self.down_tr64 = DownTransition(32, 2, elu)
        self.down_tr128 = DownTransition(64, 3, elu, dropout=True)
        self.down_tr256 = DownTransition(128, 2, elu, dropout=True)
        self.up_tr256 = UpTransition(256, 256, 2, elu, dropout=True)
        self.up_tr128 = UpTransition(256, 128, 2, elu, dropout=True)
        self.up_tr64 = UpTransition(128, 64, 1, elu)
        self.up_tr32 = UpTransition(64, 32, 1, elu)
        self.out_tr = OutputTransition(32, elu, nll)

    def forward(self, x):
        out16 = self.in_tr(x)
        out32 = self.down_tr32(out16)
        out64 = self.down_tr64(out32)
        out128 = self.down_tr128(out64)
        out256 = self.down_tr256(out128)
        out = self.up_tr256(out256, out128)
        out = self.up_tr128(out, out64)
        out = self.up_tr64(out, out32)
        out = self.up_tr32(out, out16)
        out = self.out_tr(out)
        return out

import time
import argparse
import torch

import numpy as np
import torch.nn as nn
import torch.nn.init as init
import torch.optim as optim

import torch.nn.functional as F
from torch.autograd import Variable

import torchvision.transforms as transforms

from torch.utils.data import DataLoader

from tools.dataset import KiTS19Dataset

import tools.loss as bioloss
import tools.bioutlis as utils

from torch.cuda.amp import GradScaler, autocast

import os
import sys
import math

import shutil

import setproctitle

from functools import reduce
import operator

def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv3d') != -1:
        nn.init.kaiming_normal(m.weight)
        m.bias.data.zero_()

def datestr():
    now = time.gmtime()
    return '{}{:02}{:02}_{:02}{:02}'.format(now.tm_year, now.tm_mon, now.tm_mday, now.tm_hour, now.tm_min)


def save_checkpoint(state, is_best, path, prefix, filename='checkpoint.pth.tar'):
    prefix_save = os.path.join(path, prefix)
    name = prefix_save + '_' + filename
    torch.save(state, name)
    if is_best:
        shutil.copyfile(name, prefix_save + '_model_best.pth.tar')


def inference(args, loader, model, transforms):
    src = args.inference
    dst = args.save

    model.eval()
    nvols = reduce(operator.mul, target_split, 1)
    # assume single GPU / batch size 1
    for data in loader:
        data, series, origin, spacing = data[0]
        shape = data.size()
        # convert names to batch tensor
        if args.cuda:
            data.pin_memory()
            data = data.cuda()
        data = Variable(data, volatile=True)
        output = model(data)
        _, output = output.max(1)
        output = output.view(shape)
        output = output.cpu()
        # merge subvolumes and save
        results = output.chunk(nvols)
        results = map(lambda var : torch.squeeze(var.data).numpy().astype(np.int16), results)
        volume = utils.merge_image([*results], target_split)
        print("save {}".format(series))
        utils.save_updated_image(volume, os.path.join(dst, series + ".mhd"), origin, spacing)

# performing post-train inference:
# train.py --resume <model checkpoint> --i <input directory (*.mhd)> --save <output directory>

def noop(x):
    return x

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--batchSz', type=int, default=1)
    parser.add_argument('--dice', action='store_true')
    parser.add_argument('--ngpu', type=int, default=1)
    parser.add_argument('--nEpochs', type=int, default=300)
    parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
                        help='manual epoch number (useful on restarts)')
    parser.add_argument('--resume', default='', type=str, metavar='PATH',
                        help='path to latest checkpoint (default: none)')
    parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
                        help='evaluate model on validation set')
    parser.add_argument('-i', '--inference', default='', type=str, metavar='PATH',
                        help='run inference on data set and save results')

    # 1e-8 works well for lung masks but seems to prevent
    # rapid learning for nodule masks
    parser.add_argument('--weight-decay', '--wd', default=1e-8, type=float,
                        metavar='W', help='weight decay (default: 1e-8)')
    parser.add_argument('--no-cuda', action='store_true')
    parser.add_argument('--save')
    parser.add_argument('--seed', type=int, default=1)
    parser.add_argument('--opt', type=str, default='adam',
                        choices=('sgd', 'adam', 'rmsprop'))
    args = parser.parse_args()
    best_prec1 = 100.
    args.cuda = not args.no_cuda and torch.cuda.is_available()
    args.save = args.save or 'work/vnet.base.{}'.format(datestr())
    nll = True
    if args.dice:
        nll = False
    weight_decay = args.weight_decay
    setproctitle.setproctitle(args.save)

    torch.manual_seed(args.seed)
    if args.cuda:
        torch.cuda.manual_seed(args.seed)

    print("build vnet")
    model = vnet.VNet(elu=False, nll=nll)
    batch_size = args.ngpu*args.batchSz
    gpu_ids = range(args.ngpu)
    model = nn.parallel.DataParallel(model, device_ids=gpu_ids)

    if args.resume:
        if os.path.isfile(args.resume):
            print("=> loading checkpoint '{}'".format(args.resume))
            checkpoint = torch.load(args.resume)
            args.start_epoch = checkpoint['epoch']
            best_prec1 = checkpoint['best_prec1']
            model.load_state_dict(checkpoint['state_dict'])
            print("=> loaded checkpoint '{}' (epoch {})"
                  .format(args.evaluate, checkpoint['epoch']))
        else:
            print("=> no checkpoint found at '{}'".format(args.resume))
    else:
        model.apply(weights_init)

    if nll:
        train = train_nll
        test = test_nll
        class_balance = True
    else:
        train = train_dice
        test = test_dice
        class_balance = False

    print('  + Number of params: {}'.format(
        sum([p.data.nelement() for p in model.parameters()])))
    if args.cuda:
        model = model.cuda()

    if os.path.exists(args.save):
        shutil.rmtree(args.save)
    os.makedirs(args.save, exist_ok=True)

    # LUNA16 dataset isotropically scaled to 2.5mm^3
    # and then truncated or zero-padded to 160x128x160
    normMu = [-642.794]
    normSigma = [459.512]
    normTransform = transforms.Normalize(normMu, normSigma)

    trainTransform = transforms.Compose([
        transforms.ToTensor(),
        normTransform
    ])
    testTransform = transforms.Compose([
        transforms.ToTensor(),
        normTransform
    ])
    if ct_targets == nodule_masks:
        masks = lung_masks
    else:
        masks = None

    if args.inference != '':
        if not args.resume:
            print("args.resume must be set to do inference")
            exit(1)
        kwargs = {'num_workers': 1} if args.cuda else {}
        src = args.inference
        dst = args.save
        inference_batch_size = args.ngpu
        root = os.path.dirname(src)
        images = os.path.basename(src)
        dataset = KiTS19Dataset(data_dir="\p_data")
        loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, collate_fn=noop, **kwargs)
        inference(args, loader, model, trainTransform)
        return

    kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
    print("loading training set")
    trainSet = KiTS19Dataset(data_dir="\slices")
    trainLoader = DataLoader(trainSet, batch_size=batch_size, shuffle=True, **kwargs)
    print("loading test set")
    testSet = KiTS19Dataset(old=trainSet)
    testSet.test()
    testLoader = DataLoader(testSet,batch_size=batch_size, shuffle=False, **kwargs)

    target_mean = trainSet.target_mean()
    bg_weight = target_mean / (1. + target_mean)
    fg_weight = 1. - bg_weight
    # print(bg_weight)
    class_weights = torch.FloatTensor([bg_weight, fg_weight])


    if args.cuda:
        class_weights = class_weights.cuda()

    if args.opt == 'sgd':
        optimizer = optim.SGD(model.parameters(), lr=1e-1,
                              momentum=0.99, weight_decay=weight_decay)
    elif args.opt == 'adam':
        optimizer = optim.Adam(model.parameters(), weight_decay=weight_decay)
    elif args.opt == 'rmsprop':
        optimizer = optim.RMSprop(model.parameters(), weight_decay=weight_decay)

    trainF = open(os.path.join(args.save, 'train.csv'), 'w')
    testF = open(os.path.join(args.save, 'test.csv'), 'w')
    err_best = 100.
    for epoch in range(1, args.nEpochs + 1):
        adjust_opt(args.opt, optimizer, epoch)
        train(args, epoch, model, trainLoader, optimizer, trainF, class_weights)
        err = test(args, epoch, model, testLoader, optimizer, testF, class_weights)
        is_best = False
        if err < best_prec1:
            is_best = True
            best_prec1 = err
        save_checkpoint({'epoch': epoch,
                         'state_dict': model.state_dict(),
                         'best_prec1': best_prec1},
                        is_best, args.save, "vnet")
        os.system('./plot.py {} {} &'.format(len(trainLoader), args.save))

    trainF.close()
    testF.close()


def train_nll(args, epoch, model, trainLoader, optimizer, trainF, weights):
    model.train()
    nProcessed = 0
    nTrain = len(trainLoader.dataset)
    for batch_idx, (data, target) in enumerate(trainLoader):
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data), Variable(target)
        optimizer.zero_grad()
        output = model(data)
        target = target.view(target.numel())
        loss = F.nll_loss(output, target, weight=weights)
        dice_loss = bioloss.dice_error(output, target)
        # make_graph.save('/tmp/t.dot', loss.creator); assert(False)
        loss.backward()
        optimizer.step()
        nProcessed += len(data)
        pred = output.data.max(1)[1]  # get the index of the max log-probability
        incorrect = pred.ne(target.data).cpu().sum()
        err = 100.*incorrect/target.numel()
        partialEpoch = epoch + batch_idx / len(trainLoader) - 1
        print('Train Epoch: {:.2f} [{}/{} ({:.0f}%)]\tLoss: {:.4f}\tError: {:.3f}\t Dice: {:.6f}'.format(
            partialEpoch, nProcessed, nTrain, 100. * batch_idx / len(trainLoader),
            loss.data[0], err, dice_loss))

        trainF.write('{},{},{}\n'.format(partialEpoch, loss.data[0], err))
        trainF.flush()

def test_nll(args, epoch, model, testLoader, optimizer, testF, weights):
    model.eval()
    test_loss = 0
    dice_loss = 0
    incorrect = 0
    numel = 0
    for data, target in testLoader:
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data, volatile=True), Variable(target)
        target = target.view(target.numel())
        numel += target.numel()
        output = model(data)
        test_loss += F.nll_loss(output, target, weight=weights).data[0]
        dice_loss += bioloss.dice_error(output, target)
        pred = output.data.max(1)[1]  # get the index of the max log-probability
        incorrect += pred.ne(target.data).cpu().sum()

    test_loss /= len(testLoader)  # loss function already averages over batch size
    dice_loss /= len(testLoader)
    err = 100.*incorrect/numel
    print('\nTest set: Average loss: {:.4f}, Error: {}/{} ({:.3f}%) Dice: {:.6f}\n'.format(
        test_loss, incorrect, numel, err, dice_loss))

    testF.write('{},{},{}\n'.format(epoch, test_loss, err))
    testF.flush()
    return err


def train_dice(args, epoch, model, trainLoader, optimizer, trainF, weights):
    model.train()
    nProcessed = 0
    nTrain = len(trainLoader.dataset)
    scaler = GradScaler()

    for batch_idx, (data, target) in enumerate(trainLoader):
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data), Variable(target)

        optimizer.zero_grad()

        with autocast():
            data = data.permute(1, 2, 0, 3, 4)
            target = target.permute(1, 0, 2, 3)

            output = model(data)
            loss = bioloss.dice_loss(output, target)
        make_graph.save('/tmp/t.dot', loss.creator); assert(False)
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()

        nProcessed += len(data)
        err = 100.*(1. - loss.data[0])
        partialEpoch = epoch + batch_idx / len(trainLoader) - 1
        print('Train Epoch: {:.2f} [{}/{} ({:.0f}%)]\tLoss: {:.8f}\tError: {:.8f}'.format(
            partialEpoch, nProcessed, nTrain, 100. * batch_idx / len(trainLoader),
            loss.data[0], err))

        trainF.write('{},{},{}\n'.format(partialEpoch, loss.data[0], err))
        trainF.flush()


def test_dice(args, epoch, model, testLoader, optimizer, testF, weights):
    model.eval()
    test_loss = 0
    incorrect = 0
    scaler = GradScaler()

    with torch.no_grad():
        for data, target in testLoader:
            if args.cuda:
                data, target = data.cuda(), target.cuda()

            with autocast():
                data = data.permute(1, 2, 0, 3, 4)
                target = target.permute(1, 0, 2, 3)

                output = model(data)
                loss = bioloss.dice_loss(output, target)


            test_loss += loss
            incorrect += (1. - loss)

    test_loss /= len(testLoader)  # loss function already averages over batch size
    nTotal = len(testLoader)
    err = 100.*incorrect/nTotal
    print('\nTest set: Average Dice Coeff: {:.4f}, Error: {}/{} ({:.0f}%)\n'.format(
        test_loss, incorrect, nTotal, err))

    testF.write('{},{},{}\n'.format(epoch, test_loss, err))
    testF.flush()
    return err


def adjust_opt(optAlg, optimizer, epoch):
    if optAlg == 'sgd':
        if epoch < 150:
            lr = 1e-1
        elif epoch == 150:
            lr = 1e-2
        elif epoch == 225:
            lr = 1e-3
        else:
            return

        for param_group in optimizer.param_groups:
            param_group['lr'] = lr

# SAMNet Imports
import numpy as np
import torch
import random
import matplotlib.pyplot as plt
import pandas as pd
import joblib

from starter_code.utils import load_case
from segment_anything import sam_model_registry, SamAutomaticMaskGenerator

from keras.models import Sequential, load_model
from keras.layers import Dense, Input
from sklearn.metrics import mean_squared_error as mse
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.model_selection import train_test_split
from keras.callbacks import EarlyStopping

# SAMNet Helper functions

# Changes the format of flat b&w image slices so that they can be processed by SAMnet
def to_rgb(img):
    img_rgb = np.zeros((img.shape[0], img.shape[1], 3), dtype=img.dtype)
    img_rgb[:, :, 0] = img
    img_rgb[:, :, 1] = img
    img_rgb[:, :, 2] = img
    return img_rgb

# Calculate the DICE Score between two images
def dice_coefficient(img1, img2):
    intersection = np.logical_and(img1, img2)
    return (2. * intersection.sum())  / (img1.sum() + img2.sum())

# Given an array, finds the index of the largest element
def find_max(arr):
  highest_index = 0
  for i in range(1, len(arr)):
    if arr[i] > arr[highest_index]:
      highest_index = i
  return highest_index

DEVICE = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
MODEL_TYPE = "vit_h"
CHECKPOINT_PATH = "sam_vit_h_4b8939.pth"
# The "sam_vit_h_4b8939.pth" file must be downloaded from Meta's SAMNet repo;
# https://github.com/facebookresearch/segment-anything/tree/main

ITERATIONS = 200

# Create the automatic mask generator
sam = sam_model_registry[MODEL_TYPE](checkpoint=CHECKPOINT_PATH)
sam.to(device=DEVICE)

mask_generator = SamAutomaticMaskGenerator(sam)

x = np.empty((0, 9))
y = np.empty((0))

# Randomly selected cases and slices were chosen from the allocated training region
# of the dataset. From each slice the characteristics of the masks were fed into an input
# matrix and the corresponding DICE score of the mask fed into an output vector.
for i in range(ITERATIONS):
  print(f"Progress: {i+1}/{ITERATIONS}, ({(i+1)/ITERATIONS}%)")
  case_index = random.randint(0, 159)

  volume, segmentation = load_case("case_00{:03d}".format(case_index))
  volume_data = volume.get_fdata()
  seg_data = segmentation.get_fdata()

  c = 0
  while (c == 0):
      # Load data
      slice_index = random.randint(0, len(volume_data)-1)

      volume_slice = volume_data[slice_index, :, :]
      seg_slice = seg_data[slice_index, :, :]

      # Ensures slice has a kidney in it for training.
      kidney_mask = (seg_slice == 1).astype(np.uint8)
      if not (np.all(kidney_mask == 0)):
          c = 1

  # Convert image to rgb
  vol_rgb = to_rgb(volume_slice)

  # Generate masks
  masks = mask_generator.generate(vol_rgb)

  # Create X matrix for neural net
  for mask in masks:
    mask_data = np.array(mask['segmentation'])
    y = np.append(y, dice_coefficient(kidney_mask, mask_data))

    data = np.array([mask['area'], mask['bbox'][0], mask['bbox'][1], mask['bbox'][2], mask['bbox'][3],
                  mask['predicted_iou'], mask['point_coords'][0][0], mask['point_coords'][0][1], mask['stability_score']])
    x = np.vstack((x, data))

  # np.save('trainingMatrix.npy', x)
  # np.save('trainingTarget.npy', y)

# x = np.load('./trainingMatrix.npy')
# y = np.load('./trainingTarget.npy')

# Create a randomly selected validation set
X_train, X_val, y_train, y_val = train_test_split(
    x, y, random_state=31)

scaler = StandardScaler()
scaler.fit(X_train)

x_sc = scaler.transform(X_train)
x_val_sc = scaler.transform(X_val)

random.seed(31)

model = Sequential([
    Dense(32, activation="leaky_relu"),
    Dense(8, activation="leaky_relu"),
    Dense(1, activation="exponential")
])
model.compile("adam", "mse")

es = EarlyStopping(restore_best_weights=True, patience=35)

%time hist = model.fit(x_sc, y_train, epochs=1_000, \
    callbacks=[es], validation_data=(x_val_sc, y_val))

# Plot a graph of the validation loss over the training
plt.plot(range(1, 181), hist.history["loss"])
plt.xlabel("Epoch")
plt.ylabel("MSE");

# Save the model and scaler to avoid retraining
model.save('/kidney_model.keras')

scaler_filename = "my_scaler.save"
joblib.dump(scaler, scaler_filename)

scaler = joblib.load("my_scaler.save")

x_test = np.empty((0, 9))
imgs = []

# Generate test data from final 50 cases
# Test data includes a numerical matrix (x_test) in addition to the image for each mask paired with its corresponding target kidney mask (imgs)
for i in range(161,209):
  print(f"Case: {i}")

  volume, segmentation = load_case("case_00{:03d}".format(i))
  volume_data = volume.get_fdata()
  seg_data = segmentation.get_fdata()

  for j in range(len(volume_data)):
    print(f"Slice: {j}")
    volume_slice = volume_data[j, :, :]
    seg_slice = seg_data[j, :, :]
    kidney_mask = (seg_slice == 1).astype(np.uint8)

    # Convert image to rgb
    vol_rgb = to_rgb(volume_slice)

    # Generate masks
    masks = mask_generator.generate(vol_rgb)

    # Create X matrix for neural net
    for mask in masks:
      mask_data = np.array(mask['segmentation'])
      img = np.array([mask_data, kidney_mask])
      imgs.append(img)

      data = np.array([mask['area'], mask['bbox'][0], mask['bbox'][1], mask['bbox'][2], mask['bbox'][3],
                    mask['predicted_iou'], mask['point_coords'][0][0], mask['point_coords'][0][1], mask['stability_score']])
      x_test = np.vstack((x_test, data))
      imgs_np = np.stack(imgs)
      # np.save('testMatrix.npy', x_test)
      # np.save('imgMatrix.npy', imgs_np)

# x_test = np.load('./testMatrix.npy')
# imgs_np = np.load('drive/MyDrive/imgMatrix.npy')

model = load_model('./kidney_model.keras')
scaler = joblib.load("my_scaler.save")

# Ensuring test input is preprocessed the same way as training input
x_test_sc = scaler.transform(x_test)

y_pred = np.zeros(len(x_test_sc))
for i in range(len(x_test_sc)):
    x1 = x_test_sc[i]
    x1 = x1.reshape(1, -1)
    y_pred[i] = model.predict(x1, verbose=0)

# Visualise most kidney predicted mask from entire set (252)
v = imgs_np[find_max(y_pred)][0]
plt.figure(figsize=(5, 5))
plt.imshow(v, cmap='gray')
plt.title('Volume Image Slice')
plt.axis('off')
plt.show()

# Group masks by which case/slice they represent
j = 0
slice_index = np.zeros(len(y_pred) - 1)
for i in range(y_pred.shape[0] - 1):
    if i != 0 and not np.array_equal(imgs_np[i][1], imgs_np[i-1][1]):
        j += 1
    slice_index[i] = j

# For each slice, find mask with highest predicted dice score
max_dice = np.zeros((j+1, 2))
for i in range(y_pred.shape[0] - 1):
    if max_dice[int(slice_index[i])][0] < y_pred[i]:
        max_dice[int(slice_index[i])][0] = y_pred[i]
        max_dice[int(slice_index[i])][1] = i

# Determine actual dice score using this mask
one_mask_result = np.zeros(j+1)
for k in range(j+1):
    one_mask_result[k] = dice_coefficient(imgs_np[int(max_dice[k][1])][0], imgs_np[int(max_dice[k][1])][1])

print(np.mean(one_mask_result))

# For each slice, find mask with second highest predicted dice score
max_dice2 = np.zeros((j+1, 2))
for i in range(y_pred.shape[0] - 1):
    if max_dice2[int(slice_index[i])][0] < y_pred[i] and i != max_dice[int(slice_index[i])][1]:
        max_dice2[int(slice_index[i])][0] = y_pred[i]
        max_dice2[int(slice_index[i])][1] = i

# Combine top two masks as there are usually two kidneys (improves accuracy)
two_mask_result = np.zeros(j+1)
for k in range(j+1):
    combined_mask = np.logical_or(imgs_np[int(max_dice[k][1])][0], imgs_np[int(max_dice2[k][1])][0])
    two_mask_result[k] = dice_coefficient(combined_mask, imgs_np[int(max_dice2[k][1])][1])

print(np.mean(two_mask_result))

nnUNetv2_plan_and_preprocess -d 1 --verify_dataset_integrity

#!/bin/bash

# create target directories if they don't exist
mkdir -p ./Dataset001_Kits19/imagesTr
mkdir -p ./Dataset001_Kits19/labelsTr

# all cases
for case_dir in ./data/case_*; do
  # extract the case number. remove leading zeros
  case_num=$(echo "$case_dir" | awk -F'_' '{print $2}' | sed 's/^0*//')

  # pad
  case_num_padded=$(printf "%03d" "$case_num")

  # cp, maybe mv?
  imaging_file="${case_dir}/imaging.nii.gz"
  if [[ -f "$imaging_file" ]]; then
    cp -v "$imaging_file" "./Dataset001_Kits19/imagesTr/imaging_${case_num_padded}_0000.nii.gz"
  else
    echo "error: no img file for: $case_num_padded"
  fi

  # seg file
  segmentation_file="${case_dir}/segmentation.nii.gz"
  if [[ -f "$segmentation_file" ]]; then
    cp -v "$segmentation_file" "./Dataset001_Kits19/labelsTr/imaging_${case_num_padded}.nii.gz"
  else
    echo "no seg files for ya boy: $case_num_padded"
  fi
done

echo "yeehaw"

nnUNetv2_train 1 2d 0

for fold in {0..4}; do nnUNetv2_train 1 2d $fold ; done

with torch.no_grad():
    model.eval()

    for images, masks in test_data:
        images = images.float().to(device)
        masks = masks.squeeze(0).squeeze(0).cpu()

        outputs = model(images)
        print(outputs)
        outputs = outputs.squeeze(0).squeeze(0).cpu()
        outputs[outputs < 0] = 0
        outputs[outputs > 0] = 1
        #outputs = torch.round(torch.sigmoid(outputs))
        #outputs = outputs.squeeze(0).squeeze(0).cpu()
        print(outputs)
        print(masks)
        plt.figure()
        f, axarr = plt.subplots(1, 2)
        axarr[0].imshow(outputs, cmap="gray")
        axarr[1].imshow(masks, cmap="gray")
        break

nnUNetv2_train 1 3d_fullres 0 -tr nnUNetTrainer_250epochs`

Fold	Mean Validation Dice
0	0.73045
1	0.86424
2	0.84887
3	0.80907
4	0.79151

Kidney Segmentation for the KITs19 Challenge¶

Table of Contents¶

1. Introduction¶

2. Data Sources¶

3. Exploratory Analysis¶

Starter Code¶

Visualisations¶

Properties¶

Classes¶

Pre-processing¶

Challenges¶

4. Models and Methods¶

4.1 UNet¶

4.2 VNet¶

4.3 SAMNet¶

4.4 nnU-Net¶

5. Results¶

5.1 UNet¶

5.2 VNet¶

5.3 SAMNet¶

5.4 nnUNet¶

Numbers¶

Intepretation¶

6. Discussion¶

6.1 Dataset¶

6.2 Models¶

6.2.1 UNet¶

6.2.2 VNet¶

6.2.3 SAMNet¶

6.2.4 nnU-Net¶