spacr 0.2.46__py3-none-any.whl → 0.2.56__py3-none-any.whl

spacr/deep_spacr.py

@@ -196,7 +196,7 @@ def test_model_performance(loaders, model, loader_name_list, epoch, train_mode,
     test_time = end_time - start_time
     return result, results_df
 
-def train_test_model(src, settings, custom_model=False, custom_model_path=None):
+def train_test_model(settings):
     
     from .io import _save_settings, _copy_missclassified
     from .utils import pick_best_model
@@ -208,7 +208,10 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
     gc.collect()
 
     settings = set_default_train_test_model(settings)
-    channels_str = ''.join(settings['channels'])
+
+    src = settings['src']
+
+    channels_str = ''.join(settings['train_channels'])
     dst = os.path.join(src,'model', settings['model_type'], channels_str, str(f"epochs_{settings['epochs']}"))
     os.makedirs(dst, exist_ok=True)
     settings['src'] = src
@@ -217,8 +220,8 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
     settings_csv = os.path.join(dst,'train_test_model_settings.csv')
     settings_df.to_csv(settings_csv, index=False)
     
-    if custom_model:
-        model = torch.load(custom_model_path)
+    if settings['custom_model']:
+        model = torch.load(settings['custom_model_path'])
     
     if settings['train']:
         _save_settings(settings, src)
@@ -234,7 +237,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                     validation_split=settings['val_split'],
                                                     pin_memory=settings['pin_memory'],
                                                     normalize=settings['normalize'],
-                                                    channels=settings['channels'],
+                                                    channels=settings['train_channels'],
                                                     augment=settings['augment'],
                                                     verbose=settings['verbose'])
         
@@ -242,28 +245,28 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
         train_fig.savefig(train_batch_1_figure, format='pdf', dpi=600)
     
     if settings['train']:
-        model = train_model(dst = settings['dst'],
-                            model_type=settings['model_type'],
-                            train_loaders = train, 
-                            train_loader_names = plate_names, 
-                            train_mode = settings['train_mode'], 
-                            epochs = settings['epochs'], 
-                            learning_rate = settings['learning_rate'],
-                            init_weights = settings['init_weights'],
-                            weight_decay = settings['weight_decay'], 
-                            amsgrad = settings['amsgrad'], 
-                            optimizer_type = settings['optimizer_type'], 
-                            use_checkpoint = settings['use_checkpoint'], 
-                            dropout_rate = settings['dropout_rate'], 
-                            n_jobs = settings['n_jobs'], 
-                            val_loaders = val, 
-                            test_loaders = None, 
-                            intermedeate_save = settings['intermedeate_save'],
-                            schedule = settings['schedule'],
-                            loss_type=settings['loss_type'], 
-                            gradient_accumulation=settings['gradient_accumulation'], 
-                            gradient_accumulation_steps=settings['gradient_accumulation_steps'],
-                            channels=settings['channels'])
+        model, model_path = train_model(dst = settings['dst'],
+                                        model_type=settings['model_type'],
+                                        train_loaders = train, 
+                                        train_loader_names = plate_names, 
+                                        train_mode = settings['train_mode'], 
+                                        epochs = settings['epochs'], 
+                                        learning_rate = settings['learning_rate'],
+                                        init_weights = settings['init_weights'],
+                                        weight_decay = settings['weight_decay'], 
+                                        amsgrad = settings['amsgrad'], 
+                                        optimizer_type = settings['optimizer_type'], 
+                                        use_checkpoint = settings['use_checkpoint'], 
+                                        dropout_rate = settings['dropout_rate'], 
+                                        n_jobs = settings['n_jobs'], 
+                                        val_loaders = val, 
+                                        test_loaders = None, 
+                                        intermedeate_save = settings['intermedeate_save'],
+                                        schedule = settings['schedule'],
+                                        loss_type=settings['loss_type'], 
+                                        gradient_accumulation=settings['gradient_accumulation'], 
+                                        gradient_accumulation_steps=settings['gradient_accumulation_steps'],
+                                        channels=settings['train_channels'])
         
         torch.cuda.empty_cache()
         torch.cuda.memory.empty_cache()
