smftools 0.1.3__py3-none-any.whl → 0.1.7__py3-none-any.whl

smftools/tools/models/transformer.py

@@ -0,0 +1,133 @@
+import torch
+import torch.nn as nn
+from .base import BaseTorchModel
+from .positional import PositionalEncoding 
+from ..utils.grl import grad_reverse
+
+    
+class BaseTransformer(BaseTorchModel):
+    def __init__(self, input_dim, model_dim, num_heads=4, num_layers=2, seq_len=None, use_learnable_pos=False, **kwargs):
+        super().__init__(**kwargs)
+        # Input FC layer to map D_input to D_model
+        self.input_fc = nn.Linear(input_dim, model_dim)
+
+        if use_learnable_pos:
+            assert seq_len is not None, "Must provide seq_len if use_learnable_pos=True"
+            self.pos_embed = nn.Parameter(torch.randn(seq_len, model_dim))  # (S, D)
+            self.pos_encoder = None
+        else:
+            self.pos_encoder = PositionalEncoding(model_dim)
+            self.pos_embed = None
+
+        # Specify the transformer encoder structure
+        encoder_layer = nn.TransformerEncoderLayer(d_model=model_dim, nhead=num_heads, batch_first=False)
+        # Stack the transformer encoder layers
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+
+    def encode(self, x, mask=None):
+        """
+        x: (B, S, D_input)
+        mask: (B, S) optional
+        """
+        x = self.input_fc(x)  # (B, S, D_model)
+        if self.pos_embed is not None:
+            x = x + self.pos_embed.unsqueeze(0).to(x.device)  # (B, S, D_model)
+        elif self.pos_encoder is not None:
+            x = self.pos_encoder(x)  # (B, S, D_model)
+        if mask is not None:
+            x = x * mask.unsqueeze(-1)  # (B, S, D_model)
+        x = x.permute(1, 0, 2)  # (S, B, D_model)
+        encoded = self.transformer(x)  # (S, B, D_model)
+        return encoded.permute(1, 0, 2)  # (B, S, D_model)
+    
+class TransformerClassifier(BaseTransformer):
+    def __init__(self, input_dim, model_dim, num_classes, num_heads=4, num_layers=2, **kwargs):
+        super().__init__(input_dim, model_dim, num_heads, num_layers, **kwargs)
+        # Classification head
+        self.cls_head = nn.Linear(model_dim, num_classes)
+
+    def forward(self, x):
+        """
+        x: (batch, seq_len, input_dim)
+        """
+        encoded = self.encode(x) # -> (B, S, D_model)
+        pooled = encoded.mean(dim=1) # -> (B, D_model)
+        return self.cls_head(pooled) # -> (B, C)
+    
+class DANNTransformerClassifier(TransformerClassifier):
+    def __init__(self, input_dim, model_dim, num_classes, n_domains, **kwargs):
+        super().__init__(input_dim, model_dim, num_classes, **kwargs)
+        self.domain_classifier = nn.Sequential(
+            nn.Linear(model_dim, 128),
+            nn.ReLU(),
+            nn.Linear(128, n_domains)
+        )
+
+    def forward(self, x, alpha=1.0):
+        encoded = self.encode(x)  # (B, S, D_model)
+        pooled = encoded.mean(dim=1)  # (B, D_model)
+
+        class_logits = self.cls_head(pooled)
+        domain_logits = self.domain_classifier(grad_reverse(pooled, alpha))
+
+        return class_logits, domain_logits
+
+class MaskedTransformerPretrainer(BaseTransformer):
+    def __init__(self, input_dim, model_dim, num_heads=4, num_layers=2, **kwargs):
+        super().__init__(input_dim, model_dim, num_heads, num_layers, **kwargs)
+        self.decoder = nn.Linear(model_dim, input_dim)
+
+    def forward(self, x, mask):
+        """
+        x: (batch, seq_len, input_dim)
+        mask: (batch, seq_len) optional
+        """
+        if x.dim() == 2:
+            x = x.unsqueeze(-1)
+        encoded = self.encode(x, mask=mask) # -> (B, S, D_model)
+        return self.decoder(encoded) # -> (B, D_input)
+    
+class DANNTransformer(BaseTransformer):
+    """
+    """
+    def __init__(self, seq_len, model_dim, n_heads, n_layers, n_domains):
+        super().__init__(
+            input_dim=1,  # 1D scalar input per token
+            model_dim=model_dim,
+            num_heads=n_heads,
+            num_layers=n_layers,
+            seq_len=seq_len,
+            use_learnable_pos=True  # enables learnable pos_embed in base
+        )
+
+        # Reconstruction head
+        self.recon_head = nn.Linear(model_dim, 1)
+
+        # Domain classification head
+        self.domain_classifier = nn.Sequential(
+            nn.Linear(model_dim, 128),
+            nn.ReLU(),
+            nn.Linear(128, n_domains)
+        )
+
+    def forward(self, x, alpha=1.0):
+        """
+        x: Tensor of shape (B, S) or (B, S, 1)
+        alpha: GRL coefficient (float)
+        """
+        if x.dim() == 2:
+            x = x.unsqueeze(-1)  # (B, S, 1)
+
+        # Encode sequence
+        h = self.encode(x)  # (B, S, D_model)
+
+        # Head 1: Reconstruction
+        recon = self.recon_head(h).squeeze(-1)  # (B, S)
+
+        # Head 2: Domain classification via GRL
+        pooled = h.mean(dim=1)  # (B, D_model)
+        rev = grad_reverse(pooled, alpha)
+        domain_logits = self.domain_classifier(rev)  # (B, n_batches)
+
+        return recon, domain_logits
+    

