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

spacr/plot.py

@@ -16,8 +16,9 @@ from skimage.measure import find_contours, label, regionprops
 
 from scipy.stats import normaltest, ttest_ind, mannwhitneyu, f_oneway, kruskal
 from statsmodels.stats.multicomp import pairwise_tukeyhsd
+from scipy.stats import ttest_ind, mannwhitneyu, levene, wilcoxon, kruskal
 import itertools
-
+import pingouin as pg
 
 from ipywidgets import IntSlider, interact
 from IPython.display import Image as ipyimage
@@ -1002,8 +1003,107 @@ def _display_gif(path):
     """
     with open(path, 'rb') as file:
         display(ipyimage(file.read()))
+
+def _plot_recruitment_v2(df, df_type, channel_of_interest, columns=[], figuresize=10):
+    """
+    Plot recruitment data for different conditions and pathogens.
+
+    Args:
+        df (DataFrame): The input DataFrame containing the recruitment data.
+        df_type (str): The type of DataFrame (e.g., 'train', 'test').
+        channel_of_interest (str): The channel of interest for plotting.
+        target (str): The target variable for plotting.
+        columns (list, optional): Additional columns to plot. Defaults to an empty list.
+        figuresize (int, optional): The size of the figure. Defaults to 50.
+
+    Returns:
+        None
+    """
+
+    from .plot import spacrGraph
+
+    color_list = [(55/255, 155/255, 155/255), 
+                  (155/255, 55/255, 155/255), 
+                  (55/255, 155/255, 255/255), 
+                  (255/255, 55/255, 155/255)]
+
+    sns.set_palette(sns.color_palette(color_list))
+    font = figuresize/2
+    width=figuresize
+    height=figuresize/4
+
+    # Create the subplots
+    fig, axes = plt.subplots(nrows=1, ncols=4, figsize=(width, height))
+
+    # Plot for 'cell_channel' on axes[0]
+    plotter_cell = spacrGraph(df,grouping_column='condition', data_column=f'cell_channel_{channel_of_interest}_mean_intensity')
+    plotter_cell.create_plot(ax=axes[0])
+    axes[0].set_xlabel(f'pathogen {df_type}', fontsize=font)
+    axes[0].set_ylabel(f'cell_channel_{channel_of_interest}_mean_intensity', fontsize=font)
+
+    # Plot for 'nucleus_channel' on axes[1]
+    plotter_nucleus = spacrGraph(df,grouping_column='condition', data_column=f'nucleus_channel_{channel_of_interest}_mean_intensity')
+    plotter_nucleus.create_plot(ax=axes[1])
+    axes[1].set_xlabel(f'pathogen {df_type}', fontsize=font)
+    axes[1].set_ylabel(f'nucleus_channel_{channel_of_interest}_mean_intensity', fontsize=font)
+
+    # Plot for 'cytoplasm_channel' on axes[2]
+    plotter_cytoplasm = spacrGraph(df, grouping_column='condition', data_column=f'cytoplasm_channel_{channel_of_interest}_mean_intensity')
+    plotter_cytoplasm.create_plot(ax=axes[2])
+    axes[2].set_xlabel(f'pathogen {df_type}', fontsize=font)
+    axes[2].set_ylabel(f'cytoplasm_channel_{channel_of_interest}_mean_intensity', fontsize=font)
+
+    # Plot for 'pathogen_channel' on axes[3]
+    plotter_pathogen = spacrGraph(df, grouping_column='condition', data_column=f'pathogen_channel_{channel_of_interest}_mean_intensity')
+    plotter_pathogen.create_plot(ax=axes[3])
+    axes[3].set_xlabel(f'pathogen {df_type}', fontsize=font)
+    axes[3].set_ylabel(f'pathogen_channel_{channel_of_interest}_mean_intensity', fontsize=font)
+
+    #axes[0].legend_.remove()
+    #axes[1].legend_.remove()
+    #axes[2].legend_.remove()
+    #axes[3].legend_.remove()
+
+    handles, labels = axes[3].get_legend_handles_labels()
+    axes[3].legend(handles, labels, bbox_to_anchor=(1.05, 0.5), loc='center left')
+    for i in [0,1,2,3]:
+        axes[i].tick_params(axis='both', which='major', labelsize=font)
+        axes[i].set_xticklabels(axes[i].get_xticklabels(), rotation=45)
+
+    plt.tight_layout()
+    plt.show()
+
+    columns = columns + ['pathogen_cytoplasm_mean_mean', 'pathogen_cytoplasm_q75_mean', 'pathogen_periphery_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_q75_mean']
+    #columns = columns + [f'pathogen_slope_channel_{channel_of_interest}', f'pathogen_cell_distance_channel_{channel_of_interest}', f'nucleus_cell_distance_channel_{channel_of_interest}']
+
+    width = figuresize*2
+    columns_per_row = math.ceil(len(columns) / 2)
+    height = (figuresize*2)/columns_per_row
+
+    fig, axes = plt.subplots(nrows=2, ncols=columns_per_row, figsize=(width, height * 2))
+    axes = axes.flatten()
+
+    print(f'{columns}')
+    for i, col in enumerate(columns):
+        ax = axes[i]
+        plotter_col = spacrGraph(df, grouping_column='condition', data_column=col)
+        plotter_col.create_plot(ax=ax)
+        ax.set_xlabel(f'pathogen {df_type}', fontsize=font)
+        ax.set_ylabel(f'{col}', fontsize=int(font * 2))
+        #ax.legend_.remove()
+        ax.tick_params(axis='both', which='major', labelsize=font)
+        ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
+        if i <= 5:
+            ax.set_ylim(1, None)
+
+    # Turn off any unused axes
+    for i in range(len(columns), len(axes)):
+        axes[i].axis('off')
+
+    plt.tight_layout()
+    plt.show()
         
-def _plot_recruitment(df, df_type, channel_of_interest, target, columns=[], figuresize=10):
+def _plot_recruitment(df, df_type, channel_of_interest, columns=[], figuresize=10):
     """
     Plot recruitment data for different conditions and pathogens.
 
