use huggingface models

crop.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e43631e45b61a439a3fc9d78b21501a92de8ef67a33ef050d44476f7153e6fae
-size 6228872

net0.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5a60765870a852fd71e1219d895f18ec8f9272a9c785b291b1bed29746d7e42c
-size 112286108

net1.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8f703131880526db7942a55b7867d417f989827fecf3b5b9d11077f6216ee6aa
-size 112286108

net2.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9f9bb1365149d9570272af3aa8c059e4d33cd3a6c3d03b82cf923e868caeaea0
-size 112286108

skp/configs/__init__.py

@@ -1,21 +0,0 @@
-from types import SimpleNamespace
-
-
-class Config(SimpleNamespace):
-
-    def __getattribute__(self, value):
-        # If attribute not specified in config,
-        # return None instead of raise error
-        try:
-            return super().__getattribute__(value)
-        except AttributeError:
-            return None  
-
-    def __str__(self):
-        # pretty print
-        string = ["config"]
-        string.append("=" * len(string[0]))
-        longest_param_name = max([len(k) for k in [*self.__dict__]])
-        for k, v in self.__dict__.items():
-            string.append(f"{k.ljust(longest_param_name)} : {v}")
-        return "\n".join(string)

skp/configs/base.py

@@ -1,21 +0,0 @@
-from types import SimpleNamespace
-
-
-class Config(SimpleNamespace):
-
-    def __getattribute__(self, value):
-        # If attribute not specified in config,
-        # return None instead of raise error
-        try:
-            return super().__getattribute__(value)
-        except AttribuateError:
-            return None  
-
-    def __str__(self):
-        # pretty print
-        string = ["config"]
-        string.append("=" * len(string[0]))
-        longest_param_name = max([len(k) for k in [*self.__dict__]])
-        for k, v in self.__dict__.items():
-            string.append(f"{k.ljust(longest_param_name)} : {v}")
-        return "\n".join(string)

skp/configs/boneage/cfg_baseline.py

@@ -1,117 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d_var_embed"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.embed_num_classes = 2
-cfg.embed_dim = 32
-cfg.pretrained = True
-cfg.num_input_channels = 1
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = 1
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "simple2d"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years"]
-cfg.vars = "female"
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1Loss"
-cfg.loss_params = {}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE", "classification.MSE"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_crop.py

@@ -1,123 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d"
-cfg.backbone = "mobilenetv3_small_100"
-cfg.pretrained = True
-cfg.num_input_channels = 1
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = 4
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-cfg.model_activation_fn = "sigmoid"
-
-cfg.fold = 0
-cfg.dataset = "crop2d"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/train/"
-cfg.annotations_file = (
-    "/mnt/stor/datasets/bone-age/train_with_bounding_box_crop_coords_kfold.csv"
-)
-cfg.inputs = "imgfile"
-cfg.targets = ["x1", "y1", "w", "h"]
-cfg.normalize_crop_coords = True
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 100
-
-cfg.loss = "classification.L1Loss"
-cfg.loss_params = {}
-
-cfg.batch_size = 16
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE", "classification.MSE"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-bbox_params = A.BboxParams(format="coco")
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ],
-    bbox_params=bbox_params,
-)
-
-cfg.val_transforms = A.Compose(
-    resize_transforms,
-    bbox_params=bbox_params,
-)

skp/configs/boneage/cfg_crop_simple_resize.py

@@ -1,117 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d"
-cfg.backbone = "mobilenetv3_small_100"
-cfg.pretrained = True
-cfg.num_input_channels = 1
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = 4
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-cfg.model_activation_fn = "sigmoid"
-
-cfg.fold = 0
-cfg.dataset = "crop2d"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/train/"
-cfg.annotations_file = (
-    "/mnt/stor/datasets/bone-age/train_with_bounding_box_crop_coords_kfold.csv"
-)
-cfg.inputs = "imgfile"
-cfg.targets = ["x1", "y1", "w", "h"]
-cfg.normalize_crop_coords = True
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 200
-
-cfg.loss = "classification.L1Loss"
-cfg.loss_params = {}
-
-cfg.batch_size = 16
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE", "classification.MSE"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-bbox_params = A.BboxParams(format="coco")
-resize_transforms = [
-    A.Resize(height=cfg.image_height, width=cfg.image_width, p=1)
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ],
-    bbox_params=bbox_params,
-)
-
-cfg.val_transforms = A.Compose(
-    resize_transforms,
-    bbox_params=bbox_params,
-)

skp/configs/boneage/cfg_female_channel.py

@@ -1,114 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = 1
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1Loss"
-cfg.loss_params = {}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE", "classification.MSE"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_MIL.py

@@ -1,113 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "MIL.net2d_basic_attn"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = 1
-cfg.attn_dropout = 0.0
-cfg.attn_version = "v1"
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel_grid_patch"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.patch_size = 224
-cfg.patch_num_rows = 5
-cfg.patch_num_cols = 3
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1Loss"
-cfg.loss_params = {}
-
-cfg.batch_size = 16
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE", "classification.MSE"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 560
-cfg.image_width = cfg.image_height # not used 
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_MIL_lstm.py

@@ -1,116 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "MIL.net2d_attn"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = 1
-cfg.add_lstm = True
-cfg.lstm_dropout = 0.0
-cfg.lstm_num_layers = 1
-cfg.attn_dropout = 0.0
-cfg.attn_version = "v1"
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel_grid_patch"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.patch_size = 224
-cfg.patch_num_rows = 5
-cfg.patch_num_cols = 3
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1Loss"
-cfg.loss_params = {}
-
-cfg.batch_size = 16
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE", "classification.MSE"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 560
-cfg.image_width = cfg.image_height # not used 
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_MIL_transformer.py

@@ -1,117 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "MIL.net2d_attn"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = 1
-cfg.reduce_feature_dim = 256
-cfg.add_transformer = True
-cfg.transformer_dropout = 0.0
-cfg.transformer_num_layers = 1
-cfg.attn_dropout = 0.0
-cfg.attn_version = "v1"
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel_grid_patch"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.patch_size = 224
-cfg.patch_num_rows = 5
-cfg.patch_num_cols = 3
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1Loss"
-cfg.loss_params = {}
-
-cfg.batch_size = 16
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE", "classification.MSE"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 560
-cfg.image_width = cfg.image_height # not used 
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_reg_cls.py

@@ -1,115 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d_multihead"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = [1, 240]
-cfg.num_heads = 2
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.DoubleL1Loss"
-cfg.loss_params = {"reg_weight": 1.0, "cls_weight": 0.4}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.DoubleMAE"]
-cfg.val_metric = "mae_reg"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_reg_cls_clip_outliers_aug.py

@@ -1,119 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d_multihead"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = [1, 240]
-cfg.num_heads = 2
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.clip_outlier_pixels_and_rescale = True
-cfg.clip_as_data_aug = True
-cfg.clip_proba = 0.5
-cfg.clip_bounds = (1, 99)
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.DoubleL1Loss"
-cfg.loss_params = {"reg_weight": 1.0, "cls_weight": 0.4}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.DoubleMAE"]
-cfg.val_metric = "mae_reg"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_reg_cls_match_hist.py

