omnigenome 0.3.0a1__py3-none-any.whl → 0.3.1a0__py3-none-any.whl

omnigenome/src/metric/metric.py

@@ -20,20 +20,20 @@ from ..abc.abstract_metric import OmniMetric
 def mcrmse(y_true, y_pred):
     """
     Compute Mean Column Root Mean Square Error (MCRMSE).
-    
+
     MCRMSE is a multi-target regression metric that computes the RMSE for each target
     column and then takes the mean across all targets.
-    
+
     Args:
         y_true (np.ndarray): Ground truth values with shape (n_samples, n_targets)
         y_pred (np.ndarray): Predicted values with shape (n_samples, n_targets)
-        
+
     Returns:
         float: Mean Column Root Mean Square Error
-        
+
     Raises:
         ValueError: If y_true and y_pred have different shapes
-        
+
     Example:
         >>> y_true = np.array([[1, 2], [3, 4], [5, 6]])
         >>> y_pred = np.array([[1.1, 2.1], [2.9, 4.1], [5.2, 5.8]])
@@ -57,18 +57,18 @@ class Metric(OmniMetric):
     """
     A flexible metric class that provides access to all scikit-learn metrics
     and custom metrics for evaluation.
-    
+
     This class dynamically wraps scikit-learn metrics and provides a unified
     interface for computing various evaluation metrics. It handles different
     input formats including HuggingFace trainer outputs and supports
     custom metric functions.
-    
+
     Attributes:
         metric_func: Custom metric function if provided
         ignore_y: Value to ignore in predictions and true values
         kwargs: Additional keyword arguments for metric computation
         metrics: Dictionary of available metrics including custom ones
-        
+
     Example:
         >>> from omnigenome.src.metric import Metric
         >>> metric = Metric(ignore_y=-100)
@@ -82,7 +82,7 @@ class Metric(OmniMetric):
     def __init__(self, metric_func=None, ignore_y=-100, *args, **kwargs):
         """
         Initialize the Metric class.
-        
+
         Args:
             metric_func (callable, optional): Custom metric function to use
             ignore_y (int, optional): Value to ignore in predictions and true values. Defaults to -100
@@ -98,14 +98,14 @@ class Metric(OmniMetric):
     def __getattribute__(self, name):
         """
         Dynamically create metric computation methods.
-        
+
         This method intercepts attribute access and creates wrapper functions
         for scikit-learn metrics, handling different input formats and
         preprocessing the data appropriately.
-        
+
         Args:
             name (str): Name of the metric to access
-            
+
         Returns:
             callable: Wrapper function for the requested metric
         """
@@ -119,20 +119,20 @@ class Metric(OmniMetric):
             def wrapper(y_true=None, y_score=None, *args, **kwargs):
                 """
                 Compute the metric, based on the true and predicted values.
-                
+
                 This wrapper handles different input formats including HuggingFace
                 trainer outputs and performs necessary preprocessing.
-                
+
                 Args:
                     y_true: The true values or HuggingFace EvalPrediction object
                     y_score: The predicted values
                     ignore_y: The value to ignore in the predictions and true values in corresponding positions
                     *args: Additional positional arguments for the metric
                     **kwargs: Additional keyword arguments for the metric
-                    
+
                 Returns:
                     dict: Dictionary containing the metric name and computed value
-                    
+
                 Raises:
                     ValueError: If neither y_true nor y_score is provided
                 """
@@ -176,16 +176,16 @@ class Metric(OmniMetric):
     def compute(self, y_true, y_score, *args, **kwargs):
         """
         Compute the metric, based on the true and predicted values.
-        
+
         Args:
             y_true: The true values
             y_score: The predicted values
             *args: Additional positional arguments for the metric
             **kwargs: Additional keyword arguments for the metric
-            
+
         Returns:
             The computed metric value