smftools/tools/models/wrappers.py

@@ -0,0 +1,20 @@
+import torch
+import torch.nn as nn
+
+class ScaledModel(nn.Module):
+    def __init__(self, model, mean, std):
+        super().__init__()
+        self.model = model
+        self.register_buffer("mean", torch.tensor(mean, dtype=torch.float32))
+        self.register_buffer("std", torch.tensor(std, dtype=torch.float32))
+
+    def forward(self, x):
+        mean = self.mean.to(x.device)
+        std = torch.clamp(self.std.to(x.device), min=1e-8)
+        if x.dim() == 2:
+            x = (x - mean) / std
+        elif x.dim() == 3:
+            x = (x - mean[None, None, :]) / std[None, None, :]
+        else:
+            raise ValueError(f"Unsupported input shape {x.shape}")
+        return self.model(x)

smftools/tools/nucleosome_hmm_refinement.py

@@ -0,0 +1,104 @@
+def refine_nucleosome_calls(adata, layer_name, nan_mask_layer, hexamer_size=120, octamer_size=147, max_wiggle=40, device="cpu"):
+    import numpy as np
+
+    nucleosome_layer = adata.layers[layer_name]
+    nan_mask = adata.layers[nan_mask_layer]  # should be binary mask: 1 = nan region, 0 = valid data
+
+    hexamer_layer = np.zeros_like(nucleosome_layer)
+    octamer_layer = np.zeros_like(nucleosome_layer)
+
+    for read_idx, row in enumerate(nucleosome_layer):
+        in_patch = False
+        start_idx = None
+
+        for pos in range(len(row)):
+            if row[pos] == 1 and not in_patch:
+                in_patch = True
+                start_idx = pos
+            if (row[pos] == 0 or pos == len(row) - 1) and in_patch:
+                in_patch = False
+                end_idx = pos if row[pos] == 0 else pos + 1
+
+                # Expand boundaries into NaNs
+                left_expand = 0
+                right_expand = 0
+
+                # Left
+                for i in range(1, max_wiggle + 1):
+                    if start_idx - i >= 0 and nan_mask[read_idx, start_idx - i] == 1:
+                        left_expand += 1
+                    else:
+                        break
+                # Right
+                for i in range(1, max_wiggle + 1):
+                    if end_idx + i < nucleosome_layer.shape[1] and nan_mask[read_idx, end_idx + i] == 1:
+                        right_expand += 1
+                    else:
+                        break
+
+                expanded_start = start_idx - left_expand
+                expanded_end = end_idx + right_expand
+
+                available_size = expanded_end - expanded_start
+            
+                # Octamer placement
+                if available_size >= octamer_size:
+                    center = (expanded_start + expanded_end) // 2
+                    half_oct = octamer_size // 2
+                    octamer_layer[read_idx, center - half_oct: center - half_oct + octamer_size] = 1
+
+                # Hexamer placement
+                elif available_size >= hexamer_size:
+                    center = (expanded_start + expanded_end) // 2
+                    half_hex = hexamer_size // 2
+                    hexamer_layer[read_idx, center - half_hex: center - half_hex + hexamer_size] = 1
+
+    adata.layers[f"{layer_name}_hexamers"] = hexamer_layer
+    adata.layers[f"{layer_name}_octamers"] = octamer_layer
+
+    print(f"✅ Added layers: {layer_name}_hexamers and {layer_name}_octamers")
+    return adata
+
+def infer_nucleosomes_in_large_bound(adata, large_bound_layer, combined_nuc_layer, nan_mask_layer, nuc_size=147, linker_size=50, exclusion_buffer=30, device="cpu"):
+    import numpy as np
+
+    large_bound = adata.layers[large_bound_layer]
+    existing_nucs = adata.layers[combined_nuc_layer]
+    nan_mask = adata.layers[nan_mask_layer]
+
+    inferred_layer = np.zeros_like(large_bound)
+
+    for read_idx, row in enumerate(large_bound):
+        in_patch = False
+        start_idx = None
+
+        for pos in range(len(row)):
+            if row[pos] == 1 and not in_patch:
+                in_patch = True
+                start_idx = pos
+            if (row[pos] == 0 or pos == len(row) - 1) and in_patch:
+                in_patch = False
+                end_idx = pos if row[pos] == 0 else pos + 1
+
+                # Adjust boundaries into flanking NaN regions without getting too close to existing nucleosomes
+                left_expand = start_idx
+                while left_expand > 0 and nan_mask[read_idx, left_expand - 1] == 1 and np.sum(existing_nucs[read_idx, max(0, left_expand - exclusion_buffer):left_expand]) == 0:
+                    left_expand -= 1
+
+                right_expand = end_idx
+                while right_expand < row.shape[0] and nan_mask[read_idx, right_expand] == 1 and np.sum(existing_nucs[read_idx, right_expand:min(row.shape[0], right_expand + exclusion_buffer)]) == 0:
+                    right_expand += 1
+
+                # Phase nucleosomes with linker spacing only
+                region = (left_expand, right_expand)
+                pos_cursor = region[0]
+                while pos_cursor + nuc_size <= region[1]:
+                    if np.all((existing_nucs[read_idx, pos_cursor - exclusion_buffer:pos_cursor + nuc_size + exclusion_buffer] == 0)):
+                        inferred_layer[read_idx, pos_cursor:pos_cursor + nuc_size] = 1
+                        pos_cursor += nuc_size + linker_size 
+                    else:
+                        pos_cursor += 1
+
+    adata.layers[f"{large_bound_layer}_phased_nucleosomes"] = inferred_layer
+    print(f"✅ Added layer: {large_bound_layer}_phased_nucleosomes")
+    return adata