@@ -1,116 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d_multihead"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = [1, 240]
-cfg.num_heads = 2
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel_match_hist"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.ref_image_match_hist = "/mnt/stor/datasets/bone-age/reference_cropped_image_for_histogram_matching.png"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.DoubleL1Loss"
-cfg.loss_params = {"reg_weight": 1.0, "cls_weight": 0.4}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.DoubleMAE"]
-cfg.val_metric = "mae_reg"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_with_cls.py

@@ -1,115 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d_multihead"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = [1, 24]
-cfg.num_heads = 2
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel_with_cls"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years", "bone_age_categorical"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1CELoss"
-cfg.loss_params = {"l1_weight": 1.0, "ce_weight": 0.2}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE_Accuracy"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_with_cls_clip_outliers.py

@@ -1,117 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d_multihead"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = [1, 24]
-cfg.num_heads = 2
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel_with_cls"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years", "bone_age_categorical"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.clip_outlier_pixels_and_rescale = True
-cfg.clip_bounds = (1, 99)
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1CELoss"
-cfg.loss_params = {"l1_weight": 1.0, "ce_weight": 0.2}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE_Accuracy"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/configs/boneage/cfg_female_channel_with_cls_clip_outliers_aug.py

@@ -1,119 +0,0 @@
-import albumentations as A
-import cv2
-
-from skp.configs import Config
-
-
-cfg = Config()
-cfg.neptune_mode = "async"
-
-cfg.save_dir = "/home/ian/projects/SKP/experiments/boneage/"
-cfg.project = "gradientecho/SKP"
-
-cfg.task = "classification"
-
-cfg.model = "classification.net2d_multihead"
-cfg.backbone = "tf_efficientnetv2_s"
-cfg.pretrained = True
-cfg.num_input_channels = 2
-cfg.pool = "gem"
-cfg.pool_params = {"p": 3}
-cfg.dropout = 0.1
-cfg.num_classes = [1, 24]
-cfg.num_heads = 2
-cfg.normalization = "-1_1"
-cfg.normalization_params = {"min": 0, "max": 255}
-cfg.backbone_img_size = False
-
-cfg.fold = 0
-cfg.dataset = "boneage.female_channel_with_cls"
-cfg.data_dir = "/mnt/stor/datasets/bone-age/cropped_train_plus_valid/"
-cfg.annotations_file = "/mnt/stor/datasets/bone-age/train_plus_valid_kfold.csv"
-cfg.inputs = "imgfile0"
-cfg.targets = ["bone_age_years", "bone_age_categorical"]
-cfg.cv2_load_flag = cv2.IMREAD_GRAYSCALE
-cfg.num_workers = 16
-cfg.clip_outlier_pixels_and_rescale = True
-cfg.clip_as_data_aug = True
-cfg.clip_proba = 0.5
-cfg.clip_bounds = (1, 99)
-cfg.pin_memory = True
-cfg.persistent_workers = True
-cfg.sampler = "IterationBasedSampler"
-cfg.num_iterations_per_epoch = 1000
-
-cfg.loss = "classification.L1CELoss"
-cfg.loss_params = {"l1_weight": 1.0, "ce_weight": 0.2}
-
-cfg.batch_size = 32
-cfg.num_epochs = 10
-cfg.optimizer = "AdamW"
-cfg.optimizer_params = {"lr": 3e-4}
-
-cfg.scheduler = "LinearWarmupCosineAnnealingLR"
-cfg.scheduler_params = {"pct_start": 0.1, "div_factor": 100, "final_div_factor": 1_000}
-cfg.scheduler_interval = "step"
-
-cfg.val_batch_size = cfg.batch_size * 2
-cfg.metrics = ["classification.MAE_Accuracy"]
-cfg.val_metric = "mae_mean"
-cfg.val_track = "min"
-
-cfg.image_height = 512
-cfg.image_width = 512
-
-resize_transforms = [
-    A.LongestMaxSize(max_size=cfg.image_height, p=1),
-    A.PadIfNeeded(
-        min_height=cfg.image_height,
-        min_width=cfg.image_width,
-        border_mode=cv2.BORDER_CONSTANT,
-        p=1,
-    ),
-]
-
-cfg.train_transforms = A.Compose(
-    resize_transforms
-    + [
-        A.VerticalFlip(p=0.5),
-        A.HorizontalFlip(p=0.5),
-        A.SomeOf(
-            [
-                A.ShiftScaleRotate(
-                    shift_limit=0.2,
-                    scale_limit=0.0,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.2,
-                    rotate_limit=0,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.ShiftScaleRotate(
-                    shift_limit=0.0,
-                    scale_limit=0.0,
-                    rotate_limit=30,
-                    border_mode=cv2.BORDER_CONSTANT,
-                    p=1,
-                ),
-                A.GaussianBlur(p=1),
-                A.GaussNoise(p=1),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.3, brightness_limit=0.0, p=1
-                ),
-                A.RandomBrightnessContrast(
-                    contrast_limit=0.0, brightness_limit=0.3, p=1
-                ),
-            ],
-            n=3,
-            p=0.9,
-            replace=False,
-        ),
-    ]
-)
-
-cfg.val_transforms = A.Compose(resize_transforms)

skp/models/MIL/net2d_attn.py

