Giter Club home page Giter Club logo

skm-tea's People

Contributors

ad12 avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar

skm-tea's Issues

Compared to what was written in your article, the pre-trained Unet model provided very poor results.

Hi, I've been training a segmentation network on the SKM-TEA dataset for a while now. I came across your SKM-TEA tutorial Colab notebook which provides a section to perform segmentation using a pre-trained Unet on a slide of MTR201. However, the segmentation results appear to be very poor. I made some changes to the code to process all the slides of MTR201. When I calculated the DSC (Dice Similarity Coefficient) between the predicted and ground truth masks, the results were disappointing.

FEMORAL DICE SCORE = 0.9056336561510854
TIBIAL DICE SCORE = 0.8161735476184412
MENISCUS DICE SCORE = 0.013693482102011822
PATELLA DICE SCORE = 0.00209708260035654

Could you please explain why the results I computed differ from those presented in your article? I would appreciate it if you could provide an explanation.

I computed the Dice Similarity Coefficient (DSC) using the SKM-TEA tutorial notebook with some modifications made in the Segmentation section. The modifications are given below.

def calculate_dice_coefficient(segmentation, ground_truth,epsilon=1e-6):
    intersection = np.sum(segmentation * ground_truth)
    union = np.sum(segmentation) + np.sum(ground_truth)
    return ((2. * intersection)+epsilon) / (union + epsilon)
    
    return np.mean((numerator + epsilon) / (denominator + epsilon)) # average over classes and batch
def keep_ya_head_up(source,one):
    one = one + 2
    the = source.copy() + 2
    the[the == one] = 1
    the[the != 1] = 0
    return the

# DICOM data + segmentation
image_file = scan["image_file"]
with h5py.File(image_file, "r") as f:
    echo1 = f["echo1"][()]  # Shape: (x, y, z)
    segmentation = f["seg"][()]  # Shape: (x, y, z, #classes)

echo1 = torch.as_tensor(echo1).unsqueeze(0).unsqueeze(0).float()  # Shape: (B, C, H, W)
gt_seg_sl = segmentation
gt_seg_sl = collect_mask(gt_seg_sl, (0, 1, (2, 3), (4, 5)), out_channel_first=False)
gt_seg_sl = oF.one_hot_to_categorical(gt_seg_sl, channel_dim=-1)
save_nif=np.zeros((512, 512,0))
with torch.no_grad():
    for x in range(160):
        print(x)
        echo1_sl = echo1[..., x]
        logits = model({"image": echo1_sl})["sem_seg_logits"]
        save_nif=np.concatenate((save_nif,oF.pred_to_categorical(logits, activation='sigmoid').cpu().data.numpy()[0][...,np.newaxis]),axis=2)
groundtruth_nif=gt_seg_sl

background = keep_ya_head_up(save_nif,0)
femoral = keep_ya_head_up(save_nif,1)
tibial = keep_ya_head_up(save_nif,2)
meniscus = keep_ya_head_up(save_nif,3)
patella = keep_ya_head_up(save_nif,4)

background_gt = keep_ya_head_up(groundtruth_nif,0)
femoral_gt = keep_ya_head_up(groundtruth_nif,1)
tibial_gt = keep_ya_head_up(groundtruth_nif,2)
meniscus_gt = keep_ya_head_up(groundtruth_nif,3)
patella_gt = keep_ya_head_up(groundtruth_nif,4)

bgds=calculate_dice_coefficient(background,background_gt)
fds=calculate_dice_coefficient(femoral,femoral_gt)
tds=calculate_dice_coefficient(tibial,tibial_gt)
mds=calculate_dice_coefficient(meniscus,meniscus_gt)
pds=calculate_dice_coefficient(patella,patella_gt)
superds=(fds+tds+mds+pds)/4
    
print("BACKGROUND=DICE=SCORE","=",str(bgds))
print("FEMORAL=DICE=SCORE","=",str(fds))
print("TIBIAL=DICE=SCORE","=",str(tds))
print("MENISCUS=DICE=SCORE","=",str(mds))
print("PATELLA=DICE=SCORE","=",str(pds))
print("SUPER=DICE=SCORE","=",str(superds))

Code is not compatible with newest version of pytorch-lightning (1.8.0)

When creating a new conda environment and installing the skm-tea package using pip install skm-tea, importing the package returns an error caused by the pytorch-lightning package:

>>> import skm_tea as skm
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/mnt/qb/envs/.conda/envs/skm2/lib/python3.9/site-packages/skm_tea/__init__.py", line 1, in <module>
    from skm_tea.engine.model_zoo import get_model_from_zoo  # noqa: F401
  File "/mnt/qb/envs/.conda/envs/skm2/lib/python3.9/site-packages/skm_tea/engine/__init__.py", line 1, in <module>
    from skm_tea.engine import defaults, model_zoo, modules, trainer  # noqa: F401
  File "/mnt/qb/envs/.conda/envs/skm2/lib/python3.9/site-packages/skm_tea/engine/model_zoo.py", line 10, in <module>
    from skm_tea.engine.modules import SkmTeaModule, SkmTeaSemSegModule
  File "/mnt/qb/envs/.conda/envs/skm2/lib/python3.9/site-packages/skm_tea/engine/modules/__init__.py", line 3, in <module>
    from skm_tea.engine.modules import base, module, recon
  File "/mnt/qb/envs/.conda/envs/skm2/lib/python3.9/site-packages/skm_tea/engine/modules/base.py", line 18, in <module>
    from skm_tea.engine.trainer import convert_cfg_time_to_iter
  File "/mnt/qb/envs/.conda/envs/skm2/lib/python3.9/site-packages/skm_tea/engine/trainer.py", line 13, in <module>
    from pytorch_lightning.utilities.distributed import rank_zero_only
ImportError: cannot import name 'rank_zero_only' from 'pytorch_lightning.utilities.distributed' (/mnt/qb/envs/.conda/envs/skm2/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py)

