working

requirements.txt

@@ -14,3 +14,4 @@ numpy
 scikit-image
 scipy
 tqdm
+yacs

src/datasets/dataset_isic.py

@@ -55,7 +55,11 @@ class ISIC_dataset(Dataset):
     def __init__(self, base_dir, list_dir, split, transform=None):
         self.transform = transform
         self.split = split
-        self.sample_list = open(os.path.join(list_dir, self.split + '.txt')).readlines()
+        list_path = os.path.join(list_dir, f"{self.split}.txt")
+        print(f"Looking for list file at: {list_path}")  # Debug print
+        if not os.path.exists(list_path):
+            raise FileNotFoundError(f"List file not found: {list_path}")
+        self.sample_list = open(list_path).readlines()
         self.data_dir = base_dir
 
     def __len__(self):
@@ -64,6 +68,8 @@ class ISIC_dataset(Dataset):
     def __getitem__(self, idx):
         slice_name = self.sample_list[idx].strip('\n')
         data_path = os.path.join(self.data_dir, slice_name + '.npz')
+        if not os.path.exists(data_path):
+            raise FileNotFoundError(f"Data file not found: {data_path}")
         data = np.load(data_path)
         image, label = data['image'], data['label']
         

src/organize_test_files.py

@@ -0,0 +1,29 @@
+import os
+import shutil
+
+def organize_test_files():
+    # Create test_npz directory if it doesn't exist
+    test_dir = os.path.join('datasets', 'test_npz')
+    if os.path.exists(test_dir):
+        shutil.rmtree(test_dir)
+    os.makedirs(test_dir)
+
+    # Read test.txt to get list of files
+    test_list_path = os.path.join('lists', 'ISIC', 'test.txt')
+    with open(test_list_path, 'r') as f:
+        test_files = [line.strip() for line in f.readlines()]
+
+    # Source directory containing all npz files
+    source_dir = os.path.join('datasets', 'train_npz')
+
+    # Copy each file to test_npz directory
+    for file_name in test_files:
+        source_file = os.path.join(source_dir, file_name + '.npz')
+        if os.path.exists(source_file):
+            shutil.copy2(source_file, os.path.join(test_dir, file_name + '.npz'))
+            print(f"Copied {file_name}.npz")
+        else:
+            print(f"Warning: {file_name}.npz not found in source directory")
+
+if __name__ == "__main__":
+    organize_test_files() 

src/overlay_mask.py

@@ -0,0 +1,96 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+import argparse
+from PIL import Image
+
+def save_image(image, save_path):
+    """
+    Save image as PNG
+    Args:
+        image: Image array
+        save_path: Path to save the image
+    """
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image)
+    plt.axis('off')
+    plt.savefig(save_path, bbox_inches='tight', pad_inches=0)
+    plt.close()
+
+def overlay_mask(image, mask, save_path, alpha=0.5):
+    """
+    Overlay mask on original image
+    Args:
+        image: Original image (numpy array)
+        mask: Mask (numpy array)
+        save_path: Path to save the visualization
+        alpha: Transparency of the mask overlay (0-1)
+    """
+    plt.figure(figsize=(10, 10))
+    
+    # Normalize image to 0-1 range if needed
+    if image.max() > 1:
+        image = image / 255.0
+    
+    # Show original image
+    plt.imshow(image)
+    
+    # Remove extra dimension from mask if present
+    if len(mask.shape) == 3:
+        mask = mask.squeeze()
+    
+    # Overlay mask with transparency
+    plt.imshow(mask, alpha=alpha, cmap='gray')
+    
+    plt.axis('off')
+    plt.savefig(save_path, bbox_inches='tight', pad_inches=0)
+    plt.close()
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--image_npz', type=str, required=True, help='path to npz file containing the image')
+    parser.add_argument('--mask_npy', type=str, required=True, help='path to npy file containing the mask')
+    parser.add_argument('--output_dir', type=str, default='overlays', help='output directory for overlays')
+    parser.add_argument('--alpha', type=float, default=0.1, help='transparency of mask overlay (0-1)')
+    args = parser.parse_args()
+
+    # Create output directory if it doesn't exist
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load image from NPZ file
+    image_data = np.load(args.image_npz)
+    image = image_data['image']
+    
+    # Load mask from NPY file
+    mask = np.load(args.mask_npy)
+    
+    # Handle image shape and resize
+    if len(image.shape) == 3:
+        if image.shape[0] == 1:  # If first dimension is 1
+            image = image.squeeze(0)  # Remove it
+        if image.shape[0] == 3:  # If channels first
+            image = np.transpose(image, (1, 2, 0))  # Change to channels last
+    
+    # Convert to PIL Image and resize
+    image = (image * 255).astype(np.uint8)
+    if len(image.shape) == 2:  # If grayscale
+        image = np.stack([image] * 3, axis=-1)  # Convert to RGB
+    image = Image.fromarray(image)
+    image = image.resize((224, 224), Image.Resampling.LANCZOS)
+    image = np.array(image) / 255.0
+    
+    # Create output filenames
+    base_name = os.path.splitext(os.path.basename(args.image_npz))[0]
+    original_save_path = os.path.join(args.output_dir, f'{base_name}_original.png')
+    overlay_save_path = os.path.join(args.output_dir, f'{base_name}_overlay.png')
+    
+    # Save original image
+    save_image(image, original_save_path)
+    print(f'Saved original image to {original_save_path}')
+    
+    # Create and save overlay
+    overlay_mask(image, mask, overlay_save_path, args.alpha)
+    print(f'Saved overlay to {overlay_save_path}')
+
+if __name__ == '__main__':
+    main() 

