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

smftools/preprocessing/recipes.py

@@ -1,6 +1,6 @@
 # recipes
 
-def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory, mapping_key_column='Sample', reference_column = 'Reference', sample_names_col='Sample_names', invert=False):
+def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory, mapping_key_column='Sample', reference_column = 'Reference', sample_names_col='Sample_names', invert=True):
     """
     The first part of the preprocessing workflow applied to the smf.inform.pod_to_adata() output derived from Kissiov_and_McKenna_2025.
 
@@ -9,9 +9,10 @@ def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory
     2) Appends a boolean indicating whether each position in var_names is within a given reference.
     3) Appends the cytosine context to each position from each reference.
     4) Calculate read level methylation statistics.
-    5) Optionally inverts the adata to flip the position coordinate orientation.
-    6) Calculates read length statistics (start position, end position, read length)
-    7) Returns a dictionary to pass the variable namespace to the parent scope.
+    5) Calculates read length statistics (start position, end position, read length).
+    6) Optionally inverts the adata to flip the position coordinate orientation.
+    7) Adds new layers containing NaN replaced variants of adata.X (fill_closest, nan0_0minus1, nan1_12).
+    8) Returns a dictionary to pass the variable namespace to the parent scope.
 
     Parameters:
         adata (AnnData): The AnnData object to use as input.
@@ -34,6 +35,7 @@ def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory
     from .calculate_converted_read_methylation_stats import calculate_converted_read_methylation_stats
     from .invert_adata import invert_adata
     from .calculate_read_length_stats import calculate_read_length_stats
+    from .clean_NaN import clean_NaN
 
     # Clean up some of the Reference metadata and save variable names that point to sets of values in the column.
     adata.obs[reference_column] = adata.obs[reference_column].astype('category')
@@ -42,7 +44,7 @@ def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory
     reference_mapping = {k: v for k, v in split_references}
     adata.obs[f'{reference_column}_short'] = adata.obs[reference_column].map(reference_mapping)
     short_references = set(adata.obs[f'{reference_column}_short'])
-    binary_layers = adata.layers.keys()
+    binary_layers = list(adata.layers.keys())
 
     # load sample sheet metadata
     load_sample_sheet(adata, sample_sheet_path, mapping_key_column)
@@ -59,16 +61,19 @@ def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory
     append_C_context(adata, obs_column=reference_column, use_consensus=False)
 
     # Calculate read level methylation statistics. Assess if GpC methylation level is above other_C methylation level as a QC.
-    calculate_converted_read_methylation_stats(adata, reference_column, sample_names_col, output_directory, show_methylation_histogram=False, save_methylation_histogram=False)
+    calculate_converted_read_methylation_stats(adata, reference_column, sample_names_col)
+
+    # Calculate read length statistics
+    upper_bound, lower_bound = calculate_read_length_stats(adata, reference_column, sample_names_col)
 
     # Invert the adata object (ie flip the strand orientation for visualization)
     if invert:
-        invert_adata(adata)
+        adata = invert_adata(adata)
     else:
         pass
 
-    # Calculate read length statistics, with options to display or save the read length histograms
-    upper_bound, lower_bound = calculate_read_length_stats(adata, reference_column, sample_names_col, output_directory, show_read_length_histogram=False, save_read_length_histogram=False)
+    # NaN replacement strategies stored in additional layers. Having layer=None uses adata.X
+    clean_NaN(adata, layer=None)
 
     variables = {
         "short_references": short_references,
@@ -80,22 +85,21 @@ def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory
     }
     return variables
 
-def recipe_2_Kissiov_and_McKenna_2025(adata, output_directory, binary_layers, hamming_distance_thresholds={}, reference_column = 'Reference', sample_names_col='Sample_names'):
+def recipe_2_Kissiov_and_McKenna_2025(adata, output_directory, binary_layers, distance_thresholds={}, reference_column = 'Reference', sample_names_col='Sample_names'):
     """
     The second part of the preprocessing workflow applied to the adata that has already been preprocessed by recipe_1_Kissiov_and_McKenna_2025.
 
     Performs the following tasks:
-    1) Adds new layers containing NaN replaced variants of adata.X (fill_closest, nan0_0minus1, nan1_12).
-    2) Marks putative PCR duplicates using pairwise hamming distance metrics.
-    3) Performs a complexity analysis of the library based on the PCR duplicate detection rate.
-    4) Removes PCR duplicates from the adata.
-    5) Returns two adata object: one for the filtered adata and one for the duplicate adata.
+    1) Marks putative PCR duplicates using pairwise hamming distance metrics.
+    2) Performs a complexity analysis of the library based on the PCR duplicate detection rate.
+    3) Removes PCR duplicates from the adata.
+    4) Returns two adata object: one for the filtered adata and one for the duplicate adata.
 
     Parameters:
         adata (AnnData): The AnnData object to use as input.
         output_directory (str): String representing the path to the output directory for plots.
         binary_layers (list): A list of layers to used for the binary encoding of read sequences. Used for duplicate detection.
-        hamming_distance_thresholds (dict): A dictionary keyed by obs_column categories that points to a float corresponding to the distance threshold to apply. Default is an empty dict.
+        distance_thresholds (dict): A dictionary keyed by obs_column categories that points to a float corresponding to the distance threshold to apply. Default is an empty dict.
         reference_column (str): The name of the reference column to use.
         sample_names_col (str): The name of the sample name column to use.
 
