spacr 0.3.22__py3-none-any.whl → 0.3.30__py3-none-any.whl

spacr/deep_spacr.py

@@ -610,264 +610,168 @@ def train_model(dst, model_type, train_loaders, epochs=100, learning_rate=0.0001
             
     return model, model_path
 
-def visualize_saliency_map(settings):
-    from spacr.utils import SaliencyMapGenerator, print_progress
-    from spacr.io import TarImageDataset  # Assuming you have a dataset class
-    from torchvision.utils import make_grid
-
+def generate_activation_map(settings):
+    
+    from .utils import SaliencyMapGenerator, GradCAMGenerator, SelectChannels, activation_maps_to_database, activation_correlations_to_database
+    from .utils import print_progress, save_settings, calculate_activation_correlations
+    from .io import TarImageDataset
+    from .settings import get_default_generate_activation_map_settings
+    
+    torch.cuda.empty_cache()
+    gc.collect()
+    
+    plt.clf()
     use_cuda = torch.cuda.is_available()
     device = torch.device("cuda" if use_cuda else "cpu")
-
+    
+    source_folder = os.path.dirname(os.path.dirname(settings['dataset']))
+    settings['src'] = source_folder
+    settings = get_default_generate_activation_map_settings(settings)
+    save_settings(settings, name=f"{settings['cam_type']}_settings", show=False)
+    
+    if settings['model_type'] == 'maxvit' and settings['target_layer'] == None:
+        settings['target_layer'] = 'base_model.blocks.3.layers.1.layers.MBconv.layers.conv_b'
+    if settings['cam_type'] in ['saliency_image', 'saliency_channel']:
+        settings['target_layer'] = None
+    
     # Set number of jobs for loading
-    if settings['n_jobs'] is None:
+    n_jobs = settings['n_jobs']
+    if n_jobs is None:
         n_jobs = max(1, cpu_count() - 4)
-    else:
-        n_jobs = settings['n_jobs']
 
     # Set transforms for images
-    if settings['normalize']:
-        transform = transforms.Compose([
-            transforms.ToTensor(),
-            transforms.CenterCrop(size=(settings['image_size'], settings['image_size'])),
-            transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))])
-    else:
-        transform = transforms.Compose([
-            transforms.ToTensor(),
-            transforms.CenterCrop(size=(settings['image_size'], settings['image_size']))])
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.CenterCrop(size=(settings['image_size'], settings['image_size'])),
+        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) if settings['normalize_input'] else None,
+        SelectChannels(settings['channels'])
+    ])
 
     # Handle dataset path
-    if os.path.exists(settings['dataset']):
-        tar_path = settings['dataset']
-    else:
+    if not os.path.exists(settings['dataset']):
         print(f"Dataset not found at {settings['dataset']}")
         return
-    
-    if settings.get('save', False):
-        if settings['dtype'] not in ['uint8', 'uint16']:
-            print("Invalid dtype in settings. Please use 'uint8' or 'uint16'.")
-            return
 
     # Load the model
     model = torch.load(settings['model_path'])
     model.to(device)
-    model.eval()  # Ensure the model is in evaluation mode
+    model.eval()
 
-    # Create directory for saving saliency maps if it does not exist
-    if settings.get('save', False):
-        dataset_dir = os.path.dirname(tar_path)
-        dataset_name = os.path.splitext(os.path.basename(tar_path))[0]
-        save_dir = os.path.join(dataset_dir, dataset_name, 'saliency_maps')
+    # Create directory for saving activation maps if it does not exist
+    dataset_dir = os.path.dirname(settings['dataset'])
+    dataset_name = os.path.splitext(os.path.basename(settings['dataset']))[0]
+    save_dir = os.path.join(dataset_dir, dataset_name, settings['cam_type'])
+    batch_grid_fldr = os.path.join(save_dir, 'batch_grids')
+    
+    if settings['save']:
         os.makedirs(save_dir, exist_ok=True)
-        print(f"Saliency maps will be saved in: {save_dir}")
-
+        print(f"Activation maps will be saved in: {save_dir}")
+        
+    if settings['plot']:
+        os.makedirs(batch_grid_fldr, exist_ok=True)
+        print(f"Batch grid maps will be saved in: {batch_grid_fldr}")
+    
     # Load dataset
-    dataset = TarImageDataset(tar_path, transform=transform)
-    data_loader = DataLoader(dataset, batch_size=settings['batch_size'], shuffle=True, num_workers=n_jobs, pin_memory=True)
-
-    # Initialize SaliencyMapGenerator
-    cam_generator = SaliencyMapGenerator(model)
+    dataset = TarImageDataset(settings['dataset'], transform=transform)
+    data_loader = DataLoader(dataset, batch_size=settings['batch_size'], shuffle=settings['shuffle'], num_workers=n_jobs, pin_memory=True)
+
+    # Initialize generator based on cam_type
+    if settings['cam_type'] in ['gradcam', 'gradcam_pp']:
+        cam_generator = GradCAMGenerator(model, target_layer=settings['target_layer'], cam_type=settings['cam_type'])
+    elif settings['cam_type'] in ['saliency_image', 'saliency_channel']:
+        cam_generator = SaliencyMapGenerator(model)
+        
     time_ls = []
-
     for batch_idx, (inputs, filenames) in enumerate(data_loader):
         start = time.time()
+        img_paths = []
         inputs = inputs.to(device)
-        
-        saliency_maps, predicted_classes = cam_generator.compute_saliency_and_predictions(inputs)
-
-        if settings['saliency_mode'] not in ['mean', 'sum']:
-            print("To generate channel average or sum saliency maps set saliency_mode to 'mean' or 'sum', respectively.")
-
-        if settings['saliency_mode'] == 'mean':
-            saliency_maps = saliency_maps.mean(dim=1, keepdim=True)
-
-        elif settings['saliency_mode'] == 'sum':
-            saliency_maps = saliency_maps.sum(dim=1, keepdim=True)
-
-        # Example usage with the class
-        if settings.get('plot', False):
-            if settings['plot_mode'] not in ['mean', 'channel', '3-channel']:
-                print("Invalid plot_mode in settings. Please use 'mean', 'channel', or '3-channel'.")
-                return
-            else:
-                cam_generator.plot_saliency_grid(inputs, saliency_maps, predicted_classes, mode=settings['plot_mode'])
-
-        if settings.get('save', False):
-            for i in range(inputs.size(0)):
-                saliency_map = saliency_maps[i].detach().cpu().numpy()
-
-                # Check dtype in settings and normalize accordingly
-                if settings['dtype'] == 'uint16':
-                    saliency_map = np.clip(saliency_map, 0, 1) * 65535
-                    saliency_map = saliency_map.astype(np.uint16)
-                    mode = 'I;16'
-                elif settings['dtype'] == 'uint8':
-                    saliency_map = np.clip(saliency_map, 0, 1) * 255
-                    saliency_map = saliency_map.astype(np.uint8)
-                    mode = 'L'  # Grayscale mode for uint8
-
-                # Get the class prediction (0 or 1)
-                class_pred = predicted_classes[i].item()
-
-                save_class_dir = os.path.join(save_dir, f'class_{class_pred}')
-                os.makedirs(save_class_dir, exist_ok=True)
-                save_path = os.path.join(save_class_dir, filenames[i])
-
-                # Handle different cases based on saliency_map dimensions
-                if saliency_map.ndim == 3:  # Multi-channel case (C, H, W)
-                    if saliency_map.shape[0] == 3:  # RGB-like saliency map
-                        saliency_image = Image.fromarray(np.moveaxis(saliency_map, 0, -1), mode="RGB")  # Convert (C, H, W) to (H, W, C)
-                    elif saliency_map.shape[0] == 1:  # Single-channel case (1, H, W)
-                        saliency_map = np.squeeze(saliency_map)  # Remove the extra channel dimension
-                        saliency_image = Image.fromarray(saliency_map, mode=mode)  # Use grayscale mode for single-channel
-                    else:
-                        raise ValueError(f"Unexpected number of channels: {saliency_map.shape[0]}")
-
-                elif saliency_map.ndim == 2:  # Single-channel case (H, W)
-                    saliency_image = Image.fromarray(saliency_map, mode=mode)  # Keep single channel (H, W)
-
-                else:
-                    raise ValueError(f"Unexpected number of dimensions: {saliency_map.ndim}")
-
-                # Save the image
-                saliency_image.save(save_path)
 