-            
+
         Raises:
             NotImplementedError: If no metric function is provided and compute is not implemented
         """

omnigenome/src/metric/ranking_metric.py

@@ -20,16 +20,16 @@ from ..abc.abstract_metric import OmniMetric
 class RankingMetric(OmniMetric):
     """
     A specialized metric class for ranking tasks and evaluation.
-    
+
     This class provides access to ranking-specific metrics from scikit-learn
     and handles different input formats including HuggingFace trainer outputs.
     It dynamically wraps scikit-learn metrics and provides a unified interface
     for computing various ranking evaluation metrics.
-    
+
     Attributes:
         metric_func: Custom metric function if provided
         ignore_y: Value to ignore in predictions and true values
-        
+
     Example:
         >>> from omnigenome.src.metric import RankingMetric
         >>> metric = RankingMetric(ignore_y=-100)
@@ -43,7 +43,7 @@ class RankingMetric(OmniMetric):
     def __init__(self, *args, **kwargs):
         """
         Initialize the RankingMetric class.
-        
+
         Args:
             *args: Additional positional arguments passed to parent class
             **kwargs: Additional keyword arguments passed to parent class
@@ -53,17 +53,17 @@ class RankingMetric(OmniMetric):
     def __getattr__(self, name):
         """
         Dynamically create ranking metric computation methods.
-        
+
         This method intercepts attribute access and creates wrapper functions
         for scikit-learn ranking metrics, handling different input formats and
         preprocessing the data appropriately.
-        
+
         Args:
             name (str): Name of the ranking metric to access
-            
+
         Returns:
             callable: Wrapper function for the requested ranking metric
-            
+
         Raises:
             AttributeError: If the requested metric is not found
         """
@@ -74,17 +74,17 @@ class RankingMetric(OmniMetric):
             def wrapper(y_true=None, y_score=None, *args, **kwargs):
                 """
                 Compute the ranking metric, based on the true and predicted values.
-                
+
                 This wrapper handles different input formats including HuggingFace
                 trainer outputs and performs necessary preprocessing for ranking tasks.
-                
+
                 Args:
                     y_true: The true values or HuggingFace EvalPrediction object
                     y_score: The predicted values (scores for ranking)
                     ignore_y: The value to ignore in the predictions and true values in corresponding positions
                     *args: Additional positional arguments for the metric
                     **kwargs: Additional keyword arguments for the metric
-                    
+
                 Returns:
                     dict: Dictionary containing the metric name and computed value
                 """
@@ -121,19 +121,19 @@ class RankingMetric(OmniMetric):
     def compute(self, y_true, y_score, *args, **kwargs):
         """
         Compute the ranking metric, based on the true and predicted values.
-        
+
         This method should be implemented by subclasses to provide specific
         ranking metric computation logic.
-        
+
         Args:
             y_true: The true values
             y_score: The predicted values (scores for ranking)
             *args: Additional positional arguments for the metric
             **kwargs: Additional keyword arguments for the metric
-            
+
         Returns:
             The computed ranking metric value
-            
+
         Raises:
             NotImplementedError: If compute method is not implemented in the child class
         """

omnigenome/src/metric/regression_metric.py

@@ -20,20 +20,20 @@ from ..abc.abstract_metric import OmniMetric
 def mcrmse(y_true, y_pred):
     """
     Compute Mean Column Root Mean Square Error (MCRMSE).
-    
+
     MCRMSE is a multi-target regression metric that computes the RMSE for each target
     column and then takes the mean across all targets.
-    
+
     Args:
         y_true (np.ndarray): Ground truth values with shape (n_samples, n_targets)
         y_pred (np.ndarray): Predicted values with shape (n_samples, n_targets)
-        
+
     Returns:
         float: Mean Column Root Mean Square Error
-        
+
     Raises:
         ValueError: If y_true and y_pred have different shapes
