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

omnigenome/src/model/classification/__init__.py

@@ -9,4 +9,3 @@
 """
 This package contains modules for classification models.
 """
-

omnigenome/src/model/classification/model.py

@@ -16,16 +16,16 @@ from ..module_utils import OmniPooling
 class OmniModelForTokenClassification(OmniModel):
     """
     Model for token classification tasks in genomics.
-    
+
     This model is designed for token-level classification tasks such as
     sequence labeling, where each token in the input sequence needs to be
     classified into different categories. It extends the base OmniModel
     with token-level classification capabilities.
-    
+
     The model adds a classification head on top of the base model's hidden
     states and applies softmax to produce probability distributions over
     the label classes for each token.
-    
+
     Attributes:
         softmax (torch.nn.Softmax): Softmax layer for probability computation.
         classifier (torch.nn.Linear): Linear classification head.
@@ -57,7 +57,7 @@ class OmniModelForTokenClassification(OmniModel):
     def forward(self, **inputs):
         """
         Forward pass for token classification.
-        
+
         This method performs the forward pass through the model, computing
         logits for each token in the input sequence and applying softmax
         to produce probability distributions.
@@ -95,13 +95,13 @@ class OmniModelForTokenClassification(OmniModel):
     def predict(self, sequence_or_inputs, **kwargs):
         """
         Performs token-level prediction on raw inputs.
-        
+
         This method takes raw sequences or tokenized inputs and returns
         token-level predictions. It processes the inputs through the model
         and returns the predicted class for each token.
 
         Args:
-            sequence_or_inputs: A sequence (str), list of sequences, or 
+            sequence_or_inputs: A sequence (str), list of sequences, or
                                tokenized inputs (dict/tuple).
             **kwargs: Additional arguments for tokenization and inference.
 
@@ -115,7 +115,7 @@ class OmniModelForTokenClassification(OmniModel):
             >>> # Predict on a single sequence
             >>> outputs = model.predict("ATCGATCG")
             >>> print(outputs['predictions'].shape)  # (seq_len,)
-            
+
             >>> # Predict on multiple sequences
             >>> outputs = model.predict(["ATCGATCG", "GCTAGCTA"])
         """
@@ -142,12 +142,12 @@ class OmniModelForTokenClassification(OmniModel):
     def inference(self, sequence_or_inputs, **kwargs):
         """
         Performs token-level inference with human-readable output.
-        
+
         This method provides processed, human-readable token-level predictions.
         It converts logits to class labels and handles special tokens appropriately.
 
         Args:
-            sequence_or_inputs: A sequence (str), list of sequences, or 
+            sequence_or_inputs: A sequence (str), list of sequences, or
                                tokenized inputs (dict/tuple).
             **kwargs: Additional arguments for tokenization and inference.
 
@@ -200,7 +200,7 @@ class OmniModelForTokenClassification(OmniModel):
     def loss_function(self, logits, labels):
         """
         Calculates the cross-entropy loss for token classification.
-        
+
         This method computes the cross-entropy loss between the predicted
         logits and the ground truth labels, ignoring padding tokens.
 
@@ -221,11 +221,11 @@ class OmniModelForTokenClassification(OmniModel):
 class OmniModelForSequenceClassification(OmniModel):
     """
     Model for sequence classification tasks in genomics.
-    
+
     This model is designed for sequence-level classification tasks where
     the entire input sequence is classified into one of several categories.
     It extends the base OmniModel with sequence-level classification capabilities.
-    
+
     The model uses a pooling mechanism to aggregate token-level representations
     into a sequence-level representation, which is then classified using a
     linear classifier.
@@ -263,7 +263,7 @@ class OmniModelForSequenceClassification(OmniModel):
     def forward(self, **inputs):
         """
         Forward pass for sequence classification.
-        
+
         This method performs the forward pass through the model, computing
         sequence-level logits and applying softmax to produce probability
         distributions over the label classes.
@@ -302,13 +302,13 @@ class OmniModelForSequenceClassification(OmniModel):
     def predict(self, sequence_or_inputs, **kwargs):
         """
         Performs sequence-level prediction on raw inputs.
-        
+
         This method takes raw sequences or tokenized inputs and returns
         sequence-level predictions. It processes the inputs through the model
         and returns the predicted class for each sequence.
 
         Args:
-            sequence_or_inputs: A sequence (str), list of sequences, or 
+            sequence_or_inputs: A sequence (str), list of sequences, or
                                tokenized inputs (dict/tuple).
             **kwargs: Additional arguments for tokenization and inference.
 
@@ -322,7 +322,7 @@ class OmniModelForSequenceClassification(OmniModel):
             >>> # Predict on a single sequence
             >>> outputs = model.predict("ATCGATCG")
             >>> print(outputs['predictions'])  # tensor([0])
-            
+
             >>> # Predict on multiple sequences
             >>> outputs = model.predict(["ATCGATCG", "GCTAGCTA"])
         """