src/shownpz.py

@@ -0,0 +1,44 @@
+import cv2
+import numpy as np
+from PIL import Image
+import os
+
+def draw_mask(image, mask_generated):
+    # Ensure image is in the right format (H, W, C)
+    if len(image.shape) == 3 and image.shape[0] == 3:  # If channels first
+        image = np.transpose(image, (1, 2, 0))  # Change to channels last
+    
+    # Remove any extra dimensions
+    image = image.squeeze()
+    mask_generated = mask_generated.squeeze()
+    
+    # Ensure image is 2D or 3D
+    if len(image.shape) == 1:
+        raise ValueError(f"Unexpected image shape: {image.shape}")
+    
+    # If image is 2D, convert to 3D (grayscale to RGB)
+    if len(image.shape) == 2:
+        image = np.stack([image] * 3, axis=-1)
+    
+    # Normalize image to 0-255 range if needed
+    if image.max() <= 1:
+        image = (image * 255).astype(np.uint8)
+    
+    # Create colored mask
+    colored_mask = np.zeros_like(image)
+    colored_mask[mask_generated.astype(bool)] = [0, 255, 0]  # BGR (nie RGB!)
+    
+    # Blend the image and mask
+    blended = cv2.addWeighted(image, 0.9, colored_mask, 0.1, 0)
+    
+    return Image.fromarray(blended.astype(np.uint8))
+
+def make_overlay(image, mask, save_path):
+    # Ensure the directory exists
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    
+    # Create overlay
+    overlay = draw_mask(image, mask)
+    
+    # Save the result
+    overlay.save(save_path)

src/streamlit_app.py

@@ -31,7 +31,7 @@ if st.button('Test Model'):
         st.code(result.stderr)
 
 # Optionally, display the latest log file
-log_dir = os.path.join('src', 'test_log', 'test_log_ISIC')
+log_dir = os.path.join('test_log', 'test_log_ISIC')
 if os.path.exists(log_dir):
     log_files = sorted([f for f in os.listdir(log_dir) if f.endswith('.txt')], reverse=True)
     if log_files:

src/test_isic.py

@@ -3,6 +3,7 @@ import logging
 import os
 import random
 import sys
+import shutil
 
 import numpy as np
 import torch
@@ -16,9 +17,12 @@ from datasets.dataset_isic import ISIC_dataset, RandomGenerator
 from networks.vision_transformer import SwinUnet as ViT_seg
 from utils import test_single_volume
 
+from overlay_mask import overlay_mask
+from shownpz import make_overlay
+
 parser = argparse.ArgumentParser()
 parser.add_argument('--root_path', type=str,
-                    default='datasets/train_npz',
+                    default='datasets/test_npz',
                     help='root dir for test data')
 parser.add_argument('--dataset', type=str,
                     default='ISIC', help='experiment_name')
@@ -66,7 +70,26 @@ args = parser.parse_args()
 
 config = get_config(args)
 