-        
+
     Example:
         >>> y_true = np.array([[1, 2], [3, 4], [5, 6]])
         >>> y_pred = np.array([[1.1, 2.1], [2.9, 4.1], [5.2, 5.8]])
@@ -56,18 +56,18 @@ setattr(metrics, "mcrmse", mcrmse)
 class RegressionMetric(OmniMetric):
     """
     A specialized metric class for regression tasks and evaluation.
-    
+
     This class provides access to regression-specific metrics from scikit-learn
     and handles different input formats including HuggingFace trainer outputs.
     It dynamically wraps scikit-learn metrics and provides a unified interface
     for computing various regression evaluation metrics.
-    
+
     Attributes:
         metric_func: Custom metric function if provided
         ignore_y: Value to ignore in predictions and true values
         kwargs: Additional keyword arguments for metric computation
         metrics: Dictionary of available metrics including custom ones
-        
+
     Example:
         >>> from omnigenome.src.metric import RegressionMetric
         >>> metric = RegressionMetric(ignore_y=-100)
@@ -81,7 +81,7 @@ class RegressionMetric(OmniMetric):
     def __init__(self, metric_func=None, ignore_y=-100, *args, **kwargs):
         """
         Initialize the RegressionMetric class.
-        
+
         Args:
             metric_func (callable, optional): Custom metric function to use
             ignore_y (int, optional): Value to ignore in predictions and true values. Defaults to -100
@@ -97,14 +97,14 @@ class RegressionMetric(OmniMetric):
     def __getattribute__(self, name):
         """
         Dynamically create regression metric computation methods.
-        
+
         This method intercepts attribute access and creates wrapper functions
         for scikit-learn regression metrics, handling different input formats and
         preprocessing the data appropriately.
-        
+
         Args:
             name (str): Name of the regression metric to access
-            
+
         Returns:
             callable: Wrapper function for the requested regression metric
         """
@@ -118,17 +118,17 @@ class RegressionMetric(OmniMetric):
             def wrapper(y_true=None, y_score=None, *args, **kwargs):
                 """
                 Compute the regression metric, based on the true and predicted values.
-                
+
                 This wrapper handles different input formats including HuggingFace
                 trainer outputs and performs necessary preprocessing for regression tasks.
-                
+
                 Args:
                     y_true: The true values or HuggingFace EvalPrediction object
                     y_score: The predicted values
                     ignore_y: The value to ignore in the predictions and true values in corresponding positions
                     *args: Additional positional arguments for the metric
                     **kwargs: Additional keyword arguments for the metric
-                    
+
                 Returns:
                     dict: Dictionary containing the metric name and computed value
                 """
@@ -168,16 +168,16 @@ class RegressionMetric(OmniMetric):
     def compute(self, y_true, y_score, *args, **kwargs):
         """
         Compute the regression metric, based on the true and predicted values.
-        
+
         Args:
             y_true: The true values
             y_score: The predicted values
             *args: Additional positional arguments for the metric
             **kwargs: Additional keyword arguments for the metric
-            
+
         Returns:
             The computed regression metric value
-            
+
         Raises:
             NotImplementedError: If no metric function is provided and compute is not implemented
         """

omnigenome/src/misc/utils.py

