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

spacr/deep_spacr.py

@@ -1,5 +1,4 @@
 import os, torch, time, gc, datetime
-
 torch.backends.cudnn.benchmark = True
 
 import numpy as np
@@ -8,15 +7,138 @@ 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 .logger import log_function_call
-from .utils import close_multiprocessing_processes, reset_mp
+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
+    
+    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 {settings['model_path']}")
+        print(f"Loading dataset from {settings['tar_path']}")
+        
+    model = torch.load(settings['model_path'])
+    
+    dataset = TarImageDataset(settings['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(settings['model_path']))[0] 
+    dataset_name = os.path.splitext(os.path.basename(settings['tar_path']))[0]  
+    date_name = datetime.date.today().strftime('%y%m%d')
+    dst = os.path.dirname(settings['tar_path'])
+    result_loc = f'{dst}/{date_name}_{dataset_name}_{model_name}_result.csv'
+
+    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):
     """
@@ -175,7 +297,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):
@@ -203,7 +325,10 @@ 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 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()
@@ -235,7 +360,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 +388,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 +432,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 +482,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)
     
     
@@ -732,7 +854,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."),

spacr/gui_core.py

@@ -1,9 +1,9 @@
-import traceback, ctypes, csv, re, platform, time
+import os, traceback, ctypes, csv, re, platform
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
 from multiprocessing import Process, Value, Queue, set_start_method
-from tkinter import ttk, scrolledtext
+from tkinter import ttk
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 import numpy as np
@@ -11,15 +11,13 @@ import psutil
 import GPUtil
 from collections import deque
 import tracemalloc
-from tkinter import Menu
-import io
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
 
-from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , spacrSlider, set_dark_style, standardize_figure
+from .gui_elements import spacrProgressBar, spacrButton, spacrFrame, spacrDropdownMenu , spacrSlider, set_dark_style
 
 # Define global variables
 q = None
@@ -35,6 +33,7 @@ figures = None
 figure_index = None
 progress_bar = None
 usage_bars = None
+index_control = None
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
@@ -170,39 +169,6 @@ def display_figure(fig):
             #flash_feedback("right")
             show_next_figure()
 
-    def zoom_v1(event):
-        nonlocal scale_factor
-
-        zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
-
-        # Adjust zoom factor based on the operating system and mouse event
-        if event.num == 4 or event.delta > 0:  # Scroll up
-            scale_factor *= (1 + zoom_speed)
-        elif event.num == 5 or event.delta < 0:  # Scroll down
-            scale_factor /= (1 + zoom_speed)
-
-        # Get mouse position relative to the figure
-        x_mouse, y_mouse = event.x, event.y
-        x_ratio = x_mouse / canvas_widget.winfo_width()
-        y_ratio = y_mouse / canvas_widget.winfo_height()
-
-        for ax in fig.get_axes():
-            xlim = ax.get_xlim()
-            ylim = ax.get_ylim()
-
-            # Calculate the new limits
-            x_center = xlim[0] + x_ratio * (xlim[1] - xlim[0])
-            y_center = ylim[0] + (1 - y_ratio) * (ylim[1] - ylim[0])
-
-            x_range = (xlim[1] - xlim[0]) * scale_factor
-            y_range = (ylim[1] - ylim[0]) * scale_factor
-
-            ax.set_xlim([x_center - x_range * x_ratio, x_center + x_range * (1 - x_ratio)])
-            ax.set_ylim([y_center - y_range * (1 - y_ratio), y_center + y_range * y_ratio])
-
-        # Redraw the figure
-        fig.canvas.draw_idle()
-
     def zoom(event):
         nonlocal scale_factor
 
@@ -282,7 +248,7 @@ def show_next_figure():
         figures.append(fig)
         figure_index += 1
         display_figure(fig)
-
+                       
 def process_fig_queue():
     global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index, index_control
 
@@ -329,44 +295,60 @@ def update_figure(value):
     index_control.set_to(len(figures) - 1)
     index_control.set(figure_index)
 
-def setup_plot_section(vertical_container):
+def setup_plot_section(vertical_container, settings_type):
     global canvas, canvas_widget, figures, figure_index, index_control
+    from .gui_utils import display_media_in_plot_frame
+
+    style_out = set_dark_style(ttk.Style())
+    bg = style_out['bg_color']
+    fg = style_out['fg_color']
 
     # Initialize deque for storing figures and the current index
     figures = deque()
 
     # Create a frame for the plot section
     plot_frame = tk.Frame(vertical_container)
+    plot_frame.configure(bg=bg)
     vertical_container.add(plot_frame, stretch="always")
 
-    # Set up the plot
+    # Clear the plot_frame (optional, to handle cases where it may already have content)
+    for widget in plot_frame.winfo_children():
+        widget.destroy()
+
+    # Create a figure and plot
     figure = Figure(figsize=(30, 4), dpi=100)
     plot = figure.add_subplot(111)
     plot.plot([], [])
     plot.axis('off')
+
+    if settings_type == 'map_barcodes':
+        # Load and display GIF
+        current_dir = os.path.dirname(__file__)
+        resources_path = os.path.join(current_dir, 'resources', 'icons')
+        gif_path = os.path.join(resources_path, 'dna_matrix.mp4')
+
+        display_media_in_plot_frame(gif_path, plot_frame)
+        canvas = FigureCanvasTkAgg(figure, master=plot_frame)
+        canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
+        canvas_widget = canvas.get_tk_widget()
+        return canvas, canvas_widget
     
     canvas = FigureCanvasTkAgg(figure, master=plot_frame)
     canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
     canvas_widget = canvas.get_tk_widget()
     canvas_widget.grid(row=0, column=0, sticky="nsew")
-
     plot_frame.grid_rowconfigure(0, weight=1)
     plot_frame.grid_columnconfigure(0, weight=1)
-
     canvas.draw()
-    canvas.figure = figure  # Ensure that the figure is linked to the canvas
-    style_out = set_dark_style(ttk.Style())
-    bg = style_out['bg_color']
-    fg = style_out['fg_color']
-
+    canvas.figure = figure
     figure.patch.set_facecolor(bg)
     plot.set_facecolor(bg)
     containers = [plot_frame]
 
     # Create slider
-    control_frame = tk.Frame(plot_frame, height=15*2,  bg=bg)  # Fixed height based on knob_radius
+    control_frame = tk.Frame(plot_frame, height=15*2,  bg=bg)
     control_frame.grid(row=1, column=0, sticky="ew", padx=10, pady=5)
-    control_frame.grid_propagate(False)  # Prevent the frame from resizing
+    control_frame.grid_propagate(False) 
 
     # Pass the update_figure function as the command to spacrSlider
     index_control = spacrSlider(control_frame, from_=0, to=0, value=0, thickness=2, knob_radius=10, position="center", show_index=True, command=update_figure)
@@ -442,6 +424,8 @@ def import_settings(settings_type='mask'):
         settings = get_analyze_recruitment_default_settings(settings={})
     elif settings_type == 'analyze_plaques':
         settings = {}
+    elif settings_type == 'convert':
+        settings = {}
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     
@@ -452,7 +436,8 @@ 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, 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 .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 .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
 
@@ -496,7 +481,9 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {}
+        settings = {'src':'path to images'}
+    elif settings_type == 'convert':
+        settings = {'src':'path to images'}
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
 
@@ -515,7 +502,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
 def setup_console(vertical_container):
     global console_output
     from .gui_elements import set_dark_style
-
+    
     # Apply dark style and get style output
     style = ttk.Style()
     style_out = set_dark_style(style)
@@ -546,9 +533,27 @@ def setup_console(vertical_container):
     def on_leave(event):
         top_border.config(bg=style_out['bg_color'])
 
+    #def on_enter_key(event):
+    #    user_input = console_output.get("1.0", "end-1c").strip()  # Get the user input from the console
+    #    if user_input:
+    #        # Print the user input with the (user) tag
+    #        console_output.insert("end", f"\n(user): {user_input}\n")
+    #        
+    #        # Get the AI response from the chatbot
+    #        response = chatbot.ask_question(user_input)
+    #        
+    #        # Print the AI response with the (ai) tag
+    #        console_output.insert("end", f"(ai): {response}\n")
+    #        
+    #        console_output.see("end")  # Scroll to the end
+    #        #console_output.delete("1.0", "end")  # Clear the input field
+    #    return "break"  # Prevent the default behavior of inserting a new line
+
     console_output.bind("<Enter>", on_enter)
     console_output.bind("<Leave>", on_leave)
 
+    #console_output.bind("<Return>", on_enter_key)
+
     return console_output, console_frame
 
 def setup_button_section(horizontal_container, settings_type='mask', run=True, abort=True, download=True, import_btn=True):
@@ -755,7 +760,7 @@ def initiate_abort():
 def start_process(q=None, fig_queue=None, settings_type='mask'):
     global thread_control, vars_dict, parent_frame
     from .settings import check_settings, expected_types
-    from .gui_utils import run_function_gui, set_high_priority, set_cpu_affinity, initialize_cuda
+    from .gui_utils import run_function_gui, set_cpu_affinity, initialize_cuda, display_gif_in_plot_frame, print_widget_structure
 
     if q is None:
         q = Queue()
@@ -778,16 +783,14 @@ 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', 'umap', 'measure', 'simulation', 'sequencing', 'classify', 'analyze_plaques', 
-                         'cellpose_dataset', 'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 'map_barcodes', 
-                         'regression', 'recruitment', 'cellpose_compare', 'vision_scores', 'vision_dataset']:
+                         'cellpose_dataset', 'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 
+                         'map_barcodes', 'regression', 'recruitment', 'cellpose_compare', 'vision_scores', 
+                         'vision_dataset', 'convert']:
 
         # Start the process
         process = Process(target=run_function_gui, args=process_args)
         process.start()
 
-        # Set high priority for the process
-        #set_high_priority(process)
-
         # Set CPU affinity if necessary
         set_cpu_affinity(process)
 
@@ -889,10 +892,14 @@ 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, uppdate_frequency, figures, figure_index, index_control, usage_bars
     
-    from .gui_utils import setup_frame
+    from .gui_utils import setup_frame, get_screen_dimensions
     from .settings import descriptions
+    #from .openai import Chatbot
 
     uppdate_frequency = 500
+    num_cores = os.cpu_count()
+
+    #chatbot = Chatbot(api_key="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")
 
     # Start tracemalloc and initialize global variables
     tracemalloc.start()
@@ -930,10 +937,14 @@ def initiate_root(parent, settings_type='mask'):
     else:
         scrollable_frame, vars_dict = setup_settings_panel(settings_container, settings_type)
         print('setup_settings_panel')
-        canvas, canvas_widget = setup_plot_section(vertical_container)
-        console_output, _ = setup_console(vertical_container)
+        canvas, canvas_widget = setup_plot_section(vertical_container, settings_type)
+        console_output, _ = setup_console(vertical_container) #, chatbot)
         button_scrollable_frame, btn_col = setup_button_section(horizontal_container, settings_type)
-        _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col, uppdate_frequency)
+        
+        if num_cores > 12:
+            _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col, uppdate_frequency)
+        else:
+            usage_bars = []
 
         set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, index_control, progress_bar, usage_bars)
         description_text = descriptions.get(settings_type, "No description available for this module.")