+        # Compute activation maps and predictions
+        if settings['cam_type'] in ['gradcam', 'gradcam_pp']:
+            activation_maps, predicted_classes = cam_generator.compute_gradcam_and_predictions(inputs)
+        elif settings['cam_type'] in ['saliency_image', 'saliency_channel']:
+            activation_maps, predicted_classes = cam_generator.compute_saliency_and_predictions(inputs)
+                
+        # Move activation maps to CPU
+        activation_maps = activation_maps.cpu()
+
+        # Sum saliency maps for 'saliency_image' type
+        if settings['cam_type'] == 'saliency_image':
+            summed_activation_maps = []
+            for i in range(activation_maps.size(0)):
+                activation_map = activation_maps[i]                
+                #print(f"1: {activation_map.shape}")
+                activation_map_sum = activation_map.sum(dim=0, keepdim=False)
+                #print(f"2: {activation_map.shape}")
+                activation_map_sum = np.squeeze(activation_map_sum, axis=0)
+                #print(f"3: {activation_map_sum.shape}")
+                summed_activation_maps.append(activation_map_sum)
+            activation_maps = torch.stack(summed_activation_maps)
+
+        # For plotting
+        if settings['plot']:
+            fig = cam_generator.plot_activation_grid(inputs, activation_maps, predicted_classes, overlay=settings['overlay'], normalize=settings['normalize'])
+            pdf_save_path = os.path.join(batch_grid_fldr,f"batch_{batch_idx}_grid.pdf")
+            fig.savefig(pdf_save_path, format='pdf')
+            print(f"Saved batch grid to {pdf_save_path}")
+            #plt.show()
+            display(fig)
+                    
+        for i in range(inputs.size(0)):
+            activation_map = activation_maps[i].detach().numpy()
+
+            if settings['cam_type'] in ['saliency_image', 'gradcam', 'gradcam_pp']:
+                #activation_map = activation_map.sum(axis=0) 
+                activation_map = (activation_map - activation_map.min()) / (activation_map.max() - activation_map.min())
+                activation_map = (activation_map * 255).astype(np.uint8)
+                activation_image = Image.fromarray(activation_map, mode='L')
+
+            elif settings['cam_type'] == 'saliency_channel':
+                # Handle each channel separately and save as RGB
+                rgb_activation_map = np.zeros((activation_map.shape[1], activation_map.shape[2], 3), dtype=np.uint8)
+                for c in range(min(activation_map.shape[0], 3)):  # Limit to 3 channels for RGB
+                    channel_map = activation_map[c]
+                    channel_map = (channel_map - channel_map.min()) / (channel_map.max() - channel_map.min())
+                    rgb_activation_map[:, :, c] = (channel_map * 255).astype(np.uint8)
+                activation_image = Image.fromarray(rgb_activation_map, mode='RGB')
+
+            # Save activation maps
+            class_pred = predicted_classes[i].item()
+            parts = filenames[i].split('_')
+            plate = parts[0]
+            well = parts[1]
+            save_class_dir = os.path.join(save_dir, f'class_{class_pred}', str(plate), str(well))
+            os.makedirs(save_class_dir, exist_ok=True)
+            save_path = os.path.join(save_class_dir, f'{filenames[i]}')
+            if settings['save']:
+                activation_image.save(save_path)
+            img_paths.append(save_path)
+        
+        if settings['save']:
+            activation_maps_to_database(img_paths, source_folder, settings)
+            
+        if settings['correlation']:
+            df = calculate_activation_correlations(inputs, activation_maps, filenames, manders_thresholds=settings['manders_thresholds'])
+            if settings['plot']:
+                display(df)
+            if settings['save']:
+                activation_correlations_to_database(df, img_paths, source_folder, settings)
 
         stop = time.time()
         duration = stop - start
         time_ls.append(duration)
         files_processed = batch_idx * settings['batch_size']
-        files_to_process = len(data_loader)
-        print_progress(files_processed, files_to_process, n_jobs=n_jobs, time_ls=time_ls, batch_size=settings['batch_size'], operation_type="Generating Saliency Maps")
-
-    print("Saliency map generation complete.")
-
-def visualize_saliency_map_v1(src, model_type='maxvit', model_path='', image_size=224, channels=[1,2,3], normalize=True, class_names=None, save_saliency=False, save_dir='saliency_maps'):
+        files_to_process = len(data_loader) * settings['batch_size']
+        print_progress(files_processed, files_to_process, n_jobs=n_jobs, time_ls=time_ls, batch_size=settings['batch_size'], operation_type="Generating Activation Maps")
 