@@ -25,13 +25,13 @@ default_omnigenome_repo = (
 def seed_everything(seed=42):
     """
     Sets random seeds for reproducibility across all random number generators.
-    
+
     This function sets seeds for Python's random module, NumPy, PyTorch (CPU and CUDA),
     and sets the PYTHONHASHSEED environment variable to ensure reproducible results
     across different runs.
-    
+
     Args:
-        seed (int): The seed value to use for all random number generators. 
+        seed (int): The seed value to use for all random number generators.
                    Defaults to 42.
 
     Example:
@@ -55,11 +55,11 @@ def seed_everything(seed=42):
 class RNA2StructureCache(dict):
     """
     A cache for RNA secondary structure predictions using ViennaRNA.
-    
+
     This class provides a caching mechanism for RNA secondary structure predictions
     to avoid redundant computations. It supports both single sequence and batch
     processing with optional multiprocessing for improved performance.
-    
+
     Attributes:
         cache (dict): Dictionary storing sequence-structure mappings
         cache_file (str): Path to the cache file on disk
@@ -69,7 +69,7 @@ class RNA2StructureCache(dict):
     def __init__(self, cache_file=None, *args, **kwargs):
         """
         Initialize the RNA structure cache.
-        
+
         Args:
             cache_file (str, optional): Path to the cache file. If None, uses
                                       a default temporary file.
@@ -112,10 +112,10 @@ class RNA2StructureCache(dict):
     def _fold_single_sequence(self, sequence):
         """
         Predict structure for a single sequence (worker function for multiprocessing).
-        
+
         Args:
             sequence (str): RNA sequence to fold
-            
+
         Returns:
             tuple: (structure, mfe) tuple
         """
@@ -128,12 +128,12 @@ class RNA2StructureCache(dict):
     def fold(self, sequence, return_mfe=False, num_workers=1):
         """
         Predicts RNA secondary structure for given sequences.
-        
+
         This method predicts RNA secondary structures using ViennaRNA. It supports
         both single sequences and batches of sequences. The method uses caching
         to avoid redundant predictions and supports multiprocessing for batch
         processing on non-Windows systems.
-        
+
         Args:
             sequence (str or list): A single RNA sequence or a list of sequences.
             return_mfe (bool): Whether to return minimum free energy along with
@@ -150,7 +150,7 @@ class RNA2StructureCache(dict):
             >>> # Predict structure for a single sequence
             >>> structure = cache.fold("GGGAAAUCC")
             >>> print(structure)  # "(((...)))"
-            
+
             >>> # Predict structures for multiple sequences
             >>> structures = cache.fold(["GGGAAAUCC", "AUUGCUAA"])
             >>> print(structures)  # ["(((...)))", "........"]
@@ -162,36 +162,40 @@ class RNA2StructureCache(dict):
 
         # Determine if we should use multiprocessing
         use_multiprocessing = (
-            os.name != "nt" and  # Not Windows
-            len(sequences) > 1 and  # Multiple sequences
-            num_workers > 1  # Multiple workers requested
+            os.name != "nt"  # Not Windows
+            and len(sequences) > 1  # Multiple sequences
+            and num_workers > 1  # Multiple workers requested
         )
 
         # Find sequences that need prediction
         sequences_to_predict = [seq for seq in sequences if seq not in self.cache]
-        
+
         if sequences_to_predict:
             if use_multiprocessing:
                 # Use multiprocessing for batch prediction
                 if num_workers is None:
                     num_workers = min(os.cpu_count(), len(sequences_to_predict))
-                
+
                 try:
                     # Set multiprocessing start method to 'spawn' for better compatibility
-                    if multiprocessing.get_start_method(allow_none=True) != 'spawn':
-                        multiprocessing.set_start_method('spawn', force=True)
-                    
+                    if multiprocessing.get_start_method(allow_none=True) != "spawn":
+                        multiprocessing.set_start_method("spawn", force=True)
+
                     with multiprocessing.Pool(num_workers) as pool:
                         # Use map instead of apply_async for better error handling
-                        results = pool.map(self._fold_single_sequence, sequences_to_predict)
-                        
+                        results = pool.map(
+                            self._fold_single_sequence, sequences_to_predict
+                        )
+
                         # Update cache with results
                         for seq, result in zip(sequences_to_predict, results):
                             self.cache[seq] = result
                             self.queue_num += 1
-                            
+
                 except Exception as e:
-                    warnings.warn(f"Multiprocessing failed, falling back to sequential: {e}")
+                    warnings.warn(
+                        f"Multiprocessing failed, falling back to sequential: {e}"
+                    )
                     # Fallback to sequential processing
                     for seq in sequences_to_predict:
                         self.cache[seq] = self._fold_single_sequence(seq)
@@ -207,7 +211,7 @@ class RNA2StructureCache(dict):
             structures = [self.cache[seq] for seq in sequences]
         else:
             structures = [self.cache[seq][0] for seq in sequences]
-        
+
         # Update cache file periodically
         self.update_cache_file(self.cache_file)
 
@@ -220,10 +224,10 @@ class RNA2StructureCache(dict):
     def update_cache_file(self, cache_file=None):
         """
         Updates the cache file on disk.
-        
+
         This method saves the in-memory cache to disk. It only saves when
         the queue_num reaches 100 to avoid excessive disk I/O.
-        
+
         Args:
             cache_file (str, optional): Path to the cache file. If None, uses
                                       the instance's cache_file.
@@ -252,11 +256,11 @@ class RNA2StructureCache(dict):
 def env_meta_info():
     """
     Collects metadata about the current environment and library versions.
-    
+
     This function gathers information about the current Python environment,
     including versions of key libraries like PyTorch and Transformers,
     as well as OmniGenome version information.
-    
+
     Returns:
         dict: A dictionary containing environment metadata including:
               - library_name: Name of the OmniGenome library
@@ -286,7 +290,7 @@ def env_meta_info():
 def naive_secondary_structure_repair(sequence, structure):
     """
     Repair the secondary structure of a sequence.
-    
+
     This function attempts to repair malformed RNA secondary structure
     representations by ensuring proper bracket matching. It handles
     common issues like unmatched brackets by converting them to dots.
@@ -324,7 +328,7 @@ def naive_secondary_structure_repair(sequence, structure):
 def save_args(config, save_path):
     """
     Save arguments to a file.
-    
+
     This function saves the arguments from a configuration object to a text file.
     It's useful for logging experiment parameters and configurations.
 
@@ -347,7 +351,7 @@ def save_args(config, save_path):
 def print_args(config, logger=None):
     """
     Print the arguments to the console.
-    
+
     This function prints the arguments from a configuration object to the console
     or a logger. It's useful for debugging and logging experiment parameters.
 
@@ -373,7 +377,7 @@ def print_args(config, logger=None):
 def fprint(*objects, sep=" ", end="\n", file=sys.stdout, flush=False):
     """
     Enhanced print function with automatic flushing.
-    
+
     This function provides a print-like interface with automatic flushing
     to ensure output is displayed immediately. It's useful for real-time
     logging and progress tracking.
@@ -395,7 +399,7 @@ def fprint(*objects, sep=" ", end="\n", file=sys.stdout, flush=False):
 def clean_temp_checkpoint(days_threshold=7):
     """
     Clean up temporary checkpoint files older than specified days.
-    
+
     This function removes temporary checkpoint files that are older than
     the specified threshold to free up disk space.
 
@@ -431,7 +435,7 @@ def clean_temp_checkpoint(days_threshold=7):
 def load_module_from_path(module_name, file_path):
     """
     Load a Python module from a file path.
-    
+
     This function dynamically loads a Python module from a file path,
     useful for loading configuration files or custom modules.
 
@@ -457,7 +461,7 @@ def load_module_from_path(module_name, file_path):
 def check_bench_version(bench_version, omnigenome_version):
     """
     Check if benchmark version is compatible with OmniGenome version.
-    
+
     This function compares the benchmark version with the OmniGenome version
     to ensure compatibility and warns if there are potential issues.
 
@@ -479,7 +483,7 @@ def check_bench_version(bench_version, omnigenome_version):
 def clean_temp_dir_pt_files():
     """
     Clean up temporary PyTorch files in the current directory.
-    
+
     This function removes temporary PyTorch files (like .pt, .pth files)
     that may be left over from previous runs.
 

omnigenome/src/model/augmentation/__init__.py

@@ -9,4 +9,3 @@
 """
 This package contains modules for data augmentation.
 """
-

omnigenome/src/model/augmentation/model.py

@@ -24,12 +24,12 @@ import autocuda
 class OmniModelForAugmentation(torch.nn.Module):
     """
     Data augmentation model for genomic sequences using masked language modeling.
-    
+
     This model uses a pre-trained masked language model to generate augmented
     versions of genomic sequences by randomly masking tokens and predicting
     replacements. It's useful for expanding training datasets and improving
     model generalization.
-    
+
     Attributes:
         tokenizer: Tokenizer for processing genomic sequences
         model: Pre-trained masked language model
@@ -38,7 +38,7 @@ class OmniModelForAugmentation(torch.nn.Module):
         max_length: Maximum sequence length for tokenization
         k: Number of augmented instances to generate per sequence
     """
-    
+
     def __init__(
         self,
         model_name_or_path=None,
@@ -50,7 +50,7 @@ class OmniModelForAugmentation(torch.nn.Module):
     ):
         """
         Initialize the augmentation model.
-        
+
         Args:
             model_name_or_path (str): Path or model name for loading the pre-trained model
             noise_ratio (float): The proportion of tokens to mask in each sequence for augmentation (default: 0.15)
@@ -82,10 +82,10 @@ class OmniModelForAugmentation(torch.nn.Module):
     def load_sequences_from_file(self, input_file):
         """
         Load sequences from a JSON file.
-        
+
         Args:
             input_file (str): Path to the input JSON file containing sequences
-            
+
         Returns:
             list: List of sequences loaded from the file
         """
@@ -98,10 +98,10 @@ class OmniModelForAugmentation(torch.nn.Module):
     def apply_noise_to_sequence(self, seq):
         """
         Apply noise to a single sequence by randomly masking tokens.
-        
+
         Args:
             seq (str): Input genomic sequence
-            
+
         Returns:
             str: Sequence with randomly masked tokens
         """
@@ -114,10 +114,10 @@ class OmniModelForAugmentation(torch.nn.Module):
     def augment_sequence(self, seq):
         """
         Perform augmentation on a single sequence by predicting masked tokens.
-        
+
         Args:
             seq (str): Input genomic sequence with masked tokens
-            
+
         Returns:
             str: Augmented sequence with predicted tokens replacing masked tokens
         """
@@ -145,11 +145,11 @@ class OmniModelForAugmentation(torch.nn.Module):
     def augment(self, seq, k=None):
         """
         Generate multiple augmented instances for a single sequence.
-        
+
         Args:
             seq (str): Input genomic sequence
             k (int, optional): Number of augmented instances to generate (default: None, uses self.k)
-            
+
         Returns:
             list: List of augmented sequences
         """
@@ -163,10 +163,10 @@ class OmniModelForAugmentation(torch.nn.Module):
     def augment_sequences(self, sequences):
         """
         Augment a list of sequences by applying noise and performing MLM-based predictions.
-        
+
         Args:
             sequences (list): List of genomic sequences to augment
-            
+
         Returns:
             list: List of all augmented sequences
         """
@@ -179,7 +179,7 @@ class OmniModelForAugmentation(torch.nn.Module):
     def save_augmented_sequences(self, augmented_sequences, output_file):
         """
         Save augmented sequences to a JSON file.
-        
+
         Args:
             augmented_sequences (list): List of augmented sequences to save
             output_file (str): Path to the output JSON file
@@ -191,10 +191,10 @@ class OmniModelForAugmentation(torch.nn.Module):
     def augment_from_file(self, input_file, output_file):
         """
         Main function to handle the augmentation process from a file input to a file output.
-        
+
         This method loads sequences from an input file, augments them using the MLM model,
         and saves the augmented sequences to an output file.
-        
+
         Args:
             input_file (str): Path to the input file containing sequences
             output_file (str): Path to the output file where augmented sequences will be saved