@@ -1156,10 +1256,6 @@ def _plot_controls(df, mask_chans, channel_of_interest, figuresize=5):
     plt.tight_layout()
     plt.show()
 
-###################################################
-#  Classify
-###################################################
-
 def _imshow(img, labels, nrow=20, color='white', fontsize=12):
     """
     Display multiple images in a grid with corresponding labels.
@@ -1997,4 +2093,330 @@ def create_grouped_plot(df, grouping_column, data_column, graph_type='bar', summ
     # Show the plot
     plt.show()
 
-    return plt.gcf(), results_df
+    return plt.gcf(), results_df
+    
+class spacrGraph:
+    def __init__(self, df, grouping_column, data_column, graph_type='bar', summary_func='mean', 
+                 order=None, colors=None, output_dir='./output', save=False, y_axis_start=None, 
+                 error_bar_type='std', remove_outliers=False, theme='pastel', representation='object',
+                 paired=False, all_to_all=True, compare_group=None):
+        """
+        Class for creating grouped plots with optional statistical tests and data preprocessing.
+        """
+        self.df = df
+        self.grouping_column = grouping_column
+        self.data_column = data_column
+        self.graph_type = graph_type
+        self.summary_func = summary_func
+        self.order = order
+        self.colors = colors
+        self.output_dir = output_dir
+        self.save = save
+        self.y_axis_start = y_axis_start
+        self.error_bar_type = error_bar_type
+        self.remove_outliers = remove_outliers
+        self.theme = theme
+        self.representation = representation
+        self.paired = paired
+        self.all_to_all = all_to_all
+        self.compare_group = compare_group
+
+        self.results_df = pd.DataFrame()
+        self.sns_palette = None
+        self.fig = None  # To store the generated figure
+        
+        # Preprocess and set palette
+        self._set_theme()
+        self.raw_df = self.df.copy()  # Preserve the raw data for n_object count
+        self.df = self.preprocess_data()
+        
+    def _set_theme(self):
+        """Set the Seaborn theme and reorder colors if necessary."""
+        integer_list = list(range(1, 81))
+        color_order = [0, 3, 9, 4, 6, 7, 9, 2] + integer_list
+        self.sns_palette = self._set_reordered_theme(self.theme, color_order, 100)
+
+    def _set_reordered_theme(self, theme='muted', order=None, n_colors=100, show_theme=False):
+        """Set and reorder the Seaborn color palette."""
+        palette = sns.color_palette(theme, n_colors)
+        if order:
+            reordered_palette = [palette[i] for i in order]
+        else:
+            reordered_palette = palette
+        if show_theme:
+            sns.palplot(reordered_palette)
+            plt.show()
+        return reordered_palette
+
+    def preprocess_data(self):
+        """Preprocess the data: remove NaNs, sort/order the grouping column, and optionally group by 'prc'."""
+        df = self.df.dropna(subset=[self.grouping_column, self.data_column])
+
+        # Group by 'prc' column if representation is 'well'
+        if self.representation == 'well':
+            df = df.groupby(['prc', self.grouping_column])[self.data_column].agg(self.summary_func).reset_index()
+
+        if self.order:
+            df[self.grouping_column] = pd.Categorical(df[self.grouping_column], categories=self.order, ordered=True)
+        else:
+            df[self.grouping_column] = pd.Categorical(df[self.grouping_column], categories=sorted(df[self.grouping_column].unique()), ordered=True)
+        
+        return df
+
+    def remove_outliers_from_plot(self):
+        """Remove outliers from the plot but keep them in the data."""
+        filtered_df = self.df.copy()
+        unique_groups = filtered_df[self.grouping_column].unique()
+        for group in unique_groups:
+            group_data = filtered_df[filtered_df[self.grouping_column] == group][self.data_column]
+            q1 = group_data.quantile(0.25)
+            q3 = group_data.quantile(0.75)
+            iqr = q3 - q1
+            lower_bound = q1 - 1.5 * iqr
+            upper_bound = q3 + 1.5 * iqr
+            filtered_df = filtered_df.drop(filtered_df[(filtered_df[self.grouping_column] == group) & ((filtered_df[self.data_column] < lower_bound) | (filtered_df[self.data_column] > upper_bound))].index)
+        return filtered_df
+
+    def perform_normality_tests(self):
+        """Perform normality tests for each group."""
+        unique_groups = self.df[self.grouping_column].unique()
+        grouped_data = [self.df.loc[self.df[self.grouping_column] == group, self.data_column] for group in unique_groups]
+        raw_grouped_data = [self.raw_df.loc[self.raw_df[self.grouping_column] == group, self.data_column] for group in unique_groups]
+        
+        normal_p_values = [normaltest(data).pvalue for data in grouped_data]
+        normal_stats = [normaltest(data).statistic for data in grouped_data]
+        is_normal = all(p > 0.05 for p in normal_p_values)
+
+        test_results = []
+        for group, stat, p_value in zip(unique_groups, normal_stats, normal_p_values):
+            test_results.append({
+                'Comparison': f'Normality test for {group}',
+                'Test Statistic': stat,
+                'p-value': p_value,
+                'Test Name': 'Normality test',
+                'n_object': len(raw_grouped_data[unique_groups.tolist().index(group)]),  # Raw sample size (objects/cells)
+                'n_well': len(grouped_data[unique_groups.tolist().index(group)]) if self.representation == 'well' else np.nan  # Summarized size (wells)
+            })
+        return is_normal, test_results
+
+    def perform_levene_test(self, unique_groups):
+        """Perform Levene's test for equal variance."""
+        grouped_data = [self.df.loc[self.df[self.grouping_column] == group, self.data_column] for group in unique_groups]
+        stat, p_value = levene(*grouped_data)
+        return stat, p_value
+
+    def perform_statistical_tests(self, unique_groups, is_normal):
+        """Perform statistical tests based on the number of groups, normality, and paired flag."""
+        if len(unique_groups) == 2:
+            if is_normal:
+                if self.paired:
+                    stat_test = pg.ttest  # Paired T-test
+                    test_name = 'Paired T-test'
+                else:
+                    stat_test = ttest_ind
+                    test_name = 'T-test'
+            else:
+                if self.paired:
+                    stat_test = pg.wilcoxon  # Paired Wilcoxon test
+                    test_name = 'Paired Wilcoxon test'
+                else:
+                    stat_test = mannwhitneyu
+                    test_name = 'Mann-Whitney U test'
+        else:
+            if is_normal:
+                stat_test = f_oneway
+                test_name = 'One-way ANOVA'
+            else:
+                stat_test = kruskal
+                test_name = 'Kruskal-Wallis test'
+
+        comparisons = list(itertools.combinations(unique_groups, 2))
+        test_results = []
+        for (group1, group2) in comparisons:
+            data1 = self.df[self.df[self.grouping_column] == group1][self.data_column]
+            data2 = self.df[self.df[self.grouping_column] == group2][self.data_column]
+            raw_data1 = self.raw_df[self.raw_df[self.grouping_column] == group1][self.data_column]
+            raw_data2 = self.raw_df[self.raw_df[self.grouping_column] == group2][self.data_column]
+            
+            if self.paired:
+                stat, p = stat_test(data1, data2, paired=True)
+            else:
+                stat, p = stat_test(data1, data2)
+
+            test_results.append({
+                'Comparison': f'{group1} vs {group2}',
+                'Test Statistic': stat,
+                'p-value': p,
+                'Test Name': test_name,
+                'n_object': len(raw_data1) + len(raw_data2),  # Raw sample size (objects/cells)
+                'n_well': len(data1) + len(data2) if self.representation == 'well' else np.nan  # Summarized size (wells)
+            })
+        return test_results
+
+    def perform_posthoc_tests(self, is_normal, unique_groups):
+        """Perform post-hoc tests for multiple groups based on all_to_all flag."""
+        if is_normal and len(unique_groups) > 2 and self.all_to_all:
+            # Tukey HSD Post-hoc when comparing all to all
+            tukey_result = pairwise_tukeyhsd(self.df[self.data_column], self.df[self.grouping_column], alpha=0.05)
+            posthoc_results = []
+            for comparison, p_value in zip(tukey_result._results_table.data[1:], tukey_result.pvalues):
+                raw_data1 = self.raw_df[self.raw_df[self.grouping_column] == comparison[0]][self.data_column]
+                raw_data2 = self.raw_df[self.raw_df[self.grouping_column] == comparison[1]][self.data_column]
+
+                posthoc_results.append({
+                    'Comparison': f'{comparison[0]} vs {comparison[1]}',
+                    'Test Statistic': None,  # Tukey does not provide a test statistic
+                    'p-value': p_value,
+                    'Test Name': 'Tukey HSD Post-hoc',
+                    'n_object': len(raw_data1) + len(raw_data2),
+                    'n_well': len(self.df[self.df[self.grouping_column] == comparison[0]]) + len(self.df[self.df[self.grouping_column] == comparison[1]])
+                })
+            return posthoc_results
+       
+        elif len(unique_groups) > 2 and not self.all_to_all and self.compare_group:
+            # Dunn's post-hoc test using Pingouin
+            dunn_result = pg.pairwise_tests(data=self.df, dv=self.data_column, between=self.grouping_column, padjust='bonf', test='dunn')
+            posthoc_results = []
+            for idx, row in dunn_result.iterrows():
+                if row['A'] == self.compare_group or row['B'] == self.compare_group:
+                    posthoc_results.append({
+                        'Comparison': f"{row['A']} vs {row['B']}",
+                        'Test Statistic': row['T'],  # Test statistic from Dunn's test
+                        'p-value': row['p-val'],
+                        'Test Name': 'Dunn’s Post-hoc',
+                        'n_object': None,
+                        'n_well': None
+                    })
+            return posthoc_results
+        return []
+
+    def create_plot(self, ax=None):
+        """Create and display the plot based on the chosen graph type."""
+        # Optional: Remove outliers for plotting
+        if self.remove_outliers:
+            self.df = self.remove_outliers_from_plot()
+
+        # Perform normality tests
+        is_normal, normality_results = self.perform_normality_tests()
+
+        # Perform Levene's test for equal variance
+        unique_groups = self.df[self.grouping_column].unique()
+        levene_stat, levene_p = self.perform_levene_test(unique_groups)
+        levene_result = {
+            'Comparison': 'Levene’s test for equal variance',
+            'Test Statistic': levene_stat,
+            'p-value': levene_p,
+            'Test Name': 'Levene’s Test'
+        }
+
+        # Perform statistical tests
+        stat_results = self.perform_statistical_tests(unique_groups, is_normal)
+
+        # Perform post-hoc tests if applicable
+        posthoc_results = self.perform_posthoc_tests(is_normal, unique_groups)
+
+        # Combine all test results
+        self.results_df = pd.DataFrame(normality_results + [levene_result] + stat_results + posthoc_results)
+
+        # Add sample size column
+        sample_sizes = self.df.groupby(self.grouping_column)[self.data_column].count().reset_index(name='n')
+        self.results_df['n'] = self.results_df['Comparison'].apply(
+            lambda x: next((sample_sizes[sample_sizes[self.grouping_column] == g]['n'].values[0] for g in sample_sizes[self.grouping_column] if g in x), np.nan)
+        )
+
+        # Dynamically set figure dimensions based on the number of unique groups
+        num_groups = len(unique_groups)
+        bar_width = 0.6  # Set the desired thickness of each bar
+        spacing_between_groups = 0.3  # Set the desired spacing between bars and axis
+
+        fig_width = num_groups * (bar_width + spacing_between_groups)  # Dynamically calculate the figure width
+        fig_height = 6  # Fixed height for the plot
+
+        if ax is None:
+            self.fig, ax = plt.subplots(figsize=(fig_width, fig_height))  # Store the figure in self.fig
+        else:
+            self.fig = ax.figure  # Store the figure if ax is provided
+
+        sns.set(style="ticks")
+        color_palette = self.sns_palette if not self.colors else self.colors
+
+        # Calculate x-axis limits to ensure equal space between the bars and the y-axis
+        xlim_lower = -0.5  # Ensures space between the y-axis and the first category
+        xlim_upper = num_groups - 0.5  # Ensures space after the last category
+        ax.set_xlim(xlim_lower, xlim_upper)
+
+        if self.summary_func is None:
+            sns.stripplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=color_palette, jitter=True, alpha=0.6, ax=ax)
+        elif self.graph_type == 'bar':
+            self._create_bar_plot(bar_width, ax)
+        elif self.graph_type == 'box':
+            self._create_box_plot(ax)
+        elif self.graph_type == 'violin':
+            self._create_violin_plot(ax)
+        elif self.graph_type == 'jitter':
+            self._create_jitter_plot(ax)
+        else:
+            raise ValueError(f"Invalid graph_type: {self.graph_type}. Choose from 'bar', 'box', 'violin', or 'jitter'.")
+
+        # Set y-axis start
+        if self.y_axis_start is not None:
+            ax.set_ylim(bottom=self.y_axis_start)
+
+        # Add ticks, remove grid, and save plot
+        ax.minorticks_on()
+        ax.tick_params(axis='x', which='minor', bottom=False)  # Disable minor ticks on x-axis
+        ax.tick_params(axis='x', which='major', length=6, width=2, direction='out')
+        ax.tick_params(axis='y', which='major', length=6, width=2, direction='out')
+        ax.tick_params(axis='y', which='minor', length=4, width=1, direction='out')
+        sns.despine(ax=ax, top=True, right=True)
+
+        if self.save:
+            self._save_results()
+
+        plt.show()  # Ensure the plot is shown, but plt.show() doesn't clear the figure context
+
+    def get_figure(self):
+        """Return the generated figure."""
+        return self.fig
+
+    def _create_bar_plot(self, bar_width, ax):
+        """Helper method to create a bar plot with consistent bar thickness and centered error bars."""
+        summary_df = self.df.groupby(self.grouping_column)[self.data_column].agg([self.summary_func, 'std', 'sem'])
+
+        if self.error_bar_type == 'std':
+            error_bars = summary_df['std']
+        elif self.error_bar_type == 'sem':
+            error_bars = summary_df['sem']
+        else:
+            raise ValueError(f"Invalid error_bar_type: {self.error_bar_type}. Choose either 'std' or 'sem'.")
+
+        sns.barplot(x=self.grouping_column, y=self.summary_func, data=summary_df.reset_index(), ci=None, palette=self.sns_palette, width=bar_width, ax=ax)
+
+        # Plot the error bars
+        ax.errorbar(x=np.arange(len(summary_df)), y=summary_df[self.summary_func], yerr=error_bars, fmt='none', c='black', capsize=5)
+
+    def _create_jitter_plot(self, ax):
+        """Helper method to create a jitter plot (strip plot)."""
+        sns.stripplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=self.sns_palette, jitter=True, alpha=0.6, ax=ax)
+
+    def _create_box_plot(self, ax):
+        """Helper method to create a box plot."""
+        sns.boxplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=self.sns_palette, ax=ax)
+
+    def _create_violin_plot(self, ax):
+        """Helper method to create a violin plot."""
+        sns.violinplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=self.sns_palette, ax=ax)
+
+    def _save_results(self):
+        """Helper method to save the plot and results."""
+        os.makedirs(self.output_dir, exist_ok=True)
+        plot_path = os.path.join(self.output_dir, 'grouped_plot.png')
+        self.fig.savefig(plot_path)
+        results_path = os.path.join(self.output_dir, 'test_results.csv')
+        self.results_df.to_csv(results_path, index=False)
+        print(f"Plot saved to {plot_path}")
+        print(f"Test results saved to {results_path}")
+
+    def get_results(self):
+        """Return the results dataframe."""
+        return self.results_df

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)
@@ -404,7 +404,7 @@ def deep_spacr_defaults(settings):
     settings.setdefault('sample',None)
     settings.setdefault('experiment','exp.')
     settings.setdefault('score_threshold',0.5)
