spacr 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

spacr/deep_spacr.py

@@ -1,5 +1,4 @@
-import os, torch, time, gc, datetime
-
+import os, torch, time, gc, datetime, cv2
 torch.backends.cudnn.benchmark = True
 
 import numpy as np
@@ -8,15 +7,146 @@ from torch.optim import Adagrad, AdamW
 from torch.autograd import grad
 from torch.optim.lr_scheduler import StepLR
 import torch.nn.functional as F
-from IPython.display import display, clear_output
 import matplotlib.pyplot as plt
 from PIL import Image
 from sklearn.metrics import auc, precision_recall_curve
-from multiprocessing import set_start_method
-#set_start_method('spawn', force=True)
+from IPython.display import display
+from multiprocessing import cpu_count
+
+from torchvision import transforms
+from torch.utils.data import DataLoader
+
+def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True, n_jobs=10):
+    
+    from .io import NoClassDataset
+    from .utils import print_progress
+    
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    
+    if normalize:
+        transform = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.CenterCrop(size=(image_size, 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=(image_size, image_size))])
+    
+    model = torch.load(model_path)
+    print(model)
+    
+    print(f'Loading dataset in {src} with {len(src)} images')
+    dataset = NoClassDataset(data_dir=src, transform=transform, shuffle=True, load_to_memory=False)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=n_jobs)
+    print(f'Loaded {len(src)} images')
+    
+    result_loc = os.path.splitext(model_path)[0]+datetime.date.today().strftime('%y%m%d')+'_'+os.path.splitext(model_path)[1]+'_test_result.csv'
+    print(f'Results wil be saved in: {result_loc}')
+    
+    model.eval()
+    model = model.to(device)
+    prediction_pos_probs = []
+    filenames_list = []
+    time_ls = []
+    with torch.no_grad():
+        for batch_idx, (batch_images, filenames) in enumerate(data_loader, start=1):
+            start = time.time()
+            images = batch_images.to(torch.float).to(device)
+            outputs = model(images)
+            batch_prediction_pos_prob = torch.sigmoid(outputs).cpu().numpy()
+            prediction_pos_probs.extend(batch_prediction_pos_prob.tolist())
+            filenames_list.extend(filenames)
+            stop = time.time()
+            duration = stop - start
+            time_ls.append(duration)
+            files_processed = batch_idx*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=batch_size, operation_type="Generating predictions")
+
+    data = {'path':filenames_list, 'pred':prediction_pos_probs}
+    df = pd.DataFrame(data, index=None)
+    df.to_csv(result_loc, index=True, header=True, mode='w')
+    torch.cuda.empty_cache()
+    torch.cuda.memory.empty_cache()
+    return df
+
+def apply_model_to_tar(settings={}):
+    
+    from .io import TarImageDataset
+    from .utils import process_vision_results, print_progress
+
+    if os.path.exists(settings['dataset']):
+        tar_path = settings['dataset']
+    else:
+        tar_path = os.path.join(settings['src'], 'datasets', settings['dataset'])
+    model_path = settings['model_path']
+    
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    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']))])
+    
+    if settings['verbose']:
+        print(f"Loading model from {model_path}")
+        print(f"Loading dataset from {tar_path}")
+        
+    model = torch.load(settings['model_path'])
+    
+    dataset = TarImageDataset(tar_path, transform=transform)
+    data_loader = DataLoader(dataset, batch_size=settings['batch_size'], shuffle=True, num_workers=settings['n_jobs'], pin_memory=True)
+    
+    model_name = os.path.splitext(os.path.basename(model_path))[0]
+    dataset_name = os.path.splitext(os.path.basename(settings['dataset']))[0]  
+    date_name = datetime.date.today().strftime('%y%m%d')
+    dst = os.path.dirname(tar_path)
+    result_loc = f'{dst}/{date_name}_{dataset_name}_{model_name}_result.csv'
 
