pyhalos 1.0.3__py3-none-any.whl

halo/__init__.py

@@ -0,0 +1,61 @@
+"""
+HALO-S: Framework de Atención Dispersa para Modelos de Lenguaje
+================================================================
+
+Arquitectura transformer con complejidad O(N×K) basada en neighbor lists,
+global tokens, conexiones dilatadas y Grouped Query Attention (GQA).
+
+Uso básico:
+    >>> from halo import HaloConfig, HaloSModel, set_seed
+    >>> set_seed(42)
+    >>> config = HaloConfig(vocab_size=256, hidden_size=512)
+    >>> model = HaloSModel(config)
+
+Autor: BUEORM (dalusx64@gmail.com)
+"""
+
+__version__ = "1.0.3"
+
+# --- Core ---
+from halo.core.config import HaloConfig
+
+# --- Models ---
+from halo.models.halo_model import HaloSModel
+from halo.models.baseline_model import BaselineModel
+
+# --- Training ---
+from halo.training.trainer import Trainer
+
+# --- Tokenizers ---
+from halo.tokenizers.char import CharacterTokenizer
+
+# WordTokenizer se importa condicionalmente porque se crea en una tarea posterior
+try:
+    from halo.tokenizers.word import WordTokenizer
+except ImportError:
+    WordTokenizer = None
+
+# --- Generation ---
+from halo.generation.samplers import generate
+
+# --- Utils ---
+from halo.utils.random import set_seed
+from halo.utils.metrics import count_parameters
+
+__all__ = [
+    # Core
+    "HaloConfig",
+    # Models
+    "HaloSModel",
+    "BaselineModel",
+    # Training
+    "Trainer",
+    # Tokenizers
+    "CharacterTokenizer",
+    "WordTokenizer",
+    # Generation
+    "generate",
+    # Utils
+    "set_seed",
+    "count_parameters",
+]

halo/attention/__init__.py

@@ -0,0 +1,15 @@
+"""
+HALO-S Attention — Mecanismos de atención dispersa y global.
+"""
+
+from halo.attention.halo_attention import HaloSparseAttention
+from halo.attention.global_attention import GlobalFullAttention, _use_sdpa
+from halo.attention.graph import generate_neighbor_lists, estimate_graph_stats
+
+__all__ = [
+    "HaloSparseAttention",
+    "GlobalFullAttention",
+    "_use_sdpa",
+    "generate_neighbor_lists",
+    "estimate_graph_stats",
+]

halo/attention/global_attention.py

