Get the value of a key from the parameter dict. If the key is found, increment its call frequency. :param key: The key to look for in

r""" Enhanced print function with automatic flushing. It provides a print-like interface with automatic flushing to ensure output is displayed

Pop a value from the parameter dict. :param args: Arguments to pop from the parameter dict. :return: The value popped from th

Get a list of all key-value pairs in the parameter dict. :return: A list of all key-value pairs in the parameter dict.

Load a complete model from a saved directory. This method performs a comprehensive load operation that restores: - Model met

Loads a pre-trained model and tokenizer. :param config_or_model: The name or path of the pre-trained model. :param tokenizer

Update the parameter dict with the given arguments and keyword arguments, and check if the updated configuration is valid. :param arg

Move model to specified device and/or change dtype.

Move model to specified device/dtype and keep device tracking in sync.

Tokenizes raw input and performs a forward pass in no_grad mode. This method supports two preprocessing strategies: 1. If da

Get a list of all keys in the parameter dict. :return: A list of all keys in the parameter dict.

Save the complete model, tokenizer, and metadata to a directory. This method performs a comprehensive save operation that includes:

Get a list of all values in the parameter dict. :return: A list of all values in the parameter dict.

This method takes raw sequences or tokenized inputs and returns processed predictions that are ready for human consumption. It

Set model to evaluation mode.

Build the CNN backbone. Parameters ---------- cfg : BaselineConfig Configuration with embedding and convolution h

Load model for batch testing

Design RNA sequences for a target structure using evolutionary algorithms. Args: structure (str): Target secondary struc

Encode a single sequence into pooled embeddings. Args: sequence (str): Input DNA or RNA sequence for encoding. max_le

Load a model with the following priority: 1) If the identifier is on Hugging Face, download it first. 2) Prefer instantiating

Extract attention scores from a single genomic sequence. This method extracts attention weights from transformer layers, providing insights

Predicts RNA secondary structure for given sequences. This method predicts RNA secondary structures using ViennaRNA. It supports

Placeholder for running functionality related to the benchmark hub.

Batch encode sequences into aggregated (pooled) embeddings. Args: sequences (List[str]): Input DNA or RNA sequences for encoding.

Unwrap the model from any distributed training wrappers. Args: model (Optional[torch.nn.Module]): Model to unwrap (defau

Performs a forward pass to get the last hidden state from the base model. It also handles compatibility with different model architec

Train the model using HuggingFace Trainer. Args: path_to_save (Optional[str]): Path to save the trained model

Concatenate list of outputs. Args: outputs (List[np.ndarray]): List of output arrays Returns: np.nd

Return the actual device of model parameters, not cached value.

Collects metadata about the current environment and library versions. This function gathers information about the current Python environment

This function dynamically loads a Python module from a file path, useful for loading configuration files or custom modules. Args:

Downloads a benchmark dataset from HuggingFace Hub or OmniGenome repository. **Unified Download Strategy**: This function now uses the same

Evaluate the model on the validation dataset. Returns: Dict[str, Any]: Dictionary containing evaluation metrics

This method takes raw sequences or tokenized inputs and returns the raw model outputs (logits, hidden states, etc.) without p

Generate predictions using the trained model. Args: data_loader (DataLoader): DataLoader for prediction data Re

Initialize the token regression model. Args: config_or_model: Model configuration or pre-trained model token

Create the autobench subcommand parser.

Download model or dataset from HuggingFace Hub using official API (no git-lfs required). This function uses HuggingFace's `snapshot_download

Load AutoConfig from a HuggingFace Hub dataset or local directory. This method automatically downloads the dataset if needed and loa

Train the model using distributed training. This method performs the complete training loop with validation, early stopping,

Initializes the token classification model. Args: config_or_model: Model configuration, pre-trained model path, or model

Flattens the ground truth and prediction arrays. It handles various input formats and converts them to 1D numpy arrays. Args

Calculates the loss. This method should be implemented by concrete model classes to define how the loss is calculated for their speci

Sets random seeds for reproducibility across all random number generators. This function sets seeds for Python's random module, NumPy, PyTorch (C

Initialize the dataset for token regression. Args: dataset_name_or_path: Path to the data file or a list of paths.

Initializes the SQUIDExplainer. Args: model: The pre-trained model to be explained. gpmap (str, optional): The type o

Augment a batch of masked sequences using a single forward pass. Args: seq_list (List[str]): List of masked sequences

Compute cosine similarity between two embeddings. Args: embedding1 (torch.Tensor): The first embedding embed

Create the autoinfer subcommand parser.

Create the autotrain subcommand parser.

This method provides the complete inference pipeline including preprocessing, model forward pass, and postprocessing. It's the

Performs token-level inference with human-readable output. This method provides processed, human-readable token-level predictions.

Prepares a single data instance for the model. Must be implemented by subclasses. Args: instance (dict): A single data i

Runs the benchmarking process. This method iterates through the tasks in the benchmark, loads the corresponding configurations, initi

Saves the base tokenizer to a directory. Args: save_directory (str): The directory to save the tokenizer to. Ex

Verify that a downloaded repository has all required files. Args: local_path (str): Path to downloaded repository required_f

Initialize BPP processor.

Build default label mappings when not provided. Returns ------- tuple(dict, dict) ``(label2id, id2label)`` consistent pair.

Check if the current metrics are better than the best metrics so far. Args: metrics (Dict[str, Any]): Current metric val

Check if the current metrics are better than the best metrics so far. This method is overridden to ensure only the main process perf

Generate predictions for a batch. Args: batch: Input batch Returns: Dict[str, torch.Tensor]: Dictio

Prepare a batch for model input by moving to device. Args: batch: Input batch Returns: Batch moved

Sample a bp span around the provided bp_span, bounded to <=400.

Extract attention scores from multiple genomic sequences in batches. Args: sequences (List[str]): List of input DNA or RNA sequen

Performs a basic check on the configuration arguments. Args: args: A dictionary of configuration arguments. :raises RuntimeError

1x1 convolution. Args: in_planes (int): Number of input channels out_planes (int): Number of output channels stride

Converts a list of token IDs back into a sequence. Must be implemented by subclasses. Args: sequence (list): A list of t

Get the device where the model is located.

Downloads a dataset from HuggingFace Hub or OmniGenBench repository. **Unified Download Strategy**: This function uses the same robust downl

Evaluate the model on the validation dataset. This method runs the model in evaluation mode and computes metrics on the vali

生成 SVG 并返回 Base64 URI

Generate predictions for token-level regression. Args: sequence_or_inputs: Input sequences or pre-processed inputs

Performs token-level prediction on raw inputs. This method takes raw sequences or tokenized inputs and returns token-level p

Test the model on the test dataset. Returns: Dict[str, Any]: Dictionary containing test metrics

Test the model on the test dataset. This method runs the model in evaluation mode and computes metrics on the test dataset.

Moves all tensor values in the dictionary to the specified device. Args: device (str or torch.device): The target device

Move model to device/dtype.

Move the pipeline to a specific device. Args: device (str): Target device ('cpu', 'cuda', 'cuda:0', etc.). Retu

Entry point for the OmniGenome auto-train command-line interface. :param args: A list of command-line arguments. If None, `sys.argv` is used

This function extracts a zipped checkpoint file to a directory, making it ready for use by the model loading functions. Args: ch

Recursively aggregate a dictionary of prediction results. This method recursively processes nested dictionaries and applies

Aggregate prediction results by calling the appropriate aggregation method. This method determines the type of result and calls the

Get the value of an argument and increment its call count. :param arg_name: The name of the argument. :return: The value of

Initialize the ResNet architecture. Args: channels (int): Number of input channels block: Type of ResNet blo

Aggregate a list of prediction results. This method handles different types of list elements and applies appropriate aggrega

Downloads and extracts datasets from OmniGenBench Hub powered by HuggingFace. .. deprecated:: 0.3.23 Use ``omnigenbench.

Predict structure for a single sequence (worker function for multiprocessing). Args: sequence (str): RNA sequence to fol

Instantiate an Omni model directly from its class.

Mutate population using MLM prompts and per-position masking.

Tokenize batch of prompts and get argmax token ids. Returns shape [B, len(structure)]

Predict the output of the model for the mutated parts. Args: sequence: the sequence to explain, string mutat

Negative log‑likelihood / loss function depending on regression type and noise model.

One-hot encode the sequence. Args: sequence: the sequence to encode, string Returns: one_hot: the o

Post-process sequence based on output format (RNA uses U, DNA uses T). Args: sequence (str): DNA sequence with T bases