@@ -106,16 +110,14 @@ def recipe_2_Kissiov_and_McKenna_2025(adata, output_directory, binary_layers, ha
     import anndata as ad
     import pandas as pd
     import numpy as np
-    from .clean_NaN import clean_NaN
     from .mark_duplicates import mark_duplicates
     from .calculate_complexity import calculate_complexity
     from .remove_duplicates import remove_duplicates
 
-    # NaN replacement strategies stored in additional layers. Having layer=None uses adata.X
-    clean_NaN(adata, layer=None)
+    # Add here a way to remove reads below a given read quality (based on nan content). Need to also add a way to pull from BAM files the read quality from each read
 
     # Duplicate detection using pairwise hamming distance across reads
-    mark_duplicates(adata, binary_layers, obs_column=reference_column, sample_col=sample_names_col, hamming_distance_thresholds=hamming_distance_thresholds)
+    mark_duplicates(adata, binary_layers, obs_column=reference_column, sample_col=sample_names_col, distance_thresholds=distance_thresholds, method='N_masked_distances')
 
     # Complexity analysis using the marked duplicates and the lander-watermann algorithm
     calculate_complexity(adata, output_directory, obs_column=reference_column, sample_col=sample_names_col, plot=True, save_plot=False)

smftools/preprocessing/subsample_adata.py

@@ -0,0 +1,58 @@
+def subsample_adata(adata, obs_columns=None, max_samples=2000, random_seed=42):
+    """
+    Subsamples an AnnData object so that each unique combination of categories 
+    in the given `obs_columns` has at most `max_samples` observations.
+    If `obs_columns` is None or empty, the function randomly subsamples the entire dataset.
+    
+    Parameters:
+        adata (AnnData): The AnnData object to subsample.
+        obs_columns (list of str, optional): List of observation column names to group by.
+        max_samples (int): The maximum number of observations per category combination.
+        random_seed (int): Random seed for reproducibility.
+
+    Returns:
+        AnnData: A new AnnData object with subsampled observations.
+    """
+    import anndata as ad
+    import numpy as np
+
+    np.random.seed(random_seed)  # Ensure reproducibility
+
+    if not obs_columns:  # If no obs columns are given, sample globally
+        if adata.shape[0] > max_samples:
+            sampled_indices = np.random.choice(adata.obs.index, max_samples, replace=False)
+        else:
+            sampled_indices = adata.obs.index  # Keep all if fewer than max_samples
+        
+        return adata[sampled_indices].copy()
+
+    sampled_indices = []
+
+    # Get unique category combinations from all specified obs columns
+    unique_combinations = adata.obs[obs_columns].drop_duplicates()
+
+    for _, row in unique_combinations.iterrows():
+        # Build filter condition dynamically for multiple columns
+        condition = (adata.obs[obs_columns] == row.values).all(axis=1)
+        
+        # Get indices for the current category combination
+        subset_indices = adata.obs[condition].index.to_numpy()
+
+        # Subsample or take all
+        if len(subset_indices) > max_samples:
+            sampled = np.random.choice(subset_indices, max_samples, replace=False)
+        else:
+            sampled = subset_indices  # Keep all if fewer than max_samples
+
+        sampled_indices.extend(sampled)
+
+    # ⚠ Handle backed mode detection
+    if adata.isbacked:
+        print("⚠ Detected backed mode. Subset will be loaded fully into memory.")
+        subset = adata[sampled_indices]
+        subset = subset.to_memory()
+    else:
+        subset = adata[sampled_indices]
+
+    # Create a new AnnData object with only the selected indices
+    return subset[sampled_indices].copy()

smftools/readwrite.py

@@ -23,27 +23,46 @@ def time_string():
 
 ######################################################################################################
 ## Numpy, Pandas, Anndata functionality
+
 def adata_to_df(adata, layer=None):
     """
-    Input: An adata object with a specified layer.
-    Output: A dataframe for the specific layer.
+    Convert an AnnData object into a Pandas DataFrame.
+
+    Parameters:
+        adata (AnnData): The input AnnData object.
+        layer (str, optional): The layer to extract. If None, uses adata.X.
+
+    Returns:
+        pd.DataFrame: A DataFrame where rows are observations and columns are positions.
     """
     import pandas as pd
     import anndata as ad
+    import numpy as np
+
+    # Validate that the requested layer exists
+    if layer and layer not in adata.layers:
+        raise ValueError(f"Layer '{layer}' not found in adata.layers.")
+
+    # Extract the data matrix
+    data_matrix = adata.layers.get(layer, adata.X)
+
+    # Ensure matrix is dense (handle sparse formats)
+    if hasattr(data_matrix, "toarray"):  
+        data_matrix = data_matrix.toarray()
+
+    # Ensure obs and var have unique indices
+    if adata.obs.index.duplicated().any():
+        raise ValueError("Duplicate values found in `adata.obs.index`. Ensure unique observation indices.")
+    
+    if adata.var.index.duplicated().any():
+        raise ValueError("Duplicate values found in `adata.var.index`. Ensure unique variable indices.")
+
+    # Convert to DataFrame
+    df = pd.DataFrame(data_matrix, index=adata.obs.index, columns=adata.var.index)
 
-    # Extract the data matrix from the given layer
-    if layer:
-        data_matrix = adata.layers[layer]
-    else:
-        data_matrix = adata.X
-    # Extract observation (read) annotations
-    obs_df = adata.obs
-    # Extract variable (position) annotations
-    var_df = adata.var
-    # Convert data matrix and annotations to pandas DataFrames
-    df = pd.DataFrame(data_matrix, index=obs_df.index, columns=var_df.index)
     return df
 
+
 def save_matrix(matrix, save_name):
     """
     Input: A numpy matrix and a save_name
@@ -103,4 +122,77 @@ def concatenate_h5ads(output_file, file_suffix='h5ad.gz', delete_inputs=True):
                     print(f"Error deleting file {hdf}: {e}")
     else:
         print('Keeping input files')
+
+def safe_write_h5ad(adata, path, compression="gzip", backup=False, backup_dir="./"):
+    """
+    Saves an AnnData object safely by omitting problematic columns from .obs and .var.
+
+    Parameters:
+        adata (AnnData): The AnnData object to save.
+        path (str): Output .h5ad file path.
+        compression (str): Compression method for h5ad file.
+        backup (bool): If True, saves problematic columns to CSV files.
+        backup_dir (str): Directory to store backups if backup=True.
+    """
+    import anndata as ad
+    import pandas as pd
+    import os
+
+    os.makedirs(backup_dir, exist_ok=True)
+
+    def filter_df(df, df_name):
+        bad_cols = []
+        for col in df.columns:
+            if df[col].dtype == 'object':
+                if not df[col].apply(lambda x: isinstance(x, (str, type(None)))).all():
+                    bad_cols.append(col)
+        if bad_cols:
+            print(f"⚠️ Skipping columns from {df_name}: {bad_cols}")
+            if backup:
+                df[bad_cols].to_csv(os.path.join(backup_dir, f"{df_name}_skipped_columns.csv"))
+                print(f"📝 Backed up skipped columns to {backup_dir}/{df_name}_skipped_columns.csv")
+        return df.drop(columns=bad_cols)
+
+    # Clean obs and var
+    obs_clean = filter_df(adata.obs, "obs")
+    var_clean = filter_df(adata.var, "var")
+
+    # Save clean version
+    adata_copy = ad.AnnData(
+        X=adata.X,
+        obs=obs_clean,
+        var=var_clean,
+        layers=adata.layers,
+        uns=adata.uns,
+        obsm=adata.obsm,
+        varm=adata.varm
+    )
+    adata_copy.write_h5ad(path, compression=compression)
+    print(f"✅ Saved safely to {path}")
+
+def merge_barcoded_anndatas(adata_single, adata_double):
+    import numpy as np
+    import anndata as ad
+
+    # Step 1: Identify overlap
+    overlap = np.intersect1d(adata_single.obs_names, adata_double.obs_names)
+
+    # Step 2: Filter out overlaps from adata_single
+    adata_single_filtered = adata_single[~adata_single.obs_names.isin(overlap)].copy()
+
+    # Step 3: Add source tag
+    adata_single_filtered.obs['source'] = 'single_barcode'
+    adata_double.obs['source'] = 'double_barcode'
+
+    # Step 4: Concatenate all components
+    adata_merged = ad.concat([
+        adata_single_filtered,
+        adata_double
+    ], join='outer', merge='same')  # merge='same' preserves matching layers, obsm, etc.
+
+    # Step 5: Merge `.uns`
+    adata_merged.uns = {**adata_single.uns, **adata_double.uns}
+
+    return adata_merged
+    
 ######################################################################################################

smftools/tools/__init__.py

@@ -0,0 +1,49 @@
+from .apply_hmm import apply_hmm
+from .apply_hmm_batched import apply_hmm_batched
+from .position_stats import calculate_relative_risk_on_activity, compute_positionwise_statistic
+from .calculate_distances import calculate_distances
+from .calculate_umap import calculate_umap
+from .call_hmm_peaks import call_hmm_peaks
+from .classifiers import run_training_loop, run_inference, evaluate_models_by_subgroup, prepare_melted_model_data, sliding_window_train_test
+from .cluster_adata_on_methylation import cluster_adata_on_methylation
+from .display_hmm import display_hmm
+from .general_tools import create_nan_mask_from_X, combine_layers, create_nan_or_non_gpc_mask
+from .hmm_readwrite import load_hmm, save_hmm
+from .nucleosome_hmm_refinement import refine_nucleosome_calls, infer_nucleosomes_in_large_bound
+from .read_stats import calculate_row_entropy
+from .subset_adata import subset_adata
+from .train_hmm import train_hmm
+
+from . import models
+from . import data
+from . import utils
+from . import evaluation
+from . import inference
+from . import training
+
+__all__ = [
+    "apply_hmm",
+    "apply_hmm_batched",
+    "calculate_distances",
+    "compute_positionwise_statistic",
+    "calculate_row_entropy",
+    "calculate_umap",
+    "calculate_relative_risk_on_activity",
+    "call_hmm_peaks",
+    "cluster_adata_on_methylation",
+    "create_nan_mask_from_X",
+    "create_nan_or_non_gpc_mask",
+    "combine_layers",
+    "display_hmm",
+    "evaluate_models_by_subgroup",
+    "load_hmm",
+    "prepare_melted_model_data",
+    "refine_nucleosome_calls",
+    "infer_nucleosomes_in_large_bound",
+    "run_training_loop",
+    "run_inference",
+    "save_hmm",
+    "sliding_window_train_test"
+    "subset_adata",
+    "train_hmm"
+]

smftools/tools/apply_hmm.py

@@ -0,0 +1,202 @@
+import numpy as np
+import pandas as pd
+import torch
+from tqdm import tqdm
+
+def apply_hmm(adata, model, obs_column, layer=None, footprints=True, accessible_patches=False, cpg=False, methbases=["GpC", "CpG", "A"], device="cpu", threshold=0.7):
+    """
+    Applies an HMM model to an AnnData object using tensor-based sequence inputs.
+    If multiple methbases are passed, generates a combined feature set.
+    """
+    model.to(device)
+
+    # --- Feature Definitions ---
+    feature_sets = {}
+    if footprints:
+        feature_sets["footprint"] = {
+            "features": {
+                "small_bound_stretch": [0, 30],
+                "medium_bound_stretch": [30, 80],
+                "putative_nucleosome": [80, 200],
+                "large_bound_stretch": [200, np.inf]
+            },
+            "state": "Non-Methylated"
+        }
+    if accessible_patches:
+        feature_sets["accessible"] = {
+            "features": {
+                "small_accessible_patch": [0, 30],
+                "mid_accessible_patch": [30, 80],
+                "large_accessible_patch": [80, np.inf]
+            },
+            "state": "Methylated"
+        }
+    if cpg:
+        feature_sets["cpg"] = {
+            "features": {
+                "cpg_patch": [0, np.inf]
+            },
+            "state": "Methylated"
+        }
+
+    # --- Init columns ---
+    all_features = []
+    combined_prefix = "Combined"
+    for key, fs in feature_sets.items():
+        if key == 'cpg':
+            all_features += [f"CpG_{f}" for f in fs["features"]]
+            all_features.append(f"CpG_all_{key}_features")
+        else:
+            for methbase in methbases:
+                all_features += [f"{methbase}_{f}" for f in fs["features"]]
+                all_features.append(f"{methbase}_all_{key}_features")
+            all_features += [f"{combined_prefix}_{f}" for f in fs["features"]]
+            all_features.append(f"{combined_prefix}_all_{key}_features")
+
+    for feature in all_features:
+        adata.obs[feature] = pd.Series([[] for _ in range(adata.shape[0])], dtype=object, index=adata.obs.index)
+        adata.obs[f"{feature}_distances"] = pd.Series([None] * adata.shape[0])
+        adata.obs[f"n_{feature}"] = -1
+
+    # --- Main loop ---
+    references = adata.obs[obs_column].cat.categories
+
+    for ref in tqdm(references, desc="Processing References"):
+        ref_subset = adata[adata.obs[obs_column] == ref]
+
+        # Create combined mask for methbases
+        combined_mask = None
+        for methbase in methbases:
+            mask = {
+                "a": ref_subset.var[f"{ref}_strand_FASTA_base"] == "A",
+                "gpc": ref_subset.var[f"{ref}_GpC_site"] == True,
+                "cpg": ref_subset.var[f"{ref}_CpG_site"] == True
+            }[methbase.lower()]
+            combined_mask = mask if combined_mask is None else combined_mask | mask
+
+            methbase_subset = ref_subset[:, mask]
+            matrix = methbase_subset.layers[layer] if layer else methbase_subset.X
+
+            for i, raw_read in enumerate(matrix):
+                read = [int(x) if not np.isnan(x) else np.random.choice([0, 1]) for x in raw_read]
+                tensor_read = torch.tensor(read, dtype=torch.long, device=device).unsqueeze(0).unsqueeze(-1)
+                coords = methbase_subset.var_names
+
+                for key, fs in feature_sets.items():
+                    if key == 'cpg':
+                        continue
+                    state_target = fs["state"]
+                    feature_map = fs["features"]
+
+                    classifications = classify_features(tensor_read, model, coords, feature_map, target_state=state_target)
+                    idx = methbase_subset.obs.index[i]
+
+                    for start, length, label, prob in classifications:
+                        adata.obs.at[idx, f"{methbase}_{label}"].append([start, length, prob])
+                        adata.obs.at[idx, f"{methbase}_all_{key}_features"].append([start, length, prob])
+
+        # Combined methbase subset
+        combined_subset = ref_subset[:, combined_mask]
+        combined_matrix = combined_subset.layers[layer] if layer else combined_subset.X
+
+        for i, raw_read in enumerate(combined_matrix):
+            read = [int(x) if not np.isnan(x) else np.random.choice([0, 1]) for x in raw_read]
+            tensor_read = torch.tensor(read, dtype=torch.long, device=device).unsqueeze(0).unsqueeze(-1)
+            coords = combined_subset.var_names
+
+            for key, fs in feature_sets.items():
+                if key == 'cpg':
+                    continue
+                state_target = fs["state"]
+                feature_map = fs["features"]
+
+                classifications = classify_features(tensor_read, model, coords, feature_map, target_state=state_target)
+                idx = combined_subset.obs.index[i]
+
+                for start, length, label, prob in classifications:
+                    adata.obs.at[idx, f"{combined_prefix}_{label}"].append([start, length, prob])
+                    adata.obs.at[idx, f"{combined_prefix}_all_{key}_features"].append([start, length, prob])
+
+    # --- Special handling for CpG ---
+    if cpg:
+        for ref in tqdm(references, desc="Processing CpG"):
+            ref_subset = adata[adata.obs[obs_column] == ref]
+            mask = (ref_subset.var[f"{ref}_CpG_site"] == True)
+            cpg_subset = ref_subset[:, mask]
+            matrix = cpg_subset.layers[layer] if layer else cpg_subset.X
+
+            for i, raw_read in enumerate(matrix):
+                read = [int(x) if not np.isnan(x) else np.random.choice([0, 1]) for x in raw_read]
+                tensor_read = torch.tensor(read, dtype=torch.long, device=device).unsqueeze(0).unsqueeze(-1)
+                coords = cpg_subset.var_names
+                fs = feature_sets['cpg']
+                state_target = fs["state"]
+                feature_map = fs["features"]
+                classifications = classify_features(tensor_read, model, coords, feature_map, target_state=state_target)
+                idx = cpg_subset.obs.index[i]
+                for start, length, label, prob in classifications:
+                    adata.obs.at[idx, f"CpG_{label}"].append([start, length, prob])
+                    adata.obs.at[idx, f"CpG_all_cpg_features"].append([start, length, prob])
+
+    # --- Binarization + Distance ---
+    for feature in tqdm(all_features, desc="Finalizing Layers"):
+        bin_matrix = np.zeros((adata.shape[0], adata.shape[1]), dtype=int)
+        counts = np.zeros(adata.shape[0], dtype=int)
+        for row_idx, intervals in enumerate(adata.obs[feature]):
+            if not isinstance(intervals, list):
+                intervals = []
+            for start, length, prob in intervals:
+                if prob > threshold:
+                    bin_matrix[row_idx, start:start+length] = 1
+                    counts[row_idx] += 1
+        adata.layers[f"{feature}"] = bin_matrix
+        adata.obs[f"n_{feature}"] = counts
+        adata.obs[f"{feature}_distances"] = adata.obs[feature].apply(lambda x: calculate_distances(x, threshold))
+
+def calculate_distances(intervals, threshold=0.9):
+    """Calculates distances between consecutive features in a read."""
+    intervals = sorted([iv for iv in intervals if iv[2] > threshold], key=lambda x: x[0])
+    distances = [(intervals[i + 1][0] - (intervals[i][0] + intervals[i][1]))
+                 for i in range(len(intervals) - 1)]
+    return distances
+
+
+def classify_features(sequence, model, coordinates, classification_mapping={}, target_state="Methylated"):
+    """
+    Classifies regions based on HMM state.
+
+    Parameters:
+        sequence (torch.Tensor): Tensor of binarized data [batch_size, seq_len, 1]
+        model: Trained pomegranate HMM
+        coordinates (list): Genomic coordinates for sequence
+        classification_mapping (dict): Mapping for feature labeling
+        target_state (str): The state to classify ("Methylated" or "Non-Methylated")
+    """
+    predicted_states = model.predict(sequence).squeeze(-1).squeeze(0).cpu().numpy()
+    probabilities = model.predict_proba(sequence).squeeze(0).cpu().numpy()
+    state_labels = ["Non-Methylated", "Methylated"]
+    
+    classifications, current_start, current_length, current_probs = [], None, 0, []
+
+    for i, state_index in enumerate(predicted_states):
+        state_name = state_labels[state_index]
+        state_prob = probabilities[i][state_index]
+
+        if state_name == target_state:
+            if current_start is None:
+                current_start = i
+            current_length += 1
+            current_probs.append(state_prob)
+        elif current_start is not None:
+            classifications.append((current_start, current_length, avg := np.mean(current_probs)))
+            current_start, current_length, current_probs = None, 0, []
+
+    if current_start is not None:
+        classifications.append((current_start, current_length, avg := np.mean(current_probs)))
+
+    final = []
+    for start, length, prob in classifications:
+        feature_length = int(coordinates[start + length - 1]) - int(coordinates[start]) + 1
+        label = next((ftype for ftype, rng in classification_mapping.items() if rng[0] <= feature_length < rng[1]), target_state)
+        final.append((int(coordinates[start]) + 1, feature_length, label, prob))
+    return final