smftools/tools/position_stats.py

@@ -0,0 +1,239 @@
+# ------------------------- Utilities -------------------------
+def random_fill_nans(X):
+    import numpy as np
+    nan_mask = np.isnan(X)
+    X[nan_mask] = np.random.rand(*X[nan_mask].shape)
+    return X
+
+def calculate_relative_risk_on_activity(adata, sites, alpha=0.05, groupby=None):
+    """
+    Perform Bayesian-style methylation vs activity analysis independently within each group.
+
+    Parameters:
+        adata (AnnData): Annotated data matrix.
+        sites (list of str): List of site keys (e.g., ['GpC_site', 'CpG_site']).
+        alpha (float): FDR threshold for significance.
+        groupby (str or list of str): Column(s) in adata.obs to group by.
+
+    Returns:
+        results_dict (dict): Dictionary with structure:
+            results_dict[ref][group_label] = (results_df, sig_df)
+    """
+    import numpy as np
+    import pandas as pd
+    from scipy.stats import fisher_exact
+    from statsmodels.stats.multitest import multipletests
+
+    def compute_risk_df(ref, site_subset, positions_list, relative_risks, p_values):
+        p_adj = multipletests(p_values, method='fdr_bh')[1] if p_values else []
+
+        genomic_positions = np.array(site_subset.var_names)[positions_list]
+        is_gpc_site = site_subset.var[f"{ref}_GpC_site"].values[positions_list]
+        is_cpg_site = site_subset.var[f"{ref}_CpG_site"].values[positions_list]
+
+        results_df = pd.DataFrame({
+            'Feature_Index': positions_list,
+            'Genomic_Position': genomic_positions.astype(int),
+            'Relative_Risk': relative_risks,
+            'Adjusted_P_Value': p_adj,
+            'GpC_Site': is_gpc_site,
+            'CpG_Site': is_cpg_site
+        })
+
+        results_df['log2_Relative_Risk'] = np.log2(results_df['Relative_Risk'].replace(0, 1e-300))
+        results_df['-log10_Adj_P'] = -np.log10(results_df['Adjusted_P_Value'].replace(0, 1e-300))
+        sig_df = results_df[results_df['Adjusted_P_Value'] < alpha]
+        return results_df, sig_df
+
+    results_dict = {}
+
+    for ref in adata.obs['Reference_strand'].unique():
+        ref_subset = adata[adata.obs['Reference_strand'] == ref].copy()
+        if ref_subset.shape[0] == 0:
+            continue
+
+        # Normalize groupby to list
+        if groupby is not None:
+            if isinstance(groupby, str):
+                groupby = [groupby]
+            def format_group_label(row):
+                return ",".join([f"{col}={row[col]}" for col in groupby])
+
+            combined_label = '__'.join(groupby)
+            ref_subset.obs[combined_label] = ref_subset.obs.apply(format_group_label, axis=1)
+            groups = ref_subset.obs[combined_label].unique()
+        else:
+            combined_label = None
+            groups = ['all']
+
+        results_dict[ref] = {}
+
+        for group in groups:
+            if group == 'all':
+                group_subset = ref_subset
+            else:
+                group_subset = ref_subset[ref_subset.obs[combined_label] == group]
+
+            if group_subset.shape[0] == 0:
+                continue
+
+            # Build site mask
+            site_mask = np.zeros(group_subset.shape[1], dtype=bool)
+            for site in sites:
+                site_mask |= group_subset.var[f"{ref}_{site}"]
+            site_subset = group_subset[:, site_mask].copy()
+
+            # Matrix and labels
+            X = random_fill_nans(site_subset.X.copy())
+            y = site_subset.obs['activity_status'].map({'Active': 1, 'Silent': 0}).values
+            P_active = np.mean(y)
+
+            # Analysis
+            positions_list, relative_risks, p_values = [], [], []
+            for pos in range(X.shape[1]):
+                methylation_state = (X[:, pos] > 0).astype(int)
+                table = pd.crosstab(methylation_state, y)
+                if table.shape != (2, 2):
+                    continue
+
+                P_methylated = np.mean(methylation_state)
+                P_methylated_given_active = np.mean(methylation_state[y == 1])
+                P_methylated_given_inactive = np.mean(methylation_state[y == 0])
+
+                if P_methylated_given_inactive == 0 or P_methylated in [0, 1]:
+                    continue
+
+                P_active_given_methylated = (P_methylated_given_active * P_active) / P_methylated
+                P_active_given_unmethylated = ((1 - P_methylated_given_active) * P_active) / (1 - P_methylated)
+                RR = P_active_given_methylated / P_active_given_unmethylated
+
+                _, p_value = fisher_exact(table)
+                positions_list.append(pos)
+                relative_risks.append(RR)
+                p_values.append(p_value)
+
+            results_df, sig_df = compute_risk_df(ref, site_subset, positions_list, relative_risks, p_values)
+            results_dict[ref][group] = (results_df, sig_df)
+
+    return results_dict
+
+def compute_positionwise_statistic(
+    adata,
+    layer,
+    method="pearson",
+    groupby=["Reference_strand"],
+    output_key="positionwise_result",
+    site_config=None,
+    encoding="signed",
+    max_threads=None
+):
+    """
+    Computes a position-by-position matrix (correlation, RR, or Chi-squared) from an adata layer.
+
+    Parameters:
+        adata (AnnData): Annotated data matrix.
+        layer (str): Name of the adata layer to use.
+        method (str): 'pearson', 'binary_covariance', 'relative_risk', or 'chi_squared'.
+        groupby (str or list): Column(s) in adata.obs to group by.
+        output_key (str): Key in adata.uns to store results.
+        site_config (dict): Optional {ref: [site_types]} to restrict sites per reference.
+        encoding (str): 'signed' (1/-1/0) or 'binary' (1/0/NaN).
+        max_threads (int): Number of parallel threads to use (joblib).
+    """
+    import numpy as np
+    import pandas as pd
+    from scipy.stats import chi2_contingency
+    from joblib import Parallel, delayed
+    from tqdm import tqdm
+
+    if isinstance(groupby, str):
+        groupby = [groupby]
+
+    adata.uns[output_key] = {}
+    adata.uns[output_key + "_n"] = {}
+
+    label_col = "__".join(groupby)
+    adata.obs[label_col] = adata.obs[groupby].astype(str).agg("_".join, axis=1)
+
+    for group in adata.obs[label_col].unique():
+        subset = adata[adata.obs[label_col] == group].copy()
+        if subset.shape[0] == 0:
+            continue
+
+        ref = subset.obs["Reference_strand"].unique()[0] if "Reference_strand" in groupby else None
+
+        if site_config and ref in site_config:
+            site_mask = np.zeros(subset.shape[1], dtype=bool)
+            for site in site_config[ref]:
+                site_mask |= subset.var[f"{ref}_{site}"]
+            subset = subset[:, site_mask].copy()
+
+        X = subset.layers[layer].copy()
+
+        if encoding == "signed":
+            X_bin = np.where(X == 1, 1, np.where(X == -1, 0, np.nan))
+        else:
+            X_bin = np.where(X == 1, 1, np.where(X == 0, 0, np.nan))
+
+        n_pos = subset.shape[1]
+        mat = np.zeros((n_pos, n_pos))
+
+        if method == "pearson":
+            with np.errstate(invalid='ignore'):
+                mat = np.corrcoef(np.nan_to_num(X_bin).T)
+
+        elif method == "binary_covariance":
+            binary = (X_bin == 1).astype(float)
+            valid = (X_bin == 1) | (X_bin == 0)  # Only consider true binary (ignore NaN)
+            valid = valid.astype(float)
+
+            numerator = np.dot(binary.T, binary)
+            denominator = np.dot(valid.T, valid)
+
+            with np.errstate(divide='ignore', invalid='ignore'):
+                mat = np.true_divide(numerator, denominator)
+                mat[~np.isfinite(mat)] = 0
+
+        elif method in ["relative_risk", "chi_squared"]:
+            def compute_row(i):
+                row = np.zeros(n_pos)
+                xi = X_bin[:, i]
+                for j in range(n_pos):
+                    xj = X_bin[:, j]
+                    mask = ~np.isnan(xi) & ~np.isnan(xj)
+                    if np.sum(mask) < 10:
+                        row[j] = np.nan
+                        continue
+                    if method == "relative_risk":
+                        a = np.sum((xi[mask] == 1) & (xj[mask] == 1))
+                        b = np.sum((xi[mask] == 1) & (xj[mask] == 0))
+                        c = np.sum((xi[mask] == 0) & (xj[mask] == 1))
+                        d = np.sum((xi[mask] == 0) & (xj[mask] == 0))
+                        if (a + b) > 0 and (c + d) > 0 and c > 0:
+                            p1 = a / (a + b)
+                            p2 = c / (c + d)
+                            row[j] = p1 / p2 if p2 > 0 else np.nan
+                        else:
+                            row[j] = np.nan
+                    elif method == "chi_squared":
+                        table = pd.crosstab(xi[mask], xj[mask])
+                        if table.shape != (2, 2):
+                            row[j] = np.nan
+                        else:
+                            chi2, _, _, _ = chi2_contingency(table, correction=False)
+                            row[j] = chi2
+                return row
+
+            mat = np.array(
+                Parallel(n_jobs=max_threads)(
+                    delayed(compute_row)(i) for i in tqdm(range(n_pos), desc=f"{method}: {group}")
+                )
+            )
+
+        else:
+            raise ValueError(f"Unsupported method: {method}")
+
+        var_names = subset.var_names.astype(int)
+        mat_df = pd.DataFrame(mat, index=var_names, columns=var_names)
+        adata.uns[output_key][group] = mat_df
+        adata.uns[output_key + "_n"][group] = subset.shape[0]

