Add files using upload-large-folder tool

source_code/SegMamba/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

source_code/SegMamba/0_inference.py

@@ -0,0 +1,20 @@
+
+
+import torch 
+from model_segmamba.segmamba import SegMamba
+
+t1 = torch.rand(1, 4, 128, 128, 128).cuda()
+
+
+model = SegMamba(in_chans=4,
+                 out_chans=4,
+                 depths=[2,2,2,2],
+                 feat_size=[48, 96, 192, 384]).cuda()
+
+out = model(t1)
+
+print(out.shape)
+
+
+
+

source_code/SegMamba/1_rename_mri_data.py

@@ -0,0 +1,47 @@
+
+
+
+import os 
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Rename BraTS2023 case files to short names (t1c/t1n/t2f/t2w/seg.nii.gz)."
+    )
+    parser.add_argument(
+        "--data_dir",
+        type=str,
+        default="./data/raw_data/BraTS2023/ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData/",
+        help="BraTS2023 directory that contains case folders.",
+    )
+    args = parser.parse_args()
+
+    data_dir = args.data_dir
+    if not os.path.isdir(data_dir):
+        raise FileNotFoundError(f"data_dir not found: {data_dir}")
+
+    all_cases = sorted(os.listdir(data_dir))
+    for case_name in all_cases:
+        case_dir = os.path.join(data_dir, case_name)
+        if not os.path.isdir(case_dir):
+            continue
+
+        for data_name in os.listdir(case_dir):
+            if "-" not in data_name:
+                continue
+
+            new_name = data_name.split("-")[-1]
+            new_path = os.path.join(case_dir, new_name)
+            old_path = os.path.join(case_dir, data_name)
+
+            if os.path.exists(new_path):
+                # already renamed (or conflict). Skip to be safe.
+                continue
+
+            os.rename(old_path, new_path)
+            print(f"{new_path} 命名成功")
+
+
+if __name__ == "__main__":
+    main()

source_code/SegMamba/2_preprocessing_mri.py

@@ -0,0 +1,85 @@
+
+from light_training.preprocessing.preprocessors.preprocessor_mri import MultiModalityPreprocessor 
+import argparse
+
+data_filename = ["t2w.nii.gz",
+                 "t2f.nii.gz",
+                 "t1n.nii.gz",
+                 "t1c.nii.gz"]
+seg_filename = "seg.nii.gz"
+
+def _parse_spacing(s: str):
+    parts = [p.strip() for p in s.split(",") if p.strip()]
+    if len(parts) != 3:
+        raise ValueError(f"output_spacing should be like '1,1,1', got: {s}")
+    return [float(parts[0]), float(parts[1]), float(parts[2])]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="BraTS2023 preprocessing (resample/normalization/cropping).")
+    parser.add_argument(
+        "--base_dir",
+        type=str,
+        default="./data/raw_data/BraTS2023/",
+        help="Base directory that contains the BraTS2023 image_dir folder.",
+    )
+    parser.add_argument(
+        "--image_dir",
+        type=str,
+        default="ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData",
+        help="Folder name under base_dir.",
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="./data/fullres/train/",
+        help="Output directory for preprocessed npz/npy/pkl files.",
+    )
+    parser.add_argument(
+        "--output_spacing",
+        type=str,
+        default="1,1,1",
+        help="Target spacing, e.g. '1,1,1'.",
+    )
+    parser.add_argument(
+        "--num_processes",
+        type=int,
+        default=8,
+        help="Number of worker processes for preprocessing.",
+    )
+    parser.add_argument(
+        "--only_plan",
+        action="store_true",
+        help="Only run planning (statistics) and exit.",
+    )
+    parser.add_argument(
+        "--skip_plan",
+        action="store_true",
+        help="Skip planning step.",
+    )
+    args = parser.parse_args()
+
+    preprocessor = MultiModalityPreprocessor(
+        base_dir=args.base_dir,
+        image_dir=args.image_dir,
+        data_filenames=data_filename,
+        seg_filename=seg_filename,
+    )
+
+    if not args.skip_plan:
+        preprocessor.run_plan()
+        if args.only_plan:
+            return
+
+    out_spacing = _parse_spacing(args.output_spacing)
+    preprocessor.run(
+        output_spacing=out_spacing,
+        output_dir=args.output_dir,
+        all_labels=[1, 2, 3],
+        num_processes=args.num_processes,
+    )
+
+
+if __name__ == "__main__":
+    main()
+

source_code/SegMamba/3_train.py

@@ -0,0 +1,225 @@
+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):
+        ## TC, WT and ET
+        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
+    # allow special modes used by Trainer.get_multi_processor_loader
+    # e.g. nomirror / onlymirror / onlyspatial
+    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)
+    # torchrun launcher will append this; ignore it here (Trainer will read it too)
+    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()

source_code/SegMamba/4_predict.py