@@ -280,7 +283,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                      validation_split=0.0,
                                                      pin_memory=settings['pin_memory'],
                                                      normalize=settings['normalize'],
-                                                     channels=settings['channels'],
+                                                     channels=settings['train_channels'],
                                                      augment=False,
                                                      verbose=settings['verbose'])
         if model == None:
@@ -314,6 +317,8 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
     torch.cuda.empty_cache()
     torch.cuda.memory.empty_cache()
     gc.collect()
+
+    return model_path
     
 def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='erm', 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']):
     """
@@ -348,7 +353,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
     """    
     
     from .io import _save_model, _save_progress
-    from .utils import compute_irm_penalty, calculate_loss, choose_model
+    from .utils import compute_irm_penalty, calculate_loss, choose_model, print_progress
     
     print(f'Train batches:{len(train_loaders)}, Validation batches:{len(val_loaders)}')
     
@@ -386,6 +391,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
     else:
         scheduler = None
 
+    time_ls = []
     if train_mode == 'erm':
         for epoch in range(1, epochs+1):
             model.train()
@@ -412,7 +418,13 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
                     optimizer.zero_grad()
 
                 avg_loss = running_loss / batch_idx
-                print(f'\rTrain: epoch: {epoch} batch: {batch_idx}/{len(train_loaders)} avg_loss: {avg_loss:.5f} time: {(time.time()-start_time):.5f}', end='\r', flush=True)
+                #print(f'\rTrain: epoch: {epoch} batch: {batch_idx}/{len(train_loaders)} avg_loss: {avg_loss:.5f} time: {(time.time()-start_time):.5f}', end='\r', flush=True)
+                
+                batch_size = len(train_loaders)
+                duration = time.time() - start_time
+                time_ls.append(duration)
+                metricks = f"Loss: {avg_loss:.5f}"
+                print_progress(files_processed=epoch, files_to_process=epochs, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type=f"Training {model_type} model", metricks=metricks)
 
             end_time = time.time()
             train_time = end_time - start_time
@@ -421,6 +433,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
             train_names = 'train'
             results_df, train_test_time = evaluate_model_performance(train_loaders, model, train_names, epoch, train_mode='erm', loss_type=loss_type)
             train_metrics_df['train_test_time'] = train_test_time
+
             if val_loaders != None:
                 val_names = 'val'
                 result, val_time = evaluate_model_performance(val_loaders, model, val_names, epoch, train_mode='erm', loss_type=loss_type)
@@ -430,6 +443,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
                 
                 results_df = pd.concat([results_df, result])
                 train_metrics_df['val_time'] = val_time
+
             if test_loaders != None:
                 test_names = 'test'
                 result, test_test_time = evaluate_model_performance(test_loaders, model, test_names, epoch, train_mode='erm', loss_type=loss_type)
@@ -444,9 +458,30 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
                     scheduler.step()
             
             _save_progress(dst, results_df, train_metrics_df, epoch, epochs)