smftools/tools/read_stats.py

@@ -0,0 +1,70 @@
+# ------------------------- Utilities -------------------------
+def random_fill_nans(X):
+    import numpy as np
+    nan_mask = np.isnan(X)
+    X[nan_mask] = np.random.rand(*X[nan_mask].shape)
+    return X
+
+def calculate_row_entropy(
+    adata,
+    layer,
+    output_key="entropy",
+    site_config=None,
+    ref_col="Reference_strand",
+    encoding="signed",
+    max_threads=None):
+    """
+    Adds an obs column to the adata that calculates entropy within each read from a given layer
+    when looking at each site type passed in the site_config list.
+
+    Parameters:
+        adata (AnnData): The annotated data matrix.
+        layer (str): Name of the layer to use for entropy calculation.
+        method (str): Unused currently. Placeholder for potential future methods.
+        output_key (str): Base name for the entropy column in adata.obs.
+        site_config (dict): {ref: [site_types]} for masking relevant sites.
+        ref_col (str): Column in adata.obs denoting reference strands.
+        encoding (str): 'signed' (1/-1/0) or 'binary' (1/0/NaN).
+        max_threads (int): Number of threads for parallel processing.
+    """
+    import numpy as np
+    import pandas as pd
+    from scipy.stats import entropy
+    from joblib import Parallel, delayed
+    from tqdm import tqdm
+
+    entropy_values = []
+    row_indices = []
+
+    for ref in adata.obs[ref_col].cat.categories:
+        subset = adata[adata.obs[ref_col] == ref].copy()
+        if subset.shape[0] == 0:
+            continue
+
+        if site_config and ref in site_config:
+            site_mask = np.zeros(subset.shape[1], dtype=bool)
+            for site in site_config[ref]:
+                site_mask |= subset.var[f"{ref}_{site}"]
+            subset = subset[:, site_mask].copy()
+
+        X = subset.layers[layer].copy()
+
+        if encoding == "signed":
+            X_bin = np.where(X == 1, 1, np.where(X == -1, 0, np.nan))
+        else:
+            X_bin = np.where(X == 1, 1, np.where(X == 0, 0, np.nan))
+
+        def compute_entropy(row):
+            counts = pd.Series(row).value_counts(dropna=True).sort_index()
+            probs = counts / counts.sum()
+            return entropy(probs, base=2)
+
+        entropies = Parallel(n_jobs=max_threads)(
+            delayed(compute_entropy)(X_bin[i, :]) for i in tqdm(range(X_bin.shape[0]), desc=f"Entropy: {ref}")
+        )
+
+        entropy_values.extend(entropies)
+        row_indices.extend(subset.obs_names.tolist())
+
+    entropy_key = f"{output_key}_entropy"
+    adata.obs.loc[row_indices, entropy_key] = entropy_values