@@ -1,286 +0,0 @@
-"""
-2D model for multiple instance learning (MIL)
-Performs attention over bag of features (i.e., attention-weighted mean of features)
-Option to add LSTM or Transformer before attention aggregation
-Uses timm backbones
-"""
-
-import re
-import torch
-import torch.nn as nn
-
-from einops import rearrange
-from timm import create_model
-from typing import Dict, Optional, Tuple
-
-from skp.configs.base import Config
-from skp.models.modules import FeatureReduction
-from skp.models.pooling import get_pool_layer
-
-
-class Attention(nn.Module):
-    """
-    Given a batch containing bags of features (B, N, D),
-    generate attention scores over the features in a bag, N,
-    and perform an attention-weighted mean of the features (B, D)
-    """
-
-    def __init__(self, embed_dim: int, dropout: float = 0.0, version: str = "v1"):
-        super().__init__()
-        version = version.lower()
-        if version == "v1":
-            self.mlp = nn.Sequential(
-                nn.Tanh(), nn.Dropout(dropout), nn.Linear(embed_dim, 1)
-            )
-        elif version == "v2":
-            self.mlp = nn.Sequential(
-                nn.Linear(embed_dim, embed_dim),
-                nn.Tanh(),
-                nn.Dropout(dropout),
-                nn.Linear(embed_dim, 1),
-            )
-
-    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor]:
-        a = self.mlp(x)
-        a = a.softmax(dim=1)
-        x = (x * a).sum(dim=1)
-        return x, a
-
-
-class BiLSTM(nn.Module):
-    def __init__(self, embed_dim: int, dropout: float = 0.0, num_layers: int = 1):
-        super().__init__()
-        self.lstm = nn.LSTM(
-            input_size=embed_dim,
-            hidden_size=embed_dim // 2,
-            num_layers=num_layers,
-            bias=True,
-            batch_first=True,
-            dropout=dropout,
-            bidirectional=True,
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x, _ = self.lstm(x)
-        return x
-
-
-class Transformer(nn.Module):
-    def __init__(
-        self,
-        embed_dim: int,
-        dropout: float = 0.0,
-        num_layers: int = 1,
-        nhead: int = 16,
-        activation: str = "gelu",
-    ):
-        super().__init__()
-        encoder_layer = nn.TransformerEncoderLayer(
-            d_model=embed_dim,
-            nhead=nhead,
-            dim_feedforward=embed_dim,
-            dropout=dropout,
-            activation=activation,
-            batch_first=True,
-            norm_first=False,
-            bias=True,
-        )
-        self.T = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
-
-    def forward(
-        self, x: torch.Tensor, mask: Optional[torch.Tensor] = None
-    ) -> torch.Tensor:
-        return self.T(x, mask=mask)
-
-
-class Net(nn.Module):
-    def __init__(self, cfg: Config):
-        super().__init__()
-        self.cfg = cfg
-        backbone_args = {
-            "pretrained": self.cfg.pretrained,
-            "num_classes": 0,
-            "global_pool": "",
-            "features_only": self.cfg.features_only,
-            "in_chans": self.cfg.num_input_channels,
-        }
-        if self.cfg.backbone_img_size:
-            # some models require specifying image size (e.g., coatnet)
-            if "efficientvit" in self.cfg.backbone:
-                backbone_args["img_size"] = self.cfg.image_height
-            else:
-                backbone_args["img_size"] = (
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-        self.backbone = create_model(self.cfg.backbone, **backbone_args)
-        # get feature dim by passing sample through net
-        self.feature_dim = self.backbone(
-            torch.randn(
-                (
-                    2,
-                    self.cfg.num_input_channels,
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-            )
-        ).size(
-            -1 if "xcit" in self.cfg.backbone else 1
-        )  # xcit models are channels-last
-
-        self.feature_dim = self.feature_dim * (2 if self.cfg.pool == "catavgmax" else 1)
-        self.pooling = get_pool_layer(self.cfg, dim=2)
-
-        if isinstance(self.cfg.reduce_feature_dim, int):
-            self.backbone = nn.Sequential(
-                self.backbone,
-                FeatureReduction(self.feature_dim, self.cfg.reduce_feature_dim),
-            )
-            self.feature_dim = self.cfg.reduce_feature_dim
-
-        if self.cfg.add_lstm:
-            self.pre_attn = BiLSTM(
-                embed_dim=self.feature_dim,
-                dropout=self.cfg.lstm_dropout or 0.0,
-                num_layers=self.cfg.lstm_num_layers or 1,
-            )
-        elif self.cfg.add_transformer:
-            self.pre_attn = Transformer(
-                embed_dim=self.feature_dim,
-                dropout=self.cfg.transformer_dropout or 0.0,
-                num_layers=self.cfg.transformer_num_layers or 1,
-                nhead=self.cfg.transformer_nhead or 16,
-                activation=self.cfg.transformer_act or "gelu",
-            )
-        else:
-            self.pre_attn = nn.Identity()
-
-        self.attn = Attention(
-            self.feature_dim,
-            dropout=self.cfg.attn_dropout,
-            version=self.cfg.attn_version or "v1",
-        )
-        self.dropout = nn.Dropout(p=self.cfg.dropout)
-        self.linear = nn.Linear(self.feature_dim, self.cfg.num_classes)
-
-        if self.cfg.load_pretrained_backbone:
-            print(
-                f"Loading pretrained backbone from {self.cfg.load_pretrained_backbone} ..."
-            )
-            weights = torch.load(
-                self.cfg.load_pretrained_backbone,
-                map_location=lambda storage, loc: storage,
-            )["state_dict"]
-            # Replace model prefix as this does not exist in Net
-            weights = {re.sub(r"^model.", "", k): v for k, v in weights.items()}
-            # Get backbone only
-            weights = {
-                re.sub(r"^backbone.", "", k): v
-                for k, v in weights.items()
-                if "backbone" in k
-            }
-            self.backbone.load_state_dict(weights)
-
-        self.criterion = None
-
-        self.backbone_frozen = False
-        if self.cfg.freeze_backbone:
-            self.freeze_backbone()
-
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.cfg.normalization == "-1_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-            x = x - 0.5
-            x = x * 2.0
-        elif self.cfg.normalization == "0_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-        elif self.cfg.normalization == "mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "per_channel_mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            assert len(mean) == len(sd) == x.size(1)
-            mean, sd = torch.tensor(mean).unsqueeze(0), torch.tensor(sd).unsqueeze(0)
-            for i in range(x.ndim - 2):
-                mean, sd = mean.unsqueeze(-1), sd.unsqueeze(-1)
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "none":
-            x = x
-        return x
-
-    def forward(
-        self,
-        batch: Dict,
-        return_loss: bool = False,
-        return_features: bool = False,
-        return_attn_scores: bool = False,
-    ) -> Dict[str, torch.Tensor]:
-        x = batch["x"]
-        y = batch.get("y", None)
-
-        if return_loss:
-            assert y is not None
-
-        b, n = x.shape[:2]
-        x = rearrange(x, "b n c h w -> (b n) c h w")
-        features = self.extract_features(x, normalize=True)
-        features = rearrange(features, "(b n) d -> b n d", b=b, n=n)
-        if isinstance(self.pre_attn, Transformer):
-            features = self.pre_attn(features, mask=batch.get("mask", None))
-        else:
-            features = self.pre_attn(features)
-        features, attn_scores = self.attn(features)
-
-        if self.cfg.multisample_dropout:
-            logits = torch.stack(
-                [self.linear(self.dropout(features)) for _ in range(5)]
-            ).mean(0)
-        else:
-            logits = self.linear(self.dropout(features))
-
-        if self.cfg.model_activation_fn == "sigmoid":
-            logits = logits.sigmoid()
-        elif self.cfg.model_activation_fn == "softmax":
-            logits = logits.softmax(dim=1)
-
-        out = {"logits": logits}
-        if return_features:
-            out["features"] = features
-        if return_attn_scores:
-            out["attn_scores"] = attn_scores
-        if return_loss:
-            loss = self.criterion(out, batch)
-            if isinstance(loss, dict):
-                out.update(loss)
-            else:
-                out["loss"] = loss
-
-        return out
-
-    def extract_features(self, x: torch.Tensor, normalize: bool = True) -> torch.Tensor:
-        x = self.normalize(x) if normalize else x
-        return self.pooling(self.backbone(x))
-
-    def freeze_backbone(self) -> None:
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-        self.backbone_frozen = True
-
-    def set_criterion(self, loss: nn.Module) -> None:
-        self.criterion = loss

skp/models/MIL/net2d_basic_attn.py

@@ -1,284 +0,0 @@
-"""
-2D model for multiple instance learning (MIL)
-Performs attention over bag of features (i.e., attention-weighted mean of features)
-Uses timm backbones
-"""
-
-import re
-import torch
-import torch.nn as nn
-
-from einops import rearrange
-from timm import create_model
-from typing import Dict, Optional, Tuple
-
-from skp.configs.base import Config
-from skp.models.modules import FeatureReduction
-from skp.models.pooling import get_pool_layer
-
-
-class Attention(nn.Module):
-    """
-    Given a batch containing bags of features (B, N, D),
-    generate attention scores over the features in a bag, N,
-    and perform an attention-weighted mean of the features (B, D)
-    """
-
-    def __init__(self, embed_dim: int, dropout: float = 0.0, version: str = "v1"):
-        super().__init__()
-        version = version.lower()
-        if version == "v1":
-            self.mlp = nn.Sequential(
-                nn.Tanh(), nn.Dropout(dropout), nn.Linear(embed_dim, 1)
-            )
-        elif version == "v2":
-            self.mlp = nn.Sequential(
-                nn.Linear(embed_dim, embed_dim),
-                nn.Tanh(),
-                nn.Dropout(dropout),
-                nn.Linear(embed_dim, 1),
-            )
-
-    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor]:
-        a = self.mlp(x)
-        a = a.softmax(dim=1)
-        x = (x * a).sum(dim=1)
-        return x, a
-
-
-class BiLSTM(nn.Module):
-    def __init__(self, embed_dim: int, dropout: float = 0.0, num_layers: int = 1):
-        super().__init__()
-        self.lstm = nn.LSTM(
-            input_size=embed_dim,
-            hidden_size=embed_dim // 2,
-            num_layers=num_layers,
-            bias=True,
-            batch_first=True,
-            dropout=dropout,
-            bidirectional=True,
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x, _ = self.lstm(x)
-        return x
-
-
-class Transformer(nn.Module):
-    def __init__(
-        self,
-        embed_dim: int,
-        dropout: float = 0.0,
-        num_layers: int = 1,
-        nheads: int = 16,
-        activation: str = "gelu",
-    ):
-        super().__init__()
-        encoder_layer = nn.TransformerEncoderLayer(
-            d_model=embed_dim,
-            dim_feedforward=embed_dim,
-            dropout=dropout,
-            activation=activation,
-            batch_first=True,
-            norm_first=False,
-            bias=True,
-        )
-        self.T = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
-
-    def forward(
-        self, x: torch.Tensor, mask: Optional[torch.Tensor] = None
-    ) -> torch.Tensor:
-        return self.T(x, mask=mask)
-
-
-class Net(nn.Module):
-    def __init__(self, cfg: Config):
-        super().__init__()
-        self.cfg = cfg
-        backbone_args = {
-            "pretrained": self.cfg.pretrained,
-            "num_classes": 0,
-            "global_pool": "",
-            "features_only": self.cfg.features_only,
-            "in_chans": self.cfg.num_input_channels,
-        }
-        if self.cfg.backbone_img_size:
-            # some models require specifying image size (e.g., coatnet)
-            if "efficientvit" in self.cfg.backbone:
-                backbone_args["img_size"] = self.cfg.image_height
-            else:
-                backbone_args["img_size"] = (
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-        self.backbone = create_model(self.cfg.backbone, **backbone_args)
-        # get feature dim by passing sample through net
-        self.feature_dim = self.backbone(
-            torch.randn(
-                (
-                    2,
-                    self.cfg.num_input_channels,
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-            )
-        ).size(
-            -1 if "xcit" in self.cfg.backbone else 1
-        )  # xcit models are channels-last
-
-        self.feature_dim = self.feature_dim * (2 if self.cfg.pool == "catavgmax" else 1)
-        self.pooling = get_pool_layer(self.cfg, dim=2)
-
-        if isinstance(self.cfg.reduce_feature_dim, int):
-            self.backbone = nn.Sequential(
-                self.backbone,
-                FeatureReduction(self.feature_dim, self.cfg.reduce_feature_dim),
-            )
-            self.feature_dim = self.cfg.reduce_feature_dim
-
-        if self.cfg.add_lstm:
-            self.pre_attn = BiLSTM(
-                embed_dim=self.feature_dim,
-                dropout=self.cfg.lstm_dropout or 0.0,
-                num_layers=self.cfg.lstm_num_layers or 1,
-            )
-        elif self.cfg.add_transformer:
-            self.pre_attn = Transformer(
-                embed_dim=self.feature_dim,
-                dropout=self.transformer_dropout or 0.0,
-                num_layers=self.transformer_num_layers or 1,
-                nheads=self.transformer_nheads or 16,
-                activation=self.transformer_act or "gelu",
-            )
-        else:
-            self.pre_attn = nn.Identity()
-
-        self.attn = Attention(
-            self.feature_dim,
-            dropout=self.cfg.attn_dropout,
-            version=self.cfg.attn_version or "v1",
-        )
-        self.dropout = nn.Dropout(p=self.cfg.dropout)
-        self.linear = nn.Linear(self.feature_dim, self.cfg.num_classes)
-
-        if self.cfg.load_pretrained_backbone:
-            print(
-                f"Loading pretrained backbone from {self.cfg.load_pretrained_backbone} ..."
-            )
-            weights = torch.load(
-                self.cfg.load_pretrained_backbone,
-                map_location=lambda storage, loc: storage,
-            )["state_dict"]
-            # Replace model prefix as this does not exist in Net
-            weights = {re.sub(r"^model.", "", k): v for k, v in weights.items()}
-            # Get backbone only
-            weights = {
-                re.sub(r"^backbone.", "", k): v
-                for k, v in weights.items()
-                if "backbone" in k
-            }
-            self.backbone.load_state_dict(weights)
-
-        self.criterion = None
-
-        self.backbone_frozen = False
-        if self.cfg.freeze_backbone:
-            self.freeze_backbone()
-
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.cfg.normalization == "-1_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-            x = x - 0.5
-            x = x * 2.0
-        elif self.cfg.normalization == "0_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-        elif self.cfg.normalization == "mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "per_channel_mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            assert len(mean) == len(sd) == x.size(1)
-            mean, sd = torch.tensor(mean).unsqueeze(0), torch.tensor(sd).unsqueeze(0)
-            for i in range(x.ndim - 2):
-                mean, sd = mean.unsqueeze(-1), sd.unsqueeze(-1)
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "none":
-            x = x
-        return x
-
-    def forward(
-        self,
-        batch: Dict,
-        return_loss: bool = False,
-        return_features: bool = False,
-        return_attn_scores: bool = False,
-    ) -> Dict[str, torch.Tensor]:
-        x = batch["x"]
-        y = batch.get("y", None)
-
-        if return_loss:
-            assert y is not None
-
-        b, n = x.shape[:2]
-        x = rearrange(x, "b n c h w -> (b n) c h w")
-        features = self.extract_features(x, normalize=True)
-        features = rearrange(features, "(b n) d -> b n d", b=b, n=n)
-        if isinstance(self.pre_attn, Transformer):
-            features = self.pre_attn(features, mask=batch.get("mask", None))
-        else:
-            features = self.pre_attn(features)
-        features, attn_scores = self.attn(features)
-
-        if self.cfg.multisample_dropout:
-            logits = torch.stack(
-                [self.linear(self.dropout(features)) for _ in range(5)]
-            ).mean(0)
-        else:
-            logits = self.linear(self.dropout(features))
-
-        if self.cfg.model_activation_fn == "sigmoid":
-            logits = logits.sigmoid()
-        elif self.cfg.model_activation_fn == "softmax":
-            logits = logits.softmax(dim=1)
-
-        out = {"logits": logits}
-        if return_features:
-            out["features"] = features
-        if return_attn_scores:
-            out["attn_scores"] = attn_scores
-        if return_loss:
-            loss = self.criterion(out, batch)
-            if isinstance(loss, dict):
-                out.update(loss)
-            else:
-                out["loss"] = loss
-
-        return out
-
-    def extract_features(self, x: torch.Tensor, normalize: bool = True) -> torch.Tensor:
-        x = self.normalize(x) if normalize else x
-        return self.pooling(self.backbone(x))
-
-    def freeze_backbone(self) -> None:
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-        self.backbone_frozen = True
-
-    def set_criterion(self, loss: nn.Module) -> None:
-        self.criterion = loss

skp/models/classification/net2d.py

@@ -1,172 +0,0 @@
-"""
-Simple model for 2D classification (or regression)
-Uses timm for backbones
-"""
-
-import re
-import torch
-import torch.nn as nn
-
-from timm import create_model
-from typing import Dict
-
-from skp.configs.base import Config
-from skp.models.modules import FeatureReduction
-from skp.models.pooling import get_pool_layer
-
-
-class Net(nn.Module):
-    def __init__(self, cfg: Config):
-        super().__init__()
-        self.cfg = cfg
-        backbone_args = {
-            "pretrained": self.cfg.pretrained,
-            "num_classes": 0,
-            "global_pool": "",
-            "features_only": self.cfg.features_only,
-            "in_chans": self.cfg.num_input_channels,
-        }
-        if self.cfg.backbone_img_size:
-            # some models require specifying image size (e.g., coatnet)
-            if "efficientvit" in self.cfg.backbone:
-                backbone_args["img_size"] = self.cfg.image_height
-            else:
-                backbone_args["img_size"] = (
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-        self.backbone = create_model(self.cfg.backbone, **backbone_args)
-        # get feature dim by passing sample through net
-        self.feature_dim = self.backbone(
-            torch.randn(
-                (
-                    2,
-                    self.cfg.num_input_channels,
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-            )
-        ).size(
-            -1 if "xcit" in self.cfg.backbone else 1
-        )  # xcit models are channels-last
-
-        self.feature_dim = self.feature_dim * (2 if self.cfg.pool == "catavgmax" else 1)
-        self.pooling = get_pool_layer(self.cfg, dim=2)
-
-        if isinstance(self.cfg.reduce_feature_dim, int):
-            self.backbone = nn.Sequential(
-                self.backbone,
-                FeatureReduction(self.feature_dim, self.cfg.reduce_feature_dim),
-            )
-            self.feature_dim = self.cfg.reduce_feature_dim
-
-        self.dropout = nn.Dropout(p=self.cfg.dropout)
-        self.linear = nn.Linear(self.feature_dim, self.cfg.num_classes)
-
-        if self.cfg.load_pretrained_backbone:
-            print(
-                f"Loading pretrained backbone from {self.cfg.load_pretrained_backbone} ..."
-            )
-            weights = torch.load(
-                self.cfg.load_pretrained_backbone,
-                map_location=lambda storage, loc: storage,
-            )["state_dict"]
-            # Replace model prefix as this does not exist in Net
-            weights = {re.sub(r"^model.", "", k): v for k, v in weights.items()}
-            # Get backbone only
-            weights = {
-                re.sub(r"^backbone.", "", k): v
-                for k, v in weights.items()
-                if "backbone" in k
-            }
-            self.backbone.load_state_dict(weights)
-
-        self.criterion = None
-
-        self.backbone_frozen = False
-        if self.cfg.freeze_backbone:
-            self.freeze_backbone()
-
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.cfg.normalization == "-1_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-            x = x - 0.5
-            x = x * 2.0
-        elif self.cfg.normalization == "0_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-        elif self.cfg.normalization == "mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "per_channel_mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            assert len(mean) == len(sd) == x.size(1)
-            mean, sd = torch.tensor(mean).unsqueeze(0), torch.tensor(sd).unsqueeze(0)
-            for i in range(x.ndim - 2):
-                mean, sd = mean.unsqueeze(-1), sd.unsqueeze(-1)
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "none":
-            x = x
-        return x
-
-    def forward(
-        self, batch: Dict, return_loss: bool = False, return_features: bool = False
-    ) -> Dict[str, torch.Tensor]:
-        x = batch["x"]
-        y = batch.get("y", None)
-
-        if return_loss:
-            assert y is not None
-
-        features = self.extract_features(x, normalize=True)
-
-        if self.cfg.multisample_dropout:
-            logits = torch.stack(
-                [self.linear(self.dropout(features)) for _ in range(5)]
-            ).mean(0)
-        else:
-            logits = self.linear(self.dropout(features))
-        
-        if self.cfg.model_activation_fn == "sigmoid":
-            logits = logits.sigmoid()
-        elif self.cfg.model_activation_fn == "softmax":
-            logits = logits.softmax(dim=1)
-    
-        out = {"logits": logits}
-        if return_features:
-            out["features"] = features
-        if return_loss:
-            loss = self.criterion(out, batch)
-            if isinstance(loss, dict):
-                out.update(loss)
-            else:
-                out["loss"] = loss
-
-        return out
-
-    def extract_features(self, x: torch.Tensor, normalize: bool = True) -> torch.Tensor:
-        x = self.normalize(x) if normalize else x
-        return self.pooling(self.backbone(x))
-
-    def freeze_backbone(self) -> None:
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-        self.backbone_frozen = True
-
-    def set_criterion(self, loss: nn.Module) -> None:
-        self.criterion = loss

skp/models/classification/net2d_multihead.py

@@ -1,176 +0,0 @@
-"""
-Simple model for 2D classification (or regression) with multiple heads
-Uses timm for backbones
-"""
-
-import re
-import torch
-import torch.nn as nn
-
-from collections.abc import Sequence
-from timm import create_model
-from typing import Dict
-
-from skp.configs.base import Config
-from skp.models.modules import FeatureReduction
-from skp.models.pooling import get_pool_layer
-
-
-class Net(nn.Module):
-    def __init__(self, cfg: Config):
-        super().__init__()
-        self.cfg = cfg
-        assert (
-            isinstance(self.cfg.num_classes, Sequence)
-            and len(self.cfg.num_classes) == self.cfg.num_heads
-        ), f"cfg.num_classes should be sequence of length {self.cfg.num_heads} corresponding to each head"
-        backbone_args = {
-            "pretrained": self.cfg.pretrained,
-            "num_classes": 0,
-            "global_pool": "",
-            "features_only": self.cfg.features_only,
-            "in_chans": self.cfg.num_input_channels,
-        }
-        if self.cfg.backbone_img_size:
-            # some models require specifying image size (e.g., coatnet)
-            if "efficientvit" in self.cfg.backbone:
-                backbone_args["img_size"] = self.cfg.image_height
-            else:
-                backbone_args["img_size"] = (
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-        self.backbone = create_model(self.cfg.backbone, **backbone_args)
-        # get feature dim by passing sample through net
-        self.feature_dim = self.backbone(
-            torch.randn(
-                (
-                    2,
-                    self.cfg.num_input_channels,
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-            )
-        ).size(
-            -1 if "xcit" in self.cfg.backbone else 1
-        )  # xcit models are channels-last
-
-        self.feature_dim = self.feature_dim * (2 if self.cfg.pool == "catavgmax" else 1)
-        self.pooling = get_pool_layer(self.cfg, dim=2)
-
-        if isinstance(self.cfg.reduce_feature_dim, int):
-            self.backbone = nn.Sequential(
-                self.backbone,
-                FeatureReduction(self.feature_dim, self.cfg.reduce_feature_dim),
-            )
-            self.feature_dim = self.cfg.reduce_feature_dim
-
-        self.dropout = nn.Dropout(p=self.cfg.dropout)
-        self.linear = nn.ModuleList()
-        for i in range(self.cfg.num_heads):
-            self.linear.append(nn.Linear(self.feature_dim, self.cfg.num_classes[i]))
-
-        if self.cfg.load_pretrained_backbone:
-            print(
-                f"Loading pretrained backbone from {self.cfg.load_pretrained_backbone} ..."
-            )
-            weights = torch.load(
-                self.cfg.load_pretrained_backbone,
-                map_location=lambda storage, loc: storage,
-            )["state_dict"]
-            # Replace model prefix as this does not exist in Net
-            weights = {re.sub(r"^model.", "", k): v for k, v in weights.items()}
-            # Get backbone only
-            weights = {
-                re.sub(r"^backbone.", "", k): v
-                for k, v in weights.items()
-                if "backbone" in k
-            }
-            self.backbone.load_state_dict(weights)
-
-        self.criterion = None
-
-        self.backbone_frozen = False
-        if self.cfg.freeze_backbone:
-            self.freeze_backbone()
-
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.cfg.normalization == "-1_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-            x = x - 0.5
-            x = x * 2.0
-        elif self.cfg.normalization == "0_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-        elif self.cfg.normalization == "mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "per_channel_mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            assert len(mean) == len(sd) == x.size(1)
-            mean, sd = torch.tensor(mean).unsqueeze(0), torch.tensor(sd).unsqueeze(0)
-            for i in range(x.ndim - 2):
-                mean, sd = mean.unsqueeze(-1), sd.unsqueeze(-1)
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "none":
-            x = x
-        return x
-
-    def forward(
-        self, batch: Dict, return_loss: bool = False, return_features: bool = False
-    ) -> Dict[str, torch.Tensor]:
-        x = batch["x"]
-        y = batch.get("y", None)
-
-        if return_loss:
-            assert y is not None
-
-        features = self.extract_features(x, normalize=True)
-
-        out = {}
-        for head_idx, each_head in enumerate(self.linear):
-            if self.cfg.multisample_dropout:
-                logits = torch.stack(
-                    [each_head(self.dropout(features)) for _ in range(5)]
-                ).mean(0)
-            else:
-                logits = each_head(self.dropout(features))
-            out[f"logits{head_idx}"] = logits
-
-        if return_features:
-            out["features"] = features
-        if return_loss:
-            loss = self.criterion(out, batch)
-            if isinstance(loss, dict):
-                out.update(loss)
-            else:
-                out["loss"] = loss
-
-        return out
-
-    def extract_features(self, x: torch.Tensor, normalize: bool = True) -> torch.Tensor:
-        x = self.normalize(x) if normalize else x
-        return self.pooling(self.backbone(x))
-
-    def freeze_backbone(self) -> None:
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-        self.backbone_frozen = True
-
-    def set_criterion(self, loss: nn.Module) -> None:
-        self.criterion = loss

skp/models/classification/net2d_multihead_var_embed.py

@@ -1,186 +0,0 @@
-"""
-Simple model for 2D classification (or regression) with multiple heads
-Incorporates embedding of non-image features
-Uses timm for backbones
-"""
-
-import re
-import torch
-import torch.nn as nn
-
-from collections.abc import Sequence
-from timm import create_model
-from typing import Dict
-
-from skp.configs.base import Config
-from skp.models.modules import FeatureReduction
-from skp.models.pooling import get_pool_layer
-
-
-class Net(nn.Module):
-    def __init__(self, cfg: Config):
-        super().__init__()
-        self.cfg = cfg
-        assert (
-            isinstance(self.cfg.num_classes, Sequence)
-            and len(self.cfg.num_classes) == self.cfg.num_heads
-        ), f"cfg.num_classes should be sequence of length {self.cfg.num_heads} corresponding to each head"
-        backbone_args = {
-            "pretrained": self.cfg.pretrained,
-            "num_classes": 0,
-            "global_pool": "",
-            "features_only": self.cfg.features_only,
-            "in_chans": self.cfg.num_input_channels,
-        }
-        if self.cfg.backbone_img_size:
-            # some models require specifying image size (e.g., coatnet)
-            if "efficientvit" in self.cfg.backbone:
-                backbone_args["img_size"] = self.cfg.image_height
-            else:
-                backbone_args["img_size"] = (
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-        self.backbone = create_model(self.cfg.backbone, **backbone_args)
-        # get feature dim by passing sample through net
-        self.feature_dim = self.backbone(
-            torch.randn(
-                (
-                    2,
-                    self.cfg.num_input_channels,
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-            )
-        ).size(
-            -1 if "xcit" in self.cfg.backbone else 1
-        )  # xcit models are channels-last
-
-        self.feature_dim = self.feature_dim * (2 if self.cfg.pool == "catavgmax" else 1)
-        self.pooling = get_pool_layer(self.cfg, dim=2)
-
-        if isinstance(self.cfg.reduce_feature_dim, int):
-            self.backbone = nn.Sequential(
-                self.backbone,
-                FeatureReduction(self.feature_dim, self.cfg.reduce_feature_dim),
-            )
-            self.feature_dim = self.cfg.reduce_feature_dim
-
-        self.embed = nn.Embedding(self.cfg.embed_num_classes, self.cfg.embed_dim)
-        # allows for interaction between elements of image feature vector and embedding
-        self.mlp = nn.Linear(self.feature_dim + self.cfg.embed_dim, self.feature_dim)
-        self.dropout = nn.Dropout(p=self.cfg.dropout)
-        self.linear = nn.ModuleList()
-        for i in range(self.cfg.num_heads):
-            self.linear.append(nn.Linear(self.feature_dim, self.cfg.num_classes[i]))
-
-
-        if self.cfg.load_pretrained_backbone:
-            print(
-                f"Loading pretrained backbone from {self.cfg.load_pretrained_backbone} ..."
-            )
-            weights = torch.load(
-                self.cfg.load_pretrained_backbone,
-                map_location=lambda storage, loc: storage,
-            )["state_dict"]
-            # Replace model prefix as this does not exist in Net
-            weights = {re.sub(r"^model.", "", k): v for k, v in weights.items()}
-            # Get backbone only
-            weights = {
-                re.sub(r"^backbone.", "", k): v
-                for k, v in weights.items()
-                if "backbone" in k
-            }
-            self.backbone.load_state_dict(weights)
-
-        self.criterion = None
-
-        self.backbone_frozen = False
-        if self.cfg.freeze_backbone:
-            self.freeze_backbone()
-
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.cfg.normalization == "-1_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-            x = x - 0.5
-            x = x * 2.0
-        elif self.cfg.normalization == "0_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-        elif self.cfg.normalization == "mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "per_channel_mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            assert len(mean) == len(sd) == x.size(1)
-            mean, sd = torch.tensor(mean).unsqueeze(0), torch.tensor(sd).unsqueeze(0)
-            for i in range(x.ndim - 2):
-                mean, sd = mean.unsqueeze(-1), sd.unsqueeze(-1)
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "none":
-            x = x
-        return x
-
-    def forward(
-        self, batch: Dict, return_loss: bool = False, return_features: bool = False
-    ) -> Dict[str, torch.Tensor]:
-        x = batch["x"]
-        y = batch.get("y", None)
-        var = batch["var"]
-
-        if return_loss:
-            assert y is not None
-
-        features = self.extract_features(x, var, normalize=True)
-
-        out = {}
-        for head_idx, each_head in enumerate(self.linear):
-            if self.cfg.multisample_dropout:
-                logits = torch.stack(
-                    [each_head(self.dropout(features)) for _ in range(5)]
-                ).mean(0)
-            else:
-                logits = each_head(self.dropout(features))
-            out[f"logits{head_idx}"] = logits
-
-        if return_features:
-            out["features"] = features
-        if return_loss:
-            loss = self.criterion(out, batch)
-            if isinstance(loss, dict):
-                out.update(loss)
-            else:
-                out["loss"] = loss
-
-        return out
-
-    def extract_features(self, x: torch.Tensor, var: torch.Tensor, normalize: bool = True) -> torch.Tensor:
-        x = self.normalize(x) if normalize else x
-        var = self.embed(var)
-        feat = self.pooling(self.backbone(x))
-        feat = torch.cat([feat, var], dim=1)
-        feat = self.mlp(feat)
-        return feat
-
-    def freeze_backbone(self) -> None:
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-        self.backbone_frozen = True
-
-    def set_criterion(self, loss: nn.Module) -> None:
-        self.criterion = loss

skp/models/classification/net2d_var_embed.py

@@ -1,178 +0,0 @@
-"""
-Simple model for 2D classification (or regression)
-Incorporates embedding of non-image features
-Uses timm for backbones
-"""
-
-import re
-import torch
-import torch.nn as nn
-
-from timm import create_model
-from typing import Dict
-
-from skp.configs.base import Config
-from skp.models.modules import FeatureReduction
-from skp.models.pooling import get_pool_layer
-
-
-class Net(nn.Module):
-    def __init__(self, cfg: Config):
-        super().__init__()
-        self.cfg = cfg
-        backbone_args = {
-            "pretrained": self.cfg.pretrained,
-            "num_classes": 0,
-            "global_pool": "",
-            "features_only": self.cfg.features_only,
-            "in_chans": self.cfg.num_input_channels,
-        }
-        if self.cfg.backbone_img_size:
-            # some models require specifying image size (e.g., coatnet)
-            if "efficientvit" in self.cfg.backbone:
-                backbone_args["img_size"] = self.cfg.image_height
-            else:
-                backbone_args["img_size"] = (
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-        self.backbone = create_model(self.cfg.backbone, **backbone_args)
-        # get feature dim by passing sample through net
-        self.feature_dim = self.backbone(
-            torch.randn(
-                (
-                    2,
-                    self.cfg.num_input_channels,
-                    self.cfg.image_height,
-                    self.cfg.image_width,
-                )
-            )
-        ).size(
-            -1 if "xcit" in self.cfg.backbone else 1
-        )  # xcit models are channels-last
-
-        self.feature_dim = self.feature_dim * (2 if self.cfg.pool == "catavgmax" else 1)
-        self.pooling = get_pool_layer(self.cfg, dim=2)
-
-        if isinstance(self.cfg.reduce_feature_dim, int):
-            self.backbone = nn.Sequential(
-                self.backbone,
-                FeatureReduction(self.feature_dim, self.cfg.reduce_feature_dim),
-            )
-            self.feature_dim = self.cfg.reduce_feature_dim
-
-        self.embed = nn.Embedding(self.cfg.embed_num_classes, self.cfg.embed_dim)
-        # allows for interaction between elements of image feature vector and embedding
-        self.mlp = nn.Linear(self.feature_dim + self.cfg.embed_dim, self.feature_dim)
-        self.dropout = nn.Dropout(p=self.cfg.dropout)
-        self.linear = nn.Linear(self.feature_dim, self.cfg.num_classes)
-
-        if self.cfg.load_pretrained_backbone:
-            print(
-                f"Loading pretrained backbone from {self.cfg.load_pretrained_backbone} ..."
-            )
-            weights = torch.load(
-                self.cfg.load_pretrained_backbone,
-                map_location=lambda storage, loc: storage,
-            )["state_dict"]
-            # Replace model prefix as this does not exist in Net
-            weights = {re.sub(r"^model.", "", k): v for k, v in weights.items()}
-            # Get backbone only
-            weights = {
-                re.sub(r"^backbone.", "", k): v
-                for k, v in weights.items()
-                if "backbone" in k
-            }
-            self.backbone.load_state_dict(weights)
-
-        self.criterion = None
-
-        self.backbone_frozen = False
-        if self.cfg.freeze_backbone:
-            self.freeze_backbone()
-
-    def normalize(self, x: torch.Tensor) -> torch.Tensor:
-        if self.cfg.normalization == "-1_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-            x = x - 0.5
-            x = x * 2.0
-        elif self.cfg.normalization == "0_1":
-            mini, maxi = (
-                self.cfg.normalization_params["min"],
-                self.cfg.normalization_params["max"],
-            )
-            x = x - mini
-            x = x / (maxi - mini)
-        elif self.cfg.normalization == "mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "per_channel_mean_sd":
-            mean, sd = (
-                self.cfg.normalization_params["mean"],
-                self.cfg.normalization_params["sd"],
-            )
-            assert len(mean) == len(sd) == x.size(1)
-            mean, sd = torch.tensor(mean).unsqueeze(0), torch.tensor(sd).unsqueeze(0)
-            for i in range(x.ndim - 2):
-                mean, sd = mean.unsqueeze(-1), sd.unsqueeze(-1)
-            x = (x - mean) / sd
-        elif self.cfg.normalization == "none":
-            x = x
-        return x
-
-    def forward(
-        self, batch: Dict, return_loss: bool = False, return_features: bool = False
-    ) -> Dict[str, torch.Tensor]:
-        x = batch["x"]
-        y = batch.get("y", None)
-        var = batch["var"]
-
-        if return_loss:
-            assert y is not None
-
-        features = self.extract_features(x, var, normalize=True)
-
-        if self.cfg.multisample_dropout:
-            logits = torch.stack(
-                [self.linear(self.dropout(features)) for _ in range(5)]
-            ).mean(0)
-        else:
-            logits = self.linear(self.dropout(features))
-
-        out = {"logits": logits}
-        if return_features:
-            out["features"] = features
-        if return_loss:
-            loss = self.criterion(out, batch)
-            if isinstance(loss, dict):
-                out.update(loss)
-            else:
-                out["loss"] = loss
-
-        return out
-
-    def extract_features(
-        self, x: torch.Tensor, var: torch.Tensor, normalize: bool = True
-    ) -> torch.Tensor:
-        x = self.normalize(x) if normalize else x
-        var = self.embed(var)
-        feat = self.pooling(self.backbone(x))
-        feat = torch.cat([feat, var], dim=1)
-        feat = self.mlp(feat)
-        return feat
-
-    def freeze_backbone(self) -> None:
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-        self.backbone_frozen = True
-
-    def set_criterion(self, loss: nn.Module) -> None:
-        self.criterion = loss

skp/models/modules.py

@@ -1,32 +0,0 @@
-"""
-Contains commonly used neural net modules.
-"""
-
-import math
-import torch
-import torch.nn as nn
-
-
-class FeatureReduction(nn.Module):
-    """
-    Reduce feature dimensionality
-    Intended use is after the last layer of the neural net backbone, before pooling
-    Grouped convolution is used to reduce # of extra parameters
-    """
-
-    def __init__(self, feature_dim: int, reduce_feature_dim: int):
-        super().__init__()
-        groups = math.gcd(feature_dim, reduce_feature_dim)
-        self.reduce = nn.Conv2d(
-            feature_dim,
-            reduce_feature_dim,
-            groups=groups,
-            kernel_size=1,
-            stride=1,
-            bias=False,
-        )
-        self.bn = nn.BatchNorm2d(reduce_feature_dim)
-        self.act = nn.ReLU()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return self.act(self.bn(self.reduce(x)))

skp/models/pooling.py

@@ -1,150 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from timm.layers import SelectAdaptivePool2d
-
-from skp.configs.base import Config
-
-
-class GeM(nn.Module):
-    def __init__(
-        self, p: int = 3, eps: float = 1e-6, dim: int = 2, flatten: bool = True
-    ):
-        super().__init__()
-        self.p = nn.Parameter(torch.ones(1) * p)
-        self.eps = eps
-        assert dim in {2, 3}, f"dim must be one of [2, 3], not {dim}"
-        self.dim = dim
-        if self.dim == 2:
-            self.func = F.adaptive_avg_pool2d
-        elif self.dim == 3:
-            self.func = F.adaptive_avg_pool3d
-        self.flatten = nn.Flatten(1) if flatten else nn.Identity()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # assumes x.shape is (n, c, [t], h, w)
-        x = self.func(x.clamp(min=self.eps).pow(self.p), output_size=1).pow(
-            1.0 / self.p
-        )
-        return self.flatten(x)
-
-
-def adaptive_avgmax_pool3d(x: torch.Tensor, output_size: int = 1):
-    x_avg = F.adaptive_avg_pool3d(x, output_size)
-    x_max = F.adaptive_max_pool3d(x, output_size)
-    return 0.5 * (x_avg + x_max)
-
-
-def adaptive_catavgmax_pool3d(x: torch.Tensor, output_size: int = 1):
-    x_avg = F.adaptive_avg_pool3d(x, output_size)
-    x_max = F.adaptive_max_pool3d(x, output_size)
-    return torch.cat((x_avg, x_max), 1)
-
-
-def select_adaptive_pool3d(x: torch.Tensor, pool_type: str, output_size: int = 1) -> torch.Tensor:
-    """Selectable global pooling function with dynamic input kernel size"""
-    if pool_type == "avg":
-        x = F.adaptive_avg_pool3d(x, output_size)
-    elif pool_type == "avgmax":
-        x = adaptive_avgmax_pool3d(x, output_size)
-    elif pool_type == "catavgmax":
-        x = adaptive_catavgmax_pool3d(x, output_size)
-    elif pool_type == "max":
-        x = F.adaptive_max_pool3d(x, output_size)
-    else:
-        assert False, "Invalid pool type: %s" % pool_type
-    return x
-
-
-class FastAdaptiveAvgPool3d(nn.Module):
-    def __init__(self, flatten: bool = False):
-        super(FastAdaptiveAvgPool3d, self).__init__()
-        self.flatten = flatten
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return x.mean((2, 3, 4), keepdim=not self.flatten)
-
-
-class AdaptiveAvgMaxPool3d(nn.Module):
-    def __init__(self, output_size: int = 1):
-        super(AdaptiveAvgMaxPool3d, self).__init__()
-        self.output_size = output_size
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return adaptive_avgmax_pool3d(x, self.output_size)
-
-
-class AdaptiveCatAvgMaxPool3d(nn.Module):
-    def __init__(self, output_size: int = 1):
-        super(AdaptiveCatAvgMaxPool3d, self).__init__()
-        self.output_size = output_size
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return adaptive_catavgmax_pool3d(x, self.output_size)
-
-
-class SelectAdaptivePool3d(nn.Module):
-    """Selectable global pooling layer with dynamic input kernel size"""
-
-    def __init__(self, output_size: int = 1, pool_type: str = "fast", flatten: bool = False):
-        super(SelectAdaptivePool3d, self).__init__()
-        self.pool_type = (
-            pool_type or ""
-        )  # convert other falsy values to empty string for consistent TS typing
-        self.flatten = nn.Flatten(1) if flatten else nn.Identity()
-        if pool_type == "":
-            self.pool = nn.Identity()  # pass through
-        elif pool_type == "fast":
-            assert output_size == 1
-            self.pool = FastAdaptiveAvgPool3d(flatten)
-            self.flatten = nn.Identity()
-        elif pool_type == "avg":
-            self.pool = nn.AdaptiveAvgPool3d(output_size)
-        elif pool_type == "avgmax":
-            self.pool = AdaptiveAvgMaxPool3d(output_size)
-        elif pool_type == "catavgmax":
-            self.pool = AdaptiveCatAvgMaxPool3d(output_size)
-        elif pool_type == "max":
-            self.pool = nn.AdaptiveMaxPool3d(output_size)
-        else:
-            assert False, "Invalid pool type: %s" % pool_type
-
-    def is_identity(self) -> bool:
-        return not self.pool_type
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.pool(x)
-        x = self.flatten(x)
-        return x
-
-    def __repr__(self):
-        return (
-            self.__class__.__name__
-            + " ("
-            + "pool_type="
-            + self.pool_type
-            + ", flatten="
-            + str(self.flatten)
-            + ")"
-        )
-
-
-def get_pool_layer(cfg: Config, dim: int) -> nn.Module:
-    assert cfg.pool in [
-        "avg",
-        "max",
-        "fast",
-        "avgmax",
-        "catavgmax",
-        "gem",
-        ""
-    ], f"{cfg.pool} is not a valid pooling layer"
-    params = cfg.pool_params or {}
-    if cfg.pool == "gem":
-        return GeM(**params, dim=dim)
-    else:
-        if dim == 2:
-            return SelectAdaptivePool2d(pool_type=cfg.pool, flatten=True)
-        elif dim == 3:
-            return SelectAdaptivePool3d(pool_type=cfg.pool, flatten=True)

skp/utils.py

@@ -1,49 +0,0 @@
-import re
-import torch
-
-from skp.configs import Config
-from importlib import import_module
-from typing import Dict, Optional, Sequence
-
-
-def load_weights_from_path(path: str) -> Dict[str, torch.Tensor]:
-    w = torch.load(path, map_location=lambda storage, loc: storage, weights_only=True)[
-        "state_dict"
-    ]
-    w = {
-        re.sub(r"^model.", "", k): v
-        for k, v in w.items()
-        if k.startswith("model.") and "criterion" not in k
-    }
-    return w
-
-
-def load_model_from_config(
-    cfg: Config,
-    weights_path: Optional[str] = None,
-    device: str = "cpu",
-    eval_mode: bool = True,
-) -> torch.nn.Module:
-    model = import_module(f"skp.models.{cfg.model}").Net(cfg)
-    if weights_path:
-        weights = load_weights_from_path(weights_path)
-        model.load_state_dict(weights)
-    model = model.to(device).train(mode=not eval_mode)
-    return model
-
-
-def load_kfold_ensemble_as_list(
-    cfg: Config,
-    weights_paths: Sequence[str],
-    device: str = "cpu",
-    eval_mode: bool = True,
-) -> torch.nn.ModuleList:
-    # multiple folds for the same model
-    # does not work for ensembling different types of models
-    # assumes that trained weights are available
-    # otherwise why would you load multiple of the same model randomly initialized
-    model_list = torch.nn.ModuleList()
-    for each_weight in weights_paths:
-        model = load_model_from_config(cfg, each_weight, device, eval_mode)
-        model_list.append(model)
-    return model_list