-            clear_output(wait=True)
-            display(results_df)
-            _save_model(model, model_type, results_df, dst, epoch, epochs, intermedeate_save=[0.99,0.98,0.95,0.94], channels=channels)
+            #clear_output(wait=True)
+            #display(results_df)
+
+            train_idx = f"{epoch}_train"
+            val_idx = f"{epoch}_val"
+            train_acc = results_df.loc[train_idx, 'accuracy']
+            neg_train_acc = results_df.loc[train_idx, 'neg_accuracy']
+            pos_train_acc = results_df.loc[train_idx, 'pos_accuracy']
+            val_acc = results_df.loc[val_idx, 'accuracy']
+            neg_val_acc = results_df.loc[val_idx, 'neg_accuracy']
+            pos_val_acc = results_df.loc[val_idx, 'pos_accuracy']
+            train_loss = results_df.loc[train_idx, 'loss']
+            train_prauc = results_df.loc[train_idx, 'prauc']
+            val_loss = results_df.loc[val_idx, 'loss']
+            val_prauc = results_df.loc[val_idx, 'prauc']
+
+            metricks = f"Train Acc: {train_acc:.5f} Val Acc: {val_acc:.5f} Train Loss: {train_loss:.5f} Val Loss: {val_loss:.5f} Train PRAUC: {train_prauc:.5f} Val PRAUC: {val_prauc:.5f}, Nc Train Acc: {neg_train_acc:.5f} Nc Val Acc: {neg_val_acc:.5f} Pc Train Acc: {pos_train_acc:.5f} Pc Val Acc: {pos_val_acc:.5f}"
+
+            batch_size = len(train_loaders)
+            duration = time.time() - start_time
+            time_ls.append(duration)
+            print_progress(files_processed=epoch, files_to_process=epochs, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type=f"Training {model_type} model", metricks=metricks)
+
+            model_path = _save_model(model, model_type, results_df, dst, epoch, epochs, intermedeate_save=[0.99,0.98,0.95,0.94], channels=channels)
             
     if train_mode == 'irm':
         dummy_w = torch.nn.Parameter(torch.Tensor([1.0])).to(device)
@@ -517,9 +552,10 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
             clear_output(wait=True)
             display(results_df)
             _save_progress(dst, results_df, train_metrics_df, epoch, epochs)
-            _save_model(model, model_type, results_df, dst, epoch, epochs, intermedeate_save=[0.99,0.98,0.95,0.94])
-            print(f'Saved model: {dst}')
-    return model
+            model_path = _save_model(model, model_type, results_df, dst, epoch, epochs, intermedeate_save=[0.99,0.98,0.95,0.94])
+            print(f'Saved model: {model_path}')
+    
+    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'):
 
@@ -778,8 +814,32 @@ def visualize_smooth_grad(src, model_path, target_label_idx, image_size=224, cha
             smooth_grad_image = Image.fromarray((smooth_grad_map * 255).astype(np.uint8))
             smooth_grad_image.save(os.path.join(save_dir, f'smooth_grad_{file}'))
 
-# Usage
-#src = '/path/to/images'
-#model_path = '/path/to/model.pth'
-#target_label_idx = 0  # Change this to the target class index
-#visualize_smooth_grad(src, model_path, target_label_idx)
+def deep_spacr(settings={}):
+    from .settings import deep_spacr_defaults
+    from .core import generate_training_dataset, generate_dataset, apply_model_to_tar
+    
+    settings = deep_spacr_defaults(settings)
+    src = settings['src']
+    
+    if settings['train'] or settings['test']:
+        if settings['generate_training_dataset']:
+            print(f"Generating train and test datasets ...")
+            train_path, test_path = generate_training_dataset(settings)
+            print(f'Generated Train set: {train_path}')
+            print(f'Generated Train set: {test_path}')
+            settings['src'] = os.path.dirname(train_path)
+    
+    if settings['train_DL_model']:
+        print(f"Training model ...")
+        model_path = train_test_model(settings)
+        settings['model_path'] = model_path
+        settings['src'] = src
+        
+    if settings['apply_model_to_dataset']:
+        if not os.path.exists(settings['tar_path']):
+            print(f"Generating dataset ...")
+            tar_path = generate_dataset(settings)
+            settings['tar_path'] = tar_path
+            
+        if os.path.exists(settings['model_path']):
+            apply_model_to_tar(settings)

spacr/gui.py

@@ -1,7 +1,5 @@
 import tkinter as tk
 from tkinter import ttk
-from PIL import Image, ImageTk, ImageDraw
-import os
 from multiprocessing import set_start_method
 from .gui_elements import spacrButton, create_menu_bar, set_dark_style
 from .gui_core import initiate_root
@@ -29,7 +27,7 @@ class MainApp(tk.Tk):
         }
 
         self.additional_gui_apps = {
-            "Sequencing": (lambda frame: initiate_root(self, 'sequencing'), "Analyze sequencing data."),
+            #"Sequencing": (lambda frame: initiate_root(self, 'sequencing'), "Analyze sequencing data."),
             "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."),