-from .logger import log_function_call
-from .utils import close_multiprocessing_processes, reset_mp
+    model.eval()
+    model = model.to(device)
+    
+    if settings['verbose']:
+        print(model)
+        print(f'Generated dataset with {len(dataset)} images')
+        print(f'Generating loader from {len(data_loader)} batches')
+        print(f'Results wil be saved in: {result_loc}')
+        print(f'Model is in eval mode')
+        print(f'Model loaded to device')
+        
+    prediction_pos_probs = []
+    filenames_list = []
+    time_ls = []
+    gc.collect()
+    with torch.no_grad():
+        for batch_idx, (batch_images, filenames) in enumerate(data_loader, start=1):
+            start = time.time()
+            images = batch_images.to(torch.float).to(device)
+            outputs = model(images)
+            batch_prediction_pos_prob = torch.sigmoid(outputs).cpu().numpy()
+            prediction_pos_probs.extend(batch_prediction_pos_prob.tolist())
+            filenames_list.extend(filenames)
+            stop = time.time()
+            duration = stop - start
+            time_ls.append(duration)
+            files_processed = batch_idx*settings['batch_size']
+            files_to_process = len(data_loader)*settings['batch_size']
+            print_progress(files_processed, files_to_process, n_jobs=settings['n_jobs'], time_ls=time_ls, batch_size=settings['batch_size'], operation_type="Tar dataset")
+
+    data = {'path':filenames_list, 'pred':prediction_pos_probs}
+    df = pd.DataFrame(data, index=None)
+    df = process_vision_results(df, settings['score_threshold'])
+
+    df.to_csv(result_loc, index=True, header=True, mode='w')
+    print(f"Saved results to {result_loc}")
+    torch.cuda.empty_cache()
+    torch.cuda.memory.empty_cache()
+    return df
 
 def evaluate_model_performance(model, loader, epoch, loss_type):
     """
@@ -118,7 +248,7 @@ def evaluate_model_performance(model, loader, epoch, loss_type):
     
     loss /= len(loader)
     data_dict = classification_metrics(all_labels, prediction_pos_probs)
-    data_dict['loss'] = loss
+    data_dict['loss'] = loss.item()
     data_dict['epoch'] = epoch
     data_dict['Accuracy'] = acc
     
@@ -175,7 +305,7 @@ def test_model_core(model, loader, loader_name, epoch, loss_type):
         'class_1_probability':prediction_pos_probs})
 
     loss /= len(loader)
-    data_df = classification_metrics(all_labels, prediction_pos_probs, loader_name, loss, epoch)
+    data_df = classification_metrics(all_labels, prediction_pos_probs, loss, epoch)
     return data_df, prediction_pos_probs, all_labels, results_df
 
 def test_model_performance(loaders, model, loader_name_list, epoch, loss_type):
@@ -201,9 +331,12 @@ def test_model_performance(loaders, model, loader_name_list, epoch, loss_type):
 
 def train_test_model(settings):
     
-    from .io import _save_settings, _copy_missclassified
-    from .utils import pick_best_model
-    from .core import generate_loaders
+    from .io import _copy_missclassified
+    from .utils import pick_best_model, save_settings
+    from .io import generate_loaders
+    from .settings import get_train_test_model_settings
+
+    settings = get_train_test_model_settings(settings)
 
     torch.cuda.empty_cache()
     torch.cuda.memory.empty_cache()
@@ -221,7 +354,12 @@ def train_test_model(settings):
         model = torch.load(settings['custom_model_path'])
     
     if settings['train']:
-        _save_settings(settings, src)
+        if settings['train'] and settings['test']:
+            save_settings(settings, name=f"train_test_{settings['model_type']}_{settings['epochs']}", show=True)
+        elif settings['train'] is True:
+            save_settings(settings, name=f"train_{settings['model_type']}_{settings['epochs']}", show=True)
+        elif settings['test'] is True:
+            save_settings(settings, name=f"test_{settings['model_type']}_{settings['epochs']}", show=True)
 
     if settings['train']:
         train, val, train_fig  = generate_loaders(src, 
@@ -235,7 +373,6 @@ def train_test_model(settings):
                                                   normalize=settings['normalize'],
                                                   channels=settings['train_channels'],
                                                   augment=settings['augment'],
-                                                  preload_batches=settings['preload_batches'],
                                                   verbose=settings['verbose'])
         
         #train_batch_1_figure = os.path.join(dst, 'batch_1.pdf')
@@ -264,19 +401,19 @@ def train_test_model(settings):
                                         channels=settings['train_channels'])
         
     if settings['test']:
-        test, _, plate_names_test, train_fig = generate_loaders(src, 
-                                                                mode='test', 
-                                                                image_size=settings['image_size'],
-                                                                batch_size=settings['batch_size'], 
-                                                                classes=settings['classes'], 
-                                                                n_jobs=settings['n_jobs'],
-                                                                validation_split=0.0,
-                                                                pin_memory=settings['pin_memory'],
-                                                                normalize=settings['normalize'],
-                                                                channels=settings['train_channels'],
-                                                                augment=False,
-                                                                preload_batches=settings['preload_batches'],
-                                                                verbose=settings['verbose'])
+        test, _, train_fig = generate_loaders(src, 
+                                              mode='test', 
+                                              image_size=settings['image_size'],
+                                              batch_size=settings['batch_size'], 
+                                              classes=settings['classes'], 
+                                              n_jobs=settings['n_jobs'],
+                                              validation_split=0.0,
+                                              pin_memory=settings['pin_memory'],
+                                              normalize=settings['normalize'],
+                                              channels=settings['train_channels'],
+                                              augment=False,
+                                              verbose=settings['verbose'])
+        
         if model == None:
             model_path = pick_best_model(src+'/model')
             print(f'Best model: {model_path}')
@@ -308,7 +445,10 @@ def train_test_model(settings):
     torch.cuda.memory.empty_cache()
     gc.collect()
 
-    return model_path
+    if settings['train']:
+        return model_path
+    if settings['test']:
+        return result_loc
     
 def train_model(dst, model_type, train_loaders, epochs=100, learning_rate=0.0001, weight_decay=0.05, amsgrad=False, optimizer_type='adamw', use_checkpoint=False, dropout_rate=0, n_jobs=20, val_loaders=None, test_loaders=None, init_weights='imagenet', intermedeate_save=None, chan_dict=None, schedule = None, loss_type='binary_cross_entropy_with_logits', gradient_accumulation=False, gradient_accumulation_steps=4, channels=['r','g','b'], verbose=False):
     """