@@ -350,12 +350,12 @@ class OmniModelForSequenceClassification(OmniModel):
     def inference(self, sequence_or_inputs, **kwargs):
         """
         Performs sequence-level inference with human-readable output.
-        
+
         This method provides processed, human-readable sequence-level predictions.
         It converts logits to class labels and provides confidence scores.
 
         Args:
-            sequence_or_inputs: A sequence (str), list of sequences, or 
+            sequence_or_inputs: A sequence (str), list of sequences, or
                                tokenized inputs (dict/tuple).
             **kwargs: Additional arguments for tokenization and inference.
 
@@ -403,7 +403,7 @@ class OmniModelForSequenceClassification(OmniModel):
     def loss_function(self, logits, labels):
         """
         Calculates the cross-entropy loss for sequence classification.
-        
+
         This method computes the cross-entropy loss between the predicted
         logits and the ground truth labels.
 
@@ -421,16 +421,14 @@ class OmniModelForSequenceClassification(OmniModel):
         return loss
 
 
-class OmniModelForMultiLabelSequenceClassification(
-    OmniModelForSequenceClassification
-):
+class OmniModelForMultiLabelSequenceClassification(OmniModelForSequenceClassification):
     """
     Model for multi-label sequence classification tasks in genomics.
-    
+
     This model is designed for multi-label classification tasks where
     a single sequence can be assigned multiple labels simultaneously.
     It extends the sequence classification model with multi-label capabilities.
-    
+
     The model uses sigmoid activation instead of softmax to allow multiple
     labels per sequence and uses binary cross-entropy loss for training.
 
@@ -461,7 +459,7 @@ class OmniModelForMultiLabelSequenceClassification(
     def loss_function(self, logits, labels):
         """
         Calculates the binary cross-entropy loss for multi-label classification.
-        
+
         This method computes the binary cross-entropy loss between the predicted
         probabilities and the ground truth multi-label targets.
 