spacr/gui_core.py

@@ -1,23 +1,21 @@
-import os, traceback, ctypes, requests, csv, time, requests, re
+import traceback, ctypes, csv, re, time
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
 from multiprocessing import Process, Value, Queue, set_start_method
-from multiprocessing.sharedctypes import Synchronized
 from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 import numpy as np
 import psutil
 import GPUtil
-import tkinter.font as tkFont
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
 
-from .settings import set_default_train_test_model, get_measure_crop_settings, set_default_settings_preprocess_generate_masks, get_analyze_reads_default_settings, set_default_umap_image_settings
+from .settings import set_default_train_test_model, get_measure_crop_settings, set_default_settings_preprocess_generate_masks, set_default_generate_barecode_mapping, set_default_umap_image_settings
 from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style
 
 # Define global variables
@@ -45,13 +43,15 @@ def toggle_settings(button_scrollable_frame):
     def toggle_category(settings):
         for setting in settings:
             if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
+                label, widget, _, frame = vars_dict[setting]
                 if widget.grid_info():
                     label.grid_remove()
                     widget.grid_remove()
+                    frame.grid_remove()
                 else:
                     label.grid()
                     widget.grid()
+                    frame.grid()
 
     def on_category_select(selected_category):
         if selected_category == "Select Category":
@@ -81,15 +81,20 @@ def process_fig_queue():
 
     try:
         while not fig_queue.empty():
+            time.sleep(1)
             clear_canvas(canvas)
             fig = fig_queue.get_nowait()
+
             for ax in fig.get_axes():
                 ax.set_xticks([])  # Remove x-axis ticks
                 ax.set_yticks([])  # Remove y-axis ticks
                 ax.xaxis.set_visible(False)  # Hide the x-axis
                 ax.yaxis.set_visible(False)  # Hide the y-axis
-            fig.tight_layout()
+
+            # Adjust layout to minimize spacing between axes
+            fig.subplots_adjust(left=0, right=1, top=1, bottom=0, wspace=0.01, hspace=0.01)
             fig.set_facecolor('black')
+
             canvas.figure = fig
             fig_width, fig_height = canvas_widget.winfo_width(), canvas_widget.winfo_height()
             fig.set_size_inches(fig_width / fig.dpi, fig_height / fig.dpi, forward=True)
@@ -97,12 +102,9 @@ def process_fig_queue():
     except Exception as e:
         traceback.print_exc()
     finally:
-        after_id = canvas_widget.after(100, process_fig_queue)
+        after_id = canvas_widget.after(1, process_fig_queue)
         parent_frame.after_tasks.append(after_id)
 
-
-
-
 def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, progress_bar_var, usage_bars_var):
     global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, progress_bar, usage_bars
     thread_control = thread_control_var
@@ -120,7 +122,7 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_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
+    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
 
     def read_settings_from_csv(csv_file_path):
         settings = {}
@@ -156,7 +158,7 @@ def import_settings(settings_type='mask'):
     elif settings_type == 'classify':
         settings = set_default_train_test_model(settings={})
     elif settings_type == 'sequencing':