-def test_single_image(image, label, model, classes, patch_size, test_save_path=None, case=None):
+def cleanup_previous_results():
+    """Clean up previous test results"""
+    # Clean up outputs directory
+    if os.path.exists('outputs'):
+        shutil.rmtree('outputs')
+    
+    # Clean up overlays directory
+    if os.path.exists('overlays'):
+        shutil.rmtree('overlays')
+    
+    # Clean up test_log directory
+    if os.path.exists('test_log'):
+        shutil.rmtree('test_log')
+    
+    # Create fresh directories
+    os.makedirs('outputs', exist_ok=True)
+    os.makedirs('overlays', exist_ok=True)
+    os.makedirs('test_log', exist_ok=True)
+
+def test_single_image(image, label, model, classes, patch_size, test_save_path=None, case=None, overlay_count=None):
     image = image.cuda()
     label = label.cuda()
     with torch.no_grad():
@@ -81,17 +104,18 @@ def test_single_image(image, label, model, classes, patch_size, test_save_path=N
         metric_list = []
         for i in range(1, classes):
             metric_list.append(calculate_metric_percase(pred == i, label == i))
-            
-        if test_save_path is not None:
-            save_path = os.path.join(test_save_path, case + '.npy')
-            np.save(save_path, pred)
+
+        # Only save overlay for first 3 images
+        if overlay_count is not None and overlay_count < 3:
+            make_overlay(image.cpu().numpy().squeeze(0), pred, "overlays/" + case + ".png")
             
         return metric_list
 
 def calculate_metric_percase(pred, gt):
     dice = calculate_dice(pred, gt)
-    hd95 = calculate_hd95(pred, gt)
-    return dice, hd95
+    acc = calculate_accuracy(pred, gt)
+    iou = calculate_iou(pred, gt)
+    return dice, acc, iou
 
 def calculate_dice(pred, gt):
     pred = pred.astype(np.float32)
@@ -100,10 +124,19 @@ def calculate_dice(pred, gt):
     dice = (2. * intersection) / (np.sum(pred) + np.sum(gt) + 1e-5)
     return dice
 
-def calculate_hd95(pred, gt):
-    # For 2D images, we'll use a simplified version of HD95
-    # You might want to implement a proper 2D Hausdorff distance calculation
-    return 0.0  # Placeholder for now
+def calculate_accuracy(pred, gt):
+    pred = pred.astype(np.float32)
+    gt = gt.astype(np.float32)
+    correct_pixels = np.sum(pred == gt)
+    total_pixels = gt.size
+    accuracy = correct_pixels / total_pixels
+    return accuracy
+
+def calculate_iou(pred, gt):
+    intersection = np.logical_and(pred, gt).sum()
+    union = np.logical_or(pred, gt).sum()
+    iou = intersection / union if union != 0 else 0.0
+    return iou
 
 def inference(args, model, test_save_path=None):
     # Create transform for resizing images
@@ -114,23 +147,34 @@ def inference(args, model, test_save_path=None):
     logging.info("{} test iterations per epoch".format(len(testloader)))
     model.eval()
     metric_list = 0.0
+    overlay_count = 0  # Counter for overlays
+    
     for i_batch, sampled_batch in tqdm(enumerate(testloader)):
         image, label, case_name = sampled_batch["image"], sampled_batch["label"], sampled_batch['case_name'][0]
         metric_i = test_single_image(image, label, model, classes=args.num_classes,
                                    patch_size=[args.img_size, args.img_size],
-                                   test_save_path=test_save_path, case=case_name)
+                                   test_save_path=None,  # Don't save masks
+                                   case=case_name,
+                                   overlay_count=overlay_count)
+        if overlay_count < 3:
+            overlay_count += 1
+            
         metric_list += np.array(metric_i)
-        logging.info('idx %d case %s mean_dice %f mean_hd95 %f' % (
-            i_batch, case_name, np.mean(metric_i, axis=0)[0], np.mean(metric_i, axis=0)[1]))
+        logging.info('idx %d case %s mean_dice %f mean_acc %f mean_iou %f' % (
+            i_batch, case_name, np.mean(metric_i, axis=0)[0], np.mean(metric_i, axis=0)[1], np.mean(metric_i, axis=0)[2]))
     metric_list = metric_list / len(db_test)
     for i in range(1, args.num_classes):
-        logging.info('Mean class %d mean_dice %f mean_hd95 %f' % (i, metric_list[i - 1][0], metric_list[i - 1][1]))
+        logging.info('Mean class %d mean_dice %f mean_acc %f mean_iou %f' % (i, metric_list[i - 1][0], metric_list[i - 1][1], np.mean(metric_i, axis=0)[2]))
     performance = np.mean(metric_list, axis=0)[0]