Correcting this issue yields other issues related to the updated pytorch-lightning package (like the removed LoggerCollection with the recent update https://pytorch-lightning.readthedocs.io/en/stable/generated/CHANGELOG.html).

These errors can be avoided by installing the pytorch-lightning version 1.7.7. The requirements.txt file might need to be adjusted, such that pytorch-lightning < 1.8 is installed.

data transform precompute masks function gets stuck in loop forever at 433 it

You can use the below code to reproduce it.

import os
os.environ["MEDDLR_DATASETS_DIR"] = "/mnt/datadir"

import sys 
sys.path.insert(0, './skm-teacode/')

from meddlr.data.transforms.subsample import build_mask_func
from skm_tea.data.transform import qDESSDataTransform

from meddlr.config import get_cfg

cfg = get_cfg()
cfg.merge_from_file('./skm-teacode/configs/baselines-neurips/raw-data-track/recon/unet.yaml')  ###
cfg.format_fields(unroll=True)
cfg.freeze()

mask_func_kwargs = (
    {"module": "sigpy"} # if cfg.AUG_TRAIN.UNDERSAMPLE.NAME == "PoissonDiskMaskFunc" else {}
)
mask_func = build_mask_func(cfg.AUG_TRAIN, **mask_func_kwargs)
data_transform = qDESSDataTransform(cfg, mask_func=mask_func, is_test=False)
print('precomputing the masks')
data_transform._subsampler.precompute_masks(
                acq_shapes={(416, 80), (416, 88), (416, 72)},
                N=100000,
                accelerations=8, # ADDED 
                seed=123,
                cache='./check_precomp_masks/',
                num_workers=0
                )

download the dataset

Hello, thank you for your valuable work.
I am trying to download the dataset but since we have a limited resources so I just want to download the dicom image for dicom track. I see that you enable for download the dicom image only for dicom track (which is around 16gb). However for segmentation mask, I see that there is no way to download except for download around 300 files manually.
Can you enable download all segmenation mask at the same time?
Thank you

k-space data undersampled or (synthesized) unsampled?

Hi @ad12 , thanks for such a great contribution to our community.

I have two minor questions about the k-space data:

  1. the y direction is under-sampled, while the paper suggests that 'unsampled k-space data was subsequently synthesized using Autocalibrating Reconstruction for Cartesian imaging (ARC)'
  2. according to the appendix, the size of the readout direction is 416 and padded to 512. However, the k-space data does not have zero elements near the edge.

Not sure if these questions are just features of the Orchestra toolbox. Thanks in advance!

Process Group Did Not Initialized when Multi-GPU Training

I tried to run the code by tools/train_net.py script, with the config configs/baselines-neurips/dicom-track/seg/unet.yaml. Since I don't have one GPU with 24GB+ VRAM, I tried to run the code on 2 GPUs with 12GB VRAM each.

I set the argument --num-gpus=2 when starting the program. But I got an error about "process group not initialized" when the program ran to build_sampler.

sampler, is_batch_sampler = build_train_sampler(cfg, dataset, distributed=use_ddp)

Here is the trace stack.

Traceback (most recent call last):
  ...(ignore debugger stack)
  File "/path/to/skm-tea/tools/train_net.py", line 139, in <module>
    main(args)
  File "/path/to/skm-tea/tools/train_net.py", line 99, in main
    model = pl_module(cfg, num_parallel=num_gpus, eval_on_cpu=args.eval_on_cpu)
  File "/path/to/skm-tea/skm_tea/engine/modules/module.py", line 243, in __init__
    super().__init__(cfg, num_parallel, eval_on_cpu=eval_on_cpu, **kwargs)
  File "/path/to/skm-tea/skm_tea/engine/modules/module.py", line 38, in __init__
    super().__init__(
  File "/path/to/skm-tea/skm_tea/engine/modules/base.py", line 56, in __init__
    data_loader = self.train_dataloader(cfg)
  File "/path/to/skm-tea/skm_tea/engine/modules/module.py", line 60, in train_dataloader
    return datamodule.train_dataloader(cfg, self.distributed)
  File "/path/to/skm-tea/skm_tea/data/data_module.py", line 78, in train_dataloader
    sampler, is_batch_sampler = build_train_sampler(cfg, dataset, distributed=use_ddp)
  File "/home/junru/miniconda3/envs/pytorch/lib/python3.10/site-packages/meddlr/data/samplers/build.py", line 63, in build_train_sampler
    sampler = DistributedSampler(dataset, shuffle=True) if distributed else None
  File "/home/junru/miniconda3/envs/pytorch/lib/python3.10/site-packages/torch/utils/data/distributed.py", line 67, in __init__
    num_replicas = dist.get_world_size()
  File "/home/junru/miniconda3/envs/pytorch/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py", line 867, in get_world_size
    return _get_group_size(group)
  File "/home/junru/miniconda3/envs/pytorch/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py", line 325, in _get_group_size
    default_pg = _get_default_group()
  File "/home/junru/miniconda3/envs/pytorch/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py", line 429, in _get_default_group
    raise RuntimeError(
RuntimeError: Default process group has not been initialized, please make sure to call init_process_group.

To be clear, I changed many lines from the source code to skip some exceptions that I believe come from the API change. They are about logging and profiling. I think those changes should not relate to multiprocessing.

My environment and configuration dump is,

[09/19 15:07:11] skm_tea INFO: Running with pytorch lightning
[09/19 15:07:11] skm_tea INFO: Rank of current process: 0. World size: 1
[09/19 15:07:13] skm_tea INFO: Environment info:
----------------------  ------------------------------------------------------------------------------------
sys.platform            linux
Python                  3.10.4 (main, Mar 31 2022, 08:41:55) [GCC 7.5.0]
numpy                   1.22.0
PyTorch                 1.12.1 @/home/junru/miniconda3/envs/pytorch/lib/python3.10/site-packages/torch
PyTorch debug build     False
CUDA available          True
GPU 0                   NVIDIA TITAN Xp
GPU 1                   Quadro M6000
CUDA_HOME               /usr/local/cuda
NVCC                    Build cuda_11.7.r11.7/compiler.31442593_0
Pillow                  9.2.0
torchvision             0.13.1 @/home/junru/miniconda3/envs/pytorch/lib/python3.10/site-packages/torchvision
torchvision arch flags  sm_35, sm_50, sm_60, sm_70, sm_75, sm_80, sm_86
SLURM_JOB_ID            slurm not detected
cv2                     4.5.5
----------------------  ------------------------------------------------------------------------------------
PyTorch built with:
  - GCC 9.3
  - C++ Version: 201402
  - Intel(R) oneAPI Math Kernel Library Version 2021.4-Product Build 20210904 for Intel(R) 64 architecture applications
  - Intel(R) MKL-DNN v2.6.0 (Git Hash 52b5f107dd9cf10910aaa19cb47f3abf9b349815)
  - OpenMP 201511 (a.k.a. OpenMP 4.5)
  - LAPACK is enabled (usually provided by MKL)
  - NNPACK is enabled
  - CPU capability usage: AVX2
  - CUDA Runtime 11.3
  - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_61,code=sm_61;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_37,code=compute_37
  - CuDNN 8.3.2  (built against CUDA 11.5)
  - Magma 2.5.2
  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.3, CUDNN_VERSION=8.3.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -fabi-version=11 -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_KINETO -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -DEDGE_PROFILER_USE_KINETO -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_VERSION=1.12.1, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=OFF, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, 

And the full config from the log file is,

# Config for U-Net as implemented in MedSegPy.
# Implementation based on:
#   - Desai et al. Technical considerations for semantic segmentation in MRI. ArXiv 2019.
#   - Desai et al. "Deep learning for medical image segmentation". MICCAI 2018.
MODEL:
  TASKS: ("sem_seg",)
  PARAMETERS:
    INIT:
    - 
      kind: "conv"
      patterns: (".*weight", ".*bias")
      initializers: (("kaiming_normal_", {"nonlinearity":"relu"}), "zeros_")
    - 
      kind: "norm"
      patterns: (".*weight", ".*bias")
      initializers: ("ones_", "zeros_")
    -
      patterns: ("output_block\.weight",)
      initializers: ("xavier_uniform_",)
  META_ARCHITECTURE: "GeneralizedUNet"
  UNET:
    CHANNELS: 32
    NUM_POOL_LAYERS: 5
    DROPOUT: 0.0
    BLOCK_ORDER: ("conv", "relu", "conv", "relu", "bn")
  SEG:
    LOSS_NAME: "FlattenedDiceLoss"
    CLASSES: ("pc", "fc", "men", "tc")
DATASETS:
  TRAIN: ("skmtea_v1_train",)
  VAL: ("skmtea_v1_val",)
  TEST: ("skmtea_v1_test",)
  QDESS:
    ECHO_KIND: "echo1"  # This must be specified - one of ("echo1", "echo2", "echo1-echo2-mc", "rss")
    DATASET_TYPE: "qDESSImageDataset"
    KWARGS: ("orientation", "sagittal")
DATALOADER:
  NUM_WORKERS: 8
  GROUP_SAMPLER:
    BATCH_BY: ("inplane_shape",)
    AS_BATCH_SAMPLER: True
SOLVER:
  OPTIMIZER: "Adam"
  LR_SCHEDULER_NAME: "StepLR"
  GAMMA: 0.9
  STEPS: (2,)  # drop by 0.9x every 2 epochs
  BASE_LR: 1e-3
  MIN_LR: 1e-8
  TRAIN_BATCH_SIZE: 16
  TEST_BATCH_SIZE: 16
  MAX_ITER: 100
  WEIGHT_DECAY: 0.
  CHECKPOINT_PERIOD: 1
  EARLY_STOPPING:
    MONITOR: "val_loss"
    PATIENCE: 12
    MIN_DELTA: 1e-5
DESCRIPTION:
  BRIEF: f"UNet segmentation following parameters used in MedSegPy - input={DATASETS.QDESS.ECHO_KIND}, {SOLVER.MAX_ITER} epochs, {SOLVER.BASE_LR} lr w/ {SOLVER.GAMMA}x decay every {SOLVER.STEPS} epochs, early stopping- T={SOLVER.EARLY_STOPPING.PATIENCE}, delta={SOLVER.EARLY_STOPPING.MIN_DELTA}, bsz={SOLVER.TRAIN_BATCH_SIZE}, qdess args={DATASETS.QDESS.KWARGS}"
  PROJECT_NAME: "skm-tea"
  ENTITY_NAME: "billzhonggz"
  EXP_NAME: f"seg-baseline/unet-medsegpy-{DATASETS.QDESS.ECHO_KIND}-seed={SEED}"
  TAGS: ("seg-baseline", "baseline", "unet-medsegpy", "neurips")
TEST:
  EVAL_PERIOD: 1
  VAL_METRICS:
    SEM_SEG: ("DSC","VOE","CV","DSC_scan","VOE_scan","CV_scan")
  FLUSH_PERIOD: -5
VIS_PERIOD: -100
TIME_SCALE: "epoch"
OUTPUT_DIR: f"results://skm-tea/seg-baseline/unet-{DATASETS.QDESS.ECHO_KIND}-seed={SEED}"
SEED: 9001
VERSION: 1

[09/19 15:07:13] skm_tea INFO: Running with full config:

AUG_TEST:
  UNDERSAMPLE:
    ACCELERATIONS: (6,)
AUG_TRAIN:
  NOISE_P: 0.2
  UNDERSAMPLE:
    ACCELERATIONS: (6,)
    CALIBRATION_SIZE: 24
    CENTER_FRACTIONS: ()
    MAX_ATTEMPTS: 5
    NAME: PoissonDiskMaskFunc
    PRECOMPUTE:
      NUM: -1
      SEED: -1
      USE_MULTIPROCESSING: False
  USE_NOISE: False
CUDNN_BENCHMARK: False
DATALOADER:
  ALT_SAMPLER:
    PERIOD_SUPERVISED: 1
    PERIOD_UNSUPERVISED: 1
  DATA_KEYS: ()
  DROP_LAST: True
  FILTER:
    BY: ()
  GROUP_SAMPLER:
    AS_BATCH_SAMPLER: True
    BATCH_BY: ('inplane_shape',)
  NUM_WORKERS: 8
  PREFETCH_FACTOR: 2
  SAMPLER_TRAIN: 
  SUBSAMPLE_TRAIN:
    NUM_TOTAL: -1
    NUM_TOTAL_BY_GROUP: ()
    NUM_UNDERSAMPLED: 0
    NUM_VAL: -1
    NUM_VAL_BY_GROUP: ()
    SEED: 1000
DATASETS:
  QDESS:
    DATASET_TYPE: qDESSImageDataset
    ECHO_KIND: echo1
    KWARGS: ('orientation', 'sagittal')
  TEST: ('skmtea_v1_test',)
  TRAIN: ('skmtea_v1_train',)
  VAL: ('skmtea_v1_val',)
DESCRIPTION:
  BRIEF: UNet segmentation following parameters used in MedSegPy - input=echo1, 100 epochs, 0.001 lr w/ 0.9x decay every 2 epochs, early stopping- T=12, delta=1e-05, bsz=16, qdess args=orientation-sagittal
  ENTITY_NAME: billzhonggz
  EXP_NAME: seg-baseline/unet-medsegpy-echo1-seed=9001
  PROJECT_NAME: skm-tea
  TAGS: ('seg-baseline', 'baseline', 'unet-medsegpy', 'neurips')
MODEL:
  CASCADE:
    ITFS:
      PERIOD: 0
    RECON_MODEL_NAME: 
    SEG_MODEL_NAME: 
    SEG_NORMALIZE: 
    USE_MAGNITUDE: False
    ZERO_FILL: False
  CS:
    MAX_ITER: 200
    REGULARIZATION: 0.005
  DENOISING:
    META_ARCHITECTURE: GeneralizedUnrolledCNN
    NOISE:
      STD_DEV: (1,)
      USE_FULLY_SAMPLED_TARGET: True
      USE_FULLY_SAMPLED_TARGET_EVAL: None
  DEVICE: cuda
  META_ARCHITECTURE: GeneralizedUNet
  N2R:
    META_ARCHITECTURE: GeneralizedUnrolledCNN
    USE_SUPERVISED_CONSISTENCY: False
  NORMALIZER:
    KEYWORDS: ()
    NAME: TopMagnitudeNormalizer
  PARAMETERS:
    INIT: ({'kind': 'conv', 'patterns': '(".*weight", ".*bias")', 'initializers': '(("kaiming_normal_", {"nonlinearity":"relu"}), "zeros_")'}, {'kind': 'norm', 'patterns': '(".*weight", ".*bias")', 'initializers': '("ones_", "zeros_")'}, {'patterns': '("output_block\\.weight",)', 'initializers': '("xavier_uniform_",)'})
    USE_COMPLEX_WEIGHTS: False
  RECON_LOSS:
    NAME: l1
    RENORMALIZE_DATA: True
    WEIGHT: 1.0
  SEG:
    ACTIVATION: sigmoid
    CLASSES: ('pc', 'fc', 'men', 'tc')
    INCLUDE_BACKGROUND: False
    IN_CHANNELS: None
    LOSS_NAME: FlattenedDiceLoss
    LOSS_WEIGHT: 1.0
    MODEL:
      DYNUNET_MONAI:
        DEEP_SUPERVISION: False
        DEEP_SUPR_NUM: 1
        KERNEL_SIZE: (3,)
        NORM_NAME: instance
        RES_BLOCK: False
        STRIDES: (1,)
        UPSAMPLE_KERNEL_SIZE: (2,)
      UNET_MONAI:
        ACTIVATION: ('prelu', {})
        CHANNELS: ()
        DROPOUT: 0.0
        KERNEL_SIZE: (3,)
        NORM: ('instance', {})
        NUM_RES_UNITS: 0
        STRIDES: ()
        UP_KERNEL_SIZE: (3,)
      VNET_MONAI:
        ACTIVATION: ('elu', {'inplace': True})
        DROPOUT_DIM: 2
        DROPOUT_PROB: 0.5
    USE_MAGNITUDE: True
  TASKS: ('sem_seg',)
  TB_RECON:
    CHANNELS: (16, 32, 64)
    DEC_NUM_CONV_BLOCKS: (2, 3)
    ENC_NUM_CONV_BLOCKS: (1, 2, 3)
    KERNEL_SIZE: (5,)
    MULTI_CONCAT: ()
    ORDER: ('conv', 'relu')
    STRIDES: (2,)
    USE_MAGNITUDE: False
  UNET:
    BLOCK_ORDER: ('conv', 'relu', 'conv', 'relu', 'bn')
    CHANNELS: 32
    DROPOUT: 0.0
    IN_CHANNELS: 2
    NORMALIZE: False
    NUM_POOL_LAYERS: 5
    OUT_CHANNELS: 2
  UNROLLED:
    BLOCK_ARCHITECTURE: ResNet
    CONV_BLOCK:
      ACTIVATION: relu
      NORM: none
      NORM_AFFINE: False
      ORDER: ('norm', 'act', 'drop', 'conv')
    DROPOUT: 0.0
    FIX_STEP_SIZE: False
    KERNEL_SIZE: (3,)
    NUM_EMAPS: 1
    NUM_FEATURES: 256
    NUM_RESBLOCKS: 2
    NUM_UNROLLED_STEPS: 5
    PADDING: 
    SHARE_WEIGHTS: False
    STEP_SIZES: (-2.0,)
  WEIGHTS: 
OUTPUT_DIR: ./results/skm-tea/seg-baseline/unet-echo1-seed=9001/version_001
SEED: 9001
SOLVER:
  BASE_LR: 0.001
  BIAS_LR_FACTOR: 1.0
  CHECKPOINT_MONITOR: val_loss
  CHECKPOINT_PERIOD: 1
  EARLY_STOPPING:
    MIN_DELTA: 1e-05
    MONITOR: val_loss
    PATIENCE: 12
  GAMMA: 0.9
  GRAD_ACCUM_ITERS: 1
  LR_SCHEDULER_NAME: StepLR
  MAX_ITER: 100
  MIN_LR: 1e-08
  MOMENTUM: 0.9
  OPTIMIZER: Adam
  STEPS: (2,)
  TEST_BATCH_SIZE: 16
  TRAIN_BATCH_SIZE: 16
  WARMUP_FACTOR: 0.001
  WARMUP_ITERS: 1000
  WARMUP_METHOD: linear
  WEIGHT_DECAY: 0.0
  WEIGHT_DECAY_BIAS: 0.0001
  WEIGHT_DECAY_NORM: 0.0
TEST:
  EVAL_PERIOD: 1
  EXPECTED_RESULTS: []
  FLUSH_PERIOD: -5
  QDESS_EVALUATOR:
    ADDITIONAL_PATHS: ()
  VAL_METRICS:
    RECON: ()
    SEM_SEG: ('DSC', 'VOE', 'CV', 'DSC_scan', 'VOE_scan', 'CV_scan')
TIME_SCALE: epoch
VERSION: 1
VIS_PERIOD: -100

I did some study on the source code of this repository and meddlr. To my understanding, the process group should be initialized in skm_tea/engine/modules/base.py file. But I saw many TODOs in this file about multiprocessing.

I am trying hard to fix the bug by adding init_process_group() to the file mentioned above. Would you also investigate the issue or suggest me to build an environment that guarantee to work?

T2 map

Did you provide the T2 maps calculated from ground-truth E1 and E2 ?

Thank you

Dataset access

Hi!
Is it possible to access the SKM-TEA dataset? I cannot find the link in the paper or in the repository.
Thanks!

How to predict the segmentation result of a volume

Hi, I am very interested in segmentation of skm-tea. But I have two questions. After loading a DICOM data and the weights of a model, what should be done with the data before it is sent to the network? And how to send the data into the network to predict the mask of the data? Is there an example to show the process?

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.