-    from spacr.utils import SaliencyMapGenerator, preprocess_image
-
-    use_cuda = torch.cuda.is_available()
-    device = torch.device("cuda" if use_cuda else "cpu")
-
-    # Load the entire model object
-    model = torch.load(model_path)
-    model.to(device)
-
-    # Create directory for saving saliency maps if it does not exist
-    if save_saliency and not os.path.exists(save_dir):
-        os.makedirs(save_dir)
-
-    # Collect all images and their tensors
-    images = []
-    input_tensors = []
-    filenames = []
-    for file in os.listdir(src):
-        if not file.endswith('.png'):
-            continue
-        image_path = os.path.join(src, file)
-        image, input_tensor = preprocess_image(image_path, normalize=normalize, image_size=image_size, channels=channels)
-        images.append(image)
-        input_tensors.append(input_tensor)
-        filenames.append(file)
-
-    input_tensors = torch.cat(input_tensors).to(device)
-    class_labels = torch.zeros(input_tensors.size(0), dtype=torch.long).to(device)  # Replace with actual class labels if available
-
-    # Generate saliency maps
-    cam_generator = SaliencyMapGenerator(model)
-    saliency_maps = cam_generator.compute_saliency_maps(input_tensors, class_labels)
-
-    # Convert saliency maps to numpy arrays
-    saliency_maps = saliency_maps.cpu().numpy()
-
-    N = len(images)
-
-    dst = os.path.join(src, 'saliency_maps')
-
-    for i in range(N):
-        fig, axes = plt.subplots(1, 3, figsize=(20, 5))
-        
-        # Original image
-        axes[0].imshow(images[i])
-        axes[0].axis('off')
-        if class_names:
-            axes[0].set_title(f"Class: {class_names[class_labels[i].item()]}")
-
-        # Saliency Map
-        axes[1].imshow(saliency_maps[i, 0], cmap='hot')
-        axes[1].axis('off')
-        axes[1].set_title("Saliency Map")
-
-        # Overlay
-        overlay = np.array(images[i])
-        overlay = overlay / overlay.max()
-        saliency_map_rgb = np.stack([saliency_maps[i, 0]] * 3, axis=-1)  # Convert saliency map to RGB
-        overlay = (overlay * 0.5 + saliency_map_rgb * 0.5).clip(0, 1)
-        axes[2].imshow(overlay)
-        axes[2].axis('off')
-        axes[2].set_title("Overlay")
-
-        plt.tight_layout()
-        plt.show()
-
-        # Save the saliency map if required
-        if save_saliency:
-            os.makedirs(dst, exist_ok=True)
-            saliency_image = Image.fromarray((saliency_maps[i, 0] * 255).astype(np.uint8))
-            saliency_image.save(os.path.join(dst, f'saliency_{filenames[i]}'))
-
-def visualize_grad_cam(src, model_path, target_layers=None, image_size=224, channels=[1, 2, 3], normalize=True, class_names=None, save_cam=False, save_dir='grad_cam'):
-
-    from spacr.utils import GradCAM, preprocess_image, show_cam_on_image, recommend_target_layers
-
-    use_cuda = torch.cuda.is_available()
-    device = torch.device("cuda" if use_cuda else "cpu")
-    
-    model = torch.load(model_path)
-    model.to(device)
-    
-    # If no target layers provided, recommend a target layer
-    if target_layers is None:
-        target_layers, all_layers = recommend_target_layers(model)
-        print(f"No target layer provided. Using recommended layer: {target_layers[0]}")
-        print("All possible target layers:")
-        for layer in all_layers:
-            print(layer)
-    
-    grad_cam = GradCAM(model=model, target_layers=target_layers, use_cuda=use_cuda)
-
-    if save_cam and not os.path.exists(save_dir):
-        os.makedirs(save_dir)
-
-    images = []
-    filenames = []
-    for file in os.listdir(src):
-        if not file.endswith('.png'):
-            continue
-        image_path = os.path.join(src, file)
-        image, input_tensor = preprocess_image(image_path, normalize=normalize, image_size=image_size, channels=channels)
-        images.append(image)
-        filenames.append(file)
-
-        input_tensor = input_tensor.to(device)
-        cam = grad_cam(input_tensor)
-        cam_image = show_cam_on_image(np.array(image) / 255.0, cam)
-
-        fig, ax = plt.subplots(1, 2, figsize=(10, 5))
-        ax[0].imshow(image)
-        ax[0].axis('off')
-        ax[0].set_title("Original Image")
-        ax[1].imshow(cam_image)
-        ax[1].axis('off')
-        ax[1].set_title("Grad-CAM")
-        plt.show()
-
-        if save_cam:
-            cam_pil = Image.fromarray(cam_image)
-            cam_pil.save(os.path.join(save_dir, f'grad_cam_{file}'))
+    torch.cuda.empty_cache()
+    gc.collect()
+    print("Activation map generation complete.")
 
 def visualize_classes(model, dtype, class_names, **kwargs):
 
-    from spacr.utils import class_visualization
+    from .utils import class_visualization
 
     for target_y in range(2):  # Assuming binary classification
         print(f"Visualizing class: {class_names[target_y]}")

spacr/gui.py

@@ -57,6 +57,7 @@ class MainApp(tk.Tk):
             "Map Barcodes": (lambda frame: initiate_root(self, 'map_barcodes'), "Map barcodes to data."),
             "Regression": (lambda frame: initiate_root(self, 'regression'), "Perform regression analysis."),
             "Recruitment": (lambda frame: initiate_root(self, 'recruitment'), "Analyze recruitment data."),
+            "Activation": (lambda frame: initiate_root(self, 'activation'), "Generate activation maps of computer vision models and measure channel-activation correlation."),
             "Plaque": (lambda frame: initiate_root(self, 'analyze_plaques'), "Analyze plaque data.")
         }
 

spacr/gui_core.py

@@ -379,10 +379,13 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var,
     index_control = index_control_var
 
 def import_settings(settings_type='mask'):
-    from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
     global vars_dict, scrollable_frame, button_scrollable_frame
-    from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
 
+    from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
+    from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model
+    from .settings import set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
+    from .settings import get_default_generate_activation_map_settings
+    #activation
     def read_settings_from_csv(csv_file_path):
         settings = {}
         with open(csv_file_path, newline='') as csvfile:
@@ -422,6 +425,8 @@ def import_settings(settings_type='mask'):
         settings = set_default_umap_image_settings(settings={})
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
+    elif settings_type == 'activation':
+        settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
         settings = {}
     elif settings_type == 'convert':
@@ -436,8 +441,10 @@ def import_settings(settings_type='mask'):
 
 def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
-    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
-    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings
+    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks
+    from .settings import get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
+    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .settings import generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_default_generate_activation_map_settings
     from .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
 
@@ -480,6 +487,8 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
         settings = get_perform_regression_default_settings(settings={})
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
+    elif settings_type == 'activation':
+        settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
         settings = {'src':'path to images'}
     elif settings_type == 'convert':

spacr/gui_utils.py

@@ -77,7 +77,7 @@ def load_app(root, app_name, app_func):
     else:
         proceed_with_app(root, app_name, app_func)
     