-    mean_hd95 = np.mean(metric_list, axis=0)[1]
-    logging.info('Testing performance in best val model: mean_dice : %f mean_hd95 : %f' % (performance, mean_hd95))
+    mean_acc = np.mean(metric_list, axis=0)[1]
+    mean_iou = np.mean(metric_list, axis=0)[2]
+    logging.info('Testing performance in best val model: mean_dice : %f mean_acc : %f mean_iou %f' % (performance, mean_acc, mean_iou))
     return "Testing Finished!"
 
 if __name__ == "__main__":
+    # Clean up previous results before starting new test
+    cleanup_previous_results()
+    
     if not args.deterministic:
         cudnn.benchmark = True
         cudnn.deterministic = False
@@ -146,15 +190,13 @@ if __name__ == "__main__":
     dataset_config = {
         'ISIC': {
             'root_path': args.root_path,
-            'list_dir': f'./lists/{args.dataset}',
+            'list_dir': os.path.join('src', 'lists', args.dataset),
             'num_classes': args.n_class,
         },
     }
     args.num_classes = dataset_config[dataset_name]['num_classes']
     args.root_path = dataset_config[dataset_name]['root_path']
-    # Only set args.list_dir if not provided by user
-    if args.list_dir == './lists/lists_ISIC' or args.list_dir == f'./lists/{args.dataset}':
-        args.list_dir = dataset_config[dataset_name]['list_dir']
+    args.list_dir = dataset_config[dataset_name]['list_dir']
     args.is_pretrain = True
 
     net = ViT_seg(config, img_size=args.img_size, num_classes=args.num_classes).cuda()
@@ -180,13 +222,4 @@ if __name__ == "__main__":
     logging.info(str(args))
     logging.info(snapshot_name)
 
-    if args.is_savenii:
-        args.test_save_dir = os.path.join(args.output_dir, "predictions")
-        test_save_path = args.test_save_dir
-        os.makedirs(test_save_path, exist_ok=True)
-    else:
-        test_save_path = None
-    inference(args, net, test_save_path)
-
-# Example command to run the test:
-# python test_isic.py --dataset ISIC --cfg configs/swin_tiny_patch4_window7_224_lite.yaml --is_savenii --root_path datasets/train_npz --output_dir outputs --max_epochs 150 --base_lr 0.05 --img_size 224 --batch_size 24 
+    inference(args, net)

test_log/test_log_ISIC/test_best_model.pth.txt