-        settings = get_analyze_reads_default_settings(settings={})
+        settings = set_default_generate_barecode_mapping(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
     else:
@@ -169,14 +171,15 @@ 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, set_default_train_test_model, get_analyze_reads_default_settings, set_default_umap_image_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
-    from .gui_utils import convert_settings_dict_for_gui, set_element_size
+    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, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .gui_utils import convert_settings_dict_for_gui
+    from .gui_elements import set_element_size
 
-    size_dict = set_element_size(vertical_container)
+    size_dict = set_element_size()
     settings_width = size_dict['settings_width']
 
     # Create a PanedWindow for the settings panel
-    settings_paned_window = tk.PanedWindow(vertical_container, orient=tk.HORIZONTAL)
+    settings_paned_window = tk.PanedWindow(vertical_container, orient=tk.HORIZONTAL, width=size_dict['settings_width'])
     vertical_container.add(settings_paned_window, stretch="always")
 
     settings_frame = tk.Frame(settings_paned_window, width=settings_width)
@@ -194,9 +197,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'measure':
         settings = get_measure_crop_settings(settings={})
     elif settings_type == 'classify':
-        settings = set_default_train_test_model(settings={})
-    elif settings_type == 'sequencing':
-        settings = get_analyze_reads_default_settings(settings={})
+        settings = deep_spacr_defaults(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
     elif settings_type == 'train_cellpose':
@@ -208,7 +209,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'cellpose_all':
         settings = get_check_cellpose_models_default_settings(settings={})
     elif settings_type == 'map_barcodes':
-        settings = get_map_barcodes_default_settings(settings={})
+        settings = set_default_generate_barecode_mapping(settings={})
     elif settings_type == 'regression':
         settings = get_perform_regression_default_settings(settings={})
     elif settings_type == 'recruitment':
@@ -230,8 +231,12 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
 
 def setup_plot_section(vertical_container):
     global canvas, canvas_widget
-    plot_frame = tk.PanedWindow(vertical_container, orient=tk.VERTICAL)
+
+    # Create a frame for the plot section
+    plot_frame = tk.Frame(vertical_container, bg='lightgrey')
     vertical_container.add(plot_frame, stretch="always")
+
+    # Set up the plot
     figure = Figure(figsize=(30, 4), dpi=100)
     plot = figure.add_subplot(111)
     plot.plot([], [])  # This creates an empty plot.
@@ -239,7 +244,11 @@ def setup_plot_section(vertical_container):
     canvas = FigureCanvasTkAgg(figure, master=plot_frame)
     canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
     canvas_widget = canvas.get_tk_widget()
-    plot_frame.add(canvas_widget, stretch="always")
+    canvas_widget.grid(row=0, column=0, sticky="nsew")  # Use grid for the canvas widget
+
+    plot_frame.grid_rowconfigure(0, weight=1)
+    plot_frame.grid_columnconfigure(0, weight=1)
+
     canvas.draw()
     canvas.figure = figure
     style_out = set_dark_style(ttk.Style())
@@ -250,6 +259,7 @@ def setup_plot_section(vertical_container):
     widgets = [canvas_widget]
     style = ttk.Style(vertical_container)
     _ = set_dark_style(style, containers=containers, widgets=widgets)
+
     return canvas, canvas_widget
 
 def setup_console(vertical_container):
@@ -260,46 +270,47 @@ def setup_console(vertical_container):
     style = ttk.Style()
     style_out = set_dark_style(style)
 
-    # Create a PanedWindow to hold the main content and console sections
-    main_paned_window = tk.PanedWindow(vertical_container, orient=tk.VERTICAL, bg=style_out['bg_color'])
-    vertical_container.add(main_paned_window, stretch="always")
+    # Create a frame for the console section
+    console_frame = tk.Frame(vertical_container, bg=style_out['bg_color'])
+    vertical_container.add(console_frame, stretch="always")
 
-    # Create the main content frame
-    main_content_frame = tk.Frame(main_paned_window, bg=style_out['bg_color'])
-    main_paned_window.add(main_content_frame, stretch="always")
-
-    # Create a frame to hold the console and button sections
-    console_button_frame = tk.Frame(main_paned_window, bg=style_out['bg_color'])
-    main_paned_window.add(console_button_frame, stretch="always")
-
-    # Create the main console frame
-    console_frame = tk.Frame(console_button_frame, bg=style_out['bg_color'])
-    console_frame.pack(fill=tk.BOTH, expand=True)
+    # Create a thicker frame at the top for the hover effect
+    top_border = tk.Frame(console_frame, height=5, bg=style_out['bg_color'])
+    top_border.grid(row=0, column=0, sticky="ew", pady=(0, 2))
 
     # Create the scrollable frame (which is a Text widget) with white text
     family = style_out['font_family']
-    size = style_out['font_size'] -2
-    font = tkFont.Font(family=family, size=size)
-    console_output = tk.Text(console_frame, bg=style_out['bg_color'], fg=style_out['fg_color'], font=font)
-    console_output.pack(fill=tk.BOTH, expand=True)
+    font_size = style_out['font_size'] - 2
+    font_loader = style_out['font_loader']
+    console_output = tk.Text(console_frame, bg=style_out['bg_color'], fg=style_out['fg_color'], font=font_loader.get_font(size=font_size), bd=0, highlightthickness=0)
+    
+    console_output.grid(row=1, column=0, sticky="nsew")  # Use grid for console_output
 
     # Configure the grid to allow expansion
-    console_frame.grid_rowconfigure(0, weight=1)
+    console_frame.grid_rowconfigure(1, weight=1)
     console_frame.grid_columnconfigure(0, weight=1)
 
-    # Create a lower frame to act as the anchor point
-    lower_frame = tk.Frame(console_button_frame, bg=style_out['bg_color'])
-    lower_frame.pack(fill=tk.X, expand=False)
+    def on_enter(event):
+        top_border.config(bg=style_out['active_color'])
+
+    def on_leave(event):
+        top_border.config(bg=style_out['bg_color'])
+
+    console_output.bind("<Enter>", on_enter)
+    console_output.bind("<Leave>", on_leave)
 
     return console_output, console_frame
 
 def setup_progress_frame(vertical_container):
     global progress_output
+    style_out = set_dark_style(ttk.Style())
+    font_loader = style_out['font_loader']
+    font_size = style_out['font_size']
     progress_frame = tk.Frame(vertical_container)
     vertical_container.add(progress_frame, stretch="always")
     label_frame = tk.Frame(progress_frame)
     label_frame.grid(row=0, column=0, sticky="ew", pady=(5, 0), padx=10)
-    progress_label = spacrLabel(label_frame, text="Processing: 0%", font=('Helvetica', 12), anchor='w', justify='left', align="left")
+    progress_label = spacrLabel(label_frame, text="Processing: 0%", font=font_loader.get_font(size=font_size), anchor='w', justify='left', align="left")
     progress_label.grid(row=0, column=0, sticky="w")
     progress_output = scrolledtext.ScrolledText(progress_frame, height=10)
     progress_output.grid(row=1, column=0, sticky="nsew")
@@ -313,10 +324,10 @@ def setup_progress_frame(vertical_container):
 
 def setup_button_section(horizontal_container, settings_type='mask', run=True, abort=True, download=True, import_btn=True):
     global thread_control, parent_frame, button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict, progress_bar
-    from .gui_utils import set_element_size, download_hug_dataset
-    from .settings import categories
+    from .gui_utils import download_hug_dataset
+    from .gui_elements import set_element_size
 
-    size_dict = set_element_size(horizontal_container)
+    size_dict = set_element_size()
     button_section_height = size_dict['panel_height']
     button_frame = tk.Frame(horizontal_container, height=button_section_height)
     
@@ -337,7 +348,7 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
         widgets.append(run_button)
         btn_col += 1
 
-    if abort and settings_type in ['mask', 'measure', 'classify', 'sequencing', 'umap']:
+    if abort and settings_type in ['mask', 'measure', 'classify', 'sequencing', 'umap', 'map_barcodes']:
         abort_button = spacrButton(button_scrollable_frame.scrollable_frame, text="abort", command=lambda: initiate_abort(), show_text=False, size=size_dict['btn_size'], animation=False)
         abort_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
         widgets.append(abort_button)
@@ -357,7 +368,7 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
 
     # Add the progress bar under the settings category menu
     progress_bar = spacrProgressBar(button_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate')
-    progress_bar.grid(row=btn_row, column=0, columnspan=6, pady=5, padx=5, sticky='ew')
+    progress_bar.grid(row=btn_row, column=0, columnspan=7, pady=5, padx=5, sticky='ew')
     progress_bar.set_label_position()  # Set the label position after grid placement
     widgets.append(progress_bar)
 
@@ -371,8 +382,7 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
 
 def setup_usage_panel(horizontal_container, btn_col):
     global usage_bars
-    from .gui_utils import set_element_size
-    from .gui_elements import set_dark_style
+    from .gui_elements import set_dark_style, set_element_size
 
     usg_col = 1
 
@@ -398,7 +408,7 @@ def setup_usage_panel(horizontal_container, btn_col):
         # Schedule the function to run again after 1000 ms (1 second)
         parent_frame.after(1000, update_usage, ram_bar, vram_bar, gpu_bar, usage_bars, parent_frame)
 
-    size_dict = set_element_size(horizontal_container)
+    size_dict = set_element_size()
     usage_panel_height = size_dict['panel_height']
     usage_frame = tk.Frame(horizontal_container, height=usage_panel_height)
     horizontal_container.add(usage_frame)
@@ -413,7 +423,7 @@ def setup_usage_panel(horizontal_container, btn_col):
     widgets = [usage_scrollable_frame.scrollable_frame]
     
     usage_bars = []
-    max_elements_per_column = 6
+    max_elements_per_column = 4
     row = 0
     col = 0
 
@@ -423,9 +433,9 @@ def setup_usage_panel(horizontal_container, btn_col):
     # Configure the style for the label
     style = ttk.Style()
     style_out = set_dark_style(style)
-    size = style_out['font_size'] - 2
-    usage_font = tkFont.Font(family=style_out['font_family'], size=size)
-    style.configure("usage.TLabel", font=usage_font, foreground=style_out['fg_color'])
+    font_loader = style_out['font_loader']
+    font_size = style_out['font_size'] - 2
+    style.configure("usage.TLabel", font=font_loader.get_font(size=font_size), foreground=style_out['fg_color'])
 
     # Try adding RAM bar
     try:
@@ -525,7 +535,6 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
         q = Queue()
     if fig_queue is None:
         fig_queue = Queue()
-
     try:
         settings = check_settings(vars_dict, expected_types, q)
     except ValueError as e:
@@ -540,7 +549,7 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
 
     process_args = (settings_type, settings, q, fig_queue, stop_requested)
     if settings_type in [
-        'mask', 'measure', 'simulation', 'sequencing', 'classify', 'cellpose_dataset', 
+        'mask', 'umap', 'measure', 'simulation', 'sequencing', 'classify', 'cellpose_dataset', 
         'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 'map_barcodes', 
         'regression', 'recruitment', 'plaques', 'cellpose_compare', 'vision_scores', 
         'vision_dataset'
@@ -573,7 +582,7 @@ def process_console_queue():
             try:
                 # Extract the progress information
                 match = re.search(r'Progress: (\d+)/(\d+), operation_type: ([\w\s]*)(.*)', clean_message)
-                print('match', match)
+
                 if match:
                     current_progress = int(match.group(1))
                     total_progress = int(match.group(2))
@@ -622,14 +631,18 @@ def process_console_queue():
 
             except Exception as e:
                 print(f"Error parsing progress message: {e}")
-
-    after_id = console_output.after(10, process_console_queue)
+        #else:
+        #    # Only insert messages that do not start with "Progress:"
+        #    console_output.insert(tk.END, clean_message + "\n")
+        #    console_output.see(tk.END)
+        
+    after_id = console_output.after(1, process_console_queue)
     parent_frame.after_tasks.append(after_id)
 
+
 def initiate_root(parent, settings_type='mask'):
     global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar
-    from .gui_utils import main_thread_update_function, setup_frame, set_element_size
-    from .gui import gui_app
+    from .gui_utils import main_thread_update_function, setup_frame
     from .settings import descriptions
 
     set_start_method('spawn', force=True)
@@ -678,4 +691,4 @@ def initiate_root(parent, settings_type='mask'):
         parent_window.after_tasks.append(after_id)
 
     print("Root initialization complete")
-    return parent_frame, vars_dict
+    return parent_frame, vars_dict