-def parse_list(value):
+def parse_list_v1(value):
     """
     Parses a string representation of a list and returns the parsed list.
 
@@ -98,6 +98,34 @@ def parse_list(value):
                 return parsed_value
             elif all(isinstance(item, str) for item in parsed_value):
                 return parsed_value
+            elif all(isinstance(item, float) for item in parsed_value):
+                return parsed_value
+            else:
+                raise ValueError("List contains mixed types or unsupported types")
+        else:
+            raise ValueError(f"Expected a list but got {type(parsed_value).__name__}")
+    except (ValueError, SyntaxError) as e:
+        raise ValueError(f"Invalid format for list: {value}. Error: {e}")
+    
+def parse_list(value):
+    """
+    Parses a string representation of a list and returns the parsed list.
+
+    Args:
+        value (str): The string representation of the list.
+
+    Returns:
+        list: The parsed list, which can contain integers, floats, or strings.
+
+    Raises:
+        ValueError: If the input value is not a valid list format or contains mixed types or unsupported types.
+    """
+    try:
+        parsed_value = ast.literal_eval(value)
+        if isinstance(parsed_value, list):
+            # Check if all elements are homogeneous (either all int, float, or str)
+            if all(isinstance(item, (int, float, str)) for item in parsed_value):
+                return parsed_value
             else:
                 raise ValueError("List contains mixed types or unsupported types")
         else:

spacr/io.py

@@ -2861,10 +2861,10 @@ def generate_dataset(settings={}):
     date_name = datetime.date.today().strftime('%y%m%d')
     if len(settings['src']) > 1:
         date_name = f"{date_name}_combined"
-    if not settings['file_metadata'] is None:
-        tar_name = f"{date_name}_{settings['experiment']}_{settings['file_metadata']}.tar"
-    else:
-        tar_name = f"{date_name}_{settings['experiment']}.tar"
+    #if not settings['file_metadata'] is None:
+    #    tar_name = f"{date_name}_{settings['experiment']}_{settings['file_metadata']}.tar"
+    #else:
+    tar_name = f"{date_name}_{settings['experiment']}.tar"
     tar_name = os.path.join(dst, tar_name)
     if os.path.exists(tar_name):
         number = random.randint(1, 100)

spacr/measure.py

@@ -652,43 +652,6 @@ def img_list_to_grid(grid, titles=None):
     plt.tight_layout(pad=0.1)
     return fig
 
-def filepaths_to_database(img_paths, settings, source_folder, crop_mode):
-    from. utils import _map_wells_png
-    png_df = pd.DataFrame(img_paths, columns=['png_path'])
-
-    png_df['file_name'] = png_df['png_path'].apply(lambda x: os.path.basename(x))
-
-    parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=settings['timelapse'])))
-
-    columns = ['plate', 'row', 'col', 'field']
-
-    if settings['timelapse']:
-        columns = columns + ['time_id']
-
-    columns = columns + ['prcfo']
-
-    if crop_mode == 'cell':
-        columns = columns + ['cell_id']
-
-    if crop_mode == 'nucleus':
-        columns = columns + ['nucleus_id']
-
-    if crop_mode == 'pathogen':
-        columns = columns + ['pathogen_id']
-
-    if crop_mode == 'cytoplasm':
-        columns = columns + ['cytoplasm_id']
-
-    png_df[columns] = parts
-
-    try:
-        conn = sqlite3.connect(f'{source_folder}/measurements/measurements.db', timeout=5)
-        png_df.to_sql('png_list', conn, if_exists='append', index=False)
-        conn.commit()
-    except sqlite3.OperationalError as e:
-        print(f"SQLite error: {e}", flush=True)
-        traceback.print_exc()
-
 #@log_function_call
 def _measure_crop_core(index, time_ls, file, settings):
 
@@ -711,7 +674,7 @@ def _measure_crop_core(index, time_ls, file, settings):
     """
     
     from .plot import _plot_cropped_arrays
-    from .utils import _merge_overlapping_objects, _filter_object, _relabel_parent_with_child_labels, _exclude_objects, normalize_to_dtype
+    from .utils import _merge_overlapping_objects, _filter_object, _relabel_parent_with_child_labels, _exclude_objects, normalize_to_dtype, filepaths_to_database
     from .utils import _merge_and_save_to_database, _crop_center, _find_bounding_box, _generate_names, _get_percentiles
 
     figs = {}

spacr/settings.py

@@ -246,7 +246,7 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('normalize_by','png')
     settings.setdefault('crop_mode',['cell'])
     settings.setdefault('dialate_pngs', False)
-    settings.setdefault('dialate_png_ratios', [0.2, 0,2])
+    settings.setdefault('dialate_png_ratios', [0.2,0.2])
 
     # Timelapsed settings
     settings.setdefault('timelapse', False)