@@ -481,13 +479,13 @@ class OmniModelForMultiLabelSequenceClassification(
     def predict(self, sequence_or_inputs, **kwargs):
         """
         Performs multi-label prediction on raw inputs.
-        
+
         This method takes raw sequences or tokenized inputs and returns
         multi-label predictions. It applies a threshold to determine
         which labels are active for each sequence.
 
         Args:
-            sequence_or_inputs: A sequence (str), list of sequences, or 
+            sequence_or_inputs: A sequence (str), list of sequences, or
                                tokenized inputs (dict/tuple).
             **kwargs: Additional arguments for tokenization and inference.
 
@@ -527,12 +525,12 @@ class OmniModelForMultiLabelSequenceClassification(
     def inference(self, sequence_or_inputs, **kwargs):
         """
         Performs multi-label inference with human-readable output.
-        
+
         This method provides processed, human-readable multi-label predictions.
         It converts logits to binary labels and provides confidence scores.
 
         Args:
-            sequence_or_inputs: A sequence (str), list of sequences, or 
+            sequence_or_inputs: A sequence (str), list of sequences, or
                                tokenized inputs (dict/tuple).
             **kwargs: Additional arguments for tokenization and inference.
 
@@ -551,9 +549,7 @@ class OmniModelForMultiLabelSequenceClassification(
         return self.predict(sequence_or_inputs, **kwargs)
 
 
-class OmniModelForTokenClassificationWith2DStructure(
-    OmniModelForTokenClassification
-):
+class OmniModelForTokenClassificationWith2DStructure(OmniModelForTokenClassification):
     def __init__(self, config_or_model, tokenizer, *args, **kwargs):
         super().__init__(config_or_model, tokenizer, *args, **kwargs)
         self.metadata["model_name"] = self.__class__.__name__

omnigenome/src/model/embedding/__init__.py

@@ -9,4 +9,3 @@
 """
 This package contains modules for embedding models.
 """
-

omnigenome/src/model/embedding/model.py

@@ -16,16 +16,16 @@ from omnigenome.src.misc.utils import fprint
 class OmniModelForEmbedding(torch.nn.Module):
     """
     A wrapper class for generating embeddings from pre-trained models.
-    
+
     This class provides a unified interface for loading pre-trained models and
     generating embeddings from genomic sequences. It supports various aggregation
     methods and batch processing for efficient embedding generation.
-    
+
     Attributes:
         tokenizer: The tokenizer for processing input sequences
         model: The pre-trained model for generating embeddings
         _device: The device (CPU/GPU) where the model is loaded
-        
+
     Example:
         >>> from omnigenome import OmniModelForEmbedding
         >>> model = OmniModelForEmbedding("anonymous8/OmniGenome-186M")
@@ -34,11 +34,11 @@ class OmniModelForEmbedding(torch.nn.Module):
         >>> print(f"Embeddings shape: {embeddings.shape}")
         torch.Size([2, 768])
     """
-    
+
     def __init__(self, model_name_or_path, *args, **kwargs):
         """
         Initialize the embedding model.
-        
+
         Args:
             model_name_or_path (str): Name or path of the pre-trained model to load
             *args: Additional positional arguments passed to AutoModel.from_pretrained
@@ -51,25 +51,25 @@ class OmniModelForEmbedding(torch.nn.Module):
         self.model.to(self._device)
         self.model.eval()  # Set model to evaluation mode
 
-    def batch_encode(self, sequences, batch_size=8, max_length=512, agg='head'):
+    def batch_encode(self, sequences, batch_size=8, max_length=512, agg="head"):
         """
         Encode a list of sequences to their corresponding embeddings.
-        
+
         This method processes sequences in batches for memory efficiency and
         supports different aggregation methods for the final embeddings.
-        
+
         Args:
             sequences (list of str): List of input sequences to encode
             batch_size (int, optional): Batch size for processing. Defaults to 8
             max_length (int, optional): Maximum sequence length for encoding. Defaults to 512
             agg (str, optional): Aggregation method for embeddings. Options are 'head', 'mean', 'tail'. Defaults to 'head'
-            
+
         Returns:
             torch.Tensor: Embeddings for the input sequences with shape (n_sequences, embedding_dim)
-            
+
         Raises:
             ValueError: If unsupported aggregation method is provided
-            
+
         Example:
             >>> sequences = ["ATCGGCTA", "GGCTAGCTA", "TATCGCTA"]
             >>> embeddings = model.batch_encode(sequences, batch_size=2, agg='mean')
@@ -79,7 +79,7 @@ class OmniModelForEmbedding(torch.nn.Module):
         embeddings = []
 
         for i in range(0, len(sequences), batch_size):
-            batch_sequences = sequences[i: i + batch_size]
+            batch_sequences = sequences[i : i + batch_size]
             inputs = self.tokenizer(
                 batch_sequences,
                 return_tensors="pt",
@@ -94,19 +94,19 @@ class OmniModelForEmbedding(torch.nn.Module):
 
             batch_embeddings = outputs.last_hidden_state.cpu()
 
-            if agg == 'head':
+            if agg == "head":
                 emb = batch_embeddings[:, 0, :]
-            elif agg == 'mean':
+            elif agg == "mean":
                 attention_mask = inputs["attention_mask"].cpu()
                 masked_embeddings = batch_embeddings * attention_mask.unsqueeze(-1)
                 lengths = attention_mask.sum(dim=1).unsqueeze(1)
                 emb = masked_embeddings.sum(dim=1) / lengths
-            elif agg == 'tail':
+            elif agg == "tail":
                 attention_mask = inputs["attention_mask"]
                 lengths = attention_mask.sum(dim=1) - 1
-                emb = torch.stack([
-                    batch_embeddings[i, l.item()] for i, l in enumerate(lengths)
-                ])
+                emb = torch.stack(
+                    [batch_embeddings[i, l.item()] for i, l in enumerate(lengths)]
+                )
             else:
                 raise ValueError(f"Unsupported aggregation method: {agg}")
 
@@ -116,22 +116,22 @@ class OmniModelForEmbedding(torch.nn.Module):
         fprint(f"Generated embeddings for {len(sequences)} sequences.")
         return embeddings
 
-    def encode(self, sequence, max_length=512, agg='head', keep_dim=False):
+    def encode(self, sequence, max_length=512, agg="head", keep_dim=False):
         """
         Encode a single sequence to its corresponding embedding.
-        
+
         Args:
             sequence (str): Input sequence to encode
             max_length (int, optional): Maximum sequence length for encoding. Defaults to 512
             agg (str, optional): Aggregation method. Options are 'head', 'mean', 'tail'. Defaults to 'head'
             keep_dim (bool, optional): Whether to retain the batch dimension. Defaults to False
-            
+
         Returns:
             torch.Tensor: Embedding for the input sequence
-            
+
         Raises:
             ValueError: If unsupported aggregation method is provided
-            
+
         Example:
             >>> sequence = "ATCGGCTA"
             >>> embedding = model.encode(sequence, agg='mean')
@@ -152,15 +152,15 @@ class OmniModelForEmbedding(torch.nn.Module):
 
         last_hidden = outputs.last_hidden_state.cpu()
 
-        if agg == 'head':
+        if agg == "head":
             emb = last_hidden[0, 0]
-        elif agg == 'mean':
+        elif agg == "mean":
             attention_mask = inputs["attention_mask"].cpu()
             masked_embeddings = last_hidden * attention_mask.unsqueeze(-1)
             lengths = attention_mask.sum(dim=1).unsqueeze(1)
             emb = masked_embeddings.sum(dim=1) / lengths
             emb = emb.squeeze(0)
-        elif agg == 'tail':
+        elif agg == "tail":
             attention_mask = inputs["attention_mask"]
             lengths = attention_mask.sum(dim=1) - 1
             emb = last_hidden[0, lengths[0].item()]
@@ -172,11 +172,11 @@ class OmniModelForEmbedding(torch.nn.Module):
     def save_embeddings(self, embeddings, output_path):
         """
         Save the generated embeddings to a file.
-        
+
         Args:
             embeddings (torch.Tensor): The embeddings to save
             output_path (str): Path to save the embeddings
-            
+
         Example:
             >>> embeddings = model.batch_encode(sequences)
             >>> model.save_embeddings(embeddings, "embeddings.pt")
@@ -188,13 +188,13 @@ class OmniModelForEmbedding(torch.nn.Module):
     def load_embeddings(self, embedding_path):
         """
         Load embeddings from a file.
-        
+
         Args:
             embedding_path (str): Path to the saved embeddings
-            
+
         Returns:
             torch.Tensor: The loaded embeddings
-            
+
         Example:
             >>> embeddings = model.load_embeddings("embeddings.pt")
             >>> print(f"Loaded embeddings shape: {embeddings.shape}")
@@ -207,15 +207,15 @@ class OmniModelForEmbedding(torch.nn.Module):
     def compute_similarity(self, embedding1, embedding2, dim=0):
         """
         Compute cosine similarity between two embeddings.
-        
+
         Args:
             embedding1 (torch.Tensor): The first embedding
             embedding2 (torch.Tensor): The second embedding
             dim (int, optional): Dimension along which to compute cosine similarity. Defaults to 0
-            
+
         Returns:
             float: Cosine similarity score between -1 and 1
-            
+
         Example:
             >>> emb1 = model.encode("ATCGGCTA")
             >>> emb2 = model.encode("GGCTAGCTA")
@@ -232,7 +232,7 @@ class OmniModelForEmbedding(torch.nn.Module):
     def device(self):
         """
         Get the current device ('cuda' or 'cpu').
-        
+
         Returns:
             torch.device: The device where the model is loaded
         """

omnigenome/src/model/mlm/__init__.py

@@ -9,4 +9,3 @@
 """
 This package contains modules for Masked Language Models (MLM).
 """
-

omnigenome/src/model/mlm/model.py

@@ -23,26 +23,26 @@ from ...abc.abstract_model import OmniModel
 class OmniModelForMLM(OmniModel):
     """
     Masked Language Model for genomic sequences.
-    
+
     This model implements masked language modeling for genomic sequences, where
     tokens are randomly masked and the model learns to predict the original tokens.
     It's useful for pre-training genomic language models and understanding sequence
     patterns and dependencies.
-    
+
     Attributes:
         loss_fn: Cross-entropy loss function for masked language modeling
     """
-    
+
     def __init__(self, config_or_model, tokenizer, *args, **kwargs):
         """
         Initialize the MLM model.
-        
+
         Args:
             config_or_model: Model configuration or pre-trained model
             tokenizer: Tokenizer for processing input sequences
             *args: Additional positional arguments
             **kwargs: Additional keyword arguments
-            
+
         Raises:
             ValueError: If the model doesn't support masked language modeling
         """
@@ -59,10 +59,10 @@ class OmniModelForMLM(OmniModel):
     def forward(self, **inputs):
         """
         Forward pass for masked language modeling.
-        
+
         Args:
             **inputs: Input tensors including input_ids, attention_mask, and labels
-            
+
         Returns:
             dict: Dictionary containing loss, logits, and last_hidden_state
         """
@@ -85,11 +85,11 @@ class OmniModelForMLM(OmniModel):
     def predict(self, sequence_or_inputs, **kwargs):
         """
         Generate predictions for masked language modeling.
-        
+
         Args:
             sequence_or_inputs: Input sequences or pre-processed inputs
             **kwargs: Additional keyword arguments
-            
+
         Returns:
             dict: Dictionary containing predictions, logits, and last_hidden_state
         """
@@ -124,11 +124,11 @@ class OmniModelForMLM(OmniModel):
     def inference(self, sequence_or_inputs, **kwargs):
         """
         Perform inference for masked language modeling, decoding predictions to sequences.
-        
+
         Args:
             sequence_or_inputs: Input sequences or pre-processed inputs
             **kwargs: Additional keyword arguments
-            
+
         Returns:
             dict: Dictionary containing decoded predictions, logits, and last_hidden_state
         """
@@ -164,11 +164,11 @@ class OmniModelForMLM(OmniModel):
     def loss_function(self, logits, labels):
         """
         Compute the loss for masked language modeling.
-        
+
         Args:
             logits (torch.Tensor): Model predictions [batch_size, seq_len, vocab_size]
             labels (torch.Tensor): Ground truth labels [batch_size, seq_len]
-            
+
         Returns:
             torch.Tensor: Computed cross-entropy loss value
         """

omnigenome/src/model/module_utils.py

@@ -22,21 +22,21 @@ from transformers.tokenization_utils_base import BatchEncoding
 class OmniPooling(torch.nn.Module):
     """
     A flexible pooling layer for OmniGenome models that handles different input formats.
-    
+
     This class provides a unified interface for pooling operations across different
     model architectures, supporting both causal language models and encoder-based models.
     It can handle various input formats including tuples, dictionaries, BatchEncoding
     objects, and tensors.
-    
+
     Attributes:
         config: Model configuration object containing architecture and tokenizer settings
         pooler: BertPooler instance for non-causal models, None for causal models
     """
-    
+
     def __init__(self, config, *args, **kwargs):
         """
         Initialize the OmniPooling layer.
-        
+
         Args:
             config: Model configuration object containing architecture information
             *args: Additional positional arguments
@@ -49,18 +49,18 @@ class OmniPooling(torch.nn.Module):
     def forward(self, inputs, last_hidden_state):
         """
         Perform pooling operation on the last hidden state.
-        
+
         This method handles different input formats and applies appropriate pooling:
         - For causal language models: Uses the last non-padded token
         - For encoder models: Uses the BertPooler
-        
+
         Args:
             inputs: Input data in various formats (tuple, dict, BatchEncoding, or tensor)
             last_hidden_state (torch.Tensor): Hidden states from the model [batch_size, seq_len, hidden_size]
-            
+
         Returns:
             torch.Tensor: Pooled representation [batch_size, hidden_size]
-            
+
         Raises:
             ValueError: If input format is not supported or cannot be parsed
         """
@@ -110,9 +110,9 @@ class OmniPooling(torch.nn.Module):
     def _is_causal_lm(self):
         """
         Check if the model is a causal language model.
-        
+
         Determines if the model architecture is causal based on the configuration.
-        
+
         Returns:
             bool: True if the model is a causal language model, False otherwise
         """
@@ -175,25 +175,25 @@ class OmniPooling(torch.nn.Module):
 class InteractingAttention(nn.Module):
     """
     An interacting attention mechanism for sequence modeling.
-    
+
     This class implements a multi-head attention mechanism with residual connections
     and layer normalization. It's designed for processing sequences where different
     parts of the sequence need to interact with each other.
-    
+
     Attributes:
         attention: Multi-head attention layer
         layer_norm: Layer normalization for residual connections
         fc_out: Output projection layer
     """
-    
+
     def __init__(self, embed_size, num_heads=24):
         """
         Initialize the InteractingAttention module.
-        
+
         Args:
             embed_size (int): Size of the embedding dimension
             num_heads (int): Number of attention heads (default: 24)
-            
+
         Raises:
             AssertionError: If embed_size is not divisible by num_heads
         """
@@ -213,12 +213,12 @@ class InteractingAttention(nn.Module):
     def forward(self, query, keys, values):
         """
         Forward pass through the interacting attention mechanism.
-        
+
         Args:
             query (torch.Tensor): Query tensor [batch_size, query_len, embed_size]
             keys (torch.Tensor): Key tensor [batch_size, key_len, embed_size]
             values (torch.Tensor): Value tensor [batch_size, value_len, embed_size]
-            
+
         Returns:
             torch.Tensor: Output tensor with same shape as query
         """

omnigenome/src/model/regression/__init__.py

@@ -9,4 +9,3 @@
 """
 This package contains modules for regression models.
 """
-