smftools/tools/subset_adata.py

@@ -1,32 +1,28 @@
 # subset_adata
 
-def subset_adata(adata, obs_columns):
+def subset_adata(adata, columns, cat_type='obs'):
     """
-    Subsets an AnnData object based on categorical values in specified `.obs` columns.
+    Adds subset metadata to an AnnData object based on categorical values in specified .obs or .var columns.
     
     Parameters:
-        adata (AnnData): The AnnData object to subset.
-        obs_columns (list of str): List of `.obs` column names to subset by. The order matters.
+        adata (AnnData): The AnnData object to add subset metadata to.
+        columns (list of str): List of .obs or .var column names to subset by. The order matters.
+        cat_type (str): obs or var. Default is obs
 
     Returns:
-        dict: A dictionary where keys are tuples of category values and values are corresponding AnnData subsets.
+        None
     """
+    import pandas as pd
+    import anndata as ad
 
-    def subset_recursive(adata_subset, columns):
-        if not columns:
-            return {(): adata_subset}
-        
-        current_column = columns[0]
-        categories = adata_subset.obs[current_column].cat.categories
-        
-        subsets = {}
-        for cat in categories:
-            subset = adata_subset[adata_subset.obs[current_column] == cat]
-            subsets.update(subset_recursive(subset, columns[1:]))
-        
-        return subsets
-    
-    # Start the recursive subset process
-    subsets_dict = subset_recursive(adata, obs_columns)
-    
-    return subsets_dict
+    subgroup_name = '_'.join(columns)
+    if 'obs' in cat_type:
+        df = adata.obs[columns]
+        adata.obs[subgroup_name] = df.apply(lambda row: '_'.join(row.astype(str)), axis=1)
+        adata.obs[subgroup_name] = adata.obs[subgroup_name].astype('category')
+    elif 'var' in cat_type:    
+        df = adata.var[columns]
+        adata.var[subgroup_name] = df.apply(lambda row: '_'.join(row.astype(str)), axis=1)
+        adata.var[subgroup_name] = adata.var[subgroup_name].astype('category')
+
+    return None