@@ -859,7 +859,7 @@ expected_types = {
     'dataset':str,
     'score_threshold':float,
     'sample':None,
-    'file_metadata':None,
+    'file_metadata':(str, type(None), list),
     'apply_model_to_dataset':False,
     "train":bool,
     "test":bool,
@@ -880,6 +880,11 @@ expected_types = {
     "generate_training_dataset":bool,
     "segmentation_mode":str,
     "train_DL_model":bool,
+    "normalize":bool,
+    "overlay":bool,
+    "correlate":bool,
+    "target_layer":str,
+    "normalize_input":bool,
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv"],
@@ -889,18 +894,19 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Nucleus": ["nucleus_intensity_range", "nucleus_size_range", "nucleus_chann_dim", "nucleus_channel", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_mask_dim", "nucleus_loc"],
              "Pathogen": ["pathogen_intensity_range", "pathogen_size_range", "pathogen_chann_dim", "pathogen_channel", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogen_mask_dim", "pathogens", "pathogen_loc", "pathogen_types", "pathogen_plate_metadata", ],
              "Measurements": ["remove_image_canvas", "remove_highly_correlated", "homogeneity", "homogeneity_distances", "radial_dist", "calculate_correlation", "manders_thresholds", "save_measurements", "tables", "image_nr", "dot_size", "filter_by", "remove_highly_correlated_features", "remove_low_variance_features", "channel_of_interest"],
-             "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "dialate_png_ratios", "crop_mode", "dialate_pngs", "normalize", "use_bounding_box"],
+             "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "crop_mode", "dialate_pngs", "normalize", "use_bounding_box"],
              "Sequencing": ["signal_direction","mode","comp_level","comp_type","save_h5","expected_end","offset","target_sequence","regex", "highlight"],
              "Generate Dataset":["file_metadata","class_metadata", "annotation_column","annotated_classes", "dataset_mode", "metadata_type_by","custom_measurement", "sample", "size"],
              "Hyperparamiters (Training)": ["png_type", "score_threshold","file_type", "train_channels", "epochs", "loss_type", "optimizer_type","image_size","val_split","learning_rate","weight_decay","dropout_rate", "init_weights", "train", "classes", "augment", "amsgrad","use_checkpoint","gradient_accumulation","gradient_accumulation_steps","intermedeate_save","pin_memory"],
              "Hyperparamiters (Embedding)": ["visualize","n_neighbors","min_dist","metric","resnet_features","reduction_method","embedding_by_controls","col_to_compare","log_data"],
              "Hyperparamiters (Clustering)": ["eps","min_samples","analyze_clusters","clustering","remove_cluster_noise"],
              "Hyperparamiters (Regression)":["cov_type", "class_1_threshold", "plate", "other", "fraction_threshold", "alpha", "random_row_column_effects", "regression_type", "min_cell_count", "agg_type", "transform", "dependent_variable"],
+             "Hyperparamiters (Activation)":["cam_type", "normalize", "overlay", "correlation", "target_layer", "normalize_input"],
              "Annotation": ["nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "channel_of_interest", "measurement", "treatments", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
              "Plot": ["plot", "plot_control", "plot_nr", "examples_to_plot", "normalize_plots", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
              "Test": ["test_mode", "test_images", "random_test", "test_nr", "test", "test_split"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
-             "Advanced": ["target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
+             "Advanced": ["shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
              "Miscellaneous": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor"]
              }
 
@@ -949,6 +955,14 @@ def check_settings(vars_dict, expected_types, q=None):
                 settings[key] = float(value) if '.' in value else int(value)
             elif expected_type == (str, type(None)):
                 settings[key] = str(value) if value else None
+            elif expected_type == (str, type(None), list):
+                if isinstance(value, list):
+                    settings[key] = parse_list(value) if value else None
+                elif isinstance(value, str):
+                    settings[key] = str(value) 
+                else:
+                    settings[key] = None
+            
             elif expected_type == dict:
                 try:
                     # Ensure that the value is a string that can be converted to a dictionary
@@ -1206,7 +1220,7 @@ def generate_fields(variables, scrollable_frame):
         "dataset": "str - file name of the tar file with image dataset",
         "score_threshold": "float - threshold for classification",
         "sample": "str - number of images to sample for tar dataset (including both classes). Default: None",
-        "file_metadata": "str - string that must be present in image path to be included in the dataset",
+        "file_metadata": "str or list of strings - string(s) that must be present in image path to be included in the dataset",
         "apply_model_to_dataset": "bool - whether to apply model to the dataset",
         "train_channels": "list - channels to use for training",
         "dataset_mode": "str - How to generate train/test dataset.",
@@ -1247,6 +1261,13 @@ def generate_fields(variables, scrollable_frame):
         "mode": "(str) - Mode to use for sequence analysis (either single for R1 or R2 fastq files or paired for the combination of R1 and R2).",
         "signal_direction": "(str) - Direction of fastq file (R1 or R2). only relevent when mode is single.",
         "custom_model_path": "(str) - Path to the custom model to finetune.",
+        "cam_type": "(str) - Choose between: gradcam, gradcam_pp, saliency_image, saliency_channel to generate activateion maps of DL models",
+        "target_layer": "(str) - Only used for gradcam and gradcam_pp. The layer to use for the activation map.",
+        "normalize": "(bool) - Normalize images before overlayng the activation maps.",
+        "overlay": "(bool) - Overlay activation maps on the images.",
+        "shuffle": "(bool) - Shuffle the dataset bufore generating the activation maps",
+        "correlation": "(bool) - Calculate correlation between image channels and activation maps. Data is saved to .db.",
+        "normalize_input": "(bool) - Normalize the input images before passing them to the model.",
     }
     
     for key, (var_type, options, default_value) in variables.items():
@@ -1282,6 +1303,8 @@ descriptions = {
 
     'regression': "Perform regression analysis on your data. Function: regression_tools from spacr.analysis.\n\nKey Features:\n- Statistical Analysis: Conduct various types of regression analysis to identify relationships within your data.\n- Flexible Options: Supports multiple regression models and configurations.\n- Data Insight: Gain deeper insights into your dataset through advanced regression techniques.",
     
+    'activation': "",
+
     'recruitment': "Analyze recruitment data to understand sample recruitment dynamics. Function: recruitment_analysis_tools from spacr.analysis.\n\nKey Features:\n- Recruitment Analysis: Investigate and analyze the recruitment of samples over time or conditions.\n- Visualization: Generate visualizations to represent recruitment trends and patterns.\n- Integration: Utilize data from various sources for a comprehensive recruitment analysis."
 }
 
@@ -1314,4 +1337,25 @@ def set_default_generate_barecode_mapping(settings={}):
     settings.setdefault('mode', 'paired')
     settings.setdefault('single_direction', 'R1')
     settings.setdefault('test', False)
+    return settings
+
+def get_default_generate_activation_map_settings(settings):
+    settings.setdefault('dataset', 'path')
+    settings.setdefault('model_type', 'maxvit')
+    settings.setdefault('model_path', 'path')
+    settings.setdefault('image_size', 224)
+    settings.setdefault('batch_size', 64)
+    settings.setdefault('normalize', True)
+    settings.setdefault('cam_type', 'gradcam')
+    settings.setdefault('target_layer', None)
+    settings.setdefault('plot', False)
+    settings.setdefault('save', True)
+    settings.setdefault('normalize_input', True)
+    settings.setdefault('channels', [1,2,3])
+    settings.setdefault('overlay', True)
+    settings.setdefault('shuffle', True)
+    settings.setdefault('correlation', True)
+    settings.setdefault('manders_thresholds', [15,50, 75])
+    settings.setdefault('n_jobs', None)
+    
     return settings

spacr/utils.py

@@ -1,4 +1,4 @@
-import os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform, gzip, subprocess, time, requests, ast
+import os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform, gzip, subprocess, time, requests, ast, traceback
 
 import numpy as np
 import pandas as pd
@@ -12,6 +12,7 @@ from skimage.transform import resize as resizescikit
 from skimage.morphology import dilation, square
 from skimage.measure import find_contours
 from skimage.segmentation import clear_border
+from scipy.stats import pearsonr
 
 from collections import defaultdict, OrderedDict
 from PIL import Image
@@ -67,6 +68,192 @@ from huggingface_hub import list_repo_files
 import umap.umap_ as umap
 #import umap
 
+def filepaths_to_database(img_paths, settings, source_folder, crop_mode):
+
+    png_df = pd.DataFrame(img_paths, columns=['png_path'])
+
+    png_df['file_name'] = png_df['png_path'].apply(lambda x: os.path.basename(x))
+
+    parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=settings['timelapse'])))
+
+    columns = ['plate', 'row', 'col', 'field']
+
+    if settings['timelapse']:
+        columns = columns + ['time_id']
+
+    columns = columns + ['prcfo']
+
+    if crop_mode == 'cell':
+        columns = columns + ['cell_id']
+
+    if crop_mode == 'nucleus':
+        columns = columns + ['nucleus_id']
+
+    if crop_mode == 'pathogen':
+        columns = columns + ['pathogen_id']
+
+    if crop_mode == 'cytoplasm':
+        columns = columns + ['cytoplasm_id']
+
+    png_df[columns] = parts
+
+    try:
+        conn = sqlite3.connect(f'{source_folder}/measurements/measurements.db', timeout=5)
+        png_df.to_sql('png_list', conn, if_exists='append', index=False)
+        conn.commit()
+    except sqlite3.OperationalError as e:
+        print(f"SQLite error: {e}", flush=True)
+        traceback.print_exc()
+
+def activation_maps_to_database(img_paths, source_folder, settings):
+    from .io import _create_database
+
+    png_df = pd.DataFrame(img_paths, columns=['png_path'])
+    png_df['file_name'] = png_df['png_path'].apply(lambda x: os.path.basename(x))
+    parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=False)))
+    columns = ['plate', 'row', 'col', 'field', 'prcfo', 'object']
+    png_df[columns] = parts
+
+    dataset_name = os.path.splitext(os.path.basename(settings['dataset']))[0]
+    database_name = f"{source_folder}/measurements/{dataset_name}.db"
+
+    if not os.path.exists(database_name):
+        _create_database(database_name)
+
+    try:
+        conn = sqlite3.connect(database_name, timeout=5)
+        png_df.to_sql(f"{settings['cam_type']}_list", conn, if_exists='append', index=False)
+        conn.commit()
+    except sqlite3.OperationalError as e:
+        print(f"SQLite error: {e}", flush=True)
+        traceback.print_exc()
+
+def activation_correlations_to_database(df, img_paths, source_folder, settings):
+    from .io import _create_database
+
+    png_df = pd.DataFrame(img_paths, columns=['png_path'])
+    png_df['file_name'] = png_df['png_path'].apply(lambda x: os.path.basename(x))
+    parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=False)))
+    columns = ['plate', 'row', 'col', 'field', 'prcfo', 'object']
+    png_df[columns] = parts
+
+    # Align both DataFrames by file_name
+    png_df.set_index('file_name', inplace=True)
+    df.set_index('file_name', inplace=True)
+
+    merged_df = pd.concat([png_df, df], axis=1)
+    merged_df.reset_index(inplace=True)
+
+    dataset_name = os.path.splitext(os.path.basename(settings['dataset']))[0]
+    database_name = f"{source_folder}/measurements/{dataset_name}.db"
+
+    if not os.path.exists(database_name):
+        _create_database(database_name)
+
+    try:
+        conn = sqlite3.connect(database_name, timeout=5)
+        merged_df.to_sql(f"{settings['cam_type']}_correlations", conn, if_exists='append', index=False)
+        conn.commit()
+    except sqlite3.OperationalError as e:
+        print(f"SQLite error: {e}", flush=True)
+        traceback.print_exc()
+
+def calculate_activation_correlations(inputs, activation_maps, file_names, manders_thresholds=[15, 50, 75]):
+    """
+    Calculates Pearson and Manders correlations between input image channels and activation map channels.
+    
+    Args:
+        inputs: A batch of input images, Tensor of shape (batch_size, channels, height, width)
+        activation_maps: A batch of activation maps, Tensor of shape (batch_size, channels, height, width)
+        file_names: List of file names corresponding to each image in the batch.
+        manders_thresholds: List of intensity percentiles to calculate Manders correlation.
+        
+    Returns:
+        df_correlations: A DataFrame with columns for pairwise correlations (Pearson and Manders) 
+                         between input channels and activation map channels.
+    """
+    
+    # Ensure tensors are detached and moved to CPU before converting to numpy
+    inputs = inputs.detach().cpu()
+    activation_maps = activation_maps.detach().cpu()
+
+    batch_size, in_channels, height, width = inputs.shape
+    
+    if activation_maps.dim() == 3:
+        # If activation maps have no channels, add a dummy channel dimension
+        activation_maps = activation_maps.unsqueeze(1)  # Now shape is (batch_size, 1, height, width)
+    
+    _, act_channels, act_height, act_width = activation_maps.shape
+
+    # Ensure that the inputs and activation maps are the same size
+    if (height != act_height) or (width != act_width):
+        activation_maps = torch.nn.functional.interpolate(activation_maps, size=(height, width), mode='bilinear')
+
+    # Dictionary to collect correlation results
+    correlations_dict = {'file_name': []}
+
+    # Initialize correlation columns based on input channels and activation map channels
+    for in_c in range(in_channels):
+        for act_c in range(act_channels):
+            correlations_dict[f'channel_{in_c}_activation_{act_c}_pearsons'] = []
+            for threshold in manders_thresholds:
+                correlations_dict[f'channel_{in_c}_activation_{act_c}_{threshold}_M1'] = []
+                correlations_dict[f'channel_{in_c}_activation_{act_c}_{threshold}_M2'] = []
+
+    # Loop over the batch
+    for b in range(batch_size):
+        input_img = inputs[b]  # Input image channels (C, H, W)
+        activation_map = activation_maps[b]  # Activation map channels (C, H, W)
+
+        # Add the file name to the current row
+        correlations_dict['file_name'].append(file_names[b])
+
+        # Calculate correlations for each channel pair
+        for in_c in range(in_channels):
+            input_channel = input_img[in_c].flatten().numpy()  # Flatten the input image channel
+            input_channel = input_channel[np.isfinite(input_channel)]  # Remove NaN or inf values
+
+            for act_c in range(act_channels):
+                activation_channel = activation_map[act_c].flatten().numpy()  # Flatten the activation map channel
+                activation_channel = activation_channel[np.isfinite(activation_channel)]  # Remove NaN or inf values
+
+                # Check if there are valid (non-empty) arrays left to calculate the Pearson correlation
+                if input_channel.size > 0 and activation_channel.size > 0:
+                    pearson_corr, _ = pearsonr(input_channel, activation_channel)
+                else:
+                    pearson_corr = np.nan  # Assign NaN if there are no valid data points
+                correlations_dict[f'channel_{in_c}_activation_{act_c}_pearsons'].append(pearson_corr)
+
+                # Compute Manders correlations for each threshold
+                for threshold in manders_thresholds:
+                    # Get the top percentile pixels based on intensity in both channels
+                    if input_channel.size > 0 and activation_channel.size > 0:
+                        input_threshold = np.percentile(input_channel, threshold)
+                        activation_threshold = np.percentile(activation_channel, threshold)
+
+                        # Mask the pixels above the threshold
+                        mask = (input_channel >= input_threshold) & (activation_channel >= activation_threshold)
+
+                        # If we have enough pixels, calculate Manders correlation
+                        if np.sum(mask) > 0:
+                            manders_corr_M1 = np.sum(input_channel[mask] * activation_channel[mask]) / np.sum(input_channel[mask] ** 2)
+                            manders_corr_M2 = np.sum(activation_channel[mask] * input_channel[mask]) / np.sum(activation_channel[mask] ** 2)
+                        else:
+                            manders_corr_M1 = np.nan
+                            manders_corr_M2 = np.nan
+                    else:
+                        manders_corr_M1 = np.nan
+                        manders_corr_M2 = np.nan
+
+                    # Store the Manders correlation for this threshold
+                    correlations_dict[f'channel_{in_c}_activation_{act_c}_{threshold}_M1'].append(manders_corr_M1)
+                    correlations_dict[f'channel_{in_c}_activation_{act_c}_{threshold}_M2'].append(manders_corr_M2)
+
+    # Convert the dictionary to a DataFrame
+    df_correlations = pd.DataFrame(correlations_dict)
+
+    return df_correlations
+
 def load_settings(csv_file_path, show=False, setting_key='setting_key', setting_value='setting_value'):
     """
     Convert a CSV file with 'settings_key' and 'settings_value' columns into a dictionary.
@@ -892,7 +1079,7 @@ def _map_wells_png(file_name, timelapse=False):
         print(f"Error: {e}")
         plate, row, column, field, object_id, prcfo = 'error', 'error', 'error', 'error', 'error', 'error'
     if timelapse:
-        return plate, row, column, field, timeid, prcfo, object_id,
+        return plate, row, column, field, timeid, prcfo, object_id
     else:
         return plate, row, column, field, prcfo, object_id
         
@@ -3097,46 +3284,176 @@ class SaliencyMapGenerator:
         saliency = X.grad.abs()
 
         return saliency, predictions
-    
-    def plot_saliency_grid(self, X, saliency, predictions, mode='mean'):
+
+    def plot_activation_grid(self, X, saliency, predictions, overlay=True, normalize=False):
         N = X.shape[0]
-        rows = (N + 7) // 8  # Ensure we can handle batches of different sizes
+        rows = (N + 7) // 8 
         fig, axs = plt.subplots(rows, 8, figsize=(16, rows * 2))
 
         for i in range(N):
             ax = axs[i // 8, i % 8]
+            saliency_map = saliency[i].cpu().numpy()  # Move to CPU and convert to numpy
 
-            if mode == 'mean':
-                saliency_map = saliency[i].mean(dim=0).cpu().numpy()  # Mean saliency over channels
-                ax.imshow(X[i].permute(1, 2, 0).detach().cpu().numpy())  # Added .detach() here
+            if saliency_map.shape[0] == 3:  # Channels first, reshape to (H, W, 3)
+                saliency_map = np.transpose(saliency_map, (1, 2, 0))
+
+            # Normalize image channels to 2nd and 98th percentiles
+            if overlay:
+                img_np = X[i].permute(1, 2, 0).detach().cpu().numpy()
+                if normalize:
+                    img_np = self.percentile_normalize(img_np)
+                ax.imshow(img_np)
                 ax.imshow(saliency_map, cmap='jet', alpha=0.5)
 
-            elif mode == 'channel':
-                # Plot individual channels in a loop if the image has multiple channels
-                for j in range(X.shape[1]):
-                    saliency_map = saliency[i, j].cpu().numpy()
-                    ax.imshow(saliency_map, cmap='jet')
-                    ax.axis('off')
+            # Add class label in the top-left corner
+            ax.text(5, 25, str(predictions[i].item()), fontsize=12, color='white', weight='bold',
+                    bbox=dict(facecolor='black', alpha=0.7, boxstyle='round,pad=0.2'))
+            ax.axis('off')
+
+        plt.tight_layout(pad=0)
+        return fig
+    
+    def percentile_normalize(self, img, lower_percentile=2, upper_percentile=98):
+        """
+        Normalize each channel of the image to the given percentiles.
+        Args:
+            img: Input image as numpy array with shape (H, W, C)
+            lower_percentile: Lower percentile for normalization (default 2)
+            upper_percentile: Upper percentile for normalization (default 98)
+        Returns:
+            img: Normalized image
+        """
+        img_normalized = np.zeros_like(img)
 
-            elif mode == '3-channel' and X.shape[1] == 3:
-                saliency_map = saliency[i].cpu().numpy().transpose(1, 2, 0)
-                ax.imshow(saliency_map)
-                    
-            elif mode == '2-channel' and X.shape[1] == 2:
-                saliency_map = saliency[i].cpu().numpy().transpose(1, 2, 0)
-                ax.imshow(saliency_map)
+        for c in range(img.shape[2]):  # Iterate over each channel
+            low = np.percentile(img[:, :, c], lower_percentile)
+            high = np.percentile(img[:, :, c], upper_percentile)
+            img_normalized[:, :, c] = np.clip((img[:, :, c] - low) / (high - low), 0, 1)
+
+        return img_normalized
+
+
+class GradCAMGenerator:
+    def __init__(self, model, target_layer, cam_type='gradcam'):
+        self.model = model
+        self.model.eval()
+        self.target_layer = target_layer
+        self.cam_type = cam_type
+        self.gradients = None
+        self.activations = None
+
+        # Hook the target layer
+        self.target_layer_module = self.get_layer(self.model, self.target_layer)
+        self.hook_layers()
+
+    def hook_layers(self):
+        # Forward hook to get activations
+        def forward_hook(module, input, output):
+            self.activations = output
+
+        # Backward hook to get gradients
+        def backward_hook(module, grad_input, grad_output):
+            self.gradients = grad_output[0]
+
+        self.target_layer_module.register_forward_hook(forward_hook)
+        self.target_layer_module.register_backward_hook(backward_hook)
+
+    def get_layer(self, model, target_layer):
+        # Recursively find the layer specified in target_layer
+        modules = target_layer.split('.')
+        layer = model
+        for module in modules:
+            layer = getattr(layer, module)
+        return layer
+
+    def compute_gradcam_maps(self, X, y):
+        X.requires_grad_()
 
-            # Add class label in top-left corner
+        # Forward pass
+        scores = self.model(X).squeeze()
+
+        # Perform backward pass
+        target_scores = scores * (2 * y - 1)
+        self.model.zero_grad()
+        target_scores.backward(torch.ones_like(target_scores))
+
+        # Compute GradCAM
+        pooled_gradients = torch.mean(self.gradients, dim=[0, 2, 3])
+        for i in range(self.activations.size(1)):
+            self.activations[:, i, :, :] *= pooled_gradients[i]
+
+        gradcam = torch.mean(self.activations, dim=1).squeeze()
+        gradcam = F.relu(gradcam)
+        gradcam = F.interpolate(gradcam.unsqueeze(0).unsqueeze(0), size=X.shape[2:], mode='bilinear')
+        gradcam = gradcam.squeeze().cpu().detach().numpy()
+        gradcam = (gradcam - gradcam.min()) / (gradcam.max() - gradcam.min())
+
+        return gradcam
+
+    def compute_gradcam_and_predictions(self, X):
+        self.model.eval()
+        X.requires_grad_()
+
+        # Forward pass to get predictions (logits)
+        scores = self.model(X).squeeze()
+
+        # Get predicted class (0 or 1 for binary classification)
+        predictions = (scores > 0).long()
+
+        # Compute gradcam maps
+        gradcam_maps = []
+        for i in range(X.size(0)):
+            gradcam_map = self.compute_gradcam_maps(X[i].unsqueeze(0), predictions[i])
+            gradcam_maps.append(gradcam_map)
+
+        return torch.tensor(gradcam_maps), predictions
+
+    def plot_activation_grid(self, X, gradcam, predictions, overlay=True, normalize=False):
+        N = X.shape[0]
+        rows = (N + 7) // 8
+        fig, axs = plt.subplots(rows, 8, figsize=(16, rows * 2))
+
+        for i in range(N):
+            ax = axs[i // 8, i % 8]
+            gradcam_map = gradcam[i].cpu().numpy()
+
+            # Normalize image channels to 2nd and 98th percentiles
+            if overlay:
+                img_np = X[i].permute(1, 2, 0).detach().cpu().numpy()
+                if normalize:
+                    img_np = self.percentile_normalize(img_np)
+                ax.imshow(img_np)
+                ax.imshow(gradcam_map, cmap='jet', alpha=0.5)
+
+            #ax.imshow(X[i].permute(1, 2, 0).detach().cpu().numpy())  # Original image
+            #ax.imshow(gradcam_map, cmap='jet', alpha=0.5)  # Overlay the gradcam map
+
+            # Add class label in the top-left corner
             ax.text(5, 25, str(predictions[i].item()), fontsize=12, color='white', weight='bold',
                     bbox=dict(facecolor='black', alpha=0.7, boxstyle='round,pad=0.2'))
             ax.axis('off')
 
-        # Turn off unused axes
-        for j in range(N, rows * 8):
-            fig.delaxes(axs[j // 8, j % 8])
-
         plt.tight_layout(pad=0)
-        plt.show()
+        return fig
+    
+    def percentile_normalize(self, img, lower_percentile=2, upper_percentile=98):
+        """
+        Normalize each channel of the image to the given percentiles.
+        Args:
+            img: Input image as numpy array with shape (H, W, C)
+            lower_percentile: Lower percentile for normalization (default 2)
+            upper_percentile: Upper percentile for normalization (default 98)
+        Returns:
+            img: Normalized image
+        """
+        img_normalized = np.zeros_like(img)
+
+        for c in range(img.shape[2]):  # Iterate over each channel
+            low = np.percentile(img[:, :, c], lower_percentile)
+            high = np.percentile(img[:, :, c], upper_percentile)
+            img_normalized[:, :, c] = np.clip((img[:, :, c] - low) / (high - low), 0, 1)
+
+        return img_normalized
 
 def preprocess_image(image_path, normalize=True, image_size=224, channels=[1,2,3]):
     preprocess = transforms.Compose([
@@ -3677,8 +3994,37 @@ def plot_grid(cluster_images, colors, figuresize, black_background, verbose):
     plt.show()
     return grid_fig
 
-def generate_path_list_from_db(db_path, file_metadata):
+def generate_path_list_from_db_v1(db_path, file_metadata):
+
+    all_paths = []
+
+    # Connect to the database and retrieve the image paths
+    print(f"Reading DataBase: {db_path}")
+    try:
+        with sqlite3.connect(db_path) as conn:
+            cursor = conn.cursor()
+            if file_metadata:
+                if isinstance(file_metadata, str):
+                    cursor.execute("SELECT png_path FROM png_list WHERE png_path LIKE ?", (f"%{file_metadata}%",))
+            else:
+                cursor.execute("SELECT png_path FROM png_list")
 
+            while True:
+                rows = cursor.fetchmany(1000)
+                if not rows:
+                    break
+                all_paths.extend([row[0] for row in rows])
+
+    except sqlite3.Error as e:
+        print(f"Database error: {e}")
+        return
+    except Exception as e:
+        print(f"Error: {e}")
+        return
+    
+    return all_paths
+
+def generate_path_list_from_db(db_path, file_metadata):
     all_paths = []
 
     # Connect to the database and retrieve the image paths
@@ -3686,10 +4032,19 @@ def generate_path_list_from_db(db_path, file_metadata):
     try:
         with sqlite3.connect(db_path) as conn:
             cursor = conn.cursor()
+
             if file_metadata:
                 if isinstance(file_metadata, str):
+                    # If file_metadata is a single string
                     cursor.execute("SELECT png_path FROM png_list WHERE png_path LIKE ?", (f"%{file_metadata}%",))
+                elif isinstance(file_metadata, list):
+                    # If file_metadata is a list of strings
+                    query = "SELECT png_path FROM png_list WHERE " + " OR ".join(
+                        ["png_path LIKE ?" for _ in file_metadata])
+                    params = [f"%{meta}%" for meta in file_metadata]
+                    cursor.execute(query, params)
             else:
+                # If file_metadata is None or empty
                 cursor.execute("SELECT png_path FROM png_list")
 
             while True:

{spacr-0.3.22.dist-info → spacr-0.3.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.22
+Version: 0.3.30
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.3.22.dist-info → spacr-0.3.30.dist-info}/RECORD

@@ -9,25 +9,25 @@ spacr/app_sequencing.py,sha256=DjG26jy4cpddnV8WOOAIiExtOe9MleVMY4MFa5uTo5w,157
 spacr/app_umap.py,sha256=ZWAmf_OsIKbYvolYuWPMYhdlVe-n2CADoJulAizMiEo,153
 spacr/cellpose.py,sha256=zv4BzhaP2O-mtQ-pUfYvpOyxgn1ke_bDWgdHD5UWm9I,13942
 spacr/core.py,sha256=G_x-w7FRIHNfSOoPaIZPSf_A7mVj7PA7o9HQZ4nIu5o,48231
-spacr/deep_spacr.py,sha256=iPJhwhNQKF0_PmQ3RXi_gK7BKvIb5m54DeYZRlXBqMU,46081
-spacr/gui.py,sha256=ndmWP4F0QO5j6DM6MNzoGtzv_7Yj4LTW2SLi9URBZIQ,8055
-spacr/gui_core.py,sha256=OJQxzpehIyDzjSjIsvxSHat4NIjkqjX0VZAUQTnzEzg,40921
+spacr/deep_spacr.py,sha256=HdOcNU8cHcE_19nP7_5uTz-ih3E169ffr2Hm--NvMvA,43255
+spacr/gui.py,sha256=ARyn9Q_g8HoP-cXh1nzMLVFCKqthY4v2u9yORyaQqQE,8230
+spacr/gui_core.py,sha256=LV_HX5zreu3Bye6sQFDbOuk8Dfj4StMoohy6hsrDEXA,41363
 spacr/gui_elements.py,sha256=3ru8FPZtXCZSj7167GJj18-Zo6TVebhAzkit-mmqmTI,135342
-spacr/gui_utils.py,sha256=76utRICvY0k_6X8CA1P_TmYBJARp4b87OkI9t39tldA,45822
-spacr/io.py,sha256=Xy1Drm5NPhxvwE1nyJVd2SQu3yTynlnvSrjlRuFXwBw,143371
+spacr/gui_utils.py,sha256=hY7JC8HMlyKa9d7tDjkgXgRILgBYTw85jAkRsexO0P0,46960
+spacr/io.py,sha256=AARmqn1fMmTgVDwWy8bEYK6SjH-6DZIulgCSPdBTyf0,143370
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
-spacr/measure.py,sha256=8MRjQdB-2n8JVLjEpF3cxvfT-Udug27uJ2ErJJ5t1ic,56000
+spacr/measure.py,sha256=BThn_sALgKrwGKnLOGpT4FyoJeRVoTZoP9SXbCtCMRw,54857
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
 spacr/ml.py,sha256=3XiQUfhhseCz9cZXhaVkCCv_qfqoZCdXGnO_p3ulwo4,47131
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
 spacr/plot.py,sha256=eZcs-CQrDTENXVeMY8y8N8VZnmPePO-kAWdoaweFmW8,105540
 spacr/sequencing.py,sha256=t18mgpK6rhWuB1LtFOsPxqgpFXxuUmrD06ecsaVQ0Gw,19655
-spacr/settings.py,sha256=YExChD7DWY_cJyaPGKDTpFajsXXi5ZQ8P0XR9ZQf8CE,73560
+spacr/settings.py,sha256=BUQv8mSQLaw3yT08cKB0x5Y5gl0-S7AxmV6TABoPQlk,75773
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
 spacr/submodules.py,sha256=AB7s6-cULsaqz-haAaCtXfGEIi8uPZGT4xoCslUJC3Y,18391
 spacr/timelapse.py,sha256=FSYpUtAVy6xc3lwprRYgyDTT9ysUhfRQ4zrP9_h2mvg,39465
 spacr/toxo.py,sha256=us3pQyULtMTyfTq0MWPn4QJTTmQ6BwAJKChNf75jo3I,10082
-spacr/utils.py,sha256=brlNXsDcsKyHjJ2IodB0KyMQkEpQfMBp5QZCCb0vdz8,198459
+spacr/utils.py,sha256=w4Cht32Mhep7jfXKm5CSpyFLB3lOxiBCQI6PnaYcI3Q,213360
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/MEDIAR/.gitignore,sha256=Ff1q9Nme14JUd-4Q3jZ65aeQ5X4uttptssVDgBVHYo8,152
 spacr/resources/MEDIAR/LICENSE,sha256=yEj_TRDLUfDpHDNM0StALXIt6mLqSgaV2hcCwa6_TcY,1065
@@ -150,9 +150,9 @@ spacr/resources/icons/umap.png,sha256=dOLF3DeLYy9k0nkUybiZMe1wzHQwLJFRmgccppw-8b
 spacr/resources/images/plate1_E01_T0001F001L01A01Z01C02.tif,sha256=Tl0ZUfZ_AYAbu0up_nO0tPRtF1BxXhWQ3T3pURBCCRo,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A02Z01C01.tif,sha256=m8N-V71rA1TT4dFlENNg8s0Q0YEXXs8slIn7yObmZJQ,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A03Z01C03.tif,sha256=Pbhk7xn-KUP6RSIhJsxQcrHFImBm3GEpLkzx7WOc-5M,7958528
-spacr-0.3.22.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.3.22.dist-info/METADATA,sha256=wHP5zD5dSSsxLHNjlr3-OALEmhzL7gexG_uqX6M0OWc,5949
-spacr-0.3.22.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.3.22.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.3.22.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.3.22.dist-info/RECORD,,
+spacr-0.3.30.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.3.30.dist-info/METADATA,sha256=pi7DGlwhEsgk3YMKEDCiATIXZC1ku_PuEo_CKGjDUE4,5949
+spacr-0.3.30.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.3.30.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.3.30.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.3.30.dist-info/RECORD,,