Load embedding model and tokenizer. Based on Quick Start section in README.md

Load embedding model for attention extraction

Load embedding model for batch extraction

Load embedding model

Load embedding model

Converts a sequence into a list of token IDs. Must be implemented by subclasses. Args: sequence (str): The input sequenc

Encode input IDs using the base tokenizer. Args: input_ids: Input IDs to encode **kwargs: Additional keyword

Converts a sequence into a list of token IDs. This method encodes genomic sequences into token IDs using the underlying base

Encode a sequence using the base BPE tokenizer. Args: sequence (str): Input sequence to encode **kwargs: Add

Encode a sequence with additional information. This method is not yet implemented for k-mers tokenizer. Args: s

Encodes a sequence with additional information. This method provides enhanced encoding with additional information like atte

Encode a single sequence to token-level embeddings. Args: sequence (str): Input DNA/RNA sequence for token-level encodin

Encode a single sequence to token-level embeddings. Args: sequence (str): Input DNA/RNA sequence for token-level encodin

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

This method runs the RNA sequence design process using genetic algorithms. It validates parameters, loads the model, runs the design

Generate LIME explanations for a given sequence. Args: sequence (str): The input sequence to explain. task_idx (int,

Generates 2D embeddings for a set of sequences using t-SNE. This method first obtains high-dimensional embeddings for the input sequences,

Generate ISM explanations for a given sequence. Args: sequence (str): The input sequence to explain. task_idx (int, o

Generates feature attributions for an input sequence using the SQUID method. This method performs three main steps: Gene

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

Find positions with invalid brackets

Fix invalid brackets by replacing with dots

展示 Ground Truth、ViennaRNA 与模型预测的结构对比

Perform a forward pass through the LoRA-adapted model. This method delegates the forward computation to the underlying LoRA model,

Perform pooling operation on the last hidden state. This method handles different input formats and applies appropriate pooling:

Forward pass through the interacting attention mechanism. Args: query (torch.Tensor): Query tensor [batch_size, query_le

Masked global max-pooling over the sequence dimension. Parameters ---------- x : torch.Tensor Input features with

Forward pass. Parameters ---------- input_ids : torch.LongTensor Token ids of shape ``(batch_size, seq_len)``.

Forward pass producing multi-label probabilities and hidden state. Returns ------- dict Dictionary with keys ``lo

Forward pass returning probabilities and last hidden state. Returns ------- dict Keys: ``logits`` (probabilities)

Forward pass returning probabilities and last hidden state. Returns ------- dict Keys: ``logits`` (probabilities)

Forward pass returning probabilities and last hidden state. Returns ------- dict Keys: ``logits`` (probabilities)

Compute forward features. Parameters ---------- input_ids : torch.LongTensor Shape ``(batch_size, seq_len)``.

Return token-level and pooled features. Returns ------- dict ``sequence_output``: ``(B, L, H)``, ``hidden_state``

Return token-level and pooled features using mean-pooling over mask.

Return sequence and pooled outputs from dilated conv stack.

Compute logits ``(B, num_labels)`` and optional loss from pooled features.

Compute raw logits and optional BCE-with-logits loss.

Return continuous outputs and optional MSE loss.

Return per-token logits ``(B, L, num_labels)`` and optional loss.

Return per-token continuous outputs and optional loss.

Forward pass through backbone and task head. Returns ------- dict Always includes ``logits`` and passthrough ``la

Return token-level features only. Parameters ---------- input_ids : torch.LongTensor Shape ``(B, L)``. at

Return token-level hidden states only: ``{"last_hidden_state": (B, L, H)}``.

Return per-token hidden states only. Returns ------- dict ``{"last_hidden_state": (batch, seq_len, hidden_size)}`

Forward pass for masked language modeling. Args: **inputs: Input tensors including input_ids, attention_mask, and labels

Forward pass for token-level regression. Args: **inputs: Input tensors including input_ids, attention_mask, and labels

Forward pass for sequence-level regression. Args: **inputs: Input tensors including input_ids, attention_mask, and label

Forward pass for structural imputation. Args: **inputs: Input tensors including input_ids, attention_mask, and labels

Forward pass for 2D structure-aware token regression. Args: **inputs: Input tensors including input_ids, attention_mask,

Forward pass for 2D structure-aware sequence regression. Args: **inputs: Input tensors including input_ids, attention_ma

Forward pass for matrix regression. Args: **inputs: Input tensors including matrix representations and labels R

Forward pass for matrix classification. Args: **inputs: Input tensors including matrix representations and labels

Forward pass through the BasicBlock. Args: x (Tensor): Input tensor [batch_size, channels, height, width] Retur

Forward pass through the Bottleneck block. Args: x (Tensor): Input tensor [batch_size, channels, height, width]

Forward pass through the ResNet. Args: x (Tensor): Input tensor [batch_size, channels, height, width] Returns:

Forward pass for token classification. This method performs the forward pass through the model, computing logits for each to

This method performs the forward pass through the model, computing sequence-level logits and applying softmax to produce probability

x is one‑hot with shape (N, L, A). Outputs latent φ with shape (N, 1).

Process BPP matrix to extract structural features. Args: bpp_matrix: BPP matrix [batch, seq_len, seq_len]

Fuse sequence and BPP features. Args: seq_features: Sequence features [batch, seq_dim] bpp_features:

Forward pass with BPP feature fusion. Args: input_ids: Token IDs [batch, seq_len] attention_mask: At

Forward pass with BPP feature fusion. Args: input_ids: Token IDs from tokenizer attention_mask: Atte

Create OmniDataset instances from a HuggingFace dataset. .. deprecated:: 0.3.0 `from_huggingface` is deprecated and will

Loads a tokenizer from a pre-trained model path. Args: config_or_model (str): The name or path of the pre-trained model.

Load model, config, and tokenizer from a directory.

Load backbone from a directory containing ``config.json`` and weights.

Load backbone from a directory containing ``config.json`` and weights.

Loads a single nucleotide tokenizer from a pre-trained model. This method creates a single nucleotide tokenizer wrapper around

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

Compute comprehensive statistics from attention scores. This method analyzes attention patterns by computing various statistical measures

Extract base pairs from structure

Extract base pairs

Creates a PyTorch DataLoader for this dataset. Args: batch_size (int): Batch size for the DataLoader. shuffl

Compute a *heuristic* predictive information metric. For GE we return the test‑set R². For MPA we return accuracy. This does *not* attempt

Calculates and returns statistics about sequence and label lengths. Returns: dict: A dictionary with length statistics (

Returns the set of unique labels in the dataset. Returns: set: The set of unique labels.

Get the trained model. Args: **kwargs: Additional keyword arguments Returns: torch.nn.Module: The t

Get the trained model. Args: **kwargs: Additional keyword arguments Returns: torch.nn.Module: The t