@@ -355,11 +495,6 @@ def train_model(dst, model_type, train_loaders, epochs=100, learning_rate=0.0001
     
     kwargs = {'n_jobs': n_jobs, 'pin_memory': True} if use_cuda else {}
     
-    #for idx, (images, labels, filenames) in enumerate(train_loaders):
-    #    batch, chans, height, width = images.shape
-    #    break
-
-    
     model = choose_model(model_type, device, init_weights, dropout_rate, use_checkpoint, verbose=verbose)
     
     
@@ -452,19 +587,21 @@ def train_model(dst, model_type, train_loaders, epochs=100, learning_rate=0.0001
             if schedule == 'step_lr':
                 scheduler.step()
 
-        if epoch % 10 == 0 or epoch == epochs:
-            if accumulated_train_dicts:
-                train_df = pd.DataFrame(accumulated_train_dicts)
-                _save_progress(dst, train_df, result_type='train')
-                
-            if accumulated_val_dicts:
-                val_df = pd.DataFrame(accumulated_val_dicts)
-                _save_progress(dst, val_df,result_type='validation')
-                
-            if accumulated_test_dicts:
-                val_df = pd.DataFrame(accumulated_test_dicts)
-                _save_progress(dst, val_df, result_type='test')
-                
+        if accumulated_train_dicts and accumulated_val_dicts:
+            train_df = pd.DataFrame(accumulated_train_dicts)
+            validation_df = pd.DataFrame(accumulated_val_dicts)
+            _save_progress(dst, train_df, validation_df)
+            accumulated_train_dicts, accumulated_val_dicts = [], []
+
+        elif accumulated_train_dicts:
+            train_df = pd.DataFrame(accumulated_train_dicts)
+            _save_progress(dst, train_df, None)
+            accumulated_train_dicts = []
+        elif accumulated_test_dicts:
+            test_df = pd.DataFrame(accumulated_test_dicts)
+            _save_progress(dst, test_df, None)
+            accumulated_test_dicts = []
+            
         batch_size = len(train_loaders)
         duration = time.time() - start_time
         time_ls.append(duration)
@@ -473,133 +610,168 @@ def train_model(dst, model_type, train_loaders, epochs=100, learning_rate=0.0001
             
     return model, model_path
 
-def visualize_saliency_map(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'):
-
-    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
-
+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")
     
-    model = torch.load(model_path)
-    model.to(device)
+    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 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)
+    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
     
-    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)
+    # Set number of jobs for loading
+    n_jobs = settings['n_jobs']
+    if n_jobs is None:
+        n_jobs = max(1, cpu_count() - 4)
+
+    # Set transforms for images
+    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 not os.path.exists(settings['dataset']):
+        print(f"Dataset not found at {settings['dataset']}")
+        return
 
-        input_tensor = input_tensor.to(device)
-        cam = grad_cam(input_tensor)
-        cam_image = show_cam_on_image(np.array(image) / 255.0, cam)
+    # Load the model
+    model = torch.load(settings['model_path'])
+    model.to(device)
+    model.eval()
 
-        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()
+    # 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"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(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)
+
+        # 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) * 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")
 
-        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]}")
@@ -732,7 +904,7 @@ def visualize_smooth_grad(src, model_path, target_label_idx, image_size=224, cha
 
 def deep_spacr(settings={}):
     from .settings import deep_spacr_defaults
-    from .core import generate_training_dataset, generate_dataset, apply_model_to_tar
+    from .io import generate_training_dataset, generate_dataset
     from .utils import save_settings
     
     settings = deep_spacr_defaults(settings)

spacr/gui.py

@@ -48,6 +48,7 @@ class MainApp(tk.Tk):
         }
 
         self.additional_gui_apps = {
+            "Convert": (lambda frame: initiate_root(self, 'convert'), "Convert images to Grayscale TIFs."),
             "Umap": (lambda frame: initiate_root(self, 'umap'), "Generate UMAP embeddings with datapoints represented as images."),
             "Train Cellpose": (lambda frame: initiate_root(self, 'train_cellpose'), "Train custom Cellpose models."),
             "ML Analyze": (lambda frame: initiate_root(self, 'ml_analyze'), "Machine learning analysis of data."),
@@ -56,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.")
         }