@@ -0,0 +1,215 @@
+"""
+Atención Densa para Global Tokens — HALO-S.
+
+Los Global Tokens son posiciones especiales (0..G-1) que atienden a TODA la
+secuencia (global + regular tokens) con atención densa estándar.
+Complejidad: O(G × N) donde G = num_globals, N = seq_len total.
+
+A diferencia de la atención dispersa (gather-based), aquí se computan scores
+contra todas las posiciones, permitiendo que los globals actúen como memoria
+compartida accesible por cualquier token del grafo disperso.
+"""
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional
+
+from halo.core.config import HaloConfig
+
+
+def _rotate_half(x: torch.Tensor) -> torch.Tensor:
+    """Rota la segunda mitad de las dimensiones para RoPE."""
+    x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def _apply_rope(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
+    """Aplica Rotary Positional Embeddings a un tensor individual.
+
+    Args:
+        x: Tensor con shape (batch, heads, seq_len, head_dim).
+        cos, sin: Embeddings rotacionales con shape broadcastable a x.
+
+    Returns:
+        Tensor con RoPE aplicado, misma shape que x.
+    """
+    return (x * cos) + (_rotate_half(x) * sin)
+
+
+def _use_sdpa() -> bool:
+    """Detecta si torch.nn.functional.scaled_dot_product_attention está disponible.
+
+    Retorna True solo cuando SDPA existe en el entorno y hay backend
+    eficiente (CUDA). En CPU no se beneficia significativamente.
+    """
+    if not hasattr(F, 'scaled_dot_product_attention'):
+        return False
+    # Solo se beneficia con backends Flash/Memory-efficient en CUDA
+    if torch.cuda.is_available():
+        return True
+    return False
+
+
+class GlobalFullAttention(nn.Module):
+    """
+    Atención densa para los Global Tokens con soporte GQA y SDPA.
+
+    Cada global token atiende a TODA la secuencia (globals + tokens regulares).
+    Utiliza Grouped Query Attention: num_heads queries, num_kv_heads keys/values.
+
+    Args:
+        config: Configuración HaloConfig del modelo.
+        use_flash: Si True, intenta usar SDPA como backend de atención.
+                   Se desactiva automáticamente si SDPA no está disponible.
+    """
+
+    def __init__(self, config: HaloConfig, use_flash: bool = True):
+        super().__init__()
+        self.num_heads = config.num_heads
+        self.num_kv_heads = config.num_kv_heads
+        self.head_dim = config.head_dim
+        self.hidden_size = config.hidden_size
+
+        assert self.num_heads % self.num_kv_heads == 0, (
+            "num_heads debe ser divisible por num_kv_heads"
+        )
+        self.num_groups = self.num_heads // self.num_kv_heads
+
+        # Proyecciones lineales (Q desde globals, K/V desde secuencia completa)
+        self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
+        self.k_proj = nn.Linear(self.hidden_size, self.num_kv_heads * self.head_dim, bias=False)
+        self.v_proj = nn.Linear(self.hidden_size, self.num_kv_heads * self.head_dim, bias=False)
+        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
+
+        self.dropout = nn.Dropout(config.dropout)
+
+        # Flag para usar SDPA (solo si está disponible)
+        self._use_flash = use_flash and _use_sdpa()
+
+    def forward(
+        self,
+        globals_x: torch.Tensor,
+        full_seq: torch.Tensor,
+        cos: torch.Tensor,
+        sin: torch.Tensor,
+        is_causal: bool = True
+    ) -> torch.Tensor:
+        """
+        Forward pass de atención densa para global tokens.
+
+        Args:
+            globals_x: (batch, num_globals, hidden) — queries son solo los globals.
+            full_seq: (batch, total_seq_len, hidden) — keys/values de toda la secuencia.
+            cos, sin: Embeddings RoPE con shape (1, 1, max_seq_len, head_dim).
+            is_causal: Si True, global[i] solo atiende a posiciones [0, i].
+
+        Returns:
+            (batch, num_globals, hidden) — representación actualizada de globals.
+        """
+        B, G, _ = globals_x.shape
+        _, N, _ = full_seq.shape
+
+        # Proyectar Q solo de globals, K/V de toda la secuencia
+        q = self.q_proj(globals_x).view(B, G, self.num_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(full_seq).view(B, N, self.num_kv_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(full_seq).view(B, N, self.num_kv_heads, self.head_dim).transpose(1, 2)
+        # q: (B, num_heads, G, head_dim)
+        # k: (B, num_kv_heads, N, head_dim)
+        # v: (B, num_kv_heads, N, head_dim)
+
+        # Aplicar RoPE — Q usa posiciones [0, G), K usa posiciones [0, N)
+        # Se aplican por separado porque Q y K tienen longitudes distintas
+        cos_q = cos[:, :, :G, :]
+        sin_q = sin[:, :, :G, :]
+        cos_k = cos[:, :, :N, :]
+        sin_k = sin[:, :, :N, :]
+        q = _apply_rope(q, cos_q, sin_q)
+        k = _apply_rope(k, cos_k, sin_k)
+
+        # Expandir K, V para GQA (repeat_interleave por grupos)
+        if self.num_groups > 1:
+            k = k.repeat_interleave(self.num_groups, dim=1)
+            v = v.repeat_interleave(self.num_groups, dim=1)
+        # k, v: (B, num_heads, N, head_dim)
+
+        # Construir máscara causal: global[i] solo atiende a posiciones [0, i]
+        attn_mask = None
+        if is_causal:
+            # positions_q: [0, 1, ..., G-1], positions_k: [0, 1, ..., N-1]
+            positions_q = torch.arange(G, device=q.device).unsqueeze(1)  # (G, 1)
+            positions_k = torch.arange(N, device=q.device).unsqueeze(0)  # (1, N)
+            # True donde K está en el futuro respecto a Q
+            causal_mask = positions_k > positions_q  # (G, N)
+            attn_mask = causal_mask  # Se usa abajo según el path
+
+        if self._use_flash:
+            out = self._forward_sdpa(q, k, v, attn_mask)
+        else:
+            out = self._forward_manual(q, k, v, attn_mask)
+
+        # Reshape: (B, num_heads, G, head_dim) → (B, G, hidden)
+        out = out.transpose(1, 2).contiguous().view(B, G, -1)
+        return self.o_proj(out)
+
+    def _forward_sdpa(
+        self,
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        causal_mask: Optional[torch.Tensor]
+    ) -> torch.Tensor:
+        """Path acelerado usando scaled_dot_product_attention (SDPA).
+
+        Se construye una máscara explícita dado que la causal estándar (triangular)
+        no aplica aquí: los globals tienen alcance causal muy limitado.
+        """
+        # SDPA espera attn_mask como float o bool con shape broadcastable
+        # a (B, num_heads, G, N). True = posición ignorada en la versión bool.
+        if causal_mask is not None:
+            # Convertir a float mask: 0 donde se atiende, -inf donde se bloquea
+            sdpa_mask = torch.zeros_like(causal_mask, dtype=q.dtype)
+            sdpa_mask.masked_fill_(causal_mask, float('-inf'))
+            # Expandir para broadcast: (1, 1, G, N)
+            sdpa_mask = sdpa_mask.unsqueeze(0).unsqueeze(0)
+        else:
+            sdpa_mask = None
+
+        dropout_p = self.dropout.p if self.training else 0.0
+
+        # SDPA: (B, num_heads, G, head_dim) @ (B, num_heads, N, head_dim) → (B, num_heads, G, head_dim)
+        out = F.scaled_dot_product_attention(
+            q, k, v,
+            attn_mask=sdpa_mask,
+            dropout_p=dropout_p,
+            is_causal=False  # Usamos nuestra máscara custom
+        )
+        return out
+
+    def _forward_manual(
+        self,
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        causal_mask: Optional[torch.Tensor]
+    ) -> torch.Tensor:
+        """Fallback manual: matmul scores, mask, softmax, dropout, weighted sum.
+
+        Se usa cuando SDPA no está disponible o use_flash=False.
+        """
+        # Scores: (B, num_heads, G, N)
+        scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.head_dim)
+
+        # Aplicar máscara causal
+        if causal_mask is not None:
+            # causal_mask: (G, N) — expandir para (1, 1, G, N)
+            scores.masked_fill_(causal_mask.unsqueeze(0).unsqueeze(0), float('-inf'))
+
+        # Softmax sobre la dimensión de keys
+        attn_weights = torch.softmax(scores, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+
+        # Weighted sum: (B, num_heads, G, N) @ (B, num_heads, N, head_dim) → (B, num_heads, G, head_dim)
+        out = torch.matmul(attn_weights, v)
+        return out

halo/attention/graph.py

@@ -0,0 +1,111 @@
+"""
+HALO-S Phase 0: Graph Prototype
+Módulo para la generación de la conectividad dispersa (sparse) del modelo HALO-S.
+Utiliza Neighbor Lists (listas de adyacencia) para evitar la instanciación de matrices densas NxN.
+"""
+
+import torch
+
+def generate_neighbor_lists(
+    seq_len: int,
+    local_window: int = 64,
+    num_globals: int = 2,
+    dilated_offsets: list[int] = [1, 2, 4, 8],
+    num_random: int = 2,
+    layer_id: int = 0
+) -> torch.Tensor:
+    """
+    Genera una lista de vecinos (neighbor list) de tamaño fijo para cada token en la secuencia.
+    
+    Args:
+        seq_len: Longitud total de la secuencia (incluyendo globales).
+        local_window: Tamaño de la ventana local total (mitad hacia atrás, mitad hacia adelante).
+        num_globals: Número de tokens globales al inicio de la secuencia.
+        dilated_offsets: Desplazamientos para las conexiones dilatadas.
+        num_random: Número de conexiones pseudoaleatorias.
+        layer_id: Identificador de la capa para el hash pseudoaleatorio.
+        
+    Returns:
+        neighbors: Tensor de enteros de shape (seq_len, num_neighbors)
+                   donde num_neighbors = num_globals + local_window + 2 * len(dilated_offsets) + num_random
+    """
+    if seq_len <= num_globals:
+        raise ValueError("Sequence length must be greater than num_globals")
+        
+    local_half = local_window // 2
+    num_dilated = len(dilated_offsets) * 2
+    num_neighbors = num_globals + local_window + num_dilated + num_random
+    
+    device = torch.device('cpu') # For prototype, CPU is fine to build indices
+    positions = torch.arange(seq_len, device=device)
+    
+    # 1. Global Tokens (0 to num_globals - 1)
+    global_idx = torch.arange(num_globals, device=device).unsqueeze(0).expand(seq_len, -1)
+    
+    # 2. Local Window (-local_half to +local_half - 1)
+    # Asegura tamaño exacto `local_window`
+    local_offsets = torch.arange(-local_half, local_half + (local_window % 2), device=device).unsqueeze(0)
+    local_idx = positions.unsqueeze(1) + local_offsets
+    
+    # 3. Dilated Connections
+    dilated_list = []
+    for offset in dilated_offsets:
+        dilated_list.append(positions + offset)
+        dilated_list.append(positions - offset)
+    
+    if dilated_list:
+        dilated_idx = torch.stack(dilated_list, dim=1)
+    else:
+        dilated_idx = torch.empty((seq_len, 0), dtype=torch.long, device=device)
+        
+    # 4. Pseudo-random Connections (Deterministic based on layer_id and position)
+    # Using a fast vectorizable integer hash
+    pos_expanded = positions.unsqueeze(1).expand(-1, num_random)
+    rand_offsets = torch.arange(num_random, device=device).unsqueeze(0).expand(seq_len, -1)
+    
+    # LCG-like hash parameters
+    hash_val = (pos_expanded * 2654435761 + layer_id * 805459861 + rand_offsets * 3266489917)
+    hash_val = hash_val.to(torch.int64) & 0xFFFFFFFF
+    
+    # Map back to valid sequence indices, avoiding globals
+    valid_range = max(1, seq_len - num_globals)
+    random_idx = num_globals + (hash_val % valid_range)
+    
+    # Concatenate all indices
+    all_idx = torch.cat([global_idx, local_idx, dilated_idx, random_idx], dim=1)
+    
+    # Clamp out-of-bounds indices
+    # Si un token apunta fuera de la secuencia, se redirige a sí mismo.
+    # Matemáticamente añade más peso al propio token en self-attention, lo cual es inofensivo.
+    out_of_bounds = (all_idx < 0) | (all_idx >= seq_len)
+    all_idx = torch.where(out_of_bounds, positions.unsqueeze(1), all_idx)
+    
+    return all_idx
+
+def estimate_graph_stats(neighbor_lists: torch.Tensor, seq_len: int):
+    """
+    Calcula estadísticas del grafo generado para comparar con representaciones densas.
+    """
+    num_neighbors = neighbor_lists.shape[1]
+    
+    # Memoria de la representación rala (int64)
+    sparse_memory_bytes = neighbor_lists.numel() * 8
+    
+    # Memoria teórica de una máscara densa (bool)
+    dense_memory_bytes = seq_len * seq_len * 1
+    
+    # Factor de compresión
+    compression_ratio = dense_memory_bytes / sparse_memory_bytes if sparse_memory_bytes > 0 else float('inf')
+    
+    # Conexiones totales
+    total_connections = seq_len * num_neighbors
+    
+    return {
+        "seq_len": seq_len,
+        "num_neighbors": num_neighbors,
+        "sparse_memory_mb": sparse_memory_bytes / (1024 * 1024),
+        "dense_memory_mb": dense_memory_bytes / (1024 * 1024),
+        "compression_ratio": compression_ratio,
+        "total_connections": total_connections,
+        "dense_connections": seq_len * seq_len
+    }

halo/attention/halo_attention.py

@@ -0,0 +1,118 @@
+import math
+import torch
+import torch.nn as nn
+from typing import Optional
+from halo.core.config import HaloConfig
+from halo.attention.graph import generate_neighbor_lists
+from halo.nn.rope import apply_rotary_pos_emb
+
+class HaloSparseAttention(nn.Module):
+    """
+    Atención Dispersa HALO-S con Gather-based backend y GQA.
+    Garantiza complejidad O(N * num_neighbors) en lugar de O(N^2).
+    """
+    def __init__(self, config: HaloConfig, layer_id: int):
+        super().__init__()
+        self.config = config
+        self.layer_id = layer_id
+        
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_heads
+        self.num_kv_heads = config.num_kv_heads
+        self.head_dim = config.head_dim
+        
+        assert self.num_heads % self.num_kv_heads == 0, "num_heads must be divisible by num_kv_heads"
+        self.num_groups = self.num_heads // self.num_kv_heads
+        
+        # Proyecciones lineales
+        self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
+        self.k_proj = nn.Linear(self.hidden_size, self.num_kv_heads * self.head_dim, bias=False)
+        self.v_proj = nn.Linear(self.hidden_size, self.num_kv_heads * self.head_dim, bias=False)
+        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
+        
+        self.dropout = nn.Dropout(config.dropout)
+        
+        # Cache opcional para los vecinos si seq_len no cambia (acelera entrenamiento)
+        self._cached_neighbors = None
+        self._cached_seq_len = -1
+
+    def _get_neighbors(self, seq_len: int, device: torch.device):
+        if self._cached_seq_len == seq_len and self._cached_neighbors is not None:
+            return self._cached_neighbors
+            
+        neighbors = generate_neighbor_lists(
+            seq_len=seq_len,
+            local_window=self.config.local_window,
+            num_globals=self.config.num_globals,
+            dilated_offsets=self.config.dilated_offsets,
+            num_random=self.config.num_random,
+            layer_id=self.layer_id
+        ).to(device)
+        
+        self._cached_neighbors = neighbors
+        self._cached_seq_len = seq_len
+        return neighbors
+
+    def forward(
+        self, 
+        x: torch.Tensor, 
+        cos: torch.Tensor, 
+        sin: torch.Tensor, 
+        is_causal: bool = True
+    ) -> torch.Tensor:
+        batch_size, seq_len, _ = x.shape
+        
+        # Proyectar Q, K, V
+        q = self.q_proj(x).view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(x).view(batch_size, seq_len, self.num_kv_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).view(batch_size, seq_len, self.num_kv_heads, self.head_dim).transpose(1, 2)
+        
+        # Aplicar RoPE
+        q, k = apply_rotary_pos_emb(q, k, cos, sin)
+        
+        # Obtener matriz de índices dispersos (Neighbor List)
+        # shape: (seq_len, num_neighbors)
+        neighbors = self._get_neighbors(seq_len, x.device)
+        
+        # Recopilación de vecinos dispersos mediante Advanced Indexing (GATHER)
+        # K, V shape original: (batch, num_kv_heads, seq_len, head_dim)
+        # k_gathered shape: (batch, num_kv_heads, seq_len, num_neighbors, head_dim)
+        k_gathered = k[:, :, neighbors, :]
+        v_gathered = v[:, :, neighbors, :]
+        
+        # Expansión para Grouped Query Attention (GQA)
+        # Repite el KV cache para coincidir con num_heads
+        if self.num_groups > 1:
+            k_gathered = k_gathered.repeat_interleave(self.num_groups, dim=1)
+            v_gathered = v_gathered.repeat_interleave(self.num_groups, dim=1)
+            
+        # Preparar Q para dot product
+        q_expanded = q.unsqueeze(3) # (batch, num_heads, seq_len, 1, head_dim)
+        
+        # Calcular scores de atención locales
+        # Matmul: (..., 1, head_dim) x (..., head_dim, num_neighbors) -> (..., 1, num_neighbors)
+        scores = torch.matmul(q_expanded, k_gathered.transpose(-2, -1))
+        scores = scores / math.sqrt(self.head_dim)
+        
+        # Aplicar máscara causal (autoregresiva)
+        # Ningún token puede atender a una posición mayor que él mismo.
+        if is_causal:
+            # positions: (seq_len, 1)
+            positions = torch.arange(seq_len, device=x.device).unsqueeze(1)
+            causal_mask = neighbors > positions # True si es futuro
+            causal_mask = causal_mask.view(1, 1, seq_len, 1, -1)
+            scores.masked_fill_(causal_mask, float('-inf'))
+            
+        # Softmax y Dropout
+        attn = torch.softmax(scores, dim=-1)
+        attn = self.dropout(attn)
+        
+        # Multiplicar por V local
+        # Matmul: (..., 1, num_neighbors) x (..., num_neighbors, head_dim) -> (..., 1, head_dim)
+        out = torch.matmul(attn, v_gathered)
+        out = out.squeeze(3) # (batch, num_heads, seq_len, head_dim)
+        
+        # Re-empaquetar
+        out = out.transpose(1, 2).contiguous().view(batch_size, seq_len, -1)
+        
+        return self.o_proj(out)

halo/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+HALO-S Core — Configuración y utilidades fundamentales del framework.
+"""
+
+from halo.core.config import HaloConfig
+
+__all__ = ["HaloConfig"]

halo/core/config.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass, field, asdict
+from typing import List
+
+@dataclass
+class HaloConfig:
+    """Configuración principal para el modelo HALO-S."""
+    vocab_size: int = 256  # Por defecto para CharTokenizer
+    hidden_size: int = 512
+    num_layers: int = 6
+    num_heads: int = 8
+    num_kv_heads: int = 2  # Implementando Grouped Query Attention (GQA)
+    
+    # Parámetros del grafo disperso HALO-S
+    num_globals: int = 2
+    local_window: int = 64
+    dilated_offsets: List[int] = field(default_factory=lambda: [1, 2, 4, 8])
+    num_random: int = 2
+    
+    # Hiperparámetros de regularización e inferencia
+    dropout: float = 0.1
+    max_seq_len: int = 4096
+    
+    def __post_init__(self):
+        """Validación de parámetros al crear la instancia."""
+        assert self.hidden_size % self.num_heads == 0, (
+            f"hidden_size ({self.hidden_size}) debe ser divisible por "
+            f"num_heads ({self.num_heads})"
+        )
+        assert self.num_heads % self.num_kv_heads == 0, (
+            f"num_heads ({self.num_heads}) debe ser divisible por "
+            f"num_kv_heads ({self.num_kv_heads})"
+        )
+        assert self.num_globals >= 1, (
+            f"Se requiere al menos 1 global token, se recibió num_globals={self.num_globals}"
+        )
+        assert self.local_window > 0, (
+            f"local_window debe ser > 0, se recibió {self.local_window}"
+        )
+        assert self.max_seq_len > self.num_globals, (
+            f"max_seq_len ({self.max_seq_len}) debe ser mayor que "
+            f"num_globals ({self.num_globals})"
+        )
+        assert 0 <= self.dropout < 1, (
+            f"dropout debe estar en [0, 1), se recibió {self.dropout}"
+        )
+    
+    @property
+    def head_dim(self):
+        """Dimensión por cabeza de atención."""
+        return self.hidden_size // self.num_heads
+    
+    @property
+    def num_neighbors(self) -> int:
+        """Número total de vecinos por token en el grafo disperso.
+        
+        Incluye: globals + ventana local + conexiones dilatadas (ida y vuelta) + aleatorios.
+        """
+        return (
+            self.num_globals
+            + self.local_window
+            + 2 * len(self.dilated_offsets)
+            + self.num_random
+        )
+    
+    def to_dict(self) -> dict:
+        """Serializa la configuración a un diccionario con todos los campos."""
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, d: dict) -> "HaloConfig":
+        """Reconstruye una instancia de HaloConfig desde un diccionario."""
+        return cls(**d)