@@ -1,22 +1,22 @@
-[22:30:44.649] Namespace(root_path='src/datasets/test_npz', dataset='ISIC', num_classes=2, list_dir='src/lists/ISIC', output_dir='src/outputs', max_iterations=30000, max_epochs=150, batch_size=24, img_size=224, is_savenii=True, test_save_dir='predictions', deterministic=1, base_lr=0.05, seed=1234, cfg='src/configs/swin_tiny_patch4_window7_224_lite.yaml', opts=None, zip=False, cache_mode='part', resume=None, accumulation_steps=None, use_checkpoint=False, amp_opt_level='O1', tag=None, eval=False, throughput=False, n_class=2, split_name='test', is_pretrain=True)
-[22:30:44.649] best_model.pth
-[22:30:44.659] 17 test iterations per epoch
-[22:30:52.463] idx 0 case ISIC_0000001 mean_dice 0.925362 mean_hd95 0.000000
-[22:30:52.545] idx 1 case ISIC_0000003 mean_dice 0.960937 mean_hd95 0.000000
-[22:30:52.622] idx 2 case ISIC_0000008 mean_dice 0.974235 mean_hd95 0.000000
-[22:30:52.670] idx 3 case ISIC_0000011 mean_dice 0.965687 mean_hd95 0.000000
-[22:30:52.742] idx 4 case ISIC_0000016 mean_dice 0.972417 mean_hd95 0.000000
-[22:30:52.863] idx 5 case ISIC_0000017 mean_dice 0.960936 mean_hd95 0.000000
-[22:30:52.953] idx 6 case ISIC_0000025 mean_dice 0.928897 mean_hd95 0.000000
-[22:30:53.105] idx 7 case ISIC_0000029 mean_dice 0.966497 mean_hd95 0.000000
-[22:30:53.214] idx 8 case ISIC_0000032 mean_dice 0.968455 mean_hd95 0.000000
-[22:30:53.323] idx 9 case ISIC_0000036 mean_dice 0.837651 mean_hd95 0.000000
-[22:30:53.494] idx 10 case ISIC_0000042 mean_dice 0.952283 mean_hd95 0.000000
-[22:30:53.581] idx 11 case ISIC_0000043 mean_dice 0.934522 mean_hd95 0.000000
-[22:30:53.737] idx 12 case ISIC_0000051 mean_dice 0.971923 mean_hd95 0.000000
-[22:30:53.874] idx 13 case ISIC_0000064 mean_dice 0.980977 mean_hd95 0.000000
-[22:30:54.028] idx 14 case ISIC_0000087 mean_dice 0.972324 mean_hd95 0.000000
-[22:30:54.137] idx 15 case ISIC_0000095 mean_dice 0.911183 mean_hd95 0.000000
-[22:30:54.255] idx 16 case ISIC_0000105 mean_dice 0.944544 mean_hd95 0.000000
-[22:30:55.037] Mean class 1 mean_dice 0.948755 mean_hd95 0.000000
-[22:30:55.037] Testing performance in best val model: mean_dice : 0.948755 mean_hd95 : 0.000000
+[22:50:31.836] Namespace(root_path='src/datasets/test_npz', dataset='ISIC', num_classes=2, list_dir='src\\lists\\ISIC', output_dir='src/outputs', max_iterations=30000, max_epochs=150, batch_size=24, img_size=224, is_savenii=True, test_save_dir='predictions', deterministic=1, base_lr=0.05, seed=1234, cfg='src/configs/swin_tiny_patch4_window7_224_lite.yaml', opts=None, zip=False, cache_mode='part', resume=None, accumulation_steps=None, use_checkpoint=False, amp_opt_level='O1', tag=None, eval=False, throughput=False, n_class=2, split_name='test', is_pretrain=True)
+[22:50:31.836] best_model.pth
+[22:50:31.846] 17 test iterations per epoch
+[22:50:42.989] idx 0 case ISIC_0000001 mean_dice 0.925362 mean_acc 0.988381 mean_iou 0.861091
+[22:50:43.177] idx 1 case ISIC_0000003 mean_dice 0.960937 mean_acc 0.972477 mean_iou 0.924811
+[22:50:43.342] idx 2 case ISIC_0000008 mean_dice 0.974235 mean_acc 0.982163 mean_iou 0.949764
+[22:50:43.495] idx 3 case ISIC_0000011 mean_dice 0.965687 mean_acc 0.987185 mean_iou 0.933650
+[22:50:43.844] idx 4 case ISIC_0000016 mean_dice 0.972417 mean_acc 0.988142 mean_iou 0.946314
+[22:50:44.085] idx 5 case ISIC_0000017 mean_dice 0.960936 mean_acc 0.987285 mean_iou 0.924808
+[22:50:44.405] idx 6 case ISIC_0000025 mean_dice 0.928897 mean_acc 0.969547 mean_iou 0.867234
+[22:50:44.792] idx 7 case ISIC_0000029 mean_dice 0.966497 mean_acc 0.972915 mean_iou 0.935165
+[22:50:45.088] idx 8 case ISIC_0000032 mean_dice 0.968455 mean_acc 0.979532 mean_iou 0.938840
+[22:50:45.431] idx 9 case ISIC_0000036 mean_dice 0.837651 mean_acc 0.848234 mean_iou 0.720653
+[22:50:45.830] idx 10 case ISIC_0000042 mean_dice 0.952283 mean_acc 0.966757 mean_iou 0.908912
+[22:50:46.124] idx 11 case ISIC_0000043 mean_dice 0.934522 mean_acc 0.943638 mean_iou 0.877092
+[22:50:46.445] idx 12 case ISIC_0000051 mean_dice 0.971923 mean_acc 0.983498 mean_iou 0.945379
+[22:50:46.779] idx 13 case ISIC_0000064 mean_dice 0.980977 mean_acc 0.986846 mean_iou 0.962663
+[22:50:47.095] idx 14 case ISIC_0000087 mean_dice 0.972324 mean_acc 0.978675 mean_iou 0.946139
+[22:50:47.399] idx 15 case ISIC_0000095 mean_dice 0.911183 mean_acc 0.985232 mean_iou 0.836856
+[22:50:47.718] idx 16 case ISIC_0000105 mean_dice 0.944544 mean_acc 0.992008 mean_iou 0.894916
+[22:50:49.317] Mean class 1 mean_dice 0.948755 mean_acc 0.971324 mean_iou 0.894916
+[22:50:49.317] Testing performance in best val model: mean_dice : 0.948755 mean_acc : 0.971324 mean_iou 0.904370