(Private) Converts a sequence to a one-hot encoding. This helper function converts a sequence into a one-hot encoding based on the pr

Set up data loaders for training, evaluation, and testing. Args: train_dataset (Optional[Dataset]): Training dataset

Set up training-specific components (device, scaler, etc.). This method should be implemented by subclasses to initialize tr

Project token ids to nucleotide one-hot channels. Parameters ---------- ids : torch.LongTensor Shape ``(batch_siz

Train the model for one epoch. Args: epoch (int): Current epoch number Returns: float: Average trai

Train the model for one epoch using HuggingFace Accelerate. Args: epoch (int): Current epoch number Returns:

Main function to handle the augmentation process from a file input to a file output. This method loads sequences from an input file,

Perform augmentation on a single sequence by predicting masked tokens. Args: seq (str): Input genomic sequence with mask

Augment a list of sequences by applying noise and performing MLM-based predictions. Args: sequences (list): List of geno

This function automatically identifies suitable target modules and creates a LoRA-adapted version of the input model. It handles configuratio

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

Prints and returns information about the current benchmark setup. Returns: str: A string containing benchmark informatio

Calculate various structure comparison metrics

Clean up temporary PyTorch files in the current directory. This function removes temporary PyTorch files (like .pt, .pth files) that may

Clone a model from Hugging Face Hub to local directory using git. Note: This method requires git and git-lfs to be installed for large files

Compute the metric, based on the true and predicted values. Args: y_true: The true values y_score: The predi

Compute the metric, based on the true and predicted values. This method computes the classification metric using the provided

Compute the regression metric, based on the true and predicted values. Args: y_true: The true values y_score

Compute the ranking metric, based on the true and predicted values. This method should be implemented by subclasses to provide speci

More efficient BPP computation using ViennaRNA's bpp method. Args: sequence: RNA sequence string

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

5x5 convolution with padding. Args: in_planes (int): Number of input channels out_planes (int): Number of output channels

This function iterates through all parameters of a PyTorch model and counts only those that require gradients (i.e., trainable parameters).

Create enhanced secondary structure prediction demo

Creates the argument parser for the auto-train CLI. :return: An `argparse.ArgumentParser` instance.

Creates the argument parser for the benchmark CLI. Returns: An `argparse.ArgumentParser` instance.

Create the parser for RNA design command.

MAVE‑NN wanted a pandas DataFrame. Here we simply return *seq_list* (for inspection) and a PyTorch tensor (N,) or (N,num_tasks) for y.

Download a model from Hugging Face Hub to local directory. This function provides two download strategies: 1. HuggingFace Hub API (defau

Downloads a model from a given URL. It supports both remote and local-only modes. Args: config_or_model (str): The name or path of t

Downloads a pipeline from a given URL. It supports both remote and local-only modes. Args: pipeline_name_or_path (str): The name or

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

Evaluate the fitness of RNA sequences by comparing their predicted structures with the target structure. Args: sequences (list):

Example 1: Design a simple hairpin structure A hairpin is one of the most basic RNA secondary structures, consisting of a stem (base

Example 2: Design with custom evolutionary parameters This example shows how to tune the genetic algorithm parameters for better exp

Example 3: Batch design multiple structures Demonstrates efficient batch processing of multiple target structures, useful for large-

Example 4: Validate designed sequences Shows how to verify that designed sequences actually fold into the target structure using Vie

Example 5: Save designs and reload for analysis Demonstrates best practices for saving and organizing design results.

Execute the autobench command with the provided arguments. It handles model and tokenizer loading, benchmark execution, and result lo

Generates an explanation for a given input. This is the core method of any explainer and **must be implemented** by all concrete subc

Computes the pairwise interaction matrix for a given sequence. This method calls the underlying SQUID explainer to generate the epistasis

Generates an attribution matrix for a given sequence. This method uses the underlying explainer (e.g., 'squid') to compute the attrib

Generates the 2D embeddings for the input sequences. This method acts as a wrapper, calling the `explain` method of the underlying di

Extract Python code from VSCode notebook format. Args: notebook_path: Path to the .ipynb file in VSCode format Retu

This function searches through a model's modules to identify linear layers that can be adapted using LoRA. It supports filtering by keyword p

Fix invalid base pairs in structure

Forward pass through the base model.

Compute head logits and optional loss. Parameters ---------- features : dict Must contain ``hidden_state`` or ``s

Create OmniDataset instances from HuggingFace Hub or local directory. This method supports loading datasets from: 1. OmniGen

Create a k-mers tokenizer from a pre-trained model. Args: config_or_model (str): Name or path of the pre-trained model

Generate interactive HTML visualization with multiple structures

Generate a random RNA sequence.

Compute comprehensive statistics from attention scores. Args: attention_scores (torch.Tensor): Attention tensor with shape (num_l

Returns all values for a specific column in the dataset. Args: column_name (str): The name of the column. Retur

Retrieves an explainer class from the registry by its name. Args: name (str): The name of the explainer method to retrieve. Returns:

Retrieves an explainer class from the registry by name. This function acts as a factory to access different explanation methods that have bee

Retrieves an explainer class from the registry by its name. This function acts as a factory, allowing for dynamic selection of the dimensiona

Get metadata about a HuggingFace model repository. Args: repo_id (str): HuggingFace repository identifier token (Optional[st

Return (theta_0, theta_lc, theta_lclc). Pairwise parameters are only returned if gpmap_type == 'pairwise'.

Perform inference on genomic sequences. This method provides a basic inference interface for pre-trained models that haven't

Print formatted dataset information in table format using tabulate. This method displays dataset_info in a human-readable table form

This method handles loading the model, tokenizer, and configuration from a model path or identifier. It tries to load from the ModelH

Check if the tokenization is BPE-based by analyzing token characteristics. This function examines the tokens to determine if they follow BPE

Check if a notebook is in VSCode's XML format. Args: notebook_path: Path to the notebook file Returns: True

List all files in a HuggingFace repository. Args: repo_id (str): HuggingFace repository identifier repo_type (str): Type of

This static method loads a complete pipeline including model, tokenizer, datasets, and trainer from a saved pipeline directory or hub

Loads data from a file or list of files. Args: dataset_name_or_path (str or list): Path to the data file or a list of pa

Load embeddings from a file. Args: embedding_path (str): Path to the saved embeddings Returns: torc

Load embeddings from a file. Args: embedding_path (str): Path to the saved embeddings Returns: torc

Load sequences from a JSON file. Args: input_file (str): Path to the input JSON file containing sequences Retur

Main entry point for the OGB (OmniGenBench) CLI. This provides a unified interface for all OmniGenBench command-line tools.

The main entry point for the OmniGenome command-line interface. This function sets up the command-line argument parser and handles the execut

Entry point for the autoinfer command-line interface. This function provides a standalone CLI for running inference with fine-tuned geno

Run all examples demonstrating RNA design functionality.

Main entry point for the script.

Main training function.

Prints and returns detailed information about the model. :return: A string containing the model information.

Predicts structures for multiple sequences using multithreading.

Predicts the RNA structure for a single sequence.

Print the distribution of labels for 0-dimensional (scalar) labels. This is useful for classification tasks where each sample has a s

This function retrieves model information from the OmniGenome hub, either from a remote repository or from a local cache. It supports fil

This method sets up the command-line interface for the autobench functionality, including all necessary arguments and their descripti

This method sets up the command-line interface for RNA sequence design, including all necessary arguments and their descriptions.

This method loads the dataset configuration, initializes the model and tokenizer, and runs training across multiple seeds. It support

Run all tests.

Save augmented sequences to a JSON file. Args: augmented_sequences (list): List of augmented sequences to save