@@ -0,0 +1,261 @@
+import argparse
+import glob
+import os
+import re
+import sys
+
+import numpy as np
+import torch
+import SimpleITK as sitk
+
+# Prefer pip-installed MONAI over the local monai/ folder.
+os.environ.setdefault("MONAI_SKIP_SUBMODULES", "1")
+_repo_root = os.path.abspath(os.path.dirname(__file__))
+if "" in sys.path:
+    sys.path.remove("")
+if _repo_root in sys.path:
+    sys.path.remove(_repo_root)
+import monai  # noqa: E402
+sys.path.insert(0, _repo_root)
+
+from monai.inferers import SlidingWindowInferer
+from monai.utils import set_determinism
+
+from light_training.dataloading.dataset import MedicalDataset, get_train_val_test_loader_from_train
+from light_training.evaluation.metric import dice
+from light_training.prediction import Predictor
+from light_training.trainer import Trainer
+
+set_determinism(123)
+
+
+def _parse_csv_ints(s: str, n: int):
+    parts = [p.strip() for p in str(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_csv_floats(s: str, n: int):
+    parts = [p.strip() for p in str(s).split(",") if p.strip()]
+    if len(parts) != n:
+        raise ValueError(f"expect {n} floats like '1,1,1', got: {s}")
+    return [float(x) for x in parts]
+
+
+def _find_ckpt_from_logdir(logdir: str, prefer: str = "best") -> str:
+    model_dir = os.path.join(logdir, "model")
+    if not os.path.isdir(model_dir):
+        raise FileNotFoundError(f"model dir not found: {model_dir}")
+
+    best = sorted(glob.glob(os.path.join(model_dir, "best_model_*.pt")))
+    final = sorted(glob.glob(os.path.join(model_dir, "final_model_*.pt")))
+    tmp = sorted(glob.glob(os.path.join(model_dir, "tmp_model_ep*.pt")))
+    any_pt = sorted(glob.glob(os.path.join(model_dir, "*.pt")))
+
+    def pick_by_score(paths):
+        # filenames like best_model_0.9038.pt / final_model_0.9038.pt
+        scored = []
+        for p in paths:
+            m = re.search(r"_(\d+\\.?\\d*)\\.pt$", os.path.basename(p))
+            if m is None:
+                continue
+            try:
+                scored.append((float(m.group(1)), p))
+            except ValueError:
+                continue
+        if scored:
+            scored.sort(key=lambda x: x[0], reverse=True)
+            return scored[0][1]
+        return None
+
+    if prefer == "best":
+        picked = pick_by_score(best) or (best[-1] if best else None)
+        if picked:
+            return picked
+    if prefer in {"best", "final"}:
+        picked = pick_by_score(final) or (final[-1] if final else None)
+        if picked:
+            return picked
+    if prefer in {"best", "final", "latest"}:
+        if tmp:
+            tmp.sort(key=lambda p: os.path.getmtime(p), reverse=True)
+            return tmp[0]
+        if any_pt:
+            any_pt.sort(key=lambda p: os.path.getmtime(p), reverse=True)
+            return any_pt[0]
+
+    raise FileNotFoundError(f"no checkpoint found under: {model_dir}")
+
+
+class BraTSTrainer(Trainer):
+    def __init__(
+        self,
+        ckpt_path: str,
+        save_path: str,
+        patch_size,
+        sw_batch_size: int = 2,
+        overlap: float = 0.5,
+        mirror_axes=(0, 1, 2),
+        raw_spacing=(1.0, 1.0, 1.0),
+        device="cuda:0",
+        print_dice: bool = False,
+    ):
+        super().__init__(
+            env_type="pytorch",
+            max_epochs=1,
+            batch_size=1,
+            device=device,
+            val_every=1,
+            num_gpus=1,
+            logdir="",
+            master_port=17751,
+            training_script=__file__,
+        )
+
+        self.patch_size = patch_size
+        self.augmentation = False
+        self.print_dice = print_dice
+        self.save_path = save_path
+        self.raw_spacing = raw_spacing
+
+        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.load_state_dict(ckpt_path, strict=True)
+        self.model.eval()
+
+        window_infer = SlidingWindowInferer(
+            roi_size=patch_size,
+            sw_batch_size=sw_batch_size,
+            overlap=overlap,
+            progress=True,
+            mode="gaussian",
+        )
+
+        self.predictor = Predictor(
+            window_infer=window_infer,
+            mirror_axes=list(mirror_axes) if mirror_axes is not None else None,
+        )
+
+        os.makedirs(self.save_path, exist_ok=True)
+    
+    def convert_labels(self, labels):
+        ## TC, WT and ET
+        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"]
+        properties = batch["properties"]
+        label = self.convert_labels(label)
+
+        return image, label, properties 
+    
+    def validation_step(self, batch):
+        image, label, properties = self.get_input(batch)
+        # The preprocessed datasets used in many setups (including /data/yty/brats23_processed)
+        # do NOT contain cropping/resample metadata (shape_before_cropping, bbox_used_for_cropping, ...),
+        # so we directly save predictions in the same (D,H,W) space as the inputs.
+        #
+        # We save as a TRUE 4D NIfTI (t,z,y,x) with t=3 (TC/WT/ET) so that
+        # `sitk.GetArrayFromImage` returns shape (3, D, H, W), matching `5_compute_metrics.py`.
+
+        logits = self.predictor.maybe_mirror_and_predict(image, self.model, device=self.device)  # (1,4,D,H,W) on CPU
+        pred_lbl = logits.argmax(dim=1)  # (1,D,H,W)
+        pred_3c = self.convert_labels(pred_lbl[:, None])[0].cpu().numpy().astype(np.uint8)  # (3,D,H,W)
+
+        if self.print_dice:
+            gt_3c = label[0].cpu().numpy()
+            dices = [dice(pred_3c[i], gt_3c[i]) for i in range(3)]
+            print(dices)
+
+        case_name = properties.get("name", "")
+        if isinstance(case_name, (list, tuple)) and len(case_name) > 0:
+            case_name = case_name[0]
+
+        out_path = os.path.join(self.save_path, f"{case_name}.nii.gz")
+        pred_itk = sitk.GetImageFromArray(pred_3c, isVector=False)
+        pred_itk.SetSpacing((float(self.raw_spacing[0]), float(self.raw_spacing[1]), float(self.raw_spacing[2]), 1.0))
+        sitk.WriteImage(pred_itk, out_path)
+        print(f"saved: {out_path}")
+        
+        return 0
+
+    def convert_labels_dim0(self, labels):
+        ## TC, WT and ET
+        result = [(labels == 1) | (labels == 3), (labels == 1) | (labels == 3) | (labels == 2), labels == 3]
+        
+        return torch.cat(result, dim=0).float()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="SegMamba inference/prediction for BraTS2023.")
+    parser.add_argument("--data_dir", type=str, default="./data/fullres/train", help="Preprocessed data directory (contains *.npz).")
+    parser.add_argument("--split", type=str, default="test", choices=["train", "val", "test", "all"])
+    parser.add_argument("--train_rate", type=float, default=0.7)
+    parser.add_argument("--val_rate", type=float, default=0.1)
+    parser.add_argument("--test_rate", type=float, default=0.2)
+    parser.add_argument("--seed", type=int, default=42)
+
+    parser.add_argument("--ckpt", type=str, default="", help="Checkpoint path (*.pt). If empty, will search under --logdir/model.")
+    parser.add_argument("--logdir", type=str, default="./logs/segmamba", help="Training logdir to locate checkpoints when --ckpt is empty.")
+    parser.add_argument("--ckpt_prefer", type=str, default="best", choices=["best", "final", "latest"])
+
+    parser.add_argument("--save_dir", type=str, default="./prediction_results/segmamba", help="Directory to save prediction nii.gz.")
+    parser.add_argument("--device", type=str, default="cuda:0")
+    parser.add_argument("--patch_size", type=str, default="128,128,128")
+    parser.add_argument("--sw_batch_size", type=int, default=2)
+    parser.add_argument("--overlap", type=float, default=0.5)
+    parser.add_argument("--raw_spacing", type=str, default="1,1,1", help="Spacing used when saving NIfTI, e.g. '1,1,1'.")
+    parser.add_argument("--no_mirror", action="store_true", help="Disable mirror TTA.")
+    parser.add_argument("--print_dice", action="store_true", help="Print dice against preprocessed seg (if available).")
+    args = parser.parse_args()
+
+    patch_size = _parse_csv_ints(args.patch_size, 3)
+    raw_spacing = _parse_csv_floats(args.raw_spacing, 3)
+
+    ckpt_path = args.ckpt.strip()
+    if ckpt_path == "":
+        ckpt_path = _find_ckpt_from_logdir(args.logdir, prefer=args.ckpt_prefer)
+    if not os.path.isfile(ckpt_path):
+        raise FileNotFoundError(f"checkpoint not found: {ckpt_path}")
+    print(f"Using checkpoint: {ckpt_path}")
+
+    trainer = BraTSTrainer(
+        ckpt_path=ckpt_path,
+        save_path=args.save_dir,
+        patch_size=patch_size,
+        sw_batch_size=args.sw_batch_size,
+        overlap=args.overlap,
+        mirror_axes=None if args.no_mirror else (0, 1, 2),
+        raw_spacing=raw_spacing,
+        device=args.device,
+        print_dice=args.print_dice,
+    )
+
+    if args.split == "all":
+        all_paths = sorted(glob.glob(os.path.join(args.data_dir, "*.npz")))
+        ds = MedicalDataset(all_paths, test=False)
+    else:
+        train_ds, val_ds, test_ds = get_train_val_test_loader_from_train(
+            args.data_dir,
+            train_rate=args.train_rate,
+            val_rate=args.val_rate,
+            test_rate=args.test_rate,
+            seed=args.seed,
+        )
+        ds = {"train": train_ds, "val": val_ds, "test": test_ds}[args.split]
+
+    trainer.validation_single_gpu(ds)
+
+
+if __name__ == "__main__":
+    main()

source_code/SegMamba/5_compute_metrics.py

@@ -0,0 +1,175 @@
+import argparse
+import glob
+import json
+import os
+import sys
+
+import numpy as np
+import SimpleITK as sitk
+import torch
+from medpy import metric
+
+# Prefer pip-installed MONAI over the local monai/ folder.
+os.environ.setdefault("MONAI_SKIP_SUBMODULES", "1")
+_repo_root = os.path.abspath(os.path.dirname(__file__))
+if "" in sys.path:
+    sys.path.remove("")
+if _repo_root in sys.path:
+    sys.path.remove(_repo_root)
+import monai  # noqa: E402
+sys.path.insert(0, _repo_root)
+
+from monai.utils import set_determinism
+from tqdm import tqdm
+
+from light_training.dataloading.dataset import MedicalDataset, get_train_val_test_loader_from_train
+
+set_determinism(123)
+
+def cal_metric(gt, pred, voxel_spacing):
+    if pred.sum() > 0 and gt.sum() > 0:
+        dice = metric.binary.dc(pred, gt)
+        hd95 = metric.binary.hd95(pred, gt, voxelspacing=voxel_spacing)
+        return np.array([dice, hd95])
+    else:
+        return np.array([0.0, 50])
+
+def each_cases_metric(gt, pred, voxel_spacing):
+    classes_num = 3
+    class_wise_metric = np.zeros((classes_num, 2))
+    for cls in range(0, classes_num):
+        class_wise_metric[cls, ...] = cal_metric(pred[cls], gt[cls], voxel_spacing)
+    print(class_wise_metric)
+    return class_wise_metric
+
+def convert_labels(labels):
+    ## TC, WT and ET
+    labels = labels.unsqueeze(dim=0)
+
+    result = [(labels == 1) | (labels == 3), (labels == 1) | (labels == 3) | (labels == 2), labels == 3]
+    
+    return torch.cat(result, dim=0).float()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Compute Dice/HD95 for BraTS2023 (TC/WT/ET) from saved predictions.")
+    parser.add_argument("--pred_name", required=True, type=str, help="Prediction folder name under results_root.")
+    parser.add_argument("--results_root", type=str, default="prediction_results")
+    parser.add_argument("--data_dir", type=str, default="./data/fullres/train", help="Preprocessed data directory (contains *.npz).")
+    parser.add_argument(
+        "--gt_source",
+        type=str,
+        default="processed",
+        choices=["processed", "raw"],
+        help="GT source. 'processed' uses *_seg.npy from preprocessed dataset (recommended for /data/yty/brats23_processed). "
+             "'raw' uses seg.nii.gz from --raw_data_dir.",
+    )
+    parser.add_argument(
+        "--raw_data_dir",
+        type=str,
+        default="./data/raw_data/BraTS2023/ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData/",
+        help="Raw BraTS2023 training data directory that contains case folders with seg.nii.gz.",
+    )
+    parser.add_argument("--split", type=str, default="test", choices=["train", "val", "test", "all"])
+    parser.add_argument("--train_rate", type=float, default=0.7)
+    parser.add_argument("--val_rate", type=float, default=0.1)
+    parser.add_argument("--test_rate", type=float, default=0.2)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--voxel_spacing", type=str, default="1,1,1", help="Voxel spacing for HD95, e.g. '1,1,1'.")
+    args = parser.parse_args()
+
+    voxel_spacing = [float(x) for x in args.voxel_spacing.split(",")]
+
+    if args.split == "all":
+        all_paths = sorted(glob.glob(os.path.join(args.data_dir, "*.npz")))
+        ds = MedicalDataset(all_paths, test=False)
+    else:
+        train_ds, val_ds, test_ds = get_train_val_test_loader_from_train(
+            args.data_dir,
+            train_rate=args.train_rate,
+            val_rate=args.val_rate,
+            test_rate=args.test_rate,
+            seed=args.seed,
+        )
+        ds = {"train": train_ds, "val": val_ds, "test": test_ds}[args.split]
+
+    print(f"Evaluating {len(ds)} cases from split={args.split}")
+
+    all_results = np.zeros((len(ds), 3, 2), dtype=np.float32)
+
+    for ind, batch in enumerate(tqdm(ds, total=len(ds))):
+        properties = batch["properties"]
+        case_name = properties["name"]
+        pred_path = os.path.join(args.results_root, args.pred_name, f"{case_name}.nii.gz")
+        if not os.path.isfile(pred_path):
+            raise FileNotFoundError(f"Prediction not found: {pred_path}")
+
+        if args.gt_source == "raw":
+            gt_path = os.path.join(args.raw_data_dir, case_name, "seg.nii.gz")
+            if not os.path.isfile(gt_path):
+                raise FileNotFoundError(f"GT not found: {gt_path}")
+            gt_itk = sitk.ReadImage(gt_path)
+            gt_array = sitk.GetArrayFromImage(gt_itk).astype(np.int32)
+            gt_array = torch.from_numpy(gt_array)
+            gt_array = convert_labels(gt_array).numpy()
+        else:
+            # preprocessed GT (same space as saved predictions from 4_predict.py)
+            if "seg" not in batch:
+                raise KeyError("gt_source=processed requires 'seg' in dataset samples, but it's missing.")
+            seg = batch["seg"]  # expected shape: (1, D, H, W)
+            if isinstance(seg, np.ndarray):
+                seg_t = torch.from_numpy(seg)
+            else:
+                # np.memmap is also an ndarray subclass, keep it generic
+                seg_t = torch.from_numpy(np.asarray(seg))
+            if seg_t.ndim == 4 and seg_t.shape[0] == 1:
+                seg_t = seg_t[0]
+            gt_array = convert_labels(seg_t).numpy()
+
+        pred_itk = sitk.ReadImage(pred_path)
+        pred_array = sitk.GetArrayFromImage(pred_itk)
+
+        m = each_cases_metric(gt_array, pred_array, voxel_spacing)
+        all_results[ind, ...] = m
+
+    out_dir = os.path.join(args.results_root, "result_metrics")
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = os.path.join(out_dir, f"{args.pred_name}.npy")
+    np.save(out_path, all_results)
+
+    result = np.load(out_path)
+    mean_per_class = result.mean(axis=0)
+    std_per_class = result.std(axis=0)
+    mean_dice = float(mean_per_class[:, 0].mean())
+    mean_hd95 = float(mean_per_class[:, 1].mean())
+
+    summary = {
+        "pred_name": args.pred_name,
+        "results_root": args.results_root,
+        "data_dir": args.data_dir,
+        "split": args.split,
+        "gt_source": args.gt_source,
+        "raw_data_dir": args.raw_data_dir if args.gt_source == "raw" else None,
+        "voxel_spacing": voxel_spacing,
+        "num_cases": int(result.shape[0]),
+        "mean_per_class": mean_per_class.tolist(),  # [TC, WT, ET] x [dice, hd95]
+        "std_per_class": std_per_class.tolist(),
+        "mean_dice": mean_dice,
+        "mean_hd95": mean_hd95,
+    }
+    summary_path = os.path.join(out_dir, f"{args.pred_name}_summary.json")
+    with open(summary_path, "w") as f:
+        json.dump(summary, f, indent=2)
+
+    print("saved:", out_path)
+    print("summary:", summary_path)
+    print(result.shape)
+    print("mean(TC/WT/ET) [dice, hd95]:")
+    print(mean_per_class)
+    print("std(TC/WT/ET) [dice, hd95]:")
+    print(std_per_class)
+    print("mean dice:", mean_dice)
+    print("mean hd95:", mean_hd95)
+
+
+

source_code/SegMamba/6_visualize_predictions.py

@@ -0,0 +1,219 @@
+import argparse
+import os
+import sys
+
+import numpy as np
+import SimpleITK as sitk
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.patches import Patch
+
+
+MODALITY_MAP = {
+    "t2w": 0,
+    "t2f": 1,
+    "t1n": 2,
+    "t1c": 3,
+}
+
+
+def _parse_cases(s: str):
+    if not s:
+        return []
+    return [p.strip() for p in s.split(",") if p.strip()]
+
+
+def _normalize_slice(img2d: np.ndarray) -> np.ndarray:
+    p1, p99 = np.percentile(img2d, (1, 99))
+    if p99 <= p1:
+        return np.zeros_like(img2d, dtype=np.float32)
+    img = (img2d - p1) / (p99 - p1)
+    return np.clip(img, 0.0, 1.0).astype(np.float32)
+
+
+def _pred_to_three_channels(pred: np.ndarray) -> np.ndarray:
+    # Accept either 4D (3, D, H, W) or 3D label map (D, H, W) with labels 0-3.
+    if pred.ndim == 4:
+        return pred
+    if pred.ndim != 3:
+        raise ValueError(f"unexpected pred shape: {pred.shape}")
+    # label -> TC/WT/ET
+    labels = pred
+    tc = (labels == 1) | (labels == 3)
+    wt = (labels == 1) | (labels == 2) | (labels == 3)
+    et = labels == 3
+    return np.stack([tc, wt, et], axis=0).astype(np.uint8)
+
+
+def _pick_slices(mask_3c: np.ndarray, num_slices: int) -> list[int]:
+    # mask_3c: (3, D, H, W)
+    mask_sum = mask_3c.sum(axis=0)  # (D, H, W)
+    per_slice = mask_sum.reshape(mask_sum.shape[0], -1).sum(axis=1)
+    if per_slice.max() == 0:
+        # fallback: evenly spaced slices
+        return sorted(set(np.linspace(0, mask_sum.shape[0] - 1, num_slices, dtype=int).tolist()))
+    idx = np.argsort(per_slice)[::-1]
+    chosen = []
+    for i in idx:
+        if len(chosen) >= num_slices:
+            break
+        chosen.append(int(i))
+    return sorted(chosen)
+
+
+def _overlay_mask(gray: np.ndarray, masks: list[np.ndarray]) -> np.ndarray:
+    # gray: (H, W), masks: [tc, wt, et]
+    rgb = np.stack([gray, gray, gray], axis=-1)
+    colors = [
+        (1.0, 0.0, 0.0),  # TC - red
+        (0.0, 1.0, 0.0),  # WT - green
+        (1.0, 1.0, 0.0),  # ET - yellow
+    ]
+    alphas = [0.5, 0.25, 0.5]
+    for mask, color, alpha in zip(masks, colors, alphas):
+        m = mask.astype(bool)
+        if m.any():
+            rgb[m] = rgb[m] * (1.0 - alpha) + np.array(color) * alpha
+    return rgb
+
+
+def _load_processed_image(processed_dir: str, case_name: str, modality: int) -> np.ndarray:
+    img_path = os.path.join(processed_dir, f"{case_name}.npy")
+    if not os.path.isfile(img_path):
+        raise FileNotFoundError(f"processed image not found: {img_path}")
+    arr = np.load(img_path, mmap_mode="r")
+    if arr.ndim != 4:
+        raise ValueError(f"unexpected image shape: {arr.shape}")
+    return np.asarray(arr[modality], dtype=np.float32)  # (D, H, W)
+
+
+def _load_prediction(pred_dir: str, case_name: str) -> np.ndarray:
+    pred_path = os.path.join(pred_dir, f"{case_name}.nii.gz")
+    if not os.path.isfile(pred_path):
+        raise FileNotFoundError(f"prediction not found: {pred_path}")
+    pred_itk = sitk.ReadImage(pred_path)
+    pred_arr = sitk.GetArrayFromImage(pred_itk)
+    return _pred_to_three_channels(np.asarray(pred_arr))
+
+def _load_gt(processed_dir: str, case_name: str) -> np.ndarray:
+    seg_path = os.path.join(processed_dir, f"{case_name}_seg.npy")
+    if not os.path.isfile(seg_path):
+        raise FileNotFoundError(f"gt seg not found: {seg_path}")
+    seg = np.load(seg_path, mmap_mode="r")
+    seg = np.asarray(seg)
+    if seg.ndim == 4 and seg.shape[0] == 1:
+        seg = seg[0]
+    return _pred_to_three_channels(seg)
+
+
+def visualize_case(case_name: str, pred_dir: str, processed_dir: str, modality: int, num_slices: int, out_dir: str, show_gt: bool = True):
+    img = _load_processed_image(processed_dir, case_name, modality)  # (D, H, W)
+    pred = _load_prediction(pred_dir, case_name)  # (3, D, H, W)
+    gt = None
+    if show_gt:
+        try:
+            gt = _load_gt(processed_dir, case_name)
+        except FileNotFoundError:
+            gt = None
+
+    if pred.shape[1:] != img.shape:
+        raise ValueError(f"shape mismatch for {case_name}: img={img.shape}, pred={pred.shape}")
+    if gt is not None and gt.shape[1:] != img.shape:
+        raise ValueError(f"shape mismatch for {case_name}: img={img.shape}, gt={gt.shape}")
+
+    slice_ids = _pick_slices(pred, num_slices)
+
+    ncols = 3 if gt is not None else 2
+    fig, axes = plt.subplots(nrows=len(slice_ids), ncols=ncols, figsize=(4 * ncols, 3 * len(slice_ids)))
+    if len(slice_ids) == 1:
+        axes = np.array([axes])
+    if ncols == 2 and axes.ndim == 1:
+        axes = axes[None, :]
+
+    for row, z in enumerate(slice_ids):
+        img2d = img[z]
+        gray = _normalize_slice(img2d)
+        tc = pred[0, z]
+        wt = pred[1, z]
+        et = pred[2, z]
+
+        axes[row, 0].imshow(gray, cmap="gray")
+        axes[row, 0].set_title(f"{case_name} z={z} (raw)")
+        axes[row, 0].axis("off")
+
+        overlay = _overlay_mask(gray, [tc, wt, et])
+        axes[row, 1].imshow(overlay)
+        axes[row, 1].set_title(f"{case_name} z={z} (pred)")
+        axes[row, 1].axis("off")
+
+        if gt is not None:
+            gt_tc = gt[0, z]
+            gt_wt = gt[1, z]
+            gt_et = gt[2, z]
+            gt_overlay = _overlay_mask(gray, [gt_tc, gt_wt, gt_et])
+            axes[row, 2].imshow(gt_overlay)
+            axes[row, 2].set_title(f"{case_name} z={z} (gt)")
+            axes[row, 2].axis("off")
+
+    legend = [
+        Patch(color=(1.0, 0.0, 0.0), label="TC"),
+        Patch(color=(0.0, 1.0, 0.0), label="WT"),
+        Patch(color=(1.0, 1.0, 0.0), label="ET"),
+    ]
+    fig.legend(handles=legend, loc="lower center", ncol=3)
+    fig.tight_layout(rect=[0, 0.05, 1, 1])
+
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = os.path.join(out_dir, f"{case_name}_overlay.png")
+    fig.savefig(out_path, dpi=150)
+    plt.close(fig)
+
+    return out_path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Visualize SegMamba predictions (overlay on processed images).")
+    parser.add_argument("--pred_dir", type=str, required=True, help="Prediction folder containing case_name.nii.gz.")
+    parser.add_argument("--processed_dir", type=str, required=True, help="Processed data dir containing case_name.npy.")
+    parser.add_argument("--out_dir", type=str, default="./prediction_results/visualizations")
+    parser.add_argument("--modality", type=str, default="t2f", help="t2w|t2f|t1n|t1c or an int index.")
+    parser.add_argument("--num_cases", type=int, default=5)
+    parser.add_argument("--num_slices", type=int, default=3)
+    parser.add_argument("--cases", type=str, default="", help="Comma-separated case names to visualize.")
+    parser.add_argument("--no_gt", action="store_true", help="Disable GT overlay (prediction only).")
+    args = parser.parse_args()
+
+    if args.modality.isdigit():
+        modality = int(args.modality)
+    else:
+        modality = MODALITY_MAP.get(args.modality.lower(), 1)
+    if modality < 0 or modality > 3:
+        raise ValueError("modality index must be 0..3")
+
+    cases = _parse_cases(args.cases)
+    if not cases:
+        pred_files = sorted([f for f in os.listdir(args.pred_dir) if f.endswith(".nii.gz")])
+        cases = [os.path.splitext(os.path.splitext(f)[0])[0] for f in pred_files][: args.num_cases]
+
+    if not cases:
+        print("No cases found.")
+        sys.exit(0)
+
+    print(f"Visualizing {len(cases)} cases, modality={modality}")
+    for case_name in cases:
+        out_path = visualize_case(
+            case_name=case_name,
+            pred_dir=args.pred_dir,
+            processed_dir=args.processed_dir,
+            modality=modality,
+            num_slices=args.num_slices,
+            out_dir=args.out_dir,
+            show_gt=not args.no_gt,
+        )
+        print(f"saved: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

source_code/SegMamba/README.md

@@ -0,0 +1,132 @@
+# SegMamba
+
+**Recent news: If you are interested in the research about vision language models, please refers to the latest work: https://github.com/MrGiovanni/RadGPT (ICCV2025)**
+
+**Now we have open-sourced the pre-processing, training, inference, and metrics computation codes.**
+
+SegMamba: Long-range Sequential Modeling Mamba For 3D Medical Image Segmentation
+
+[https://arxiv.org/abs/2401.13560](https://arxiv.org/abs/2401.13560)
+
+![](images/method_figure.jpg)
+
+![](images/modules.jpg)
+
+Our advantage in speed and memory.
+![](images/segmamba_ablation.jpg)
+
+## Contact 
+If you have any questions about our project, please feel free to contact us by email at zxing565@connect.hkust-gz.edu.cn or via WeChat at 18340097191. Furthermore, the data underlying this article will be shared on reasonable request to gaof57@mail.sysu.edu.cn.
+
+## Environment install
+Clone this repository and navigate to the root directory of the project.
+
+```bash
+git clone https://github.com/ge-xing/SegMamba.git
+
+cd SegMamba
+```
+### Install causal-conv1d
+
+```bash
+cd causal-conv1d
+
+python setup.py install
+```
+
+### Install mamba
+
+```bash
+cd mamba
+
+python setup.py install
+```
+
+### Install monai 
+
+```bash
+pip install monai
+```
+
+## Simple test
+
+```bash
+python 0_inference.py
+```
+
+## Preprocessing, training, testing, inference, and metrics computation
+
+### Data downloading 
+
+Data is from [https://arxiv.org/abs/2305.17033](https://arxiv.org/abs/2305.17033)
+
+Download from Baidu Disk  [https://pan.baidu.com/s/1C0FUHdDtWNaYWLtDDP9TnA?pwd=ty22提取码ty22](https://pan.baidu.com/s/1C0FUHdDtWNaYWLtDDP9TnA?pwd=ty22) 
+
+Download from OneDrive [https://hkustgz-my.sharepoint.com/:f:/g/personal/zxing565_connect_hkust-gz_edu_cn/EqqaINbHRxREuIj0XGicY2EBv8hjwEFKgFOhF_Ub0mvENw?e=yTpE9B](https://hkustgz-my.sharepoint.com/:f:/g/personal/zxing565_connect_hkust-gz_edu_cn/EqqaINbHRxREuIj0XGicY2EBv8hjwEFKgFOhF_Ub0mvENw?e=yTpE9B)
+
+### Preprocessing
+In my setting, the data directory of BraTS2023 is : "./data/raw_data/BraTS2023/ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData/"
+
+First, we need to run the rename process.
+
+```bash 
+python 1_rename_mri_data.py
+```
+
+Then, we need to run the pre-processing code to do resample, normalization, and crop processes.
+
+```bash
+python 2_preprocessing_mri.py
+```
+
+After pre-processing, the data structure will be in this format:
+
+![](images/data_structure.jpg)
+### Training 
+
+When the pre-processing process is done, we can train our model.
+
+We mainly use the pre-processde data from last step: **data_dir = "./data/fullres/train"**
+
+
+```bash 
+python 3_train.py
+```
+
+The training logs and checkpoints are saved in:
+**logdir = f"./logs/segmamba"**
+
+
+
+
+### Inference 
+
+When we have trained our models, we can inference all the data in testing set.
+
+```bash 
+python 4_predict.py
+```
+
+When this process is done, the prediction cases will be put in this path:
+**save_path = "./prediction_results/segmamba"**
+
+### Metrics computation
+We can obtain the Dice score and HD95 on each segmentation target (WT, TC, ET for BraTS2023 dataset) using this code:
+
+```bash
+python 5_compute_metrics.py --pred_name="segmamba"
+```
+
+
+
+## Acknowledgement
+Many thanks for these repos for their great contribution!
+
+[https://github.com/MIC-DKFZ/nnUNet](https://github.com/MIC-DKFZ/nnUNet)
+
+[https://github.com/Project-MONAI/MONAI](https://github.com/Project-MONAI/MONAI)
+
+[https://github.com/hustvl/Vim](https://github.com/hustvl/Vim)
+
+[https://github.com/bowang-lab/U-Mamba](https://github.com/bowang-lab/U-Mamba)
+

source_code/SegMamba/causal-conv1d/AUTHORS

@@ -0,0 +1 @@
+Tri Dao, tri@tridao.me

source_code/SegMamba/causal-conv1d/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2022, the respective contributors, as shown by the AUTHORS file.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

source_code/SegMamba/causal-conv1d/README.md

@@ -0,0 +1 @@
+# Causal depthwise conv1d in CUDA with a PyTorch interface

source_code/SegMamba/causal-conv1d/build/lib.linux-x86_64-cpython-312/causal_conv1d/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "1.0.0"
+
+from causal_conv1d.causal_conv1d_interface import causal_conv1d_fn, causal_conv1d_update

source_code/SegMamba/causal-conv1d/build/lib.linux-x86_64-cpython-312/causal_conv1d/causal_conv1d_interface.py

@@ -0,0 +1,104 @@
+# Copyright (c) 2023, Tri Dao.
+
+import torch
+import torch.nn.functional as F
+
+
+import causal_conv1d_cuda
+
+
+class CausalConv1dFn(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x, weight, bias=None, activation=None):
+        if activation not in [None, "silu", "swish"]:
+            raise NotImplementedError("activation must be None, silu, or swish")
+        if x.stride(2) != 1 and x.stride(1) != 1:
+            x = x.contiguous()
+        bias = bias.contiguous() if bias is not None else None
+        ctx.save_for_backward(x, weight, bias)
+        ctx.activation = activation in ["silu", "swish"]
+        out = causal_conv1d_cuda.causal_conv1d_fwd(x, weight, bias, ctx.activation)
+        return out
+
+    @staticmethod
+    def backward(ctx, dout):
+        x, weight, bias = ctx.saved_tensors
+        if dout.stride(2) != 1 and dout.stride(1) != 1:
+            dout = dout.contiguous()
+        # The kernel supports passing in a pre-allocated dx (e.g., in case we want to fuse the
+        # backward of conv1d with the backward of chunk).
+        # Here we just pass in None and dx will be allocated in the C++ code.
+        dx, dweight, dbias = causal_conv1d_cuda.causal_conv1d_bwd(
+            x, weight, bias, dout, None, ctx.activation
+        )
+        return dx, dweight, dbias if bias is not None else None, None
+
+
+def causal_conv1d_fn(x, weight, bias=None, activation=None):
+    """
+    x: (batch, dim, seqlen)
+    weight: (dim, width)
+    bias: (dim,)
+    activation: either None or "silu" or "swish"
+
+    out: (batch, dim, seqlen)
+    """
+    return CausalConv1dFn.apply(x, weight, bias, activation)
+
+
+def causal_conv1d_ref(x, weight, bias=None, activation=None):
+    """
+    x: (batch, dim, seqlen)
+    weight: (dim, width)
+    bias: (dim,)
+
+    out: (batch, dim, seqlen)
+    """
+    if activation not in [None, "silu", "swish"]:
+        raise NotImplementedError("activation must be None, silu, or swish")
+    dtype_in = x.dtype
+    x = x.to(weight.dtype)
+    seqlen = x.shape[-1]
+    dim, width = weight.shape
+    out = F.conv1d(x, weight.unsqueeze(1), bias, padding=width - 1, groups=dim)
+    out = out[..., :seqlen]
+    return (out if activation is None else F.silu(out)).to(dtype=dtype_in)
+
+
+def causal_conv1d_update(x, conv_state, weight, bias=None, activation=None):
+    """
+    x: (batch, dim)
+    conv_state: (batch, dim, width)
+    weight: (dim, width)
+    bias: (dim,)
+
+    out: (batch, dim)
+    """
+    if activation not in [None, "silu", "swish"]:
+        raise NotImplementedError("activation must be None, silu, or swish")
+    activation = activation in ["silu", "swish"]
+    return causal_conv1d_cuda.causal_conv1d_update(x, conv_state, weight, bias, activation)
+
+
+def causal_conv1d_update_ref(x, conv_state, weight, bias=None, activation=None):
+    """
+    x: (batch, dim)
+    conv_state: (batch, dim, width)
+    weight: (dim, width)
+    bias: (dim,)
+
+    out: (batch, dim)
+    """
+    if activation not in [None, "silu", "swish"]:
+        raise NotImplementedError("activation must be None, silu, or swish")
+    dtype_in = x.dtype
+    batch, dim = x.shape
+    width = weight.shape[1]
+    assert conv_state.shape == (batch, dim, width)
+    assert weight.shape == (dim, width)
+    conv_state.copy_(torch.roll(conv_state, shifts=-1, dims=-1)) # Update state (B D W)
+    conv_state[:, :, -1] = x
+    out = torch.sum(conv_state * weight, dim=-1) # (B D)
+    if bias is not None:
+        out += bias
+    return (out if activation is None else F.silu(out)).to(dtype=dtype_in)

source_code/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/.ninja_log

@@ -0,0 +1,5 @@
+# ninja log v5
+1	3925	1769349295059886191	/root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d_update.o	3402387f7700f2cb
+0	8815	1769349299946937322	/root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d_fwd.o	f8d3256741ca6581
+0	19513	1769349310651049313	/root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d.o	9aac860c790009d8
+0	21969	1769349313087074800	/root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d_bwd.o	2a543079906b9d85

source_code/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/build.ninja

@@ -0,0 +1,40 @@
+ninja_required_version = 1.3
+cxx = c++
+nvcc = /usr/local/cuda/bin/nvcc
+
+cflags = -pthread -B /root/miniforge/compiler_compat -fno-strict-overflow -Wsign-compare -DNDEBUG -O2 -Wall -fPIC -O2 -isystem /root/miniforge/include -fPIC -O2 -isystem /root/miniforge/include -fPIC -I/root/githubs/SegMamba/causal-conv1d -I/root/miniforge/lib/python3.12/site-packages/torch/include -I/root/miniforge/lib/python3.12/site-packages/torch/include/torch/csrc/api/include -I/usr/local/cuda/include -I/root/miniforge/include/python3.12 -c
+post_cflags = -O3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=causal_conv1d_cuda -std=c++17
+cuda_cflags = -I/root/githubs/SegMamba/causal-conv1d -I/root/miniforge/lib/python3.12/site-packages/torch/include -I/root/miniforge/lib/python3.12/site-packages/torch/include/torch/csrc/api/include -I/usr/local/cuda/include -I/root/miniforge/include/python3.12 -c
+cuda_post_cflags = -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options ''"'"'-fPIC'"'"'' -O3 -U__CUDA_NO_HALF_OPERATORS__ -U__CUDA_NO_HALF_CONVERSIONS__ -U__CUDA_NO_BFLOAT16_OPERATORS__ -U__CUDA_NO_BFLOAT16_CONVERSIONS__ -U__CUDA_NO_BFLOAT162_OPERATORS__ -U__CUDA_NO_BFLOAT162_CONVERSIONS__ --expt-relaxed-constexpr --expt-extended-lambda --use_fast_math --ptxas-options=-v -lineinfo -gencode arch=compute_70,code=sm_70 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_90,code=sm_90 --threads 4 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=causal_conv1d_cuda -std=c++17
+cuda_dlink_post_cflags = 
+sycl_dlink_post_cflags = 
+ldflags = 
+
+rule compile
+  command = $cxx -MMD -MF $out.d $cflags -c $in -o $out $post_cflags
+  depfile = $out.d
+  deps = gcc
+
+rule cuda_compile
+  depfile = $out.d
+  deps = gcc
+  command = $nvcc --generate-dependencies-with-compile --dependency-output $out.d $cuda_cflags -c $in -o $out $cuda_post_cflags
+
+
+
+
+
+
+
+build /root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d.o: compile /root/githubs/SegMamba/causal-conv1d/csrc/causal_conv1d.cpp
+build /root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d_bwd.o: cuda_compile /root/githubs/SegMamba/causal-conv1d/csrc/causal_conv1d_bwd.cu
+build /root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d_fwd.o: cuda_compile /root/githubs/SegMamba/causal-conv1d/csrc/causal_conv1d_fwd.cu
+build /root/githubs/SegMamba/causal-conv1d/build/temp.linux-x86_64-cpython-312/csrc/causal_conv1d_update.o: cuda_compile /root/githubs/SegMamba/causal-conv1d/csrc/causal_conv1d_update.cu
+
+
+
+
+
+
+
+

source_code/SegMamba/causal-conv1d/causal_conv1d.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: causal_conv1d
+Version: 1.0.0
+Summary: Causal depthwise conv1d in CUDA, with a PyTorch interface
+Home-page: https://github.com/Dao-AILab/causal-conv1d
+Author: Tri Dao
+Author-email: tri@tridao.me
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: Unix
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: torch
+Requires-Dist: packaging
+Requires-Dist: ninja
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Causal depthwise conv1d in CUDA with a PyTorch interface

source_code/SegMamba/causal-conv1d/causal_conv1d.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+AUTHORS
+LICENSE
+README.md
+setup.py
+causal_conv1d/__init__.py
+causal_conv1d/causal_conv1d_interface.py
+causal_conv1d.egg-info/PKG-INFO
+causal_conv1d.egg-info/SOURCES.txt
+causal_conv1d.egg-info/dependency_links.txt
+causal_conv1d.egg-info/requires.txt
+causal_conv1d.egg-info/top_level.txt
+csrc/causal_conv1d.cpp
+csrc/causal_conv1d_bwd.cu
+csrc/causal_conv1d_fwd.cu
+csrc/causal_conv1d_update.cu
+tests/test_causal_conv1d.py

source_code/SegMamba/causal-conv1d/causal_conv1d.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

source_code/SegMamba/causal-conv1d/causal_conv1d.egg-info/requires.txt

@@ -0,0 +1,3 @@
+torch
+packaging
+ninja

source_code/SegMamba/causal-conv1d/causal_conv1d.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+causal_conv1d
+causal_conv1d_cuda

source_code/SegMamba/causal-conv1d/causal_conv1d/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "1.0.0"
+
+from causal_conv1d.causal_conv1d_interface import causal_conv1d_fn, causal_conv1d_update

source_code/SegMamba/causal-conv1d/causal_conv1d/causal_conv1d_interface.py

@@ -0,0 +1,104 @@
+# Copyright (c) 2023, Tri Dao.
+
+import torch
+import torch.nn.functional as F
+
+
+import causal_conv1d_cuda
+
+
+class CausalConv1dFn(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x, weight, bias=None, activation=None):
+        if activation not in [None, "silu", "swish"]:
+            raise NotImplementedError("activation must be None, silu, or swish")
+        if x.stride(2) != 1 and x.stride(1) != 1:
+            x = x.contiguous()
+        bias = bias.contiguous() if bias is not None else None
+        ctx.save_for_backward(x, weight, bias)
+        ctx.activation = activation in ["silu", "swish"]
+        out = causal_conv1d_cuda.causal_conv1d_fwd(x, weight, bias, ctx.activation)
+        return out
+
+    @staticmethod
+    def backward(ctx, dout):
+        x, weight, bias = ctx.saved_tensors
+        if dout.stride(2) != 1 and dout.stride(1) != 1:
+            dout = dout.contiguous()
+        # The kernel supports passing in a pre-allocated dx (e.g., in case we want to fuse the
+        # backward of conv1d with the backward of chunk).
+        # Here we just pass in None and dx will be allocated in the C++ code.
+        dx, dweight, dbias = causal_conv1d_cuda.causal_conv1d_bwd(
+            x, weight, bias, dout, None, ctx.activation
+        )
+        return dx, dweight, dbias if bias is not None else None, None
+
+
+def causal_conv1d_fn(x, weight, bias=None, activation=None):
+    """
+    x: (batch, dim, seqlen)
+    weight: (dim, width)
+    bias: (dim,)
+    activation: either None or "silu" or "swish"
+
+    out: (batch, dim, seqlen)
+    """
+    return CausalConv1dFn.apply(x, weight, bias, activation)
+
+
+def causal_conv1d_ref(x, weight, bias=None, activation=None):
+    """
+    x: (batch, dim, seqlen)
+    weight: (dim, width)
+    bias: (dim,)
+
+    out: (batch, dim, seqlen)
+    """
+    if activation not in [None, "silu", "swish"]:
+        raise NotImplementedError("activation must be None, silu, or swish")
+    dtype_in = x.dtype
+    x = x.to(weight.dtype)
+    seqlen = x.shape[-1]
+    dim, width = weight.shape
+    out = F.conv1d(x, weight.unsqueeze(1), bias, padding=width - 1, groups=dim)
+    out = out[..., :seqlen]
+    return (out if activation is None else F.silu(out)).to(dtype=dtype_in)
+
+
+def causal_conv1d_update(x, conv_state, weight, bias=None, activation=None):
+    """
+    x: (batch, dim)
+    conv_state: (batch, dim, width)
+    weight: (dim, width)
+    bias: (dim,)
+
+    out: (batch, dim)
+    """
+    if activation not in [None, "silu", "swish"]:
+        raise NotImplementedError("activation must be None, silu, or swish")
+    activation = activation in ["silu", "swish"]
+    return causal_conv1d_cuda.causal_conv1d_update(x, conv_state, weight, bias, activation)
+
+
+def causal_conv1d_update_ref(x, conv_state, weight, bias=None, activation=None):
+    """
+    x: (batch, dim)
+    conv_state: (batch, dim, width)
+    weight: (dim, width)
+    bias: (dim,)
+
+    out: (batch, dim)
+    """
+    if activation not in [None, "silu", "swish"]:
+        raise NotImplementedError("activation must be None, silu, or swish")
+    dtype_in = x.dtype
+    batch, dim = x.shape
+    width = weight.shape[1]
+    assert conv_state.shape == (batch, dim, width)
+    assert weight.shape == (dim, width)
+    conv_state.copy_(torch.roll(conv_state, shifts=-1, dims=-1)) # Update state (B D W)
+    conv_state[:, :, -1] = x
+    out = torch.sum(conv_state * weight, dim=-1) # (B D)
+    if bias is not None:
+        out += bias
+    return (out if activation is None else F.silu(out)).to(dtype=dtype_in)

source_code/SegMamba/causal-conv1d/csrc/causal_conv1d.cpp

@@ -0,0 +1,333 @@
+/******************************************************************************
+ * Copyright (c) 2023, Tri Dao.
+ ******************************************************************************/
+
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+#include <torch/extension.h>
+#include <vector>
+
+#include "causal_conv1d.h"
+
+#define CHECK_SHAPE(x, ...) TORCH_CHECK(x.sizes() == torch::IntArrayRef({__VA_ARGS__}), #x " must have shape (" #__VA_ARGS__ ")")
+
+#define DISPATCH_ITYPE_FLOAT_AND_HALF_AND_BF16(ITYPE, NAME, ...)                    \
+    if (ITYPE == at::ScalarType::Half) {                                            \
+        using input_t = at::Half;                                                   \
+        __VA_ARGS__();                                                              \
+    } else if (ITYPE == at::ScalarType::BFloat16) {                                 \
+        using input_t = at::BFloat16;                                               \
+        __VA_ARGS__();                                                              \
+    } else if (ITYPE == at::ScalarType::Float)  {                                   \
+        using input_t = float;                                                      \
+        __VA_ARGS__();                                                              \
+    } else {                                                                        \
+        AT_ERROR(#NAME, " not implemented for input type '", toString(ITYPE), "'"); \
+    }
+
+#define DISPATCH_WTYPE_FLOAT_AND_HALF_AND_BF16(WTYPE, NAME, ...)                     \
+    if (WTYPE == at::ScalarType::Half) {                                             \
+        using weight_t = at::Half;                                                   \
+        __VA_ARGS__();                                                               \
+    } else if (WTYPE == at::ScalarType::BFloat16) {                                  \
+        using weight_t = at::BFloat16;                                               \
+        __VA_ARGS__();                                                               \
+    } else if (WTYPE == at::ScalarType::Float)  {                                    \
+        using weight_t = float;                                                      \
+        __VA_ARGS__();                                                               \
+    } else {                                                                         \
+        AT_ERROR(#NAME, " not implemented for weight type '", toString(WTYPE), "'"); \
+    }
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_fwd_cuda(ConvParamsBase &params, cudaStream_t stream);
+template <typename input_t, typename weight_t>
+void causal_conv1d_channellast_fwd_cuda(ConvParamsBase &params, cudaStream_t stream);
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_bwd_cuda(ConvParamsBwd &params, cudaStream_t stream);
+template<typename input_t, typename weight_t>
+void causal_conv1d_channellast_bwd_cuda(ConvParamsBwd &params, cudaStream_t stream);
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_update_cuda(ConvParamsBase &params, cudaStream_t stream);
+
+void set_conv_params_fwd(ConvParamsBase &params,
+                         // sizes
+                         const size_t batch,
+                         const size_t dim,
+                         const size_t seqlen,
+                         const size_t width,
+                         // device pointers
+                         const at::Tensor x,
+                         const at::Tensor weight,
+                         const at::Tensor out,
+                         void* bias_ptr,
+                         bool silu_activation) {
+
+    // Reset the parameters
+    memset(&params, 0, sizeof(params));
+
+    params.batch = batch;
+    params.dim = dim;
+    params.seqlen = seqlen;
+    params.width = width;
+
+    params.silu_activation = silu_activation;
+
+    // Set the pointers and strides.
+    params.x_ptr = x.data_ptr();
+    params.weight_ptr = weight.data_ptr();
+    params.bias_ptr = bias_ptr;
+    params.out_ptr = out.data_ptr();
+    // All stride are in elements, not bytes.
+    params.x_batch_stride = x.stride(0);
+    params.x_c_stride = x.stride(1);
+    params.x_l_stride = x.stride(-1);
+    params.weight_c_stride = weight.stride(0);
+    params.weight_width_stride = weight.stride(1);
+    params.out_batch_stride = out.stride(0);
+    params.out_c_stride = out.stride(1);
+    params.out_l_stride = out.stride(-1);
+}
+
+
+void set_conv_params_bwd(ConvParamsBwd &params,
+                         // sizes
+                         const size_t batch,
+                         const size_t dim,
+                         const size_t seqlen,
+                         const size_t width,
+                         // device pointers
+                         const at::Tensor x,
+                         const at::Tensor weight,
+                         void* bias_ptr,
+                         const at::Tensor dout,
+                         const at::Tensor dx,
+                         const at::Tensor dweight,
+                         void* dbias_ptr,
+                         bool silu_activation) {
+    // Pass in "dout" instead of "out", we're not gonna use "out" at all.
+    set_conv_params_fwd(params, batch, dim, seqlen, width,
+                        x, weight, dout, bias_ptr, silu_activation);
+
+    // Set the pointers and strides.
+    params.dout_ptr = dout.data_ptr();
+    params.dx_ptr = dx.data_ptr();
+    params.dweight_ptr = dweight.data_ptr();
+    params.dbias_ptr = dbias_ptr;
+    // All stride are in elements, not bytes.
+    params.dout_batch_stride = dout.stride(0);
+    params.dout_c_stride = dout.stride(1);
+    params.dout_l_stride = dout.stride(2);
+    params.dweight_c_stride = dweight.stride(0);
+    params.dweight_width_stride = dweight.stride(1);
+    params.dx_batch_stride = dx.stride(0);
+    params.dx_c_stride = dx.stride(1);
+    params.dx_l_stride = dx.stride(2);
+}
+
+at::Tensor
+causal_conv1d_fwd(const at::Tensor &x, const at::Tensor &weight,
+                  const c10::optional<at::Tensor> &bias_,
+                  bool silu_activation) {
+    auto input_type = x.scalar_type();
+    auto weight_type = weight.scalar_type();
+    TORCH_CHECK(input_type == at::ScalarType::Float || input_type == at::ScalarType::Half || input_type == at::ScalarType::BFloat16);
+    TORCH_CHECK(weight_type == at::ScalarType::Float || weight_type == at::ScalarType::Half || weight_type == at::ScalarType::BFloat16);
+
+    TORCH_CHECK(x.is_cuda());
+    TORCH_CHECK(weight.is_cuda());
+
+    const auto sizes = x.sizes();
+    const int batch_size = sizes[0];
+    const int dim = sizes[1];
+    const int seqlen = sizes[2];
+    const int width = weight.size(-1);
+
+    CHECK_SHAPE(x, batch_size, dim, seqlen);
+    CHECK_SHAPE(weight, dim, width);
+
+    TORCH_CHECK(x.stride(2) == 1 || x.stride(1) == 1);
+    const bool is_channel_last = x.stride(1) == 1 && x.stride(2) > 1;
+
+    if (is_channel_last) {
+        TORCH_CHECK(dim % 8 == 0, "causal_conv1d only supports channel dimension divisible by 8 for now");
+    }
+    TORCH_CHECK(width >= 2 && width <= 4, "causal_conv1d only supports width between 2 and 4");
+
+
+    if (bias_.has_value()) {
+        auto bias = bias_.value();
+        TORCH_CHECK(bias.scalar_type() == weight_type);
+        TORCH_CHECK(bias.is_cuda());
+        TORCH_CHECK(bias.stride(-1) == 1);
+        CHECK_SHAPE(bias, dim);
+    }
+
+    at::Tensor out = torch::empty_like(x);
+
+    ConvParamsBase params;
+    set_conv_params_fwd(params, batch_size, dim, seqlen, width, x, weight, out,
+                        bias_.has_value() ? bias_.value().data_ptr() : nullptr,
+                        silu_activation);
+
+    // Otherwise the kernel will be launched from cuda:0 device
+    // Cast to char to avoid compiler warning about narrowing
+    at::cuda::CUDAGuard device_guard{(char)x.get_device()};
+    auto stream = at::cuda::getCurrentCUDAStream().stream();
+    DISPATCH_ITYPE_FLOAT_AND_HALF_AND_BF16(x.scalar_type(), "causal_conv1d_fwd", [&] {
+        DISPATCH_WTYPE_FLOAT_AND_HALF_AND_BF16(weight.scalar_type(), "causal_conv1d_fwd", [&] {
+            if (!is_channel_last) {
+                causal_conv1d_fwd_cuda<input_t, weight_t>(params, stream);
+            } else {
+                causal_conv1d_channellast_fwd_cuda<input_t, weight_t>(params, stream);
+            }
+        });
+    });
+    return out;
+}
+
+std::vector<at::Tensor>
+causal_conv1d_bwd(const at::Tensor &x, const at::Tensor &weight,
+                  const c10::optional<at::Tensor> &bias_,
+                  at::Tensor &dout,
+                  c10::optional<at::Tensor> &dx_,
+                  bool silu_activation) {
+    auto input_type = x.scalar_type();
+    auto weight_type = weight.scalar_type();
+    TORCH_CHECK(input_type == at::ScalarType::Float || input_type == at::ScalarType::Half || input_type == at::ScalarType::BFloat16);
+    TORCH_CHECK(weight_type == at::ScalarType::Float || weight_type == at::ScalarType::Half || weight_type == at::ScalarType::BFloat16);
+
+    TORCH_CHECK(x.is_cuda());
+    TORCH_CHECK(weight.is_cuda());
+    TORCH_CHECK(dout.is_cuda());
+
+    const auto sizes = x.sizes();
+    const int batch_size = sizes[0];
+    const int dim = sizes[1];
+    const int seqlen = sizes[2];
+    const int width = weight.size(-1);
+
+    TORCH_CHECK(width >= 2 && width <= 4, "causal_conv1d only supports width between 2 and 4");
+
+    CHECK_SHAPE(x, batch_size, dim, seqlen);
+    CHECK_SHAPE(weight, dim, width);
+    CHECK_SHAPE(dout, batch_size, dim, seqlen);
+
+    TORCH_CHECK(x.stride(2) == 1 || x.stride(1) == 1);
+    const bool is_channel_last = x.stride(1) == 1 && x.stride(2) > 1;
+    if (!is_channel_last && dout.stride(2) != 1) { dout = dout.contiguous(); }
+    if (is_channel_last && dout.stride(1) != 1) { dout = dout.transpose(-1, -2).contiguous().transpose(-1, -2); }
+
+    if (bias_.has_value()) {
+        auto bias = bias_.value();
+        TORCH_CHECK(bias.scalar_type() == weight_type);
+        TORCH_CHECK(bias.is_cuda());
+        TORCH_CHECK(bias.stride(-1) == 1);
+        CHECK_SHAPE(bias, dim);
+    }
+
+    at::Tensor dx;
+    if (dx_.has_value()) {
+        dx = dx_.value();
+        TORCH_CHECK(dx.scalar_type() == input_type);
+        TORCH_CHECK(dx.is_cuda());
+        CHECK_SHAPE(dx, batch_size, dim, seqlen);
+        if (!is_channel_last) { TORCH_CHECK(dx.stride(2) == 1); }
+        if (is_channel_last) { TORCH_CHECK(dx.stride(1) == 1); }
+    } else {
+        dx = torch::empty_like(x);
+    }
+
+    // Otherwise the kernel will be launched from cuda:0 device
+    // Cast to char to avoid compiler warning about narrowing
+    at::cuda::CUDAGuard device_guard{(char)x.get_device()};
+
+    at::Tensor dweight = torch::zeros_like(weight, weight.options().dtype(at::kFloat));
+    at::Tensor dbias;
+    if (bias_.has_value()) { dbias = torch::zeros_like(bias_.value(), bias_.value().options().dtype(at::kFloat)); }
+
+    ConvParamsBwd params;
+    set_conv_params_bwd(params, batch_size, dim, seqlen, width,
+                        x, weight, bias_.has_value() ? bias_.value().data_ptr() : nullptr,
+                        dout, dx, dweight, bias_.has_value() ? dbias.data_ptr() : nullptr,
+                        silu_activation);
+
+    auto stream = at::cuda::getCurrentCUDAStream().stream();
+    DISPATCH_ITYPE_FLOAT_AND_HALF_AND_BF16(x.scalar_type(), "causal_conv1d_bwd", [&] {
+        DISPATCH_WTYPE_FLOAT_AND_HALF_AND_BF16(weight.scalar_type(), "causal_conv1d_bwd", [&] {
+            if (!is_channel_last) {
+                causal_conv1d_bwd_cuda<input_t, weight_t>(params, stream);
+            } else {
+                causal_conv1d_channellast_bwd_cuda<input_t, weight_t>(params, stream);
+            }
+        });
+    });
+    return {dx, dweight.to(weight.dtype()), bias_.has_value() ? dbias.to(bias_.value().dtype()) : dbias};
+}
+
+at::Tensor
+causal_conv1d_update(const at::Tensor &x,
+                     const at::Tensor &conv_state,
+                     const at::Tensor &weight,
+                     const c10::optional<at::Tensor> &bias_,
+                  bool silu_activation) {
+    auto input_type = x.scalar_type();
+    auto weight_type = weight.scalar_type();
+    TORCH_CHECK(input_type == at::ScalarType::Float || input_type == at::ScalarType::Half || input_type == at::ScalarType::BFloat16);
+    TORCH_CHECK(weight_type == at::ScalarType::Float || weight_type == at::ScalarType::Half || weight_type == at::ScalarType::BFloat16);
+    TORCH_CHECK(conv_state.scalar_type() == input_type);
+
+    TORCH_CHECK(x.is_cuda());
+    TORCH_CHECK(conv_state.is_cuda());
+    TORCH_CHECK(weight.is_cuda());
+
+    const auto sizes = x.sizes();
+    const int batch_size = sizes[0];
+    const int dim = sizes[1];
+    const int width = weight.size(-1);
+
+    CHECK_SHAPE(x, batch_size, dim);
+    CHECK_SHAPE(conv_state, batch_size, dim, width);
+    CHECK_SHAPE(weight, dim, width);
+
+    TORCH_CHECK(width >= 2 && width <= 4, "causal_conv1d only supports width between 2 and 4");
+
+    if (bias_.has_value()) {
+        auto bias = bias_.value();
+        TORCH_CHECK(bias.scalar_type() == weight_type);
+        TORCH_CHECK(bias.is_cuda());
+        TORCH_CHECK(bias.stride(-1) == 1);
+        CHECK_SHAPE(bias, dim);
+    }
+
+    at::Tensor out = torch::empty_like(x);
+
+    ConvParamsBase params;
+    set_conv_params_fwd(params, batch_size, dim, /*seqlen=*/1, width, x, weight, out,
+                        bias_.has_value() ? bias_.value().data_ptr() : nullptr,
+                        silu_activation);
+    params.conv_state_ptr = conv_state.data_ptr();
+    // All stride are in elements, not bytes.
+    params.conv_state_batch_stride = conv_state.stride(0);
+    params.conv_state_c_stride = conv_state.stride(1);
+    params.conv_state_l_stride = conv_state.stride(2);
+
+    // Otherwise the kernel will be launched from cuda:0 device
+    // Cast to char to avoid compiler warning about narrowing
+    at::cuda::CUDAGuard device_guard{(char)x.get_device()};
+    auto stream = at::cuda::getCurrentCUDAStream().stream();
+    DISPATCH_ITYPE_FLOAT_AND_HALF_AND_BF16(x.scalar_type(), "causal_conv1d_update", [&] {
+        DISPATCH_WTYPE_FLOAT_AND_HALF_AND_BF16(weight.scalar_type(), "causal_conv1d_update", [&] {
+            causal_conv1d_update_cuda<input_t, weight_t>(params, stream);
+        });
+    });
+    return out;
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+    m.def("causal_conv1d_fwd", &causal_conv1d_fwd, "Causal conv1d forward");
+    m.def("causal_conv1d_bwd", &causal_conv1d_bwd, "Causal conv1d backward");
+    m.def("causal_conv1d_update", &causal_conv1d_update, "Causal conv1d update");
+}

source_code/SegMamba/causal-conv1d/csrc/causal_conv1d.h

@@ -0,0 +1,53 @@
+/******************************************************************************
+ * Copyright (c) 2023, Tri Dao.
+ ******************************************************************************/
+
+#pragma once
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct ConvParamsBase {
+    using index_t = uint32_t;
+
+    int batch, dim, seqlen, width;
+    bool silu_activation;
+
+    index_t x_batch_stride;
+    index_t x_c_stride;
+    index_t x_l_stride;
+    index_t weight_c_stride;
+    index_t weight_width_stride;
+    index_t out_batch_stride;
+    index_t out_c_stride;
+    index_t out_l_stride;
+
+    index_t conv_state_batch_stride;
+    index_t conv_state_c_stride;
+    index_t conv_state_l_stride;
+
+    // Common data pointers.
+    void *__restrict__ x_ptr;
+    void *__restrict__ weight_ptr;
+    void *__restrict__ bias_ptr;
+    void *__restrict__ out_ptr;
+
+    void *__restrict__ conv_state_ptr;
+};
+
+struct ConvParamsBwd: public ConvParamsBase {
+    index_t dx_batch_stride;
+    index_t dx_c_stride;
+    index_t dx_l_stride;
+    index_t dweight_c_stride;
+    index_t dweight_width_stride;
+    index_t dout_batch_stride;
+    index_t dout_c_stride;
+    index_t dout_l_stride;
+
+    // Common data pointers.
+    void *__restrict__ dx_ptr;
+    void *__restrict__ dweight_ptr;
+    void *__restrict__ dbias_ptr;
+    void *__restrict__ dout_ptr;
+};
+

source_code/SegMamba/causal-conv1d/csrc/causal_conv1d_bwd.cu

@@ -0,0 +1,525 @@
+/******************************************************************************
+ * Copyright (c) 2023, Tri Dao.
+ ******************************************************************************/
+
+#include <c10/util/BFloat16.h>
+#include <c10/util/Half.h>
+#include <c10/cuda/CUDAException.h>  // For C10_CUDA_CHECK and C10_CUDA_KERNEL_LAUNCH_CHECK
+
+#include <cub/block/block_load.cuh>
+#include <cub/block/block_store.cuh>
+#include <cub/block/block_reduce.cuh>
+
+#include "causal_conv1d.h"
+#include "causal_conv1d_common.h"
+#include "static_switch.h"
+
+template<int kNThreads_, int kWidth_, bool kSiluAct_, bool kIsVecLoad_, typename input_t_, typename weight_t_>
+struct Causal_conv1d_bwd_kernel_traits {
+    using input_t = input_t_;
+    using weight_t = weight_t_;
+    static constexpr int kNThreads = kNThreads_;
+    static constexpr int kWidth = kWidth_;
+    static constexpr bool kSiluAct = kSiluAct_;
+    static constexpr int kNBytes = sizeof(input_t);
+    static_assert(kNBytes == 2 || kNBytes == 4);
+    static constexpr int kNElts = kNBytes == 4 ? 4 : 8;
+    static_assert(kWidth <= kNElts);
+    // It's possible that we need to do 2 rounds of exchange if input_t is 16 bits
+    // (since then we'd have 8 values of float, and each round we can exchange 4 floats).
+    static constexpr int kNExchangeRounds = sizeof(float) / sizeof(input_t);
+    static constexpr bool kIsVecLoad = kIsVecLoad_;
+    using vec_t = typename BytesToType<kNBytes * kNElts>::Type;
+    using BlockLoadT = cub::BlockLoad<input_t, kNThreads, kNElts, cub::BLOCK_LOAD_WARP_TRANSPOSE>;
+    using BlockLoadVecT = cub::BlockLoad<vec_t, kNThreads, 1, cub::BLOCK_LOAD_DIRECT>;
+    using BlockStoreT = cub::BlockStore<input_t, kNThreads, kNElts, cub::BLOCK_STORE_WARP_TRANSPOSE>;
+    using BlockStoreVecT = cub::BlockStore<vec_t, kNThreads, 1, cub::BLOCK_STORE_DIRECT>;
+    using BlockReduceFloatT = cub::BlockReduce<float, kNThreads>;
+    static constexpr int kSmemIOSize = kIsVecLoad
+        ? 0
+        : std::max({sizeof(typename BlockLoadT::TempStorage), sizeof(typename BlockStoreT::TempStorage)});
+    static constexpr int kSmemExchangeSize = kNThreads * kNBytes * kNElts * (!kSiluAct ? 1 : kNExchangeRounds + 1);
+    static constexpr int kSmemSize = std::max({kSmemExchangeSize,
+            int(sizeof(typename BlockReduceFloatT::TempStorage))}) + (kIsVecLoad ? 0 : kSmemIOSize);
+};
+
+template<typename Ktraits>
+__global__ __launch_bounds__(Ktraits::kNThreads)
+void causal_conv1d_bwd_kernel(ConvParamsBwd params) {
+    constexpr int kWidth = Ktraits::kWidth;
+    constexpr int kNThreads = Ktraits::kNThreads;
+    constexpr bool kSiluAct = Ktraits::kSiluAct;
+    constexpr int kNElts = Ktraits::kNElts;
+    constexpr int kNExchangeRounds = Ktraits::kNExchangeRounds;
+    constexpr bool kIsVecLoad = Ktraits::kIsVecLoad;
+    using input_t = typename Ktraits::input_t;
+    using vec_t = typename Ktraits::vec_t;
+    using weight_t = typename Ktraits::weight_t;
+
+    // Shared memory.
+    extern __shared__ char smem_[];
+    auto& smem_load = reinterpret_cast<typename Ktraits::BlockLoadT::TempStorage&>(smem_);
+    auto& smem_load_vec = reinterpret_cast<typename Ktraits::BlockLoadVecT::TempStorage&>(smem_);
+    auto& smem_store = reinterpret_cast<typename Ktraits::BlockStoreT::TempStorage&>(smem_);
+    auto& smem_store_vec = reinterpret_cast<typename Ktraits::BlockStoreVecT::TempStorage&>(smem_);
+    vec_t *smem_exchange = reinterpret_cast<vec_t *>(smem_ + Ktraits::kSmemIOSize);
+    vec_t *smem_exchange_x = reinterpret_cast<vec_t *>(smem_ + Ktraits::kSmemIOSize) + kNThreads * kNExchangeRounds;
+    auto& smem_reduce_float = *reinterpret_cast<typename Ktraits::BlockReduceFloatT::TempStorage*>(smem_ + Ktraits::kSmemIOSize);
+
+    const int tidx = threadIdx.x;
+    const int batch_id = blockIdx.x;
+    const int dim_id = blockIdx.y;
+    input_t *x = reinterpret_cast<input_t *>(params.x_ptr) + batch_id * params.x_batch_stride
+        + dim_id * params.x_c_stride;
+    weight_t *weight = reinterpret_cast<weight_t *>(params.weight_ptr) + dim_id * params.weight_c_stride;
+    input_t *dout = reinterpret_cast<input_t *>(params.dout_ptr) + batch_id * params.dout_batch_stride
+        + dim_id * params.dout_c_stride;
+    input_t *dx = reinterpret_cast<input_t *>(params.dx_ptr) + batch_id * params.dx_batch_stride
+        + dim_id * params.dx_c_stride;
+    float *dweight = reinterpret_cast<float *>(params.dweight_ptr) + dim_id * params.dweight_c_stride;
+    float bias_val = params.bias_ptr == nullptr ? 0.f : float(reinterpret_cast<weight_t *>(params.bias_ptr)[dim_id]);
+
+    // Thread kNThreads - 1 will load the first elements of the next chunk so we initialize those to 0.
+    if (tidx == 0) {
+        if constexpr (!kSiluAct) {
+            input_t zeros[kNElts] = {0};
+            smem_exchange[0] = reinterpret_cast<vec_t *>(zeros)[0];
+        } else {
+            float zeros[kNElts] = {0};
+            #pragma unroll
+            for (int r = 0; r < kNExchangeRounds; ++r) {
+                smem_exchange[r * kNThreads] = reinterpret_cast<vec_t *>(zeros)[r];
+            }
+        }
+    }
+
+    float weight_vals[kWidth];
+    #pragma unroll
+    for (int i = 0; i < kWidth; ++i) { weight_vals[i] = weight[i * params.weight_width_stride]; }
+
+    float dweight_vals[kWidth] = {0};
+    float dbias_val = 0;
+
+    constexpr int kChunkSize = kNThreads * kNElts;
+    const int n_chunks = (params.seqlen + kChunkSize - 1) / kChunkSize;
+    x += (n_chunks - 1) * kChunkSize;
+    dout += (n_chunks - 1) * kChunkSize;
+    dx += (n_chunks - 1) * kChunkSize;
+    for (int chunk = n_chunks - 1; chunk >= 0; --chunk) {
+        input_t x_vals_load[2 * kNElts] = {0};
+        input_t dout_vals_load[2 * kNElts] = {0};
+        if constexpr(kIsVecLoad) {
+            Ktraits::BlockLoadVecT(smem_load_vec).Load(reinterpret_cast<vec_t*>(x), *reinterpret_cast<vec_t (*)[1]>(&x_vals_load[kNElts]), (params.seqlen - chunk * kChunkSize) / kNElts);
+            Ktraits::BlockLoadVecT(smem_load_vec).Load(reinterpret_cast<vec_t*>(dout), *reinterpret_cast<vec_t (*)[1]>(&dout_vals_load[0]), (params.seqlen - chunk * kChunkSize) / kNElts);
+        } else {
+            __syncthreads();
+            Ktraits::BlockLoadT(smem_load).Load(x, *reinterpret_cast<input_t (*)[kNElts]>(&x_vals_load[kNElts]), params.seqlen - chunk * kChunkSize);
+            __syncthreads();
+            Ktraits::BlockLoadT(smem_load).Load(dout, *reinterpret_cast<input_t (*)[kNElts]>(&dout_vals_load[0]), params.seqlen - chunk * kChunkSize);
+        }
+        float dout_vals[2 * kNElts], x_vals[2 * kNElts];
+        if constexpr (!kSiluAct) {
+            __syncthreads();
+            // Thread 0 don't write yet, so that thread kNThreads - 1 can read
+            // the first elements of the next chunk.
+            if (tidx > 0) { smem_exchange[tidx] = reinterpret_cast<vec_t *>(dout_vals_load)[0]; }
+            __syncthreads();
+            reinterpret_cast<vec_t *>(dout_vals_load)[1] = smem_exchange[tidx < kNThreads - 1 ? tidx + 1 : 0];
+            __syncthreads();
+            // Now thread 0 can write the first elements of the current chunk.
+            if (tidx == 0) { smem_exchange[tidx] = reinterpret_cast<vec_t *>(dout_vals_load)[0]; }
+            #pragma unroll
+            for (int i = 0; i < 2 * kNElts; ++i) {
+                dout_vals[i] = float(dout_vals_load[i]);
+                x_vals[i] = float(x_vals_load[i]);
+            }
+        } else {
+            if (tidx == 0 && chunk > 0) {
+                if constexpr(kIsVecLoad) {
+                    reinterpret_cast<vec_t *>(x_vals_load)[0] = reinterpret_cast<vec_t *>(x)[-1];
+                } else {
+                    #pragma unroll
+                    for (int i = 0; i < kNElts; ++i) {
+                        if (chunk * kChunkSize + i < params.seqlen) { x_vals_load[i] = x[-kNElts + i]; }
+                    }
+                }
+            }
+            __syncthreads();
+            smem_exchange_x[tidx] = reinterpret_cast<vec_t *>(x_vals_load)[1];
+            __syncthreads();
+            if (tidx > 0) { reinterpret_cast<vec_t *>(x_vals_load)[0] = smem_exchange_x[tidx - 1]; }
+            #pragma unroll
+            for (int i = 0; i < 2 * kNElts; ++i) { x_vals[i] = float(x_vals_load[i]); }
+            // Recompute the output
+            #pragma unroll
+            for (int i = 0; i < kNElts; ++i) {
+                float out_val = bias_val;
+                #pragma unroll
+                for (int w = 0; w < kWidth; ++w) {
+                    out_val += weight_vals[w] * x_vals[kNElts + i - (kWidth - w - 1)];
+                }
+                float out_sigmoid_val = 1.0f / (1.0f + expf(-out_val));
+                dout_vals[i] = float(dout_vals_load[i]) * out_sigmoid_val
+                               * (1.0f + out_val * (1.0f - out_sigmoid_val));
+            }
+            // Exchange the dout_vals. It's possible that we need to do 2 rounds of exchange
+            // if input_t is 16 bits (since then we'd have 8 values of float)
+            __syncthreads();
+            // Thread 0 don't write yet, so that thread kNThreads - 1 can read
+            // the first elements of the next chunk.
+            if (tidx > 0) {
+                #pragma unroll
+                for (int r = 0; r < kNExchangeRounds; ++r) {
+                    smem_exchange[r * kNThreads + tidx] = reinterpret_cast<vec_t *>(dout_vals)[r];
+                }
+            }
+            __syncthreads();
+            #pragma unroll
+            for (int r = 0; r < kNExchangeRounds; ++r) {
+                reinterpret_cast<vec_t *>(dout_vals)[kNExchangeRounds + r]
+                    = smem_exchange[r * kNThreads + (tidx < kNThreads - 1 ? tidx + 1 : 0)];
+            }
+            __syncthreads();
+            // Now thread 0 can write the first elements of the current chunk.
+            if (tidx == 0) {
+                #pragma unroll
+                for (int r = 0; r < kNExchangeRounds; ++r) {
+                    smem_exchange[r * kNThreads + tidx] = reinterpret_cast<vec_t *>(dout_vals)[r];
+                }
+            }
+        }
+        dout -= kChunkSize;
+        x -= kChunkSize;
+
+        #pragma unroll
+        for (int i = 0; i < kNElts; ++i) { dbias_val += dout_vals[i]; }
+
+        float dx_vals[kNElts] = {0};
+        #pragma unroll
+        for (int i = 0; i < kNElts; ++i) {
+            #pragma unroll
+            for (int w = 0; w < kWidth; ++w) {
+                dx_vals[i] += weight_vals[w] * dout_vals[i + kWidth - w - 1];
+            }
+        }
+
+        input_t dx_vals_store[kNElts];
+        #pragma unroll
+        for (int i = 0; i < kNElts; ++i) { dx_vals_store[i] = dx_vals[i]; }
+        if constexpr(kIsVecLoad) {
+            Ktraits::BlockStoreVecT(smem_store_vec).Store(reinterpret_cast<vec_t*>(dx), reinterpret_cast<vec_t (&)[1]>(dx_vals_store), (params.seqlen - chunk * kChunkSize) / kNElts);
+        } else {
+            Ktraits::BlockStoreT(smem_store).Store(dx, dx_vals_store, params.seqlen - chunk * kChunkSize);
+        }
+        dx -= kChunkSize;
+
+        #pragma unroll
+        for (int w = 0; w < kWidth; ++w) {
+            #pragma unroll
+            for (int i = 0; i < kNElts; ++i) {
+                dweight_vals[w] += x_vals[kNElts + i] * dout_vals[i + kWidth - w - 1];
+            }
+        }
+    }
+
+    #pragma unroll
+    for (int w = 0; w < kWidth; ++w) {
+        __syncthreads();
+        dweight_vals[w] = Ktraits::BlockReduceFloatT(smem_reduce_float).Sum(dweight_vals[w]);
+        if (tidx == 0) {
+            atomicAdd(&reinterpret_cast<float *>(dweight)[w * params.dweight_width_stride], dweight_vals[w]);
+        }
+    }
+    if (params.bias_ptr != nullptr) {
+        __syncthreads();
+        dbias_val = Ktraits::BlockReduceFloatT(smem_reduce_float).Sum(dbias_val);
+        if (tidx == 0) {
+            atomicAdd(&reinterpret_cast<float *>(params.dbias_ptr)[dim_id], dbias_val);
+        }
+    }
+}
+
+template<int kNThreads, int kWidth, typename input_t, typename weight_t>
+void causal_conv1d_bwd_launch(ConvParamsBwd &params, cudaStream_t stream) {
+    static constexpr int kNElts = sizeof(input_t) == 4 ? 4 : 8;
+    BOOL_SWITCH(params.seqlen % kNElts == 0, kIsVecLoad, [&] {
+        BOOL_SWITCH(params.silu_activation, kSiluAct, [&] {
+            using Ktraits = Causal_conv1d_bwd_kernel_traits<kNThreads, kWidth, kSiluAct, kIsVecLoad, input_t, weight_t>;
+            constexpr int kSmemSize = Ktraits::kSmemSize;
+            dim3 grid(params.batch, params.dim);
+            auto kernel = &causal_conv1d_bwd_kernel<Ktraits>;
+            if (kSmemSize >= 48 * 1024) {
+                C10_CUDA_CHECK(cudaFuncSetAttribute(
+                    kernel, cudaFuncAttributeMaxDynamicSharedMemorySize, kSmemSize));
+                }
+            kernel<<<grid, Ktraits::kNThreads, kSmemSize, stream>>>(params);
+            C10_CUDA_KERNEL_LAUNCH_CHECK();
+        });
+    });
+}
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_bwd_cuda(ConvParamsBwd &params, cudaStream_t stream) {
+    if (params.width == 2) {
+        causal_conv1d_bwd_launch<128, 2, input_t, weight_t>(params, stream);
+    } else if (params.width == 3) {
+        causal_conv1d_bwd_launch<128, 3, input_t, weight_t>(params, stream);
+    } else if (params.width == 4) {
+        causal_conv1d_bwd_launch<128, 4, input_t, weight_t>(params, stream);
+    }
+}
+
+template<int kNThreads_, int kWidth_, int kChunkSizeL_, bool kSiluAct_, bool kIsVecLoad_, typename input_t_, typename weight_t_>
+struct Causal_conv1d_channellast_bwd_kernel_traits {
+    // The cache line is 128 bytes, and we try to read 16 bytes per thread.
+    // So we have 8 threads per "row", so 32 or 64 elements in the channel dimension.
+    // That leaves 4 columns per warp, and so 16 columns per block (assuming each block has 128
+    // threads). Each each load is 16 x 32|64 elements in the L x C dimensions.
+    using input_t = input_t_;
+    using weight_t = weight_t_;
+    static constexpr bool kSiluAct = kSiluAct_;
+    static constexpr int kNThreads = kNThreads_;
+    static_assert(kNThreads % 32 == 0);
+    static constexpr int kNWarps = kNThreads / 32;
+    static constexpr int kWidth = kWidth_;
+    static constexpr int kChunkSizeL = kChunkSizeL_;
+    static constexpr int kNBytes = sizeof(input_t);
+    static_assert(kNBytes == 2 || kNBytes == 4);
+    static constexpr int kNElts = kNBytes == 4 ? 4 : 8;
+    static constexpr int kNEltsPerRow = 128 / kNBytes;
+    static constexpr int kNThreadsPerRow = kNEltsPerRow / kNElts;  // Always 8 for now
+    static_assert(kNThreadsPerRow * kNBytes * kNElts == 128);
+    static constexpr int kNColsPerWarp = 32 / kNThreadsPerRow;  // Always 4 for now
+    static_assert(kNColsPerWarp * kNThreadsPerRow == 32);
+    static constexpr int kNColsPerLoad = kNColsPerWarp * kNWarps;
+    static constexpr int kNLoads = kChunkSizeL / kNColsPerLoad;
+    static_assert(kNLoads * kNColsPerLoad == kChunkSizeL);
+    static constexpr bool kIsVecLoad = kIsVecLoad_;
+    using vec_t = typename BytesToType<kNBytes * kNElts>::Type;
+    // using BlockLoadT = cub::BlockLoad<input_t, kNThreads, kNItems, cub::BLOCK_LOAD_WARP_TRANSPOSE>;
+    // using BlockStoreT = cub::BlockStore<input_t, kNThreads, kNItems, cub::BLOCK_STORE_WARP_TRANSPOSE>;
+    // static constexpr int kSmemSize = std::max({sizeof(typename BlockLoadT::TempStorage),
+    //                                            sizeof(typename BlockStoreT::TempStorage)});
+    // static constexpr int kSmemSize = kChunkSizeL * kNEltsPerRow * kNBytes;
+};
+
+template<typename Ktraits>
+__global__ __launch_bounds__(Ktraits::kNThreads)
+void causal_conv1d_channellast_bwd_kernel(ConvParamsBwd params) {
+    constexpr int kWidth = Ktraits::kWidth;
+    constexpr int kNThreads = Ktraits::kNThreads;
+    constexpr bool kSiluAct = Ktraits::kSiluAct;
+    constexpr int kNElts = Ktraits::kNElts;
+    constexpr int kNWarp = Ktraits::kNWarps;
+    constexpr int kNThreadsPerC = Ktraits::kNThreadsPerRow;
+    constexpr int kLPerLoad = Ktraits::kNColsPerLoad;
+    constexpr int kChunkSizeL = Ktraits::kChunkSizeL;
+    constexpr int kChunkSizeC = Ktraits::kNEltsPerRow;
+    using input_t = typename Ktraits::input_t;
+    using vec_t = typename Ktraits::vec_t;
+    using weight_t = typename Ktraits::weight_t;
+
+    // Shared memory.
+    __shared__ input_t dout_smem[kChunkSizeL + kWidth - 1][kChunkSizeC + kNElts];
+    __shared__ input_t x_smem[kWidth - 1 + kChunkSizeL + kWidth - 1][kChunkSizeC + kNElts];
+
+    const int tid = threadIdx.x;
+    const int l_idx = tid / kNThreadsPerC;
+    const int c_idx = tid % kNThreadsPerC;
+    const int batch_id = blockIdx.x;
+    const int chunk_l_id = blockIdx.y;
+    const int chunk_c_id = blockIdx.z;
+    input_t *x = reinterpret_cast<input_t *>(params.x_ptr) + batch_id * params.x_batch_stride
+        + (chunk_l_id * kChunkSizeL + l_idx) * params.x_l_stride + chunk_c_id * kChunkSizeC + c_idx * kNElts;
+    weight_t *weight = reinterpret_cast<weight_t *>(params.weight_ptr)
+        + chunk_c_id * kChunkSizeC * params.weight_c_stride;
+    input_t *dout = reinterpret_cast<input_t *>(params.dout_ptr) + batch_id * params.dout_batch_stride
+        + (chunk_l_id * kChunkSizeL + l_idx) * params.dout_l_stride + chunk_c_id * kChunkSizeC + c_idx * kNElts;
+    input_t *dx = reinterpret_cast<input_t *>(params.dx_ptr) + batch_id * params.dx_batch_stride
+        + (chunk_l_id * kChunkSizeL + l_idx) * params.dx_l_stride + chunk_c_id * kChunkSizeC + c_idx * kNElts;
+    float *dweight = reinterpret_cast<float *>(params.dweight_ptr)
+        + chunk_c_id * kChunkSizeC * params.dweight_c_stride;
+
+    #pragma unroll
+    for (int l = 0; l < Ktraits::kNLoads; ++l) {
+        input_t dout_vals_load[kNElts] = {0};
+        input_t x_vals_load[kNElts] = {0};
+        if (chunk_l_id * kChunkSizeL + l * kLPerLoad + l_idx < params.seqlen
+            && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+            reinterpret_cast<vec_t *>(dout_vals_load)[0] = *reinterpret_cast<vec_t *>(dout + l * kLPerLoad * params.dout_l_stride);
+            reinterpret_cast<vec_t *>(x_vals_load)[0] = *reinterpret_cast<vec_t *>(x + l * kLPerLoad * params.x_l_stride);
+        }
+        reinterpret_cast<vec_t *>(dout_smem[l * kLPerLoad + l_idx])[c_idx] = reinterpret_cast<vec_t *>(dout_vals_load)[0];
+        reinterpret_cast<vec_t *>(x_smem[kWidth - 1 + l * kLPerLoad + l_idx])[c_idx] = reinterpret_cast<vec_t *>(x_vals_load)[0];
+    }
+    // Load the elements from the previous chunk or next chunk that are needed for convolution.
+    if (l_idx < kWidth - 1) {
+        input_t dout_vals_load[kNElts] = {0};
+        input_t x_vals_load[kNElts] = {0};
+        if ((chunk_l_id + 1) * kChunkSizeL + l_idx < params.seqlen
+            && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+            reinterpret_cast<vec_t *>(dout_vals_load)[0] = *reinterpret_cast<vec_t *>(dout + kChunkSizeL * params.dout_l_stride);
+        }
+        if (chunk_l_id * kChunkSizeL + l_idx - (kWidth - 1) >= 0
+            && chunk_l_id * kChunkSizeL + l_idx - (kWidth - 1) < params.seqlen
+            && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+            reinterpret_cast<vec_t *>(x_vals_load)[0] = *reinterpret_cast<vec_t *>(x - (kWidth - 1) * params.x_l_stride);
+        }
+        reinterpret_cast<vec_t *>(dout_smem[kChunkSizeL + l_idx])[c_idx] = reinterpret_cast<vec_t *>(dout_vals_load)[0];
+        reinterpret_cast<vec_t *>(x_smem[l_idx])[c_idx] = reinterpret_cast<vec_t *>(x_vals_load)[0];
+    }
+    // Need to load (kWdith - 1) extra x's on the right to recompute the (kChunkSizeL + kWidth - 1) outputs
+    if constexpr (kSiluAct) {
+        if (l_idx < kWidth - 1) {
+            input_t x_vals_load[kNElts] = {0};
+            if ((chunk_l_id + 1) * kChunkSizeL + l_idx < params.seqlen
+                && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+                reinterpret_cast<vec_t *>(x_vals_load)[0] = *reinterpret_cast<vec_t *>(x + kChunkSizeL * params.x_l_stride);
+            }
+            reinterpret_cast<vec_t *>(x_smem[kWidth - 1 + kChunkSizeL + l_idx])[c_idx] = reinterpret_cast<vec_t *>(x_vals_load)[0];
+        }
+    }
+
+    __syncthreads();
+
+    constexpr int kLPerThread = std::min(kChunkSizeL * kChunkSizeC / kNThreads, kChunkSizeL);
+    static_assert(kLPerThread * kNThreads == kChunkSizeL * kChunkSizeC);
+    constexpr int kNThreadsPerRow = kChunkSizeL / kLPerThread;
+    static_assert(kNThreadsPerRow * kLPerThread == kChunkSizeL);
+    // kChunkSizeL, kLPerThread, kNThreadsPerRow should be powers of 2 for simplicity
+    static_assert((kChunkSizeL & (kChunkSizeL - 1)) == 0);
+    static_assert((kLPerThread & (kLPerThread - 1)) == 0);
+    static_assert((kNThreadsPerRow & (kNThreadsPerRow - 1)) == 0);
+    static_assert(kNThreadsPerRow <= 32);
+
+    const int row_idx = tid / kNThreadsPerRow;
+    const int col_idx = tid % kNThreadsPerRow;
+
+    float bias_val = params.bias_ptr == nullptr || chunk_c_id * kChunkSizeC + row_idx >= params.dim ? 0.f : float(reinterpret_cast<weight_t *>(params.bias_ptr)[chunk_c_id * kChunkSizeC + row_idx]);
+    float weight_vals[kWidth] = {0};
+    if (chunk_c_id * kChunkSizeC + row_idx < params.dim) {
+        #pragma unroll
+        for (int w = 0; w < kWidth; ++w) {
+            weight_vals[w] = weight[row_idx * params.weight_c_stride + w * params.weight_width_stride];
+        }
+    }
+    float dout_vals[kLPerThread + kWidth - 1];
+    float x_vals[kWidth - 1 + kLPerThread + kWidth - 1];
+    #pragma unroll
+    for (int i = 0; i < kWidth - 1 + kLPerThread; ++i) {
+        dout_vals[i] = float(dout_smem[col_idx * kLPerThread + i][row_idx]);
+        x_vals[i] = float(x_smem[col_idx * kLPerThread + i][row_idx]);
+    }
+
+    if constexpr (kSiluAct) {  // Recompute the output
+        #pragma unroll
+        for (int i = kWidth - 1 + kLPerThread; i < kWidth - 1 + kLPerThread + kWidth - 1; ++i) {
+            x_vals[i] = float(x_smem[col_idx * kLPerThread + i][row_idx]);
+        }
+        #pragma unroll
+        for (int i = 0; i < kLPerThread + kWidth - 1; ++i) {
+            float out_val = bias_val;
+            #pragma unroll
+            for (int w = 0; w < kWidth; ++w) { out_val += weight_vals[w] * x_vals[i + w]; }
+            float out_val_sigmoid = 1.f / (1.f + expf(-out_val));
+            dout_vals[i] *= out_val_sigmoid * (1 + out_val * (1 - out_val_sigmoid));
+        }
+    }
+
+    float dweight_vals[kWidth] = {0};
+    SumOp<float> sum_op;
+    #pragma unroll
+    for (int w = 0; w < kWidth; ++w) {
+        #pragma unroll
+        for (int i = 0; i < kLPerThread; ++i) { dweight_vals[w] += x_vals[i + w] * dout_vals[i]; }
+        dweight_vals[w] = Allreduce<kNThreadsPerRow>::run(dweight_vals[w], sum_op);
+        if (col_idx == 0 && chunk_c_id * kChunkSizeC + row_idx < params.dim) {
+            atomicAdd(&reinterpret_cast<float *>(dweight)[row_idx * params.dweight_c_stride + w * params.dweight_width_stride], dweight_vals[w]);
+        }
+    }
+
+    if (params.bias_ptr != nullptr) {
+        float dbias_val = 0.f;
+        for (int i = 0; i < kLPerThread; ++i) { dbias_val += dout_vals[i]; }
+        dbias_val = Allreduce<kNThreadsPerRow>::run(dbias_val, sum_op);
+        if (col_idx == 0 && chunk_c_id * kChunkSizeC + row_idx < params.dim) {
+            atomicAdd(&reinterpret_cast<float *>(params.dbias_ptr)[chunk_c_id * kChunkSizeC + row_idx], dbias_val);
+        }
+    }
+
+    float dx_vals[kLPerThread] = {0};
+    #pragma unroll
+    for (int i = 0; i < kLPerThread; ++i) {
+        #pragma unroll
+        for (int w = 0; w < kWidth; ++w) { dx_vals[i] += weight_vals[kWidth - 1 - w] * dout_vals[i + w]; }
+    }
+    // Since kNThreadsPerRow is a power of 2 and <= 32, we only need syncwarp and not syncthreads.
+    __syncwarp();
+    #pragma unroll
+    for (int i = 0; i < kLPerThread; ++i) { x_smem[col_idx * kLPerThread + i][row_idx] = dx_vals[i]; }
+    __syncthreads();
+
+    #pragma unroll
+    for (int l = 0; l < Ktraits::kNLoads; ++l) {
+        input_t dx_vals_store[kNElts];
+        reinterpret_cast<vec_t *>(dx_vals_store)[0] = reinterpret_cast<vec_t *>(x_smem[l * kLPerLoad + l_idx])[c_idx];
+        if (chunk_l_id * kChunkSizeL + l * kLPerLoad + l_idx < params.seqlen
+            && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+            *reinterpret_cast<vec_t *>(dx + l * kLPerLoad * params.dx_l_stride) = reinterpret_cast<vec_t *>(dx_vals_store)[0];
+        }
+    }
+
+}
+
+template<int kNThreads, int kWidth, typename input_t, typename weight_t>
+void causal_conv1d_channellast_bwd_launch(ConvParamsBwd &params, cudaStream_t stream) {
+    BOOL_SWITCH(params.silu_activation, kSiluAct, [&] {
+        using Ktraits = Causal_conv1d_channellast_bwd_kernel_traits<kNThreads, kWidth, 64, kSiluAct, true, input_t, weight_t>;
+        // constexpr int kSmemSize = Ktraits::kSmemSize;
+        constexpr int kChunkSizeL = Ktraits::kChunkSizeL;
+        constexpr int kChunkSizeC = Ktraits::kNEltsPerRow;
+        const int n_chunks_L = (params.seqlen + kChunkSizeL - 1) / kChunkSizeL;
+        const int n_chunks_C = (params.dim + kChunkSizeC - 1) / kChunkSizeC;
+        dim3 grid(params.batch, n_chunks_L, n_chunks_C);
+        dim3 block(Ktraits::kNThreads);
+        auto kernel = &causal_conv1d_channellast_bwd_kernel<Ktraits>;
+        // if (kSmemSize >= 48 * 1024) {
+        //     C10_CUDA_CHECK(cudaFuncSetAttribute(
+        //         kernel, cudaFuncAttributeMaxDynamicSharedMemorySize, kSmemSize));
+        //     }
+        // kernel<<<grid, Ktraits::kNThreads, kSmemSize, stream>>>(params);
+        kernel<<<grid, Ktraits::kNThreads, 0, stream>>>(params);
+        C10_CUDA_KERNEL_LAUNCH_CHECK();
+    });
+}
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_channellast_bwd_cuda(ConvParamsBwd &params, cudaStream_t stream) {
+    if (params.width == 2) {
+        causal_conv1d_channellast_bwd_launch<128, 2, input_t, weight_t>(params, stream);
+    } else if (params.width == 3) {
+        causal_conv1d_channellast_bwd_launch<128, 3, input_t, weight_t>(params, stream);
+    } else if (params.width == 4) {
+        causal_conv1d_channellast_bwd_launch<128, 4, input_t, weight_t>(params, stream);
+    }
+}
+
+template void causal_conv1d_bwd_cuda<float, float>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<at::Half, float>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<at::BFloat16, float>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<float, at::Half>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<at::Half, at::Half>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<at::BFloat16, at::Half>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<float, at::BFloat16>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<at::Half, at::BFloat16>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_bwd_cuda<at::BFloat16, at::BFloat16>(ConvParamsBwd &params, cudaStream_t stream);
+
+template void causal_conv1d_channellast_bwd_cuda<float, float>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<at::Half, float>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<at::BFloat16, float>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<float, at::Half>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<at::Half, at::Half>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<at::BFloat16, at::Half>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<float, at::BFloat16>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<at::Half, at::BFloat16>(ConvParamsBwd &params, cudaStream_t stream);
+template void causal_conv1d_channellast_bwd_cuda<at::BFloat16, at::BFloat16>(ConvParamsBwd &params, cudaStream_t stream);

source_code/SegMamba/causal-conv1d/csrc/causal_conv1d_common.h

@@ -0,0 +1,64 @@
+/******************************************************************************
+ * Copyright (c) 2023, Tri Dao.
+ ******************************************************************************/
+
+#pragma once
+
+#include <cuda_bf16.h>
+#include <cuda_fp16.h>
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<int BYTES> struct BytesToType {};
+
+template<> struct BytesToType<16> {
+    using Type = uint4;
+    static_assert(sizeof(Type) == 16);
+};
+
+template<> struct BytesToType<8> {
+    using Type = uint64_t;
+    static_assert(sizeof(Type) == 8);
+};
+
+template<> struct BytesToType<4> {
+    using Type = uint32_t;
+    static_assert(sizeof(Type) == 4);
+};
+
+template<> struct BytesToType<2> {
+    using Type = uint16_t;
+    static_assert(sizeof(Type) == 2);
+};
+
+template<> struct BytesToType<1> {
+    using Type = uint8_t;
+    static_assert(sizeof(Type) == 1);
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+struct SumOp {
+__device__ inline T operator()(T const & x, T const & y) { return x + y; }
+};
+
+template<int THREADS>
+struct Allreduce {
+    static_assert(THREADS == 32 || THREADS == 16 || THREADS == 8 || THREADS == 4);
+    template<typename T, typename Operator>
+    static __device__ inline T run(T x, Operator &op) {
+        constexpr int OFFSET = THREADS / 2;
+        x = op(x, __shfl_xor_sync(uint32_t(-1), x, OFFSET));
+        return Allreduce<OFFSET>::run(x, op);
+    }
+};
+
+template<>
+struct Allreduce<2> {
+template<typename T, typename Operator>
+static __device__ inline T run(T x, Operator &op) {
+    x = op(x, __shfl_xor_sync(uint32_t(-1), x, 1));
+    return x;
+}
+};

source_code/SegMamba/causal-conv1d/csrc/causal_conv1d_fwd.cu

@@ -0,0 +1,350 @@
+/******************************************************************************
+ * Copyright (c) 2023, Tri Dao.
+ ******************************************************************************/
+
+#include <c10/util/BFloat16.h>
+#include <c10/util/Half.h>
+#include <c10/cuda/CUDAException.h>  // For C10_CUDA_CHECK and C10_CUDA_KERNEL_LAUNCH_CHECK
+
+#include <cub/block/block_load.cuh>
+#include <cub/block/block_store.cuh>
+
+#include "causal_conv1d.h"
+#include "causal_conv1d_common.h"
+#include "static_switch.h"
+
+template<int kNThreads_, int kWidth_, bool kIsVecLoad_, typename input_t_, typename weight_t_>
+struct Causal_conv1d_fwd_kernel_traits {
+    using input_t = input_t_;
+    using weight_t = weight_t_;
+    static constexpr int kNThreads = kNThreads_;
+    static constexpr int kWidth = kWidth_;
+    static constexpr int kNBytes = sizeof(input_t);
+    static_assert(kNBytes == 2 || kNBytes == 4);
+    static constexpr int kNElts = kNBytes == 4 ? 4 : 8;
+    static_assert(kWidth <= kNElts);
+    static constexpr bool kIsVecLoad = kIsVecLoad_;
+    using vec_t = typename BytesToType<kNBytes * kNElts>::Type;
+    using BlockLoadT = cub::BlockLoad<input_t, kNThreads, kNElts, cub::BLOCK_LOAD_WARP_TRANSPOSE>;
+    using BlockLoadVecT = cub::BlockLoad<vec_t, kNThreads, 1, cub::BLOCK_LOAD_DIRECT>;
+    using BlockStoreT = cub::BlockStore<input_t, kNThreads, kNElts, cub::BLOCK_STORE_WARP_TRANSPOSE>;
+    using BlockStoreVecT = cub::BlockStore<vec_t, kNThreads, 1, cub::BLOCK_STORE_DIRECT>;
+    static constexpr int kSmemIOSize = kIsVecLoad
+        ? 0
+        : std::max({sizeof(typename BlockLoadT::TempStorage), sizeof(typename BlockStoreT::TempStorage)});
+    static constexpr int kSmemExchangeSize = kNThreads * kNBytes * kNElts;
+    static constexpr int kSmemSize = kSmemIOSize + kSmemExchangeSize;
+};
+
+template<typename Ktraits>
+__global__ __launch_bounds__(Ktraits::kNThreads)
+void causal_conv1d_fwd_kernel(ConvParamsBase params) {
+    constexpr int kWidth = Ktraits::kWidth;
+    constexpr int kNThreads = Ktraits::kNThreads;
+    constexpr int kNElts = Ktraits::kNElts;
+    constexpr bool kIsVecLoad = Ktraits::kIsVecLoad;
+    using input_t = typename Ktraits::input_t;
+    using vec_t = typename Ktraits::vec_t;
+    using weight_t = typename Ktraits::weight_t;
+
+    // Shared memory.
+    extern __shared__ char smem_[];
+    auto& smem_load = reinterpret_cast<typename Ktraits::BlockLoadT::TempStorage&>(smem_);
+    auto& smem_load_vec = reinterpret_cast<typename Ktraits::BlockLoadVecT::TempStorage&>(smem_);
+    auto& smem_store = reinterpret_cast<typename Ktraits::BlockStoreT::TempStorage&>(smem_);
+    auto& smem_store_vec = reinterpret_cast<typename Ktraits::BlockStoreVecT::TempStorage&>(smem_);
+    vec_t *smem_exchange = reinterpret_cast<vec_t *>(smem_ + Ktraits::kSmemIOSize);
+
+    const int tidx = threadIdx.x;
+    const int batch_id = blockIdx.x;
+    const int channel_id = blockIdx.y;
+    input_t *x = reinterpret_cast<input_t *>(params.x_ptr) + batch_id * params.x_batch_stride
+        + channel_id * params.x_c_stride;
+    weight_t *weight = reinterpret_cast<weight_t *>(params.weight_ptr) + channel_id * params.weight_c_stride;
+    input_t *out = reinterpret_cast<input_t *>(params.out_ptr) + batch_id * params.out_batch_stride
+        + channel_id * params.out_c_stride;
+    float bias_val = params.bias_ptr == nullptr ? 0.f : float(reinterpret_cast<weight_t *>(params.bias_ptr)[channel_id]);
+
+    // Thread 0 will load the last elements of the previous chunk, so we initialize those to 0.
+    if (tidx == 0) {
+        input_t zeros[kNElts] = {0};
+        smem_exchange[kNThreads - 1] = reinterpret_cast<vec_t *>(zeros)[0];
+    }
+
+    float weight_vals[kWidth];
+    #pragma unroll
+    for (int i = 0; i < kWidth; ++i) { weight_vals[i] = float(weight[i * params.weight_width_stride]); }
+
+    constexpr int kChunkSize = kNThreads * kNElts;
+    const int n_chunks = (params.seqlen + kChunkSize - 1) / kChunkSize;
+    for (int chunk = 0; chunk < n_chunks; ++chunk) {
+        input_t x_vals_load[2 * kNElts] = {0};
+        if constexpr(kIsVecLoad) {
+            Ktraits::BlockLoadVecT(smem_load_vec).Load(reinterpret_cast<vec_t*>(x), *reinterpret_cast<vec_t (*)[1]>(&x_vals_load[kNElts]), (params.seqlen - chunk * kChunkSize) / kNElts);
+        } else {
+            __syncthreads();
+            Ktraits::BlockLoadT(smem_load).Load(x, *reinterpret_cast<input_t (*)[kNElts]>(&x_vals_load[kNElts]), params.seqlen - chunk * kChunkSize);
+        }
+        x += kChunkSize;
+        __syncthreads();
+        // Thread kNThreads - 1 don't write yet, so that thread 0 can read
+        // the last elements of the previous chunk.
+        if (tidx < kNThreads - 1) { smem_exchange[tidx] = reinterpret_cast<vec_t *>(x_vals_load)[1]; }
+        __syncthreads();
+        reinterpret_cast<vec_t *>(x_vals_load)[0] = smem_exchange[tidx > 0 ? tidx - 1 : kNThreads - 1];
+        __syncthreads();
+        // Now thread kNThreads - 1 can write the last elements of the current chunk.
+        if (tidx == kNThreads - 1) { smem_exchange[tidx] = reinterpret_cast<vec_t *>(x_vals_load)[1]; }
+
+        float x_vals[2 * kNElts];
+        #pragma unroll
+        for (int i = 0; i < 2 * kNElts; ++i) { x_vals[i] = float(x_vals_load[i]); }
+
+        float out_vals[kNElts];
+        #pragma unroll
+        for (int i = 0; i < kNElts; ++i) {
+            out_vals[i] = bias_val;
+            #pragma unroll
+            for (int w = 0; w < kWidth; ++w) {
+                out_vals[i] += weight_vals[w] * x_vals[kNElts + i - (kWidth - w - 1)];
+            }
+        }
+
+        if (params.silu_activation) {
+            #pragma unroll
+            for (int i = 0; i < kNElts; ++i) {
+                out_vals[i] = out_vals[i] / (1 + expf(-out_vals[i]));
+            }
+        }
+
+        input_t out_vals_store[kNElts];
+        #pragma unroll
+        for (int i = 0; i < kNElts; ++i) { out_vals_store[i] = out_vals[i]; }
+        if constexpr(kIsVecLoad) {
+            Ktraits::BlockStoreVecT(smem_store_vec).Store(reinterpret_cast<vec_t*>(out), reinterpret_cast<vec_t (&)[1]>(out_vals_store), (params.seqlen - chunk * kChunkSize) / kNElts);
+        } else {
+            Ktraits::BlockStoreT(smem_store).Store(out, out_vals_store, params.seqlen - chunk * kChunkSize);
+        }
+        out += kChunkSize;
+    }
+}
+
+template<int kNThreads, int kWidth, typename input_t, typename weight_t>
+void causal_conv1d_fwd_launch(ConvParamsBase &params, cudaStream_t stream) {
+    static constexpr int kNElts = sizeof(input_t) == 4 ? 4 : 8;
+    BOOL_SWITCH(params.seqlen % kNElts == 0, kIsVecLoad, [&] {
+        using Ktraits = Causal_conv1d_fwd_kernel_traits<kNThreads, kWidth, kIsVecLoad, input_t, weight_t>;
+        constexpr int kSmemSize = Ktraits::kSmemSize;
+        dim3 grid(params.batch, params.dim);
+        auto kernel = &causal_conv1d_fwd_kernel<Ktraits>;
+        if (kSmemSize >= 48 * 1024) {
+            C10_CUDA_CHECK(cudaFuncSetAttribute(
+                kernel, cudaFuncAttributeMaxDynamicSharedMemorySize, kSmemSize));
+            }
+        kernel<<<grid, Ktraits::kNThreads, kSmemSize, stream>>>(params);
+        C10_CUDA_KERNEL_LAUNCH_CHECK();
+    });
+}
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_fwd_cuda(ConvParamsBase &params, cudaStream_t stream) {
+    if (params.width == 2) {
+        causal_conv1d_fwd_launch<128, 2, input_t, weight_t>(params, stream);
+    } else if (params.width == 3) {
+        causal_conv1d_fwd_launch<128, 3, input_t, weight_t>(params, stream);
+    } else if (params.width == 4) {
+        causal_conv1d_fwd_launch<128, 4, input_t, weight_t>(params, stream);
+    }
+}
+
+template<int kNThreads_, int kWidth_, int kChunkSizeL_, bool kIsVecLoad_, typename input_t_, typename weight_t_>
+struct Causal_conv1d_channellast_fwd_kernel_traits {
+    // The cache line is 128 bytes, and we try to read 16 bytes per thread.
+    // So we have 8 threads per "row", so 32 or 64 elements in the channel dimension.
+    // That leaves 4 columns per warp, and so 16 columns per block (assuming each block has 128
+    // threads). Each each load is 16 x 32|64 elements in the L x C dimensions.
+    using input_t = input_t_;
+    using weight_t = weight_t_;
+    static constexpr int kNThreads = kNThreads_;
+    static_assert(kNThreads % 32 == 0);
+    static constexpr int kNWarps = kNThreads / 32;
+    static constexpr int kWidth = kWidth_;
+    static constexpr int kChunkSizeL = kChunkSizeL_;
+    static constexpr int kNBytes = sizeof(input_t);
+    static_assert(kNBytes == 2 || kNBytes == 4);
+    static constexpr int kNElts = kNBytes == 4 ? 4 : 8;
+    static constexpr int kNEltsPerRow = 128 / kNBytes;
+    static constexpr int kNThreadsPerRow = kNEltsPerRow / kNElts;  // Always 8 for now
+    static_assert(kNThreadsPerRow * kNBytes * kNElts == 128);
+    static constexpr int kNColsPerWarp = 32 / kNThreadsPerRow;  // Always 4 for now
+    static_assert(kNColsPerWarp * kNThreadsPerRow == 32);
+    static constexpr int kNColsPerLoad = kNColsPerWarp * kNWarps;
+    static constexpr int kNLoads = kChunkSizeL / kNColsPerLoad;
+    static_assert(kNLoads * kNColsPerLoad == kChunkSizeL);
+    static constexpr bool kIsVecLoad = kIsVecLoad_;
+    using vec_t = typename BytesToType<kNBytes * kNElts>::Type;
+    // using BlockLoadT = cub::BlockLoad<input_t, kNThreads, kNItems, cub::BLOCK_LOAD_WARP_TRANSPOSE>;
+    // using BlockStoreT = cub::BlockStore<input_t, kNThreads, kNItems, cub::BLOCK_STORE_WARP_TRANSPOSE>;
+    // static constexpr int kSmemSize = std::max({sizeof(typename BlockLoadT::TempStorage),
+    //                                            sizeof(typename BlockStoreT::TempStorage)});
+    // static constexpr int kSmemSize = kChunkSizeL * kNEltsPerRow * kNBytes;
+};
+
+template<typename Ktraits>
+__global__ __launch_bounds__(Ktraits::kNThreads)
+void causal_conv1d_channellast_fwd_kernel(ConvParamsBase params) {
+    constexpr int kWidth = Ktraits::kWidth;
+    constexpr int kNThreads = Ktraits::kNThreads;
+    constexpr int kNElts = Ktraits::kNElts;
+    constexpr int kNWarp = Ktraits::kNWarps;
+    constexpr int kNThreadsPerC = Ktraits::kNThreadsPerRow;
+    constexpr int kLPerLoad = Ktraits::kNColsPerLoad;
+    constexpr int kChunkSizeL = Ktraits::kChunkSizeL;
+    constexpr int kChunkSizeC = Ktraits::kNEltsPerRow;
+    using input_t = typename Ktraits::input_t;
+    using vec_t = typename Ktraits::vec_t;
+    using weight_t = typename Ktraits::weight_t;
+
+    // Shared memory.
+    __shared__ input_t x_smem[kWidth - 1 + kChunkSizeL][kChunkSizeC + kNElts];
+
+    const int tid = threadIdx.x;
+    const int l_idx = tid / kNThreadsPerC;
+    const int c_idx = tid % kNThreadsPerC;
+    const int batch_id = blockIdx.x;
+    const int chunk_l_id = blockIdx.y;
+    const int chunk_c_id = blockIdx.z;
+    input_t *x = reinterpret_cast<input_t *>(params.x_ptr) + batch_id * params.x_batch_stride
+        + (chunk_l_id * kChunkSizeL + l_idx) * params.x_l_stride + chunk_c_id * kChunkSizeC + c_idx * kNElts;
+    weight_t *weight = reinterpret_cast<weight_t *>(params.weight_ptr)
+        + chunk_c_id * kChunkSizeC * params.weight_c_stride;
+    input_t *out = reinterpret_cast<input_t *>(params.out_ptr) + batch_id * params.out_batch_stride
+        + (chunk_l_id * kChunkSizeL + l_idx) * params.out_l_stride + chunk_c_id * kChunkSizeC + c_idx * kNElts;
+
+    #pragma unroll
+    for (int l = 0; l < Ktraits::kNLoads; ++l) {
+        input_t x_vals_load[kNElts] = {0};
+        if (chunk_l_id * kChunkSizeL + l * kLPerLoad + l_idx < params.seqlen
+            && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+            reinterpret_cast<vec_t *>(x_vals_load)[0] = *reinterpret_cast<vec_t *>(x + l * kLPerLoad * params.x_l_stride);
+        }
+        reinterpret_cast<vec_t *>(x_smem[kWidth - 1 + l * kLPerLoad + l_idx])[c_idx] = reinterpret_cast<vec_t *>(x_vals_load)[0];
+    }
+    // Load the elements from the previous chunk that are needed for convolution.
+    if (l_idx < kWidth - 1) {
+        input_t x_vals_load[kNElts] = {0};
+        if (chunk_l_id * kChunkSizeL + l_idx - (kWidth - 1) >= 0
+            && chunk_l_id * kChunkSizeL + l_idx - (kWidth - 1) < params.seqlen
+            && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+            reinterpret_cast<vec_t *>(x_vals_load)[0] = *reinterpret_cast<vec_t *>(x - (kWidth - 1) * params.x_l_stride);
+        }
+        reinterpret_cast<vec_t *>(x_smem[l_idx])[c_idx] = reinterpret_cast<vec_t *>(x_vals_load)[0];
+    }
+
+    __syncthreads();
+
+    constexpr int kLPerThread = std::min(kChunkSizeL * kChunkSizeC / kNThreads, kChunkSizeL);
+    static_assert(kLPerThread * kNThreads == kChunkSizeL * kChunkSizeC);
+    constexpr int kNThreadsPerRow = kChunkSizeL / kLPerThread;
+    static_assert(kNThreadsPerRow * kLPerThread == kChunkSizeL);
+    // kChunkSizeL, kLPerThread, kNThreadsPerRow should be powers of 2 for simplicity
+    static_assert((kChunkSizeL & (kChunkSizeL - 1)) == 0);
+    static_assert((kLPerThread & (kLPerThread - 1)) == 0);
+    static_assert((kNThreadsPerRow & (kNThreadsPerRow - 1)) == 0);
+    static_assert(kNThreadsPerRow <= 32);
+
+    const int row_idx = tid / kNThreadsPerRow;
+    const int col_idx = tid % kNThreadsPerRow;
+
+    float bias_val = params.bias_ptr == nullptr || chunk_c_id * kChunkSizeC + row_idx >= params.dim ? 0.f : float(reinterpret_cast<weight_t *>(params.bias_ptr)[chunk_c_id * kChunkSizeC + row_idx]);
+    float weight_vals[kWidth] = {0};
+    if (chunk_c_id + kChunkSizeC + row_idx < params.dim) {
+        #pragma unroll
+        for (int w = 0; w < kWidth; ++w) {
+            weight_vals[w] = weight[row_idx * params.weight_c_stride + w * params.weight_width_stride];
+        }
+    }
+    float x_vals[kWidth - 1 + kLPerThread];
+    #pragma unroll
+    for (int i = 0; i < kWidth - 1 + kLPerThread; ++i) {
+        x_vals[i] = float(x_smem[col_idx * kLPerThread + i][row_idx]);
+    }
+
+    float out_vals[kLPerThread];
+    #pragma unroll
+    for (int i = 0; i < kLPerThread; ++i) {
+        out_vals[i] = bias_val;
+        #pragma unroll
+        for (int w = 0; w < kWidth; ++w) { out_vals[i] += weight_vals[w] * x_vals[i + w]; }
+        if (params.silu_activation) {out_vals[i] = out_vals[i] / (1 + expf(-out_vals[i])); }
+    }
+
+    // Since kNThreadsPerRow is a power of 2 and <= 32, we only need syncwarp and not syncthreads.
+    __syncwarp();
+    #pragma unroll
+    for (int i = 0; i < kLPerThread; ++i) { x_smem[col_idx * kLPerThread + i][row_idx] = out_vals[i]; }
+    __syncthreads();
+
+    #pragma unroll
+    for (int l = 0; l < Ktraits::kNLoads; ++l) {
+        input_t out_vals_store[kNElts];
+        reinterpret_cast<vec_t *>(out_vals_store)[0] = reinterpret_cast<vec_t *>(x_smem[l * kLPerLoad + l_idx])[c_idx];
+        if (chunk_l_id * kChunkSizeL + l * kLPerLoad + l_idx < params.seqlen
+            && chunk_c_id * kChunkSizeC + c_idx * kNElts < params.dim) {
+            *reinterpret_cast<vec_t *>(out + l * kLPerLoad * params.out_l_stride) = reinterpret_cast<vec_t *>(out_vals_store)[0];
+        }
+    }
+
+}
+
+template<int kNThreads, int kWidth, typename input_t, typename weight_t>
+void causal_conv1d_channellast_fwd_launch(ConvParamsBase &params, cudaStream_t stream) {
+    using Ktraits = Causal_conv1d_channellast_fwd_kernel_traits<kNThreads, kWidth, 64, true, input_t, weight_t>;
+    // constexpr int kSmemSize = Ktraits::kSmemSize;
+    constexpr int kChunkSizeL = Ktraits::kChunkSizeL;
+    constexpr int kChunkSizeC = Ktraits::kNEltsPerRow;
+    const int n_chunks_L = (params.seqlen + kChunkSizeL - 1) / kChunkSizeL;
+    const int n_chunks_C = (params.dim + kChunkSizeC - 1) / kChunkSizeC;
+    // printf("n_chunks_L: %d, n_chunks_C: %d\n", n_chunks_L, n_chunks_C);
+    dim3 grid(params.batch, n_chunks_L, n_chunks_C);
+    dim3 block(Ktraits::kNThreads);
+    auto kernel = &causal_conv1d_channellast_fwd_kernel<Ktraits>;
+    // if (kSmemSize >= 48 * 1024) {
+    //     C10_CUDA_CHECK(cudaFuncSetAttribute(
+    //         kernel, cudaFuncAttributeMaxDynamicSharedMemorySize, kSmemSize));
+    //     }
+    // kernel<<<grid, Ktraits::kNThreads, kSmemSize, stream>>>(params);
+    kernel<<<grid, Ktraits::kNThreads, 0, stream>>>(params);
+    C10_CUDA_KERNEL_LAUNCH_CHECK();
+}
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_channellast_fwd_cuda(ConvParamsBase &params, cudaStream_t stream) {
+    if (params.width == 2) {
+        causal_conv1d_channellast_fwd_launch<128, 2, input_t, weight_t>(params, stream);
+    } else if (params.width == 3) {
+        causal_conv1d_channellast_fwd_launch<128, 3, input_t, weight_t>(params, stream);
+    } else if (params.width == 4) {
+        causal_conv1d_channellast_fwd_launch<128, 4, input_t, weight_t>(params, stream);
+    }
+}
+
+template void causal_conv1d_fwd_cuda<float, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<at::Half, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<at::BFloat16, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<float, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<at::Half, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<at::BFloat16, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<float, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<at::Half, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_fwd_cuda<at::BFloat16, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);
+
+template void causal_conv1d_channellast_fwd_cuda<float, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<at::Half, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<at::BFloat16, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<float, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<at::Half, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<at::BFloat16, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<float, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<at::Half, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_channellast_fwd_cuda<at::BFloat16, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);

source_code/SegMamba/causal-conv1d/csrc/causal_conv1d_update.cu

@@ -0,0 +1,96 @@
+/******************************************************************************
+ * Copyright (c) 2023, Tri Dao.
+ ******************************************************************************/
+
+#include <c10/util/BFloat16.h>
+#include <c10/util/Half.h>
+#include <c10/cuda/CUDAException.h>  // For C10_CUDA_CHECK and C10_CUDA_KERNEL_LAUNCH_CHECK
+
+#include <cub/block/block_load.cuh>
+#include <cub/block/block_store.cuh>
+
+#include "causal_conv1d.h"
+#include "causal_conv1d_common.h"
+#include "static_switch.h"
+
+template<int kNThreads_, int kWidth_, typename input_t_, typename weight_t_>
+struct Causal_conv1d_update_kernel_traits {
+    using input_t = input_t_;
+    using weight_t = weight_t_;
+    static constexpr int kNThreads = kNThreads_;
+    static constexpr int kWidth = kWidth_;
+    static constexpr int kNBytes = sizeof(input_t);
+    static_assert(kNBytes == 2 || kNBytes == 4);
+};
+
+template<typename Ktraits>
+__global__ __launch_bounds__(Ktraits::kNThreads)
+void causal_conv1d_update_kernel(ConvParamsBase params) {
+    constexpr int kWidth = Ktraits::kWidth;
+    constexpr int kNThreads = Ktraits::kNThreads;
+    using input_t = typename Ktraits::input_t;
+    using weight_t = typename Ktraits::weight_t;
+
+    const int tidx = threadIdx.x;
+    const int batch_id = blockIdx.x;
+    const int channel_id = blockIdx.y * kNThreads + tidx;
+    input_t *x = reinterpret_cast<input_t *>(params.x_ptr) + batch_id * params.x_batch_stride
+        + channel_id * params.x_c_stride;
+    input_t *conv_state = reinterpret_cast<input_t *>(params.conv_state_ptr) + batch_id * params.conv_state_batch_stride
+        + channel_id * params.conv_state_c_stride;
+    weight_t *weight = reinterpret_cast<weight_t *>(params.weight_ptr) + channel_id * params.weight_c_stride;
+    input_t *out = reinterpret_cast<input_t *>(params.out_ptr) + batch_id * params.out_batch_stride
+        + channel_id * params.out_c_stride;
+    float bias_val = params.bias_ptr == nullptr || channel_id >= params.dim ? 0.f : float(reinterpret_cast<weight_t *>(params.bias_ptr)[channel_id]);
+
+    float weight_vals[kWidth] = {0};
+    if (channel_id < params.dim) {
+        #pragma unroll
+        for (int i = 0; i < kWidth; ++i) { weight_vals[i] = float(weight[i * params.weight_width_stride]); }
+    }
+
+    float x_vals[kWidth] = {0};
+    if (channel_id < params.dim) {
+        #pragma unroll
+        for (int i = 0; i < kWidth - 1; ++i) { x_vals[i] = float(conv_state[(i + 1) * params.conv_state_l_stride]); }
+        x_vals[kWidth - 1] = float(x[0]);
+        #pragma unroll
+        for (int i = 0; i < kWidth; ++i) { conv_state[i * params.conv_state_l_stride] = input_t(x_vals[i]); }
+    }
+
+    float out_val = bias_val;
+    #pragma unroll
+    for (int i = 0; i < kWidth; ++i) { out_val += weight_vals[i] * x_vals[i]; }
+    if (params.silu_activation) { out_val = out_val / (1 + expf(-out_val)); }
+    if (channel_id < params.dim) { out[0] = input_t(out_val); }
+}
+
+template<int kNThreads, int kWidth, typename input_t, typename weight_t>
+void causal_conv1d_update_launch(ConvParamsBase &params, cudaStream_t stream) {
+    using Ktraits = Causal_conv1d_update_kernel_traits<kNThreads, kWidth, input_t, weight_t>;
+    dim3 grid(params.batch, (params.dim + kNThreads - 1) / kNThreads);
+    auto kernel = &causal_conv1d_update_kernel<Ktraits>;
+    kernel<<<grid, Ktraits::kNThreads, 0, stream>>>(params);
+    C10_CUDA_KERNEL_LAUNCH_CHECK();
+}
+
+template<typename input_t, typename weight_t>
+void causal_conv1d_update_cuda(ConvParamsBase &params, cudaStream_t stream) {
+    if (params.width == 2) {
+        causal_conv1d_update_launch<64, 2, input_t, weight_t>(params, stream);
+    } else if (params.width == 3) {
+        causal_conv1d_update_launch<64, 3, input_t, weight_t>(params, stream);
+    } else if (params.width == 4) {
+        causal_conv1d_update_launch<64, 4, input_t, weight_t>(params, stream);
+    }
+}
+
+template void causal_conv1d_update_cuda<float, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<at::Half, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<at::BFloat16, float>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<float, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<at::Half, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<at::BFloat16, at::Half>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<float, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<at::Half, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);
+template void causal_conv1d_update_cuda<at::BFloat16, at::BFloat16>(ConvParamsBase &params, cudaStream_t stream);

source_code/SegMamba/causal-conv1d/csrc/static_switch.h

@@ -0,0 +1,25 @@
+// Inspired by https://github.com/NVIDIA/DALI/blob/main/include/dali/core/static_switch.h
+// and https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/Dispatch.h
+
+#pragma once
+
+/// @param COND       - a boolean expression to switch by
+/// @param CONST_NAME - a name given for the constexpr bool variable.
+/// @param ...       - code to execute for true and false
+///
+/// Usage:
+/// ```
+/// BOOL_SWITCH(flag, BoolConst, [&] {
+///     some_function<BoolConst>(...);
+/// });
+/// ```
+#define BOOL_SWITCH(COND, CONST_NAME, ...)                                           \
+    [&] {                                                                            \
+        if (COND) {                                                                  \
+            static constexpr bool CONST_NAME = true;                                 \
+            return __VA_ARGS__();                                                    \
+        } else {                                                                     \
+            static constexpr bool CONST_NAME = false;                                \
+            return __VA_ARGS__();                                                    \
+        }                                                                            \
+    }()

source_code/SegMamba/causal-conv1d/setup.py

@@ -0,0 +1,264 @@
+# Copyright (c) 2023, Tri Dao.
+import sys
+import warnings
+import os
+import re
+import ast
+from pathlib import Path
+from packaging.version import parse, Version
+import platform
+
+from setuptools import setup, find_packages
+import subprocess
+
+import urllib.request
+import urllib.error
+from wheel.bdist_wheel import bdist_wheel as _bdist_wheel
+
+import torch
+from torch.utils.cpp_extension import (
+    BuildExtension,
+    CppExtension,
+    CUDAExtension,
+    CUDA_HOME,
+)
+
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+
+# ninja build does not work unless include_dirs are abs path
+this_dir = os.path.dirname(os.path.abspath(__file__))
+
+PACKAGE_NAME = "causal_conv1d"
+
+BASE_WHEEL_URL = "https://github.com/Dao-AILab/causal-conv1d/releases/download/{tag_name}/{wheel_name}"
+
+# FORCE_BUILD: Force a fresh build locally, instead of attempting to find prebuilt wheels
+# SKIP_CUDA_BUILD: Intended to allow CI to use a simple `python setup.py sdist` run to copy over raw files, without any cuda compilation
+FORCE_BUILD = os.getenv("CAUSAL_CONV1D_FORCE_BUILD", "FALSE") == "TRUE"
+SKIP_CUDA_BUILD = os.getenv("CAUSAL_CONV1D_SKIP_CUDA_BUILD", "FALSE") == "TRUE"
+# For CI, we want the option to build with C++11 ABI since the nvcr images use C++11 ABI
+FORCE_CXX11_ABI = os.getenv("CAUSAL_CONV1D_FORCE_CXX11_ABI", "FALSE") == "TRUE"
+
+
+def get_platform():
+    """
+    Returns the platform name as used in wheel filenames.
+    """
+    if sys.platform.startswith("linux"):
+        return "linux_x86_64"
+    elif sys.platform == "darwin":
+        mac_version = ".".join(platform.mac_ver()[0].split(".")[:2])
+        return f"macosx_{mac_version}_x86_64"
+    elif sys.platform == "win32":
+        return "win_amd64"
+    else:
+        raise ValueError("Unsupported platform: {}".format(sys.platform))
+
+
+def get_cuda_bare_metal_version(cuda_dir):
+    raw_output = subprocess.check_output(
+        [cuda_dir + "/bin/nvcc", "-V"], universal_newlines=True
+    )
+    output = raw_output.split()
+    release_idx = output.index("release") + 1
+    bare_metal_version = parse(output[release_idx].split(",")[0])
+
+    return raw_output, bare_metal_version
+
+
+def check_if_cuda_home_none(global_option: str) -> None:
+    if CUDA_HOME is not None:
+        return
+    # warn instead of error because user could be downloading prebuilt wheels, so nvcc won't be necessary
+    # in that case.
+    warnings.warn(
+        f"{global_option} was requested, but nvcc was not found.  Are you sure your environment has nvcc available?  "
+        "If you're installing within a container from https://hub.docker.com/r/pytorch/pytorch, "
+        "only images whose names contain 'devel' will provide nvcc."
+    )
+
+
+def append_nvcc_threads(nvcc_extra_args):
+    return nvcc_extra_args + ["--threads", "4"]
+
+
+cmdclass = {}
+ext_modules = []
+
+if not SKIP_CUDA_BUILD:
+    print("\n\ntorch.__version__  = {}\n\n".format(torch.__version__))
+    TORCH_MAJOR = int(torch.__version__.split(".")[0])
+    TORCH_MINOR = int(torch.__version__.split(".")[1])
+
+    check_if_cuda_home_none("causal_conv1d")
+    # Check, if CUDA11 is installed for compute capability 8.0
+    cc_flag = []
+    if CUDA_HOME is not None:
+        _, bare_metal_version = get_cuda_bare_metal_version(CUDA_HOME)
+        if bare_metal_version < Version("11.6"):
+            raise RuntimeError(
+                "causal_conv1d is only supported on CUDA 11.6 and above.  "
+                "Note: make sure nvcc has a supported version by running nvcc -V."
+            )
+
+    cc_flag.append("-gencode")
+    cc_flag.append("arch=compute_70,code=sm_70")
+    cc_flag.append("-gencode")
+    cc_flag.append("arch=compute_80,code=sm_80")
+    if bare_metal_version >= Version("11.8"):
+        cc_flag.append("-gencode")
+        cc_flag.append("arch=compute_90,code=sm_90")
+
+    # HACK: The compiler flag -D_GLIBCXX_USE_CXX11_ABI is set to be the same as
+    # torch._C._GLIBCXX_USE_CXX11_ABI
+    # https://github.com/pytorch/pytorch/blob/8472c24e3b5b60150096486616d98b7bea01500b/torch/utils/cpp_extension.py#L920
+    if FORCE_CXX11_ABI:
+        torch._C._GLIBCXX_USE_CXX11_ABI = True
+
+    ext_modules.append(
+        CUDAExtension(
+            name="causal_conv1d_cuda",
+            sources=[
+                "csrc/causal_conv1d.cpp",
+                "csrc/causal_conv1d_fwd.cu",
+                "csrc/causal_conv1d_bwd.cu",
+                "csrc/causal_conv1d_update.cu",
+            ],
+            extra_compile_args={
+                "cxx": ["-O3"],
+                "nvcc": append_nvcc_threads(
+                    [
+                        "-O3",
+                        "-U__CUDA_NO_HALF_OPERATORS__",
+                        "-U__CUDA_NO_HALF_CONVERSIONS__",
+                        "-U__CUDA_NO_BFLOAT16_OPERATORS__",
+                        "-U__CUDA_NO_BFLOAT16_CONVERSIONS__",
+                        "-U__CUDA_NO_BFLOAT162_OPERATORS__",
+                        "-U__CUDA_NO_BFLOAT162_CONVERSIONS__",
+                        "--expt-relaxed-constexpr",
+                        "--expt-extended-lambda",
+                        "--use_fast_math",
+                        "--ptxas-options=-v",
+                        "-lineinfo",
+                    ]
+                    + cc_flag
+                ),
+            },
+            include_dirs=[this_dir],
+        )
+    )
+
+
+def get_package_version():
+    with open(Path(this_dir) / "causal_conv1d" / "__init__.py", "r") as f:
+        version_match = re.search(r"^__version__\s*=\s*(.*)$", f.read(), re.MULTILINE)
+    public_version = ast.literal_eval(version_match.group(1))
+    local_version = os.environ.get("CAUSAL_CONV1D_LOCAL_VERSION")
+    if local_version:
+        return f"{public_version}+{local_version}"
+    else:
+        return str(public_version)
+
+
+def get_wheel_url():
+    # Determine the version numbers that will be used to determine the correct wheel
+    # We're using the CUDA version used to build torch, not the one currently installed
+    # _, cuda_version_raw = get_cuda_bare_metal_version(CUDA_HOME)
+    torch_cuda_version = parse(torch.version.cuda)
+    torch_version_raw = parse(torch.__version__)
+    # For CUDA 11, we only compile for CUDA 11.8, and for CUDA 12 we only compile for CUDA 12.2
+    # to save CI time. Minor versions should be compatible.
+    torch_cuda_version = parse("11.8") if torch_cuda_version.major == 11 else parse("12.2")
+    python_version = f"cp{sys.version_info.major}{sys.version_info.minor}"
+    platform_name = get_platform()
+    causal_conv1d_version = get_package_version()
+    # cuda_version = f"{cuda_version_raw.major}{cuda_version_raw.minor}"
+    cuda_version = f"{torch_cuda_version.major}{torch_cuda_version.minor}"
+    torch_version = f"{torch_version_raw.major}.{torch_version_raw.minor}"
+    cxx11_abi = str(torch._C._GLIBCXX_USE_CXX11_ABI).upper()
+
+    # Determine wheel URL based on CUDA version, torch version, python version and OS
+    wheel_filename = f"{PACKAGE_NAME}-{causal_conv1d_version}+cu{cuda_version}torch{torch_version}cxx11abi{cxx11_abi}-{python_version}-{python_version}-{platform_name}.whl"
+    wheel_url = BASE_WHEEL_URL.format(
+        tag_name=f"v{causal_conv1d_version}", wheel_name=wheel_filename
+    )
+    return wheel_url, wheel_filename
+
+
+class CachedWheelsCommand(_bdist_wheel):
+    """
+    The CachedWheelsCommand plugs into the default bdist wheel, which is ran by pip when it cannot
+    find an existing wheel (which is currently the case for all installs). We use
+    the environment parameters to detect whether there is already a pre-built version of a compatible
+    wheel available and short-circuits the standard full build pipeline.
+    """
+
+    def run(self):
+        if FORCE_BUILD:
+            return super().run()
+
+        wheel_url, wheel_filename = get_wheel_url()
+        print("Guessing wheel URL: ", wheel_url)
+        try:
+            urllib.request.urlretrieve(wheel_url, wheel_filename)
+
+            # Make the archive
+            # Lifted from the root wheel processing command
+            # https://github.com/pypa/wheel/blob/cf71108ff9f6ffc36978069acb28824b44ae028e/src/wheel/bdist_wheel.py#LL381C9-L381C85
+            if not os.path.exists(self.dist_dir):
+                os.makedirs(self.dist_dir)
+
+            impl_tag, abi_tag, plat_tag = self.get_tag()
+            archive_basename = f"{self.wheel_dist_name}-{impl_tag}-{abi_tag}-{plat_tag}"
+
+            wheel_path = os.path.join(self.dist_dir, archive_basename + ".whl")
+            print("Raw wheel path", wheel_path)
+            os.rename(wheel_filename, wheel_path)
+        except urllib.error.HTTPError:
+            print("Precompiled wheel not found. Building from source...")
+            # If the wheel could not be downloaded, build from source
+            super().run()
+
+
+setup(
+    name=PACKAGE_NAME,
+    version=get_package_version(),
+    packages=find_packages(
+        exclude=(
+            "build",
+            "csrc",
+            "include",
+            "tests",
+            "dist",
+            "docs",
+            "benchmarks",
+            "causal_conv1d.egg-info",
+        )
+    ),
+    author="Tri Dao",
+    author_email="tri@tridao.me",
+    description="Causal depthwise conv1d in CUDA, with a PyTorch interface",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Dao-AILab/causal-conv1d",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: BSD License",
+        "Operating System :: Unix",
+    ],
+    ext_modules=ext_modules,
+    cmdclass={"bdist_wheel": CachedWheelsCommand, "build_ext": BuildExtension}
+    if ext_modules
+    else {
+        "bdist_wheel": CachedWheelsCommand,
+    },
+    python_requires=">=3.7",
+    install_requires=[
+        "torch",
+        "packaging",
+        "ninja",
+    ],
+)

source_code/SegMamba/causal-conv1d/tests/test_causal_conv1d.py

@@ -0,0 +1,173 @@
+# Copyright (C) 2023, Tri Dao.
+
+import math
+
+import torch
+import pytest
+
+from einops import rearrange
+
+from causal_conv1d.causal_conv1d_interface import causal_conv1d_fn, causal_conv1d_ref
+from causal_conv1d.causal_conv1d_interface import causal_conv1d_update, causal_conv1d_update_ref
+
+
+@pytest.mark.parametrize("channel_last", [False, True])
+# @pytest.mark.parametrize('channel_last', [True])
+@pytest.mark.parametrize("itype", [torch.float32, torch.float16, torch.bfloat16])
+# @pytest.mark.parametrize('itype', [torch.float16])
+@pytest.mark.parametrize("silu_activation", [False, True])
+# @pytest.mark.parametrize('silu_activation', [True])
+@pytest.mark.parametrize("has_bias", [False, True])
+# @pytest.mark.parametrize('has_bias', [True])
+@pytest.mark.parametrize("width", [2, 3, 4])
+# @pytest.mark.parametrize('width', [2])
+@pytest.mark.parametrize(
+    "seqlen", [8, 16, 32, 64, 128, 151, 256, 372, 512, 784, 1024, 1134, 2048, 4096]
+)
+# @pytest.mark.parametrize('seqlen', [8, 16, 32, 64, 128, 256, 512, 784, 1024, 2048, 4096])
+# @pytest.mark.parametrize('seqlen', [128])
+def test_causal_conv1d(seqlen, width, has_bias, silu_activation, itype, channel_last):
+    device = "cuda"
+    rtol, atol = (3e-4, 1e-3) if itype == torch.float32 else (3e-3, 5e-3)
+    if itype == torch.bfloat16:
+        rtol, atol = 1e-2, 5e-2
+    rtolw, atolw = (1e-3, 1e-3)
+    # set seed
+    torch.random.manual_seed(0)
+    batch_size = 2
+    # batch_size = 1
+    dim = 4096 + 32  # Try dim not divisible by 64
+    # dim = 64
+    if not channel_last:
+        x = torch.randn(batch_size, 4096 + dim + 64, seqlen, device=device, dtype=itype)[:, 4096:4096 + dim, :].requires_grad_()
+    else:
+        x = rearrange(
+            torch.randn(batch_size, seqlen, 4096 + dim + 64, device=device, dtype=itype)[:, :, 4096:4096 + dim], "b s d -> b d s"
+        ).requires_grad_()
+    weight = torch.randn(dim, width, device=device, dtype=torch.float32, requires_grad=True)
+    if has_bias:
+        bias = torch.randn(dim, device=device, dtype=torch.float32, requires_grad=True)
+    else:
+        bias = None
+    x_ref = x.detach().clone().requires_grad_()
+    weight_ref = weight.detach().clone().requires_grad_()
+    bias_ref = bias.detach().clone().requires_grad_() if bias is not None else None
+    activation = None if not silu_activation else "silu"
+    out = causal_conv1d_fn(x, weight, bias, activation=activation)
+    out_ref = causal_conv1d_ref(x_ref, weight_ref, bias_ref, activation=activation)
+
+    print(f"Output max diff: {(out - out_ref).abs().max().item()}")
+    print(f"Output mean diff: {(out - out_ref).abs().mean().item()}")
+    assert torch.allclose(out, out_ref, rtol=rtol, atol=atol)
+
+    g = torch.randn_like(out)
+    out_ref.backward(g)
+    out.backward(g)
+
+    print(f"dx max diff: {(x.grad - x_ref.grad).abs().max().item()}")
+    print(f"dweight max diff: {(weight.grad - weight_ref.grad).abs().max().item()}")
+    if has_bias:
+        print(f"dbias max diff: {(bias.grad - bias_ref.grad).abs().max().item()}")
+
+    assert torch.allclose(x.grad, x_ref.grad.to(dtype=itype), rtol=rtol, atol=atol)
+    assert torch.allclose(weight.grad, weight_ref.grad, rtol=rtolw, atol=atolw)
+    if has_bias:
+        assert torch.allclose(bias.grad, bias_ref.grad, rtol=rtolw, atol=atolw)
+
+
+@pytest.mark.parametrize("itype", [torch.float32, torch.float16, torch.bfloat16])
+# @pytest.mark.parametrize('itype', [torch.float16])
+@pytest.mark.parametrize("silu_activation", [False, True])
+# @pytest.mark.parametrize('silu_activation', [False])
+@pytest.mark.parametrize("has_bias", [False, True])
+# @pytest.mark.parametrize('has_bias', [True])
+@pytest.mark.parametrize("width", [2, 3, 4])
+# @pytest.mark.parametrize('width', [2])
+@pytest.mark.parametrize("dim", [2048, 2048 + 16, 4096])
+# @pytest.mark.parametrize("dim", [2048])
+def test_causal_conv1d_update(dim, width, has_bias, silu_activation, itype):
+    device = "cuda"
+    rtol, atol = (3e-4, 1e-3) if itype == torch.float32 else (3e-3, 5e-3)
+    if itype == torch.bfloat16:
+        rtol, atol = 1e-2, 5e-2
+    rtolw, atolw = (1e-3, 1e-3)
+    # set seed
+    torch.random.manual_seed(0)
+    batch_size = 2
+    # batch_size = 1
+    # dim = 64
+    x = torch.randn(batch_size, dim, device=device, dtype=itype)
+    conv_state = torch.randn(batch_size, dim, width, device=device, dtype=itype)
+    weight = torch.randn(dim, width, device=device, dtype=torch.float32, requires_grad=True)
+    if has_bias:
+        bias = torch.randn(dim, device=device, dtype=torch.float32, requires_grad=True)
+    else:
+        bias = None
+    conv_state_ref = conv_state.detach().clone()
+    activation = None if not silu_activation else "silu"
+    out = causal_conv1d_update(x, conv_state, weight, bias, activation=activation)
+    out_ref = causal_conv1d_update_ref(x, conv_state_ref, weight, bias, activation=activation)
+
+    print(f"Output max diff: {(out - out_ref).abs().max().item()}")
+    print(f"Output mean diff: {(out - out_ref).abs().mean().item()}")
+    assert torch.equal(conv_state, conv_state_ref)
+    assert torch.allclose(out, out_ref, rtol=rtol, atol=atol)
+
+
+# @pytest.mark.parametrize("channel_last", [False, True])
+@pytest.mark.parametrize('channel_last', [True])
+# @pytest.mark.parametrize("itype", [torch.float32, torch.float16, torch.bfloat16])
+@pytest.mark.parametrize('itype', [torch.bfloat16])
+# @pytest.mark.parametrize("silu_activation", [False, True])
+@pytest.mark.parametrize('silu_activation', [True])
+# @pytest.mark.parametrize("has_bias", [False, True])
+@pytest.mark.parametrize('has_bias', [True])
+# @pytest.mark.parametrize("width", [2, 3, 4])
+@pytest.mark.parametrize('width', [4])
+@pytest.mark.parametrize(
+    # "seqlen", [8, 16, 32, 64, 128, 151, 256, 372, 512, 784, 1024, 1134, 2048, 4096]
+    "seqlen", [2048]
+)
+# @pytest.mark.parametrize('seqlen', [8, 16, 32, 64, 128, 256, 512, 784, 1024, 2048, 4096])
+# @pytest.mark.parametrize('seqlen', [128])
+def test_causal_conv1d_race_condition(seqlen, width, has_bias, silu_activation, itype, channel_last):
+    device = "cuda"
+    # set seed
+    torch.random.manual_seed(0)
+    batch_size = 2
+    # batch_size = 1
+    dim = 4096 + 32  # Try dim not divisible by 64
+    # dim = 64
+    if not channel_last:
+        x = torch.randn(batch_size, 4096 + dim + 64, seqlen, device=device, dtype=itype)[:, 4096:4096 + dim, :].requires_grad_()
+    else:
+        x = rearrange(
+            torch.randn(batch_size, seqlen, 4096 + dim + 64, device=device, dtype=itype)[:, :, 4096:4096 + dim], "b s d -> b d s"
+        ).requires_grad_()
+    weight = torch.randn(dim, width, device=device, dtype=torch.float32, requires_grad=True)
+    if has_bias:
+        bias = torch.randn(dim, device=device, dtype=torch.float32, requires_grad=True)
+    else:
+        bias = None
+    activation = None if not silu_activation else "silu"
+    out0 = causal_conv1d_fn(x, weight, bias, activation=activation)
+    g = torch.randn_like(out0)
+    dx0, dw0, db0 = torch.autograd.grad(out0, (x, weight, bias), g)
+    dw_atol = 1e-4
+    db_atol = 1e-4
+
+    for i in range(10000):
+        out = causal_conv1d_fn(x, weight, bias, activation=activation)
+        dx, dw, db = torch.autograd.grad(out, (x, weight, bias), g)
+        dw_equal = torch.allclose(dw, dw0, atol=dw_atol)
+        # if not dw_equal:
+        #     breakpoint()
+        if has_bias:
+            db_equal = torch.allclose(db, db0, atol=db_atol)
+            # if not db_equal:
+            #     breakpoint()
+        assert torch.equal(out, out0)
+        assert torch.equal(dx, dx0)
+        assert dw_equal
+        if has_bias:
+            assert dw_equal

source_code/SegMamba/light_training/augment/multi_processor.py

@@ -0,0 +1,10 @@
+from batchgenerators.dataloading.nondet_multi_threaded_augmenter import NonDetMultiThreadedAugmenter
+
+
+class LimitedLenWrapper(NonDetMultiThreadedAugmenter):
+    def __init__(self, my_imaginary_length, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.len = my_imaginary_length
+
+    def __len__(self):
+        return self.len

source_code/SegMamba/light_training/augment/train_augment.py

@@ -0,0 +1,279 @@
+import inspect
+import multiprocessing
+import os
+import shutil
+import sys
+import warnings
+from copy import deepcopy
+from datetime import datetime
+from time import time, sleep
+from typing import Union, Tuple, List
+import numpy as np
+import torch
+from batchgenerators.dataloading.single_threaded_augmenter import SingleThreadedAugmenter
+from batchgenerators.transforms.abstract_transforms import AbstractTransform, Compose
+from batchgenerators.transforms.color_transforms import BrightnessMultiplicativeTransform, \
+    ContrastAugmentationTransform, GammaTransform
+from batchgenerators.transforms.noise_transforms import GaussianNoiseTransform, GaussianBlurTransform
+from batchgenerators.transforms.resample_transforms import SimulateLowResolutionTransform
+from batchgenerators.transforms.spatial_transforms import SpatialTransform, MirrorTransform
+from batchgenerators.transforms.utility_transforms import RemoveLabelTransform, RenameTransform, NumpyToTensor
+
+
+def get_train_transforms(patch_size, mirror_axes=None):
+    tr_transforms = []
+    patch_size_spatial = patch_size
+    ignore_axes = None
+    angle = (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi)
+
+    tr_transforms.append(SpatialTransform(
+    patch_size_spatial, patch_center_dist_from_border=None,
+    do_elastic_deform=False, alpha=(0, 0), sigma=(0, 0),
+    do_rotation=True, angle_x=angle, angle_y=angle, angle_z=angle,
+    p_rot_per_axis=1,  # todo experiment with this
+    do_scale=True, scale=(0.7, 1.4),
+    border_mode_data="constant", border_cval_data=0, order_data=3,
+    border_mode_seg="constant", border_cval_seg=-1, order_seg=1,
+    random_crop=False,  # random cropping is part of our dataloaders
+    p_el_per_sample=0, p_scale_per_sample=0.2, p_rot_per_sample=0.2,
+    independent_scale_for_each_axis=False  # todo experiment with this
+    ))
+
+    tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.1))
+    tr_transforms.append(GaussianBlurTransform((0.5, 1.), different_sigma_per_channel=True, p_per_sample=0.2,
+                                            p_per_channel=0.5))
+    tr_transforms.append(BrightnessMultiplicativeTransform(multiplier_range=(0.75, 1.25), p_per_sample=0.15))
+    tr_transforms.append(ContrastAugmentationTransform(p_per_sample=0.15))
+    tr_transforms.append(SimulateLowResolutionTransform(zoom_range=(0.5, 1), per_channel=True,
+                                                    p_per_channel=0.5,
+                                                    order_downsample=0, order_upsample=3, p_per_sample=0.25,
+                                                    ignore_axes=ignore_axes))
+    tr_transforms.append(GammaTransform((0.7, 1.5), True, True, retain_stats=True, p_per_sample=0.1))
+    tr_transforms.append(GammaTransform((0.7, 1.5), False, True, retain_stats=True, p_per_sample=0.3))
+
+    if mirror_axes is not None and len(mirror_axes) > 0:
+        tr_transforms.append(MirrorTransform(mirror_axes))
+
+    tr_transforms.append(RemoveLabelTransform(-1, 0))
+    tr_transforms.append(NumpyToTensor(['data', 'seg'], 'float'))
+
+    tr_transforms = Compose(tr_transforms)
+
+    return tr_transforms
+
+def get_train_transforms_nomirror(patch_size, mirror_axes=None):
+    tr_transforms = []
+    patch_size_spatial = patch_size
+    ignore_axes = None
+    angle = (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi)
+
+    tr_transforms.append(SpatialTransform(
+    patch_size_spatial, patch_center_dist_from_border=None,
+    do_elastic_deform=False, alpha=(0, 0), sigma=(0, 0),
+    do_rotation=True, angle_x=angle, angle_y=angle, angle_z=angle,
+    p_rot_per_axis=1,  # todo experiment with this
+    do_scale=True, scale=(0.7, 1.4),
+    border_mode_data="constant", border_cval_data=0, order_data=3,
+    border_mode_seg="constant", border_cval_seg=-1, order_seg=1,
+    random_crop=False,  # random cropping is part of our dataloaders
+    p_el_per_sample=0, p_scale_per_sample=0.2, p_rot_per_sample=0.2,
+    independent_scale_for_each_axis=False  # todo experiment with this
+    ))
+
+    tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.1))
+    tr_transforms.append(GaussianBlurTransform((0.5, 1.), different_sigma_per_channel=True, p_per_sample=0.2,
+                                            p_per_channel=0.5))
+    tr_transforms.append(BrightnessMultiplicativeTransform(multiplier_range=(0.75, 1.25), p_per_sample=0.15))
+    tr_transforms.append(ContrastAugmentationTransform(p_per_sample=0.15))
+    tr_transforms.append(SimulateLowResolutionTransform(zoom_range=(0.5, 1), per_channel=True,
+                                                    p_per_channel=0.5,
+                                                    order_downsample=0, order_upsample=3, p_per_sample=0.25,
+                                                    ignore_axes=ignore_axes))
+    tr_transforms.append(GammaTransform((0.7, 1.5), True, True, retain_stats=True, p_per_sample=0.1))
+    tr_transforms.append(GammaTransform((0.7, 1.5), False, True, retain_stats=True, p_per_sample=0.3))
+
+    # if mirror_axes is not None and len(mirror_axes) > 0:
+    #     tr_transforms.append(MirrorTransform(mirror_axes))
+
+    tr_transforms.append(RemoveLabelTransform(-1, 0))
+    tr_transforms.append(NumpyToTensor(['data', 'seg'], 'float'))
+
+    tr_transforms = Compose(tr_transforms)
+
+    return tr_transforms
+
+def get_train_transforms_onlymirror(patch_size, mirror_axes=None):
+    tr_transforms = []
+    patch_size_spatial = patch_size
+    ignore_axes = None
+    angle = (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi)
+
+    # tr_transforms.append(SpatialTransform(
+    # patch_size_spatial, patch_center_dist_from_border=None,
+    # do_elastic_deform=False, alpha=(0, 0), sigma=(0, 0),
+    # do_rotation=True, angle_x=angle, angle_y=angle, angle_z=angle,
+    # p_rot_per_axis=1,  # todo experiment with this
+    # do_scale=True, scale=(0.7, 1.4),
+    # border_mode_data="constant", border_cval_data=0, order_data=3,
+    # border_mode_seg="constant", border_cval_seg=-1, order_seg=1,
+    # random_crop=False,  # random cropping is part of our dataloaders
+    # p_el_per_sample=0, p_scale_per_sample=0.2, p_rot_per_sample=0.2,
+    # independent_scale_for_each_axis=False  # todo experiment with this
+    # ))
+
+    tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.1))
+    tr_transforms.append(GaussianBlurTransform((0.5, 1.), different_sigma_per_channel=True, p_per_sample=0.2,
+                                            p_per_channel=0.5))
+    tr_transforms.append(BrightnessMultiplicativeTransform(multiplier_range=(0.75, 1.25), p_per_sample=0.15))
+    tr_transforms.append(ContrastAugmentationTransform(p_per_sample=0.15))
+    tr_transforms.append(SimulateLowResolutionTransform(zoom_range=(0.5, 1), per_channel=True,
+                                                    p_per_channel=0.5,
+                                                    order_downsample=0, order_upsample=3, p_per_sample=0.25,
+                                                    ignore_axes=ignore_axes))
+    tr_transforms.append(GammaTransform((0.7, 1.5), True, True, retain_stats=True, p_per_sample=0.1))
+    tr_transforms.append(GammaTransform((0.7, 1.5), False, True, retain_stats=True, p_per_sample=0.3))
+
+    if mirror_axes is not None and len(mirror_axes) > 0:
+        tr_transforms.append(MirrorTransform(mirror_axes))
+
+    tr_transforms.append(RemoveLabelTransform(-1, 0))
+    tr_transforms.append(NumpyToTensor(['data', 'seg'], 'float'))
+
+    tr_transforms = Compose(tr_transforms)
+
+    return tr_transforms
+
+def get_train_transforms_onlyspatial(patch_size, mirror_axes=None):
+    tr_transforms = []
+    patch_size_spatial = patch_size
+    ignore_axes = None
+    angle = (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi)
+
+    tr_transforms.append(SpatialTransform(
+    patch_size_spatial, patch_center_dist_from_border=None,
+    do_elastic_deform=False, alpha=(0, 0), sigma=(0, 0),
+    do_rotation=True, angle_x=angle, angle_y=angle, angle_z=angle,
+    p_rot_per_axis=1,  # todo experiment with this
+    do_scale=True, scale=(0.7, 1.4),
+    border_mode_data="constant", border_cval_data=0, order_data=3,
+    border_mode_seg="constant", border_cval_seg=-1, order_seg=1,
+    random_crop=False,  # random cropping is part of our dataloaders
+    p_el_per_sample=0, p_scale_per_sample=0.2, p_rot_per_sample=0.2,
+    independent_scale_for_each_axis=False  # todo experiment with this
+    ))
+
+    # tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.1))
+    # tr_transforms.append(GaussianBlurTransform((0.5, 1.), different_sigma_per_channel=True, p_per_sample=0.2,
+    #                                         p_per_channel=0.5))
+    # tr_transforms.append(BrightnessMultiplicativeTransform(multiplier_range=(0.75, 1.25), p_per_sample=0.15))
+    # tr_transforms.append(ContrastAugmentationTransform(p_per_sample=0.15))
+    # tr_transforms.append(SimulateLowResolutionTransform(zoom_range=(0.5, 1), per_channel=True,
+    #                                                 p_per_channel=0.5,
+    #                                                 order_downsample=0, order_upsample=3, p_per_sample=0.25,
+    #                                                 ignore_axes=ignore_axes))
+    # tr_transforms.append(GammaTransform((0.7, 1.5), True, True, retain_stats=True, p_per_sample=0.1))
+    # tr_transforms.append(GammaTransform((0.7, 1.5), False, True, retain_stats=True, p_per_sample=0.3))
+
+    if mirror_axes is not None and len(mirror_axes) > 0:
+        tr_transforms.append(MirrorTransform(mirror_axes))
+
+    tr_transforms.append(RemoveLabelTransform(-1, 0))
+    tr_transforms.append(NumpyToTensor(['data', 'seg'], 'float'))
+
+    tr_transforms = Compose(tr_transforms)
+
+    return tr_transforms
+
+def get_train_transforms_noaug(patch_size, mirror_axes=None):
+    tr_transforms = []
+    # patch_size_spatial = patch_size
+    # ignore_axes = None
+    # angle = (-30. / 360 * 2. * np.pi, 30. / 360 * 2. * np.pi)
+
+    # tr_transforms.append(SpatialTransform(
+    # patch_size_spatial, patch_center_dist_from_border=None,
+    # do_elastic_deform=False, alpha=(0, 0), sigma=(0, 0),
+    # do_rotation=True, angle_x=angle, angle_y=angle, angle_z=angle,
+    # p_rot_per_axis=1,  # todo experiment with this
+    # do_scale=True, scale=(0.7, 1.4),
+    # border_mode_data="constant", border_cval_data=0, order_data=3,
+    # border_mode_seg="constant", border_cval_seg=-1, order_seg=1,
+    # random_crop=False,  # random cropping is part of our dataloaders
+    # p_el_per_sample=0, p_scale_per_sample=0.2, p_rot_per_sample=0.2,
+    # independent_scale_for_each_axis=False  # todo experiment with this
+    # ))
+
+    # tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.1))
+    # tr_transforms.append(GaussianBlurTransform((0.5, 1.), different_sigma_per_channel=True, p_per_sample=0.2,
+    #                                         p_per_channel=0.5))
+    # tr_transforms.append(BrightnessMultiplicativeTransform(multiplier_range=(0.75, 1.25), p_per_sample=0.15))
+    # tr_transforms.append(ContrastAugmentationTransform(p_per_sample=0.15))
+    # tr_transforms.append(SimulateLowResolutionTransform(zoom_range=(0.5, 1), per_channel=True,
+    #                                                 p_per_channel=0.5,
+    #                                                 order_downsample=0, order_upsample=3, p_per_sample=0.25,
+    #                                                 ignore_axes=ignore_axes))
+    # tr_transforms.append(GammaTransform((0.7, 1.5), True, True, retain_stats=True, p_per_sample=0.1))
+    # tr_transforms.append(GammaTransform((0.7, 1.5), False, True, retain_stats=True, p_per_sample=0.3))
+
+    # if mirror_axes is not None and len(mirror_axes) > 0:
+    #     tr_transforms.append(MirrorTransform(mirror_axes))
+
+    tr_transforms.append(RemoveLabelTransform(-1, 0))
+    tr_transforms.append(NumpyToTensor(['data', 'seg'], 'float'))
+
+    tr_transforms = Compose(tr_transforms)
+
+    return tr_transforms
+
+def get_validation_transforms() -> AbstractTransform:
+        val_transforms = []
+        val_transforms.append(RemoveLabelTransform(-1, 0))
+
+        # val_transforms.append(RenameTransform('seg', 'target', True))
+
+        val_transforms.append(NumpyToTensor(['data', 'seg'], 'float'))
+        val_transforms = Compose(val_transforms)
+        return val_transforms
+
+# import SimpleITK as sitk 
+# import matplotlib.pyplot as plt 
+
+# image = sitk.ReadImage("/Users/xingzhaohu/Documents/工作/code/medical_image_processing/SSL/BraTS20_Training_365/BraTS20_Training_365_flair.nii.gz")
+# label = sitk.ReadImage("/Users/xingzhaohu/Documents/工作/code/medical_image_processing/SSL/BraTS20_Training_365/BraTS20_Training_365_seg.nii.gz")
+
+# # image = sitk.ReadImage("./AIIB/image/AIIB23_171.nii.gz")
+# # label = sitk.ReadImage("./AIIB/gt/AIIB23_171.nii.gz")
+
+# image_arr = sitk.GetArrayFromImage(image)
+# label_arr = sitk.GetArrayFromImage(label)
+# intensityproperties = {}
+
+# norm = RescaleTo01Normalization(intensityproperties=intensityproperties)
+# image_arr = image_arr[0:128, 0:128, 0:128][None, None]
+# label_arr = label_arr[0:128, 0:128, 0:128][None, None]
+
+
+# image_arr = norm.run(image_arr, label_arr)
+
+# print(image_arr.shape, label_arr.shape)
+
+# tr_transforms = Compose(tr_transforms)
+
+# trans_out = tr_transforms(data=image_arr, seg=label_arr)
+
+# image_arr_aug = trans_out["data"]
+# label_arr_aug = trans_out["seg"]
+
+# print(image_arr_aug.shape, label_arr_aug.shape)
+
+
+# for i in range(40, 128):
+#     plt.subplot(1, 4, 1)
+#     plt.imshow(image_arr[0, 0, i], cmap="gray")
+#     plt.subplot(1, 4, 2)
+#     plt.imshow(label_arr[0, 0, i], cmap="gray")
+#     plt.subplot(1, 4, 3)
+#     plt.imshow(image_arr_aug[0, 0, i], cmap="gray")
+#     plt.subplot(1, 4, 4)
+#     plt.imshow(label_arr_aug[0, 0, i], cmap="gray")
+#     plt.show()

source_code/SegMamba/light_training/dataloading/base_data_loader.py

@@ -0,0 +1,213 @@
+import numpy as np 
+from typing import Union, Tuple
+import time 
+
+class DataLoaderMultiProcess:
+    def __init__(self, dataset, 
+                 patch_size,
+                 batch_size=2,
+                 oversample_foreground_percent=0.33,
+                 probabilistic_oversampling=False,
+                 print_time=False):
+        pass
+        self.dataset = dataset
+        self.patch_size = patch_size
+        # self.annotated_classes_key = annotated_classes_key ## (1, 2, 3 ..)
+        self.batch_size = batch_size
+        self.keys = [i for i in range(len(dataset))]
+        self.thread_id = 0
+        self.oversample_foreground_percent = oversample_foreground_percent
+        self.need_to_pad = (np.array([0, 0, 0])).astype(int)
+
+        self.get_do_oversample = self._oversample_last_XX_percent if not probabilistic_oversampling \
+            else self._probabilistic_oversampling
+        self.data_shape = None 
+        self.seg_shape = None
+        self.print_time = print_time
+
+    def determine_shapes(self):
+        # load one case
+        item = self.dataset.__getitem__(0)
+        data, seg, properties = item["data"], item["seg"], item["properties"]
+        num_color_channels = data.shape[0]
+        num_output_channels = seg.shape[0]
+        patch_size = self.patch_size
+        data_shape = (self.batch_size, num_color_channels, patch_size[0], patch_size[1], patch_size[2])
+        seg_shape = (self.batch_size, num_output_channels, patch_size[0], patch_size[1], patch_size[2])
+        return data_shape, seg_shape
+    
+    def generate_train_batch(self):
+        
+        selected_keys = np.random.choice(self.keys, self.batch_size, True, None)
+        if self.data_shape is None:
+            self.data_shape, self.seg_shape = self.determine_shapes()
+
+        data_all = np.zeros(self.data_shape, dtype=np.float32)
+        data_all_global = np.zeros(self.data_shape, dtype=np.float32)
+        seg_all_global = np.zeros(self.seg_shape, dtype=np.float32)
+        data_global = None
+        seg_global = None
+        seg_all = np.zeros(self.seg_shape, dtype=np.float32)
+
+        case_properties = []
+
+        index = 0
+        for j, key in enumerate(selected_keys):
+
+            force_fg = self.get_do_oversample(j)
+            s = time.time()
+            item = self.dataset.__getitem__(key)
+            e = time.time()
+            if self.print_time:
+                print(f"read single data time is {e - s}")
+            # print(f"read data time is {e - s}")
+            data, seg, properties = item["data"], item["seg"], item["properties"]
+            
+            if "data_global" in item:
+                data_global = item["data_global"]
+            
+            if "seg_global" in item:
+                seg_global = item["seg_global"]
+
+            case_properties.append(properties)
+            # If we are doing the cascade then the segmentation from the previous stage will already have been loaded by
+            # self._data.load_case(i) (see nnUNetDataset.load_case)
+            shape = data.shape[1:]
+            dim = len(shape)
+            
+            s = time.time()
+            bbox_lbs, bbox_ubs = self.get_bbox(shape, force_fg, properties['class_locations'])
+            e = time.time()
+            if self.print_time:
+                print(f"get bbox time is {e - s}")
+            # whoever wrote this knew what he was doing (hint: it was me). We first crop the data to the region of the
+            # bbox that actually lies within the data. This will result in a smaller array which is then faster to pad.
+            # valid_bbox is just the coord that lied within the data cube. It will be padded to match the patch size
+            # later
+            valid_bbox_lbs = [max(0, bbox_lbs[i]) for i in range(dim)]
+            valid_bbox_ubs = [min(shape[i], bbox_ubs[i]) for i in range(dim)]
+
+            # At this point you might ask yourself why we would treat seg differently from seg_from_previous_stage.
+            # Why not just concatenate them here and forget about the if statements? Well that's because segneeds to
+            # be padded with -1 constant whereas seg_from_previous_stage needs to be padded with 0s (we could also
+            # remove label -1 in the data augmentation but this way it is less error prone)
+            this_slice = tuple([slice(0, data.shape[0])] + [slice(i, j) for i, j in zip(valid_bbox_lbs, valid_bbox_ubs)])
+            data = data[this_slice]
+
+            this_slice = tuple([slice(0, seg.shape[0])] + [slice(i, j) for i, j in zip(valid_bbox_lbs, valid_bbox_ubs)])
+            seg = seg[this_slice]
+
+
+            s = time.time()
+            padding = [(-min(0, bbox_lbs[i]), max(bbox_ubs[i] - shape[i], 0)) for i in range(dim)]
+            # print(f"box is {bbox_lbs, bbox_ubs}, padding is {padding}")
+            data_all[j] = np.pad(data, ((0, 0), *padding), 'constant', constant_values=0)
+            seg_all[j] = np.pad(seg, ((0, 0), *padding), 'constant', constant_values=0)
+
+            if data_global is not None :
+                data_all_global[j] = data_global
+
+            if seg_global is not None :
+                seg_all_global[j] = seg_global
+
+
+            e = time.time()
+            if self.print_time:
+                print(f"box is {bbox_lbs, bbox_ubs}, padding is {padding}")
+                print(f"setting data value time is {e - s}")
+                
+        
+        if data_global is None:
+            return {'data': data_all,
+                    'seg': seg_all, 'properties': case_properties, 
+                    'keys': selected_keys}
+    
+        return {'data': data_all, "data_global": data_all_global,
+                    "seg_global": seg_all_global, 
+                    'seg': seg_all, 'properties': case_properties, 
+                    'keys': selected_keys}
+
+    def __next__(self):
+    
+        return self.generate_train_batch() 
+    
+    def set_thread_id(self, thread_id):
+        self.thread_id = thread_id
+    
+    def _oversample_last_XX_percent(self, sample_idx: int) -> bool:
+        """
+        determines whether sample sample_idx in a minibatch needs to be guaranteed foreground
+        """
+        return not sample_idx < round(self.batch_size * (1 - self.oversample_foreground_percent))
+
+    def _probabilistic_oversampling(self, sample_idx: int) -> bool:
+        # print('YEAH BOIIIIII')
+        return np.random.uniform() < self.oversample_foreground_percent
+    
+    def get_bbox(self, data_shape: np.ndarray, force_fg: bool, class_locations: Union[dict, None],
+                 overwrite_class: Union[int, Tuple[int, ...]] = None, verbose: bool = False):
+        # in dataloader 2d we need to select the slice prior to this and also modify the class_locations to only have
+        # locations for the given slice
+        need_to_pad = self.need_to_pad.copy()
+        dim = len(data_shape)
+
+        for d in range(dim):
+            # if case_all_data.shape + need_to_pad is still < patch size we need to pad more! We pad on both sides
+            # always
+            if need_to_pad[d] + data_shape[d] < self.patch_size[d]:
+                need_to_pad[d] = self.patch_size[d] - data_shape[d]
+
+        # we can now choose the bbox from -need_to_pad // 2 to shape - patch_size + need_to_pad // 2. Here we
+        # define what the upper and lower bound can be to then sample form them with np.random.randint
+        lbs = [- need_to_pad[i] // 2 for i in range(dim)]
+        ubs = [data_shape[i] + need_to_pad[i] // 2 + need_to_pad[i] % 2 - self.patch_size[i] for i in range(dim)]
+
+        # if not force_fg then we can just sample the bbox randomly from lb and ub. Else we need to make sure we get
+        # at least one of the foreground classes in the patch
+        if not force_fg:
+            bbox_lbs = [np.random.randint(lbs[i], ubs[i] + 1) for i in range(dim)]
+            # print('I want a random location')
+        else:
+            assert class_locations is not None, 'if force_fg is set class_locations cannot be None'
+            if overwrite_class is not None:
+                assert overwrite_class in class_locations.keys(), 'desired class ("overwrite_class") does not ' \
+                                                                    'have class_locations (missing key)'
+            # this saves us a np.unique. Preprocessing already did that for all cases. Neat.
+            # class_locations keys can also be tuple
+            eligible_classes_or_regions = [i for i in class_locations.keys() if len(class_locations[i]) > 0]
+
+            # if we have annotated_classes_key locations and other classes are present, remove the annotated_classes_key from the list
+            # strange formulation needed to circumvent
+            # ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
+            # tmp = [i == self.annotated_classes_key if isinstance(i, tuple) else False for i in eligible_classes_or_regions]
+            # if any(tmp):
+            #     if len(eligible_classes_or_regions) > 1:
+            #         eligible_classes_or_regions.pop(np.where(tmp)[0][0])
+
+            if len(eligible_classes_or_regions) == 0:
+                # this only happens if some image does not contain foreground voxels at all
+                selected_class = None
+                if verbose:
+                    print('case does not contain any foreground classes')
+            else:
+                # I hate myself. Future me aint gonna be happy to read this
+                # 2022_11_25: had to read it today. Wasn't too bad
+                selected_class = eligible_classes_or_regions[np.random.choice(len(eligible_classes_or_regions))] if \
+                    (overwrite_class is None or (overwrite_class not in eligible_classes_or_regions)) else overwrite_class
+            # print(f'I want to have foreground, selected class: {selected_class}')
+          
+            voxels_of_that_class = class_locations[selected_class] if selected_class is not None else None
+
+            if voxels_of_that_class is not None and len(voxels_of_that_class) > 0:
+                selected_voxel = voxels_of_that_class[np.random.choice(len(voxels_of_that_class))]
+                # selected voxel is center voxel. Subtract half the patch size to get lower bbox voxel.
+                # Make sure it is within the bounds of lb and ub
+                # i + 1 because we have first dimension 0!
+                bbox_lbs = [max(lbs[i], selected_voxel[i + 1] - self.patch_size[i] // 2) for i in range(dim)]
+            else:
+                # If the image does not contain any foreground classes, we fall back to random cropping
+                bbox_lbs = [np.random.randint(lbs[i], ubs[i] + 1) for i in range(dim)]
+
+        bbox_ubs = [bbox_lbs[i] + self.patch_size[i] for i in range(dim)]
+
+        return bbox_lbs, bbox_ubs

source_code/SegMamba/light_training/dataloading/dataset.py

@@ -0,0 +1,318 @@
+
+# Copyright 2020 - 2022 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from sklearn.model_selection import KFold  ## K折交叉验证
+import pickle
+import os
+import json
+import math
+import numpy as np
+import torch
+import SimpleITK as sitk
+from tqdm import tqdm 
+from torch.utils.data import Dataset 
+import glob 
+from light_training.dataloading.utils import unpack_dataset
+import random 
+
+class MedicalDataset(Dataset):
+    def __init__(self, datalist, test=False) -> None:
+        super().__init__()
+        
+        self.datalist = datalist
+        self.test = test 
+
+        self.data_cached = []
+        for p in tqdm(self.datalist, total=len(self.datalist)):
+            info = self.load_pkl(p)
+
+            self.data_cached.append(info)
+
+        ## unpacking
+        print(f"unpacking data ....")
+        # for 
+        folder = []
+        for p in self.datalist:
+            f = os.path.dirname(p)
+            if f not in folder:
+                folder.append(f)
+        for f in folder:
+            unpack_dataset(f, 
+                        unpack_segmentation=True,
+                        overwrite_existing=False,
+                        num_processes=8)
+
+
+        print(f"data length is {len(self.datalist)}")
+        
+    def load_pkl(self, data_path):
+        pass 
+        properties_path = f"{data_path[:-4]}.pkl"
+        df = open(properties_path, "rb")
+        info = pickle.load(df)
+
+        return info 
+    
+    def post(self, batch_data):
+        return batch_data
+    
+    def read_data(self, data_path):
+        
+        image_path = data_path.replace(".npz", ".npy")
+        seg_path = data_path.replace(".npz", "_seg.npy")
+        image_data = np.load(image_path, "r+")
+      
+        seg_data = None 
+        if not self.test:
+            seg_data = np.load(seg_path, "r+")
+        return image_data, seg_data
+
+    def __getitem__(self, i):
+        
+        image, seg = self.read_data(self.datalist[i])
+
+        properties = self.data_cached[i]
+
+        if seg is None:
+            return {
+                "data": image,
+                "properties": properties
+            }
+        else :
+            return {
+                "data": image,
+                "seg": seg,
+                "properties": properties
+            }
+
+    def __len__(self):
+        return len(self.datalist)
+
+def get_train_test_loader_from_test_list(data_dir, test_list):
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+
+    test_datalist = []
+    train_datalist = []
+
+    test_list_1 = []
+    for t in test_list:
+        test_list_1.append(t.replace(".nii.gz", ""))
+
+    test_list = test_list_1
+    for p in all_paths:
+        p2 = p.split("/")[-1].split(".")[0]
+        if p2 in test_list:
+            test_datalist.append(p)
+        else :
+            train_datalist.append(p)
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"test data is {len(test_datalist)}", test_datalist)
+
+    train_ds = MedicalDataset(train_datalist)
+    test_ds = MedicalDataset(test_datalist)
+
+    loader = [train_ds, test_ds]
+
+    return loader
+
+def get_kfold_data(data_paths, n_splits, shuffle=False):
+    X = np.arange(len(data_paths))
+    kfold = KFold(n_splits=n_splits, shuffle=shuffle)  ## kfold为KFolf类的一个对象
+    return_res = []
+    for a, b in kfold.split(X):
+        fold_train = []
+        fold_val = []
+        for i in a:
+            fold_train.append(data_paths[i])
+        for j in b:
+            fold_val.append(data_paths[j])
+        return_res.append({"train_data": fold_train, "val_data": fold_val})
+
+    return return_res
+
+def get_kfold_loader(data_dir, fold=0, test_dir=None):
+
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = fold_data["train_data"]
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_all_training_loader(data_dir, fold=0, test_dir=None):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = all_paths
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_val_test_loader_seperate(train_dir, val_dir, test_dir=None):
+    train_datalist = glob.glob(f"{train_dir}/*.npz")
+    val_datalist = glob.glob(f"{val_dir}/*.npz")
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+
+    if test_dir is not None:
+        test_datalist = glob.glob(f"{test_dir}/*.npz")
+        print(f"test data is {len(test_datalist)}")
+        test_ds = MedicalDataset(test_datalist, test=True)
+    else :
+        test_ds = None
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_val_test_loader_from_split_json(data_dir, split_json_file):
+    import json 
+
+    with open(split_json_file, "r") as f:
+
+        datalist = json.loads(f.read())
+
+    train_datalist = datalist["train"]
+    val_datalist = datalist["validation"]
+    test_datalist = datalist["test"]
+
+    def add_pre(datalist):
+        for i in range(len(datalist)):
+            datalist[i] = os.path.join(data_dir, datalist[i])
+    
+    add_pre(train_datalist)
+    add_pre(val_datalist)
+    add_pre(test_datalist)
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    print(f"test data is {len(test_datalist)}", sorted(test_datalist))
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    test_ds = MedicalDataset(test_datalist)
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+
+def get_train_val_test_loader_from_train(data_dir, train_rate=0.7, val_rate=0.1, test_rate=0.2, seed=42):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    # fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_number = int(len(all_paths) * train_rate)
+    val_number = int(len(all_paths) * val_rate)
+    test_number = int(len(all_paths) * test_rate)
+    random.seed(seed)
+    # random_state = random.random
+    random.shuffle(all_paths)
+
+    train_datalist = all_paths[:train_number]
+    val_datalist = all_paths[train_number: train_number + val_number]
+    test_datalist = all_paths[-test_number:] 
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    print(f"test data is {len(test_datalist)}", sorted(test_datalist))
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    test_ds = MedicalDataset(test_datalist)
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_loader_from_train(data_dir):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    # fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_ds = MedicalDataset(all_paths)
+  
+    return train_ds
+
+def get_test_loader_from_test(data_dir):
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+
+    test_ds = MedicalDataset(all_paths)
+  
+    return test_ds
+
+def get_multi_dir_training_loader(data_dir, fold=0, test_dir=None):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = []
+    for p in data_dir:
+        paths = glob.glob(f"{p}/*.npz")
+        for pp in paths:
+            all_paths.append(pp)
+
+    # print(all_paths)
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = all_paths
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader

source_code/SegMamba/light_training/dataloading/dataset_sdm_edge.py

@@ -0,0 +1,331 @@
+
+# Copyright 2020 - 2022 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from sklearn.model_selection import KFold  ## K折交叉验证
+import pickle
+import os
+import json
+import math
+import numpy as np
+import torch
+from monai import transforms
+import SimpleITK as sitk
+from tqdm import tqdm 
+from torch.utils.data import Dataset 
+import glob 
+from light_training.dataloading.utils import unpack_dataset
+import random 
+import torch
+import numpy as np 
+from scipy.ndimage import distance_transform_edt as distance
+from skimage import segmentation as skimage_seg
+from skimage.morphology import dilation, disk
+import scipy.ndimage as ndimage
+
+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)
+    return_edge = np.zeros_like(image_3d)
+
+    for i in range(image_3d.shape[0]):
+        for j in range(image_3d.shape[1]):
+            return_edge[i, j] = get_edge_points(image_3d[i, j])
+    
+    return return_edge
+
+def compute_sdf(img_gt, out_shape):
+    """
+    compute the signed distance map of binary mask
+    input: segmentation, shape = (batch_size,c, x, y, z)
+    output: the Signed Distance Map (SDM) 
+    sdf(x) = 0; x in segmentation boundary
+             -inf|x-y|; x in segmentation
+             +inf|x-y|; x out of segmentation
+    normalize sdf to [-1,1]
+
+    """
+
+    img_gt = img_gt.astype(np.uint8)
+    normalized_sdf = np.zeros(out_shape)
+
+    for b in range(out_shape[0]): # batch size
+        for c in range(out_shape[1]):
+            posmask = img_gt[b, c].astype(np.bool_)
+            if posmask.any():
+                negmask = ~posmask
+                posdis = distance(posmask)
+                negdis = distance(negmask)
+                boundary = skimage_seg.find_boundaries(posmask, mode='inner').astype(np.uint8)
+                sdf = (negdis-np.min(negdis))/(np.max(negdis)-np.min(negdis)) - (posdis-np.min(posdis))/(np.max(posdis)-np.min(posdis))
+                sdf[boundary==1] = 0
+                normalized_sdf[b][c] = sdf
+                assert np.min(sdf) == -1.0, print(np.min(posdis), np.max(posdis), np.min(negdis), np.max(negdis))
+                assert np.max(sdf) ==  1.0, print(np.min(posdis), np.min(negdis), np.max(posdis), np.max(negdis))
+
+    return normalized_sdf
+
+def convert_labels(labels):
+    ## TC, WT and ET
+    labels = labels[None, None]
+    result = [(labels == 1) | (labels == 3), (labels == 1) | (labels == 3) | (labels == 2), labels == 3]
+    
+    return torch.cat(result, dim=1).float()
+
+class MedicalDataset(Dataset):
+    def __init__(self, datalist, test=False) -> None:
+        super().__init__()
+        
+        self.datalist = datalist
+        self.test = test 
+
+        self.data_cached = []
+        for p in tqdm(self.datalist, total=len(self.datalist)):
+            info = self.load_pkl(p)
+
+            self.data_cached.append(info)
+
+        ## unpacking
+        print(f"unpacking data ....")
+        # for 
+        folder = []
+        for p in self.datalist:
+            f = os.path.dirname(p)
+            if f not in folder:
+                folder.append(f)
+        for f in folder:
+            unpack_dataset(f, 
+                        unpack_segmentation=True,
+                        overwrite_existing=False,
+                        num_processes=8)
+
+
+        print(f"data length is {len(self.datalist)}")
+        
+    def load_pkl(self, data_path):
+        pass 
+        properties_path = f"{data_path[:-4]}.pkl"
+        df = open(properties_path, "rb")
+        info = pickle.load(df)
+
+        return info 
+        
+    def read_data(self, data_path):
+        
+        image_path = data_path.replace(".npz", ".npy")
+        seg_path = data_path.replace(".npz", "_seg.npy")
+        image_data = np.load(image_path, "r")
+      
+        seg_data = None 
+        if not self.test:
+            seg_data = np.load(seg_path, "r")
+        return image_data, seg_data
+
+    # def post(self, batch_data):
+    #     seg = convert_labels(batch_data["seg"]).numpy()
+    #     seg_shape = seg.shape
+    #     seg_edge = edge_3d(seg)
+    #     seg_sdm = 1 - compute_sdf(seg, out_shape=seg_shape)
+    #     seg_sdm = seg_sdm + seg_edge
+
+    #     seg_edge = torch.from_numpy(seg_edge)
+    #     seg_sdm = torch.from_numpy(seg_sdm)
+
+    #     batch_data["seg_edge"] = seg_edge
+    #     batch_data["seg_sdm"] = seg_sdm
+
+    #     print(f"post!!!!!!!!!")
+    #     return batch_data
+
+    def __getitem__(self, i):
+        
+        image, seg = self.read_data(self.datalist[i])
+
+        properties = self.data_cached[i]
+        case_name = properties["name"]
+
+        if seg is not None:
+            sdm = np.load(os.path.join("./data/fullres/train_sdm/", f"{case_name}_seg_sdm.npy"), "r")
+
+            # print(seg.shape, sdm.shape)
+            sdm = sdm[0]
+            seg = np.concatenate([seg, sdm], axis=0)
+
+            # print(f"sdm sum is {sdm.sum()}")
+        if seg is None:
+            return {
+                "data": image,
+                "properties": properties
+            }
+        else :
+            return {
+                "data": image,
+                "seg": seg,
+                "properties": properties
+            }
+
+    def __len__(self):
+        return len(self.datalist)
+
+def get_kfold_data(data_paths, n_splits, shuffle=False):
+    X = np.arange(len(data_paths))
+    kfold = KFold(n_splits=n_splits, shuffle=shuffle)  ## kfold为KFolf类的一个对象
+    return_res = []
+    for a, b in kfold.split(X):
+        fold_train = []
+        fold_val = []
+        for i in a:
+            fold_train.append(data_paths[i])
+        for j in b:
+            fold_val.append(data_paths[j])
+        return_res.append({"train_data": fold_train, "val_data": fold_val})
+
+    return return_res
+
+def get_kfold_loader(data_dir, fold=0, test_dir=None):
+
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = fold_data["train_data"]
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_all_training_loader(data_dir, fold=0, test_dir=None):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = all_paths
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_val_test_loader_seperate(train_dir, val_dir, test_dir=None):
+    train_datalist = glob.glob(f"{train_dir}/*.npz")
+    val_datalist = glob.glob(f"{val_dir}/*.npz")
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+
+    if test_dir is not None:
+        test_datalist = glob.glob(f"{test_dir}/*.npz")
+        print(f"test data is {len(test_datalist)}")
+        test_ds = MedicalDataset(test_datalist, test=True)
+    else :
+        test_ds = None
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_val_test_loader_from_train(data_dir, train_rate=0.7, val_rate=0.1, test_rate=0.2):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    # fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_number = int(len(all_paths) * train_rate)
+    val_number = int(len(all_paths) * val_rate)
+    test_number = int(len(all_paths) * test_rate)
+
+    random.shuffle(all_paths)
+
+    train_datalist = all_paths[:train_number]
+    val_datalist = all_paths[train_number: train_number + val_number]
+    test_datalist = all_paths[-test_number:] 
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    print(f"test data is {len(test_datalist)}")
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    test_ds = MedicalDataset(test_datalist)
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_multi_dir_training_loader(data_dir, fold=0, test_dir=None):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = []
+    for p in data_dir:
+        paths = glob.glob(f"{p}/*.npz")
+        for pp in paths:
+            all_paths.append(pp)
+
+    # print(all_paths)
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = all_paths
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader

source_code/SegMamba/light_training/dataloading/get_train_val_test_datalist.py

@@ -0,0 +1,36 @@
+
+import glob 
+import random 
+import json 
+
+def get_train_val_test_list_from_fulldata(data_dir, train_rate=0.7, val_rate=0.1, test_rate=0.2, seed=42):
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+
+    ## eliminate the pre
+    all_paths_save = []
+    for p in all_paths:
+        all_paths_save.append(p.split("/")[-1])
+    all_paths = all_paths_save
+    train_number = int(len(all_paths) * train_rate)
+    val_number = int(len(all_paths) * val_rate)
+    test_number = int(len(all_paths) * test_rate)
+    random.seed(seed)
+    random.shuffle(all_paths)
+    train_datalist = all_paths[:train_number]
+    val_datalist = all_paths[train_number: train_number + val_number]
+    test_datalist = all_paths[-test_number:] 
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    print(f"test data is {len(test_datalist)}", sorted(test_datalist))
+
+    datalist = {
+        "train": train_datalist,
+        "validation": val_datalist, 
+        "test": test_datalist
+    }
+
+    datalist = json.dumps(datalist)
+
+    with open("./data_split.json", "w") as f:
+        f.write(datalist)

source_code/SegMamba/light_training/dataloading/utils.py

@@ -0,0 +1,25 @@
+import numpy as np 
+import os 
+from batchgenerators.utilities.file_and_folder_operations import isfile, subfiles
+import multiprocessing
+
+def _convert_to_npy(npz_file: str, unpack_segmentation: bool = True, overwrite_existing: bool = False) -> None:
+    # try:
+    a = np.load(npz_file)  # inexpensive, no compression is done here. This just reads metadata
+    if overwrite_existing or not isfile(npz_file[:-3] + "npy"):
+        np.save(npz_file[:-3] + "npy", a['data'])
+        
+    if unpack_segmentation and (overwrite_existing or not isfile(npz_file[:-4] + "_seg.npy")):
+        np.save(npz_file[:-4] + "_seg.npy", a['seg'])
+
+def unpack_dataset(folder: str, unpack_segmentation: bool = True, overwrite_existing: bool = False,
+                   num_processes: int = 8):
+    """
+    all npz files in this folder belong to the dataset, unpack them all
+    """
+    with multiprocessing.get_context("spawn").Pool(num_processes) as p:
+        npz_files = subfiles(folder, True, None, ".npz", True)
+        p.starmap(_convert_to_npy, zip(npz_files,
+                                       [unpack_segmentation] * len(npz_files),
+                                       [overwrite_existing] * len(npz_files))
+                  )

source_code/SegMamba/light_training/dataloading_global/dataset.py

@@ -0,0 +1,329 @@
+
+# Copyright 2020 - 2022 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from sklearn.model_selection import KFold  ## K折交叉验证
+import pickle
+import os
+import json
+import math
+import numpy as np
+import torch
+from monai import transforms
+import SimpleITK as sitk
+from tqdm import tqdm 
+from torch.utils.data import Dataset 
+import glob 
+from light_training.dataloading_global.utils import unpack_dataset
+import random 
+
+class MedicalDataset(Dataset):
+    def __init__(self, datalist, test=False) -> None:
+        super().__init__()
+        
+        self.datalist = datalist
+        self.test = test 
+
+        self.data_cached = []
+        for p in tqdm(self.datalist, total=len(self.datalist)):
+            info = self.load_pkl(p)
+
+            self.data_cached.append(info)
+
+        ## unpacking
+        print(f"unpacking data ....")
+        # for 
+        folder = []
+        for p in self.datalist:
+            f = os.path.dirname(p)
+            if f not in folder:
+                folder.append(f)
+        for f in folder:
+            unpack_dataset(f, 
+                        unpack_segmentation=True,
+                        overwrite_existing=False,
+                        num_processes=8)
+
+
+        print(f"data length is {len(self.datalist)}")
+        
+    def load_pkl(self, data_path):
+        pass 
+        properties_path = f"{data_path[:-4]}.pkl"
+        df = open(properties_path, "rb")
+        info = pickle.load(df)
+
+        return info 
+    
+    def post(self, batch_data):
+        return batch_data
+    
+    def read_data(self, data_path):
+        
+        image_path = data_path.replace(".npz", ".npy")
+        seg_path = data_path.replace(".npz", "_seg.npy")
+        image_global_path = data_path.replace(".npz", "_global.npy")
+        seg_global_path = data_path.replace(".npz", "_global_seg.npy")
+
+        image_data = np.load(image_path, "r+")
+        image_data_global = np.load(image_global_path, "r+")
+      
+        seg_data = None 
+        if not self.test:
+            seg_data = np.load(seg_path, "r+")
+            seg_global_data = np.load(seg_global_path, "r+")
+            
+        return image_data, image_data_global, seg_data, seg_global_data
+    
+
+    def __getitem__(self, i):
+        
+        image, image_data_global, seg, seg_global = self.read_data(self.datalist[i])
+
+        # print(image_data_global.shape)
+        properties = self.data_cached[i]
+
+        if seg is None:
+            return {
+                "data": image,
+                "data_global": image_data_global,
+                "properties": properties
+            }
+        else :
+            return {
+                "data": image,
+                "data_global": image_data_global,
+                "seg": seg,
+                "seg_global": seg_global,
+                "properties": properties
+            }
+
+    def __len__(self):
+        return len(self.datalist)
+
+def get_train_test_loader_from_test_list(data_dir, test_list):
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+
+    test_datalist = []
+    train_datalist = []
+
+    test_list_1 = []
+    for t in test_list:
+        test_list_1.append(t.replace(".nii.gz", ""))
+
+    test_list = test_list_1
+    for p in all_paths:
+        p2 = p.split("/")[-1].split(".")[0]
+        if p2 in test_list:
+            test_datalist.append(p)
+        else :
+            train_datalist.append(p)
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"test data is {len(test_datalist)}", test_datalist)
+
+    train_ds = MedicalDataset(train_datalist)
+    test_ds = MedicalDataset(test_datalist)
+
+    loader = [train_ds, test_ds]
+
+    return loader
+
+def get_kfold_data(data_paths, n_splits, shuffle=False):
+    X = np.arange(len(data_paths))
+    kfold = KFold(n_splits=n_splits, shuffle=shuffle)  ## kfold为KFolf类的一个对象
+    return_res = []
+    for a, b in kfold.split(X):
+        fold_train = []
+        fold_val = []
+        for i in a:
+            fold_train.append(data_paths[i])
+        for j in b:
+            fold_val.append(data_paths[j])
+        return_res.append({"train_data": fold_train, "val_data": fold_val})
+
+    return return_res
+
+def get_kfold_loader(data_dir, fold=0, test_dir=None):
+
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = fold_data["train_data"]
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_all_training_loader(data_dir, fold=0, test_dir=None):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = all_paths
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_val_test_loader_seperate(train_dir, val_dir, test_dir=None):
+    train_datalist = glob.glob(f"{train_dir}/*.npz")
+    val_datalist = glob.glob(f"{val_dir}/*.npz")
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+
+    if test_dir is not None:
+        test_datalist = glob.glob(f"{test_dir}/*.npz")
+        print(f"test data is {len(test_datalist)}")
+        test_ds = MedicalDataset(test_datalist, test=True)
+    else :
+        test_ds = None
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_val_test_loader_from_train(data_dir, train_rate=0.7, val_rate=0.1, test_rate=0.2, seed=42):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    # fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_number = int(len(all_paths) * train_rate)
+    val_number = int(len(all_paths) * val_rate)
+    test_number = int(len(all_paths) * test_rate)
+    random.seed(seed)
+    # random_state = random.random
+    random.shuffle(all_paths)
+    train_datalist = all_paths[:train_number]
+    val_datalist = all_paths[train_number: train_number + val_number]
+    test_datalist = all_paths[-test_number:] 
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    print(f"test data is {len(test_datalist)}", sorted(test_datalist))
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    test_ds = MedicalDataset(test_datalist)
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_val_test_loader_from_split_json(data_dir, split_json_file):
+    import json 
+
+    with open(split_json_file, "r") as f:
+
+        datalist = json.loads(f.read())
+
+    train_datalist = datalist["train"]
+    val_datalist = datalist["validation"]
+    test_datalist = datalist["test"]
+
+    def add_pre(datalist):
+        for i in range(len(datalist)):
+            datalist[i] = os.path.join(data_dir, datalist[i])
+    
+    add_pre(train_datalist)
+    add_pre(val_datalist)
+    add_pre(test_datalist)
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    print(f"test data is {len(test_datalist)}", sorted(test_datalist))
+
+    train_ds = MedicalDataset(train_datalist)
+    val_ds = MedicalDataset(val_datalist)
+    test_ds = MedicalDataset(test_datalist)
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader
+
+def get_train_loader_from_train(data_dir):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+    # fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_ds = MedicalDataset(all_paths)
+  
+    return train_ds
+
+def get_test_loader_from_test(data_dir):
+    all_paths = glob.glob(f"{data_dir}/*.npz")
+
+    test_ds = MedicalDataset(all_paths)
+  
+    return test_ds
+
+def get_multi_dir_training_loader(data_dir, fold=0, test_dir=None):
+    ## train all labeled data 
+    ## fold denote the validation data in training data
+    all_paths = []
+    for p in data_dir:
+        paths = glob.glob(f"{p}/*.npz")
+        for pp in paths:
+            all_paths.append(pp)
+
+    # print(all_paths)
+    fold_data = get_kfold_data(all_paths, 5)[fold]
+
+    train_datalist = all_paths
+    val_datalist = fold_data["val_data"]  
+
+    print(f"training data is {len(train_datalist)}")
+    print(f"validation data is {len(val_datalist)}")
+    train_ds = MedicalDataset(train_datalist)
+    
+    val_ds = MedicalDataset(val_datalist)
+
+    if test_dir is not None:
+        test_paths = glob.glob(f"{test_dir}/*.npz")
+        test_ds = MedicalDataset(test_paths, test=True)
+    else:
+        test_ds = None 
+
+    loader = [train_ds, val_ds, test_ds]
+
+    return loader

source_code/SegMamba/light_training/dataloading_global/utils.py

@@ -0,0 +1,27 @@
+import numpy as np 
+import os 
+from batchgenerators.utilities.file_and_folder_operations import isfile, subfiles
+import multiprocessing
+
+def _convert_to_npy(npz_file: str, unpack_segmentation: bool = True, overwrite_existing: bool = False) -> None:
+    # try:
+    a = np.load(npz_file)  # inexpensive, no compression is done here. This just reads metadata
+    if overwrite_existing or not isfile(npz_file[:-3] + "npy"):
+        np.save(npz_file[:-3] + "npy", a['data'])
+        np.save(npz_file[:-4] + "_global.npy", a['data_global'])
+        np.save(npz_file[:-4] + "_global_seg.npy", a['seg_global'])
+
+    if unpack_segmentation and (overwrite_existing or not isfile(npz_file[:-4] + "_seg.npy")):
+        np.save(npz_file[:-4] + "_seg.npy", a['seg'])
+
+def unpack_dataset(folder: str, unpack_segmentation: bool = True, overwrite_existing: bool = False,
+                   num_processes: int = 8):
+    """
+    all npz files in this folder belong to the dataset, unpack them all
+    """
+    with multiprocessing.get_context("spawn").Pool(num_processes) as p:
+        npz_files = subfiles(folder, True, None, ".npz", True)
+        p.starmap(_convert_to_npy, zip(npz_files,
+                                       [unpack_segmentation] * len(npz_files),
+                                       [overwrite_existing] * len(npz_files))
+                  )

source_code/SegMamba/light_training/evaluation/metric.py

@@ -0,0 +1,406 @@
+#    Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+import numpy as np
+from medpy import metric
+
+
+def assert_shape(test, reference):
+
+    assert test.shape == reference.shape, "Shape mismatch: {} and {}".format(
+        test.shape, reference.shape)
+
+
+class ConfusionMatrix:
+
+    def __init__(self, test=None, reference=None):
+
+        self.tp = None
+        self.fp = None
+        self.tn = None
+        self.fn = None
+        self.size = None
+        self.reference_empty = None
+        self.reference_full = None
+        self.test_empty = None
+        self.test_full = None
+        self.set_reference(reference)
+        self.set_test(test)
+
+    def set_test(self, test):
+
+        self.test = test
+        self.reset()
+
+    def set_reference(self, reference):
+
+        self.reference = reference
+        self.reset()
+
+    def reset(self):
+
+        self.tp = None
+        self.fp = None
+        self.tn = None
+        self.fn = None
+        self.size = None
+        self.test_empty = None
+        self.test_full = None
+        self.reference_empty = None
+        self.reference_full = None
+
+    def compute(self):
+
+        if self.test is None or self.reference is None:
+            raise ValueError("'test' and 'reference' must both be set to compute confusion matrix.")
+
+        assert_shape(self.test, self.reference)
+
+        self.tp = int(((self.test != 0) * (self.reference != 0)).sum())
+        self.fp = int(((self.test != 0) * (self.reference == 0)).sum())
+        self.tn = int(((self.test == 0) * (self.reference == 0)).sum())
+        self.fn = int(((self.test == 0) * (self.reference != 0)).sum())
+        self.size = int(np.prod(self.reference.shape, dtype=np.int64))
+        self.test_empty = not np.any(self.test)
+        self.test_full = np.all(self.test)
+        self.reference_empty = not np.any(self.reference)
+        self.reference_full = np.all(self.reference)
+
+    def get_matrix(self):
+
+        for entry in (self.tp, self.fp, self.tn, self.fn):
+            if entry is None:
+                self.compute()
+                break
+
+        return self.tp, self.fp, self.tn, self.fn
+
+    def get_size(self):
+
+        if self.size is None:
+            self.compute()
+        return self.size
+
+    def get_existence(self):
+
+        for case in (self.test_empty, self.test_full, self.reference_empty, self.reference_full):
+            if case is None:
+                self.compute()
+                break
+
+        return self.test_empty, self.test_full, self.reference_empty, self.reference_full
+
+
+def dice(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """2TP / (2TP + FP + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty and reference_empty:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(2. * tp / (2 * tp + fp + fn))
+
+
+def jaccard(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """TP / (TP + FP + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty and reference_empty:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tp / (tp + fp + fn))
+
+
+def precision(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """TP / (TP + FP)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tp / (tp + fp))
+
+
+def sensitivity(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """TP / (TP + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if reference_empty:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tp / (tp + fn))
+
+
+def recall(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """TP / (TP + FN)"""
+
+    return sensitivity(test, reference, confusion_matrix, nan_for_nonexisting, **kwargs)
+
+
+def specificity(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """TN / (TN + FP)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(tn / (tn + fp))
+
+
+def accuracy(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """(TP + TN) / (TP + FP + FN + TN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return float((tp + tn) / (tp + fp + tn + fn))
+
+
+def fscore(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, beta=1., **kwargs):
+    """(1 + b^2) * TP / ((1 + b^2) * TP + b^2 * FN + FP)"""
+
+    precision_ = precision(test, reference, confusion_matrix, nan_for_nonexisting)
+    recall_ = recall(test, reference, confusion_matrix, nan_for_nonexisting)
+
+    return (1 + beta*beta) * precision_ * recall_ /\
+        ((beta*beta * precision_) + recall_)
+
+
+def false_positive_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """FP / (FP + TN)"""
+
+    return 1 - specificity(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def false_omission_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """FN / (TN + FN)"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0.
+
+    return float(fn / (fn + tn))
+
+
+def false_negative_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """FN / (TP + FN)"""
+
+    return 1 - sensitivity(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def true_negative_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """TN / (TN + FP)"""
+
+    return specificity(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def false_discovery_rate(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """FP / (TP + FP)"""
+
+    return 1 - precision(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def negative_predictive_value(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, **kwargs):
+    """TN / (TN + FN)"""
+
+    return 1 - false_omission_rate(test, reference, confusion_matrix, nan_for_nonexisting)
+
+
+def total_positives_test(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TP + FP"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tp + fp
+
+
+def total_negatives_test(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TN + FN"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tn + fn
+
+
+def total_positives_reference(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TP + FN"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tp + fn
+
+
+def total_negatives_reference(test=None, reference=None, confusion_matrix=None, **kwargs):
+    """TN + FP"""
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    tp, fp, tn, fn = confusion_matrix.get_matrix()
+
+    return tn + fp
+
+
+def hausdorff_distance(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.hd(test, reference, voxel_spacing, connectivity)
+
+
+def hausdorff_distance_95(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.hd95(test, reference, voxel_spacing, connectivity)
+
+
+def avg_surface_distance(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.asd(test, reference, voxel_spacing, connectivity)
+
+
+def avg_surface_distance_symmetric(test=None, reference=None, confusion_matrix=None, nan_for_nonexisting=True, voxel_spacing=None, connectivity=1, **kwargs):
+
+    if confusion_matrix is None:
+        confusion_matrix = ConfusionMatrix(test, reference)
+
+    test_empty, test_full, reference_empty, reference_full = confusion_matrix.get_existence()
+
+    if test_empty or test_full or reference_empty or reference_full:
+        if nan_for_nonexisting:
+            return float("NaN")
+        else:
+            return 0
+
+    test, reference = confusion_matrix.test, confusion_matrix.reference
+
+    return metric.assd(test, reference, voxel_spacing, connectivity)
+
+
+ALL_METRICS = {
+    "False Positive Rate": false_positive_rate,
+    "Dice": dice,
+    "Jaccard": jaccard,
+    "Hausdorff Distance": hausdorff_distance,
+    "Hausdorff Distance 95": hausdorff_distance_95,
+    "Precision": precision,
+    "Recall": recall,
+    "Avg. Symmetric Surface Distance": avg_surface_distance_symmetric,
+    "Avg. Surface Distance": avg_surface_distance,
+    "Accuracy": accuracy,
+    "False Omission Rate": false_omission_rate,
+    "Negative Predictive Value": negative_predictive_value,
+    "False Negative Rate": false_negative_rate,
+    "True Negative Rate": true_negative_rate,
+    "False Discovery Rate": false_discovery_rate,
+    "Total Positives Test": total_positives_test,
+    "Total Negatives Test": total_negatives_test,
+    "Total Positives Reference": total_positives_reference,
+    "total Negatives Reference": total_negatives_reference
+}

source_code/SegMamba/light_training/examples/1_rename_mri_data_BraTS2023.py

@@ -0,0 +1,27 @@
+
+
+
+import os 
+
+# data_dir = "./data/raw_data/BraTS2023/ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData/"
+data_dir = "./data/raw_data/BraTS2023/ASNR-MICCAI-BraTS2023-GLI-Challenge-ValidationData/"
+
+all_cases = os.listdir(data_dir)
+
+for case_name in all_cases:
+    case_dir = os.path.join(data_dir, case_name)
+
+    for data_name in os.listdir(case_dir):
+
+        if "-" not in data_name:
+            continue
+        new_name = data_name.split("-")[-1]
+
+        new_path = os.path.join(case_dir, new_name)
+
+        old_path = os.path.join(case_dir, data_name)
+
+        os.rename(old_path, new_path)
+
+        print(f"{new_path} 命名成功")
+

source_code/SegMamba/light_training/examples/2_preprocessing_AIIB23.py

@@ -0,0 +1,130 @@
+
+from light_training.preprocessing.preprocessors.default_preprocessor import DefaultPreprocessor 
+import numpy as np 
+import pickle 
+import json 
+
+
+def process_train():
+    # fullres spacing is [0.5        0.70410156 0.70410156]
+    # median_shape is [602.5 516.5 516.5]
+    base_dir = "./data/raw_data/AIIB23_Train_T1"
+    image_dir = "img"
+    label_dir = "gt"
+    preprocessor = DefaultPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    label_dir=label_dir,
+                                   )
+
+    out_spacing = [0.5, 0.70410156, 0.70410156]
+    output_dir = "./data/fullres/train/"
+
+    with open("./data_analysis_result.txt", "r") as f:
+        content = f.read().strip("\n")
+        print(content)
+    content = eval(content)
+    foreground_intensity_properties_per_channel = content["intensity_statistics_per_channel"]
+    
+    preprocessor.run(output_spacing=out_spacing, 
+                     output_dir=output_dir, 
+                     all_labels=[1, ],
+                     num_processes=16,
+                     foreground_intensity_properties_per_channel=foreground_intensity_properties_per_channel)
+
+def process_val():
+    # fullres spacing is [0.5        0.70410156 0.70410156]
+    # median_shape is [602.5 516.5 516.5]
+    base_dir = "./data/raw_data/Val"
+    image_dir = "img"
+    preprocessor = DefaultPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    label_dir=None,
+                                   )
+
+    out_spacing = [0.5, 0.70410156, 0.70410156]
+
+    with open("./data_analysis_result.txt", "r") as f:
+        content = f.read().strip("\n")
+        print(content)
+    content = eval(content)
+    foreground_intensity_properties_per_channel = content["intensity_statistics_per_channel"]
+
+    output_dir = "./data/fullres/val_test/"
+    preprocessor.run(output_spacing=out_spacing, 
+                     output_dir=output_dir,
+                     all_labels=[1, ],
+                     foreground_intensity_properties_per_channel=foreground_intensity_properties_per_channel,
+                     num_processes=16)
+
+def process_val_semi():
+    # fullres spacing is [0.5        0.70410156 0.70410156]
+    # median_shape is [602.5 516.5 516.5]
+    base_dir = "./data/raw_data/Val_semi_postprocess"
+    image_dir = "img"
+    preprocessor = DefaultPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    label_dir="gt",
+                                   )
+
+    out_spacing = [0.5, 0.70410156, 0.70410156]
+
+    with open("./data_analysis_result.txt", "r") as f:
+        content = f.read().strip("\n")
+        print(content)
+    content = eval(content)
+    foreground_intensity_properties_per_channel = content["intensity_statistics_per_channel"]
+
+    output_dir = "./data/fullres/val_semi_postprocess/"
+    preprocessor.run(output_spacing=out_spacing, 
+                     output_dir=output_dir,
+                     all_labels=[1, ],
+                     foreground_intensity_properties_per_channel=foreground_intensity_properties_per_channel)
+
+
+def plan():
+    base_dir = "./data/raw_data/AIIB23_Train_T1"
+    image_dir = "img"
+    label_dir = "gt"
+
+    preprocessor = DefaultPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    label_dir=label_dir,
+                                   )
+
+    preprocessor.run_plan()
+
+if __name__ == "__main__":
+
+    # plan()
+
+    process_train()
+    # import time 
+    # s = time.time()
+    # process_val()
+    # e = time.time()
+
+    # print(f"preprocessing time is {e - s}")
+
+    # process_val_semi()
+    
+    
+# 
+    # preprocessor.run(output_spacing=[3, 0.9765625, 0.9765625], output_dir=output_dir)
+
+    # data = np.load("/home/xingzhaohu/sharefs/datasets/AIIB23_nnunet/train/AIIB23_96.npz")
+
+    # image = data["data"]
+    # label = data["seg"]
+    # print(image.shape)
+    # print(label.shape)
+
+    # import matplotlib.pyplot as plt 
+
+    # for i in range(20):
+    #     plt.imshow(image[0, i], cmap="gray")
+    #     plt.show()
+
+    # df = open("/home/xingzhaohu/sharefs/datasets/AIIB23_nnunet/train/AIIB23_96.pkl", "rb")
+
+    # info = pickle.load(df)
+    # print(info)

source_code/SegMamba/light_training/examples/2_preprocessing_BraTS2023.py

@@ -0,0 +1,94 @@
+
+from light_training.preprocessing.preprocessors.preprocessor_mri import MultiModalityPreprocessor 
+import numpy as np 
+import pickle 
+import json 
+
+data_filename = ["t2w.nii.gz",
+                 "t2f.nii.gz",
+                 "t1n.nii.gz",
+                 "t1c.nii.gz"]
+seg_filename = "seg.nii.gz"
+
+def process_train():
+    # fullres spacing is [0.5        0.70410156 0.70410156]
+    # median_shape is [602.5 516.5 516.5]
+    base_dir = "./data/raw_data/BraTS2023/"
+    image_dir = "ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData"
+    preprocessor = MultiModalityPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    data_filenames=data_filename,
+                                    seg_filename=seg_filename
+                                   )
+
+    out_spacing = [1.0, 1.0, 1.0]
+    output_dir = "./data/fullres/train/"
+    
+    preprocessor.run(output_spacing=out_spacing, 
+                     output_dir=output_dir, 
+                     all_labels=[1, 2, 3],
+    )
+
+def process_val():
+    base_dir = "./data/raw_data/BraTS2023/"
+    image_dir = "ASNR-MICCAI-BraTS2023-GLI-Challenge-ValidationData"
+    preprocessor = MultiModalityPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    data_filenames=data_filename,
+                                    seg_filename=""
+                                   )
+
+    out_spacing = [1.0, 1.0, 1.0]
+    output_dir = "./data/fullres/val/"
+    
+    preprocessor.run(output_spacing=out_spacing, 
+                     output_dir=output_dir, 
+                     all_labels=[1, 2, 3],
+    )
+
+def process_test():
+    # fullres spacing is [0.5        0.70410156 0.70410156]
+    # median_shape is [602.5 516.5 516.5]
+    base_dir = "/home/xingzhaohu/sharefs/datasets/WORD-V0.1.0/"
+    image_dir = "imagesTs"
+    label_dir = "labelsTs"
+    preprocessor = DefaultPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    label_dir=label_dir,
+                                   )
+
+    out_spacing = [3.0, 0.9765625, 0.9765625]
+
+    output_dir = "./data/fullres/test/"
+    with open("./data_analysis_result.txt", "r") as f:
+        content = f.read().strip("\n")
+        print(content)
+    content = json.loads(content)
+    foreground_intensity_properties_per_channel = content["intensity_statistics_per_channel"]
+    
+    preprocessor.run(output_spacing=out_spacing, 
+                     output_dir=output_dir, 
+                     all_labels=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+                     foreground_intensity_properties_per_channel=foreground_intensity_properties_per_channel)
+
+
+def plan():
+    base_dir = "./data/raw_data/BraTS2023/"
+    image_dir = "ASNR-MICCAI-BraTS2023-GLI-Challenge-TrainingData"
+    preprocessor = MultiModalityPreprocessor(base_dir=base_dir, 
+                                    image_dir=image_dir,
+                                    data_filenames=data_filename,
+                                    seg_filename=seg_filename
+                                   )
+    
+    preprocessor.run_plan()
+
+
+if __name__ == "__main__":
+# 
+    # plan()
+
+    process_train()
+    # process_val()
+    # process_test()
+