spacr 0.4.60__py3-none-any.whl → 0.9.0__py3-none-any.whl

spacr/resources/MEDIAR/train_tools/models/MEDIARFormer.py

@@ -1,102 +0,0 @@
-import torch
-import torch.nn as nn
-
-from segmentation_models_pytorch import MAnet
-from segmentation_models_pytorch.base.modules import Activation
-
-__all__ = ["MEDIARFormer"]
-
-
-class MEDIARFormer(MAnet):
-    """MEDIAR-Former Model"""
-
-    def __init__(
-        self,
-        encoder_name="mit_b5",  # Default encoder
-        encoder_weights="imagenet",  # Pre-trained weights
-        decoder_channels=(1024, 512, 256, 128, 64),  # Decoder configuration
-        decoder_pab_channels=256,  # Decoder Pyramid Attention Block channels
-        in_channels=3,  # Number of input channels
-        classes=3,  # Number of output classes
-    ):
-        # Initialize the MAnet model with provided parameters
-        super().__init__(
-            encoder_name=encoder_name,
-            encoder_weights=encoder_weights,
-            decoder_channels=decoder_channels,
-            decoder_pab_channels=decoder_pab_channels,
-            in_channels=in_channels,
-            classes=classes,
-        )
-
-        # Remove the default segmentation head as it's not used in this architecture
-        self.segmentation_head = None
-
-        # Modify all activation functions in the encoder and decoder from ReLU to Mish
-        _convert_activations(self.encoder, nn.ReLU, nn.Mish(inplace=True))
-        _convert_activations(self.decoder, nn.ReLU, nn.Mish(inplace=True))
-
-        # Add custom segmentation heads for different segmentation tasks
-        self.cellprob_head = DeepSegmentationHead(
-            in_channels=decoder_channels[-1], out_channels=1
-        )
-        self.gradflow_head = DeepSegmentationHead(
-            in_channels=decoder_channels[-1], out_channels=2
-        )
-
-    def forward(self, x):
-        """Forward pass through the network"""
-        # Ensure the input shape is correct
-        self.check_input_shape(x)
-
-        # Encode the input and then decode it
-        features = self.encoder(x)
-        decoder_output = self.decoder(*features)
-
-        # Generate masks for cell probability and gradient flows
-        cellprob_mask = self.cellprob_head(decoder_output)
-        gradflow_mask = self.gradflow_head(decoder_output)
-
-        # Concatenate the masks for output
-        masks = torch.cat([gradflow_mask, cellprob_mask], dim=1)
-
-        return masks
-
-
-class DeepSegmentationHead(nn.Sequential):
-    """Custom segmentation head for generating specific masks"""
-
-    def __init__(
-        self, in_channels, out_channels, kernel_size=3, activation=None, upsampling=1
-    ):
-        # Define a sequence of layers for the segmentation head
-        layers = [
-            nn.Conv2d(
-                in_channels,
-                in_channels // 2,
-                kernel_size=kernel_size,
-                padding=kernel_size // 2,
-            ),
-            nn.Mish(inplace=True),
-            nn.BatchNorm2d(in_channels // 2),
-            nn.Conv2d(
-                in_channels // 2,
-                out_channels,
-                kernel_size=kernel_size,
-                padding=kernel_size // 2,
-            ),
-            nn.UpsamplingBilinear2d(scale_factor=upsampling)
-            if upsampling > 1
-            else nn.Identity(),
-            Activation(activation) if activation else nn.Identity(),
-        ]
-        super().__init__(*layers)
-
-
-def _convert_activations(module, from_activation, to_activation):
-    """Recursively convert activation functions in a module"""
-    for name, child in module.named_children():
-        if isinstance(child, from_activation):
-            setattr(module, name, to_activation)
-        else:
-            _convert_activations(child, from_activation, to_activation)

spacr/resources/MEDIAR/train_tools/models/__init__.py

@@ -1 +0,0 @@
-from .MEDIARFormer import *

spacr/resources/MEDIAR/train_tools/utils.py

@@ -1,70 +0,0 @@
-import torch
-import numpy as np
-import os, json, random
-from pprint import pprint
-
-__all__ = ["ConfLoader", "directory_setter", "random_seeder", "pprint_config"]
-
-
-class ConfLoader:
-    """
-    Load json config file using DictWithAttributeAccess object_hook.
-    ConfLoader(conf_name).opt attribute is the result of loading json config file.
-    """
-
-    class DictWithAttributeAccess(dict):
-        """
-        This inner class makes dict to be accessed same as class attribute.
-        For example, you can use opt.key instead of the opt['key'].
-        """
-
-        def __getattr__(self, key):
-            return self[key]
-
-        def __setattr__(self, key, value):
-            self[key] = value
-
-    def __init__(self, conf_name):
-        self.conf_name = conf_name
-        self.opt = self.__get_opt()
-
-    def __load_conf(self):
-        with open(self.conf_name, "r") as conf:
-            opt = json.load(
-                conf, object_hook=lambda dict: self.DictWithAttributeAccess(dict)
-            )
-        return opt
-
-    def __get_opt(self):
-        opt = self.__load_conf()
-        opt = self.DictWithAttributeAccess(opt)
-
-        return opt
-
-
-def directory_setter(path="./results", make_dir=False):
-    """
-    Make dictionary if not exists.
-    """
-    if not os.path.exists(path) and make_dir:
-        os.makedirs(path)  # make dir if not exist
-        print("directory %s is created" % path)
-
-    if not os.path.isdir(path):
-        raise NotADirectoryError(
-            "%s is not valid. set make_dir=True to make dir." % path
-        )
-
-
-def random_seeder(seed):
-    """Fix randomness."""
-    torch.manual_seed(seed)
-    np.random.seed(seed)
-    random.seed(seed)
-    torch.backends.cudnn.deterministic = True
-    torch.backends.cudnn.benchmark = False
-
-def pprint_config(opt):
-    print("\n" + "=" * 50 + " Configuration " + "=" * 50)
-    pprint(opt, compact=True)
-    print("=" * 115 + "\n")

spacr/stats.py

@@ -1,221 +0,0 @@
-from scipy.stats import shapiro, normaltest, levene, ttest_ind, mannwhitneyu, kruskal, f_oneway
-from statsmodels.stats.multicomp import pairwise_tukeyhsd
-import scikit_posthocs as sp
-import numpy as np
-import pandas as pd
-from scipy.stats import chi2_contingency, fisher_exact
-import itertools
-from statsmodels.stats.multitest import multipletests
-
-
-def choose_p_adjust_method(num_groups, num_data_points):
-    """
-    Selects the most appropriate p-value adjustment method based on data characteristics.
-    
-    Parameters:
-    - num_groups: Number of unique groups being compared
-    - num_data_points: Number of data points per group (assuming balanced groups)
-    
-    Returns:
-    - A string representing the recommended p-adjustment method
-    """
-    num_comparisons = (num_groups * (num_groups - 1)) // 2  # Number of pairwise comparisons
-
-    # Decision logic for choosing the adjustment method
-    if num_comparisons <= 10 and num_data_points > 5:
-        return 'holm'  # Balanced between power and Type I error control
-    elif num_comparisons > 10 and num_data_points <= 5:
-        return 'fdr_bh'  # FDR control for large number of comparisons and small sample size
-    elif num_comparisons <= 10:
-        return 'sidak'  # Less conservative than Bonferroni, good for independent comparisons
-    else:
-        return 'bonferroni'  # Very conservative, use for strict control of Type I errors
-
-def perform_normality_tests(df, grouping_column, data_columns):
-    """Perform normality tests for each group and data column."""
-    unique_groups = df[grouping_column].unique()
-    normality_results = []
-
-    for column in data_columns:
-        for group in unique_groups:
-            data = df.loc[df[grouping_column] == group, column].dropna()
-            n_samples = len(data)
-
-            if n_samples < 3:
-                # Skip test if there aren't enough data points
-                print(f"Skipping normality test for group '{group}' on column '{column}' - Not enough data.")
-                normality_results.append({
-                    'Comparison': f'Normality test for {group} on {column}',
-                    'Test Statistic': None,
-                    'p-value': None,
-                    'Test Name': 'Skipped',
-                    'Column': column,
-                    'n': n_samples
-                })
-                continue
-
-            # Choose the appropriate normality test based on the sample size
-            if n_samples >= 8:
-                stat, p_value = normaltest(data)
-                test_name = "D'Agostino-Pearson test"
-            else:
-                stat, p_value = shapiro(data)
-                test_name = "Shapiro-Wilk test"
-
-            normality_results.append({
-                'Comparison': f'Normality test for {group} on {column}',
-                'Test Statistic': stat,
-                'p-value': p_value,
-                'Test Name': test_name,
-                'Column': column,
-                'n': n_samples
-            })
-
-        # Check if all groups are normally distributed (p > 0.05)
-        normal_p_values = [result['p-value'] for result in normality_results if result['Column'] == column and result['p-value'] is not None]
-        is_normal = all(p > 0.05 for p in normal_p_values)
-
-    return is_normal, normality_results
-
-
-def perform_levene_test(df, grouping_column, data_column):
-    """Perform Levene's test for equal variance."""
-    unique_groups = df[grouping_column].unique()
-    grouped_data = [df.loc[df[grouping_column] == group, data_column].dropna() for group in unique_groups]
-    stat, p_value = levene(*grouped_data)
-    return stat, p_value
-
-def perform_statistical_tests(df, grouping_column, data_columns, paired=False):
-    """Perform statistical tests for each data column."""
-    unique_groups = df[grouping_column].unique()
-    test_results = []
-
-    for column in data_columns:
-        grouped_data = [df.loc[df[grouping_column] == group, column].dropna() for group in unique_groups]
-        if len(unique_groups) == 2:  # For two groups
-            if paired:
-                print("Performing paired tests (not implemented in this template).")
-                continue  # Extend as needed
-            else:
-                # Check normality for two groups
-                is_normal, _ = perform_normality_tests(df, grouping_column, [column])
-                if is_normal:
-                    stat, p = ttest_ind(grouped_data[0], grouped_data[1])
-                    test_name = 'T-test'
-                else:
-                    stat, p = mannwhitneyu(grouped_data[0], grouped_data[1])
-                    test_name = 'Mann-Whitney U test'
-        else:
-            # Check normality for multiple groups
-            is_normal, _ = perform_normality_tests(df, grouping_column, [column])
-            if is_normal:
-                stat, p = f_oneway(*grouped_data)
-                test_name = 'One-way ANOVA'
-            else:
-                stat, p = kruskal(*grouped_data)
-                test_name = 'Kruskal-Wallis test'
-
-        test_results.append({
-            'Column': column,
-            'Test Name': test_name,
-            'Test Statistic': stat,
-            'p-value': p,
-            'Groups': len(unique_groups)
-        })
-
-    return test_results
-
-
-def perform_posthoc_tests(df, grouping_column, data_column, is_normal):
-    """Perform post-hoc tests for multiple groups with both original and adjusted p-values."""
-    unique_groups = df[grouping_column].unique()
-    posthoc_results = []
-
-    if len(unique_groups) > 2:
-        num_groups = len(unique_groups)
-        num_data_points = len(df[data_column].dropna()) // num_groups  # Assuming roughly equal data points per group
-        p_adjust_method = choose_p_adjust_method(num_groups, num_data_points)
-
-        if is_normal:
-            # Tukey's HSD automatically adjusts p-values
-            tukey_result = pairwise_tukeyhsd(df[data_column], df[grouping_column], alpha=0.05)
-            for comparison, p_value in zip(tukey_result._results_table.data[1:], tukey_result.pvalues):
-                posthoc_results.append({
-                    'Comparison': f"{comparison[0]} vs {comparison[1]}",
-                    'Original p-value': None,  # Tukey HSD does not provide raw p-values
-                    'Adjusted p-value': p_value,
-                    'Adjusted Method': 'Tukey HSD',
-                    'Test Name': 'Tukey HSD'
-                })
-        else:
-            # Dunn's test with p-value adjustment
-            raw_dunn_result = sp.posthoc_dunn(df, val_col=data_column, group_col=grouping_column, p_adjust=None)
-            adjusted_dunn_result = sp.posthoc_dunn(df, val_col=data_column, group_col=grouping_column, p_adjust=p_adjust_method)
-            for i, group_a in enumerate(adjusted_dunn_result.index):
-                for j, group_b in enumerate(adjusted_dunn_result.columns):
-                    if i < j:  # Only consider unique pairs
-                        posthoc_results.append({
-                            'Comparison': f"{group_a} vs {group_b}",
-                            'Original p-value': raw_dunn_result.iloc[i, j],
-                            'Adjusted p-value': adjusted_dunn_result.iloc[i, j],
-                            'Adjusted Method': p_adjust_method,
-                            'Test Name': "Dunn's Post-hoc"
-                        })
-
-    return posthoc_results
-
-def chi_pairwise(raw_counts, verbose=False):
-    """
-    Perform pairwise chi-square or Fisher's exact tests between all unique group pairs
-    and apply p-value correction.
-
-    Parameters:
-    - raw_counts (DataFrame): Contingency table with group-wise counts.
-    - verbose (bool): Whether to print results for each pair.
-
-    Returns:
-    - pairwise_df (DataFrame): DataFrame with pairwise test results, including corrected p-values.
-    """
-    pairwise_results = []
-    groups = raw_counts.index.unique()  # Use index from raw_counts for group pairs
-    raw_p_values = []  # Store raw p-values for correction later
-    
-    # Calculate the number of groups and average number of data points per group
-    num_groups = len(groups)
-    num_data_points = raw_counts.sum(axis=1).mean()  # Average total data points per group
-    p_adjust_method = choose_p_adjust_method(num_groups, num_data_points)
-
-    for group1, group2 in itertools.combinations(groups, 2):
-        contingency_table = raw_counts.loc[[group1, group2]].values
-        if contingency_table.shape[1] == 2:  # Fisher's Exact Test for 2x2 tables
-            oddsratio, p_value = fisher_exact(contingency_table)
-            test_name = "Fisher's Exact Test"
-        else:  # Chi-Square Test for larger tables
-            chi2_stat, p_value, _, _ = chi2_contingency(contingency_table)
-            test_name = 'Pairwise Chi-Square Test'
-        
-        pairwise_results.append({
-            'Group 1': group1,
-            'Group 2': group2,
-            'Test Name': test_name,
-            'p-value': p_value
-        })
-        raw_p_values.append(p_value)
-
-    # Apply p-value correction
-    corrected_p_values = multipletests(raw_p_values, method=p_adjust_method)[1]
-
-    # Add corrected p-values to results
-    for i, result in enumerate(pairwise_results):
-        result['p-value_adj'] = corrected_p_values[i]
-
-    pairwise_df = pd.DataFrame(pairwise_results)
-    
-    pairwise_df['adj'] = p_adjust_method
-
-    if verbose:
-        # Print pairwise results
-        print("\nPairwise Frequency Analysis Results:")
-        print(pairwise_df.to_string(index=False))
-
-    return pairwise_df