-    settings.setdefault('tar_path','path')
+    settings.setdefault('dataset','path')
     settings.setdefault('model_path','path')
     settings.setdefault('file_type','cell_png')
     settings.setdefault('generate_training_dataset', True)
@@ -461,7 +461,7 @@ def get_analyze_recruitment_default_settings(settings):
     settings.setdefault('pathogen_mask_dim',6)
     settings.setdefault('channel_of_interest',2)
     settings.setdefault('plot',True)
-    settings.setdefault('plot_nr',10)
+    settings.setdefault('plot_nr',3)
     settings.setdefault('plot_control',True)
     settings.setdefault('figuresize',10)
     settings.setdefault('uninfected',True)
@@ -534,6 +534,7 @@ def get_perform_regression_default_settings(settings):
     settings.setdefault('random_row_column_effects',False)
     settings.setdefault('alpha',1)
     settings.setdefault('fraction_threshold',0.1)
+    settings.setdefault('location_column','column')
     settings.setdefault('nc','c1')
     settings.setdefault('pc','c2')
     settings.setdefault('other','c3')
@@ -855,10 +856,10 @@ expected_types = {
     'reverse_complement':bool,
     'file_type':str,
     'model_path':str,
-    'tar_path':str,
+    '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,
@@ -879,27 +880,33 @@ 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", "tar_path","model_path","grna_csv","row_csv","column_csv"],
+categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv"],
              "General": ["metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "segmentation_mode"],
              "Cellpose":["from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "circular", "invert", "diameter", "grayscale", "background", "Signal_to_noise", "resize", "target_height", "target_width"],
              "Cell": ["cell_intensity_range", "cell_size_range", "cell_chann_dim", "cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "include_uninfected", "merge_edge_pathogen_cells", "adjust_cells", "cells", "cell_loc"],
              "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"]
              }
 
@@ -948,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
@@ -1202,10 +1217,10 @@ def generate_fields(variables, scrollable_frame):
         "complevel": "int - level of compression (0-9). Higher is slower and yealds smaller files",
         "file_type": "str - type of file to process",
         "model_path": "str - path to the model",
-        "tar_path": "str - path to the tar file with image dataset",
+        "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.",
@@ -1246,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():
@@ -1281,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."
 }
 
@@ -1313,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