rxnn 0.2.51__tar.gz → 0.2.53__tar.gz

{rxnn-0.2.51 → rxnn-0.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rxnn
-Version: 0.2.51
+Version: 0.2.53
 Summary: RxNN: Reactive Neural Networks Platform
 License: Apache-2.0
 Keywords: deep-learning,ai,machine-learning

{rxnn-0.2.51 → rxnn-0.2.53}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rxnn"
-version = "0.2.51"
+version = "0.2.53"
 description = "RxNN: Reactive Neural Networks Platform"
 
 license = "Apache-2.0"

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/experimental/attention.py

@@ -318,76 +318,102 @@ class SparseQueryAttention(MultiHeadAttention):
 
 
 # Others
-
 class FlexAttention(MultiHeadAttention):
     def __init__(
-            self,
-            embed_dim: int,
-            num_heads: int,
-            num_global_tokens: int = 16,
-            window_size: int = 128,
-            **kwargs
+        self,
+        embed_dim: int,
+        num_heads: int,
+        dropout: float = 0.0,
+        rope: RotaryPositionalEmbedding = None,
+        rope_only_for_query: bool = False,
+        rope_only_for_keys: bool = False,
+        use_relative_embeddings: bool = False,
+        max_seq_len: int = 1024,
+        use_flash_attention: bool = True,
+        is_causal: bool = False,
+        use_bias: bool = False,
+        num_global_tokens: int = 16,
+        window_size: int = 128,
     ):
-        super().__init__(embed_dim, num_heads, **kwargs)
+        super(FlexAttention, self).__init__(
+            embed_dim,
+            num_heads,
+            dropout=dropout,
+            rope=rope,
+            rope_only_for_query=rope_only_for_query,
+            rope_only_for_keys=rope_only_for_keys,
+            use_relative_embeddings=use_relative_embeddings,
+            max_seq_len=max_seq_len,
+            use_flash_attention=use_flash_attention,
+            is_causal=is_causal,
+            use_bias=use_bias,
+        )
+        self.head_dim = embed_dim // num_heads
         self.num_global_tokens = num_global_tokens
         self.window_size = window_size
-        self.global_tokens = nn.Parameter(torch.zeros(1, num_global_tokens, embed_dim))
 
-    def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, mask=None):
+        # Learnable global tokens
+        self.global_tokens = nn.Parameter(torch.randn(1, num_global_tokens, embed_dim))
+
+
+    def _split_heads(self, x: torch.Tensor) -> torch.Tensor:
+        b, t, d = x.size()
+        return x.view(b, t, self.num_heads, self.head_dim).transpose(1, 2)
+
+    def _merge_heads(self, x: torch.Tensor) -> torch.Tensor:
+        b, h, t, d = x.size()
+        return self._transpose_output(x, b, t, h * d)
+
+    def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, mask: torch.Tensor = None):
         b, t, d = query.size()
-        head_dim = d // self.num_heads
 
-        # Split into global and local
-        x = torch.cat([self.global_tokens.expand(b, -1, -1), query], dim=1)
-        seq_len = x.size(1)
-        num_windows = (seq_len - self.num_global_tokens + self.window_size - 1) // self.window_size
+        # Prepend global tokens to the input query
+        global_tokens = self.global_tokens.expand(b, -1, -1)
+        x = torch.cat([global_tokens, query], dim=1)
 
         # Project Q, K, V
-        q, k, v = self._forward_qkv(x, key, value, b, seq_len, d)
-
-        # Process Global-to-Global Attention
-        global_q = q[:, :, :self.num_global_tokens]  # [B, H, G, head_dim]
-        global_k = k[:, :, :self.num_global_tokens]
-        global_v = v[:, :, :self.num_global_tokens]
-        global_attn = self._calculate_attn_weights(global_q, global_k, d) @ global_v
-
-        # Process Global-to-Local Attention
-        local_k = k[:, :, self.num_global_tokens:]  # [B, H, (num_windows * window_size), head_dim]
-        local_v = v[:, :, self.num_global_tokens:]
-        # Apply RoPE to local_k if needed
+        q = self._split_heads(self.q_proj(x))
+        k = self._split_heads(self.k_proj(key))
+        v = self._split_heads(self.v_proj(value))
+
+        # Apply RoPE
         if self.rope:
-            # Compute frequencies for entire local sequence
-            local_k = self.rope.forward_one(local_k)
-
-        global_local_attn = self._calculate_attn_weights(global_q, local_k, d) @ local_v
-
-        # Process Local-to-Local Attention (per window)
-        local_q = q[:, :, self.num_global_tokens:]  # [B, H, (num_windows * window_size), head_dim]
-        local_q = local_q.view(b, self.num_heads, num_windows, self.window_size, head_dim)
-        local_k = local_k.view(b, self.num_heads, num_windows, self.window_size, head_dim)
-        local_v = local_v.view(b, self.num_heads, num_windows, self.window_size, head_dim)
-
-        local_attn = []
-        for i in range(num_windows):
-            window_q = local_q[:, :, i]  # [B, H, window_size, head_dim]
-            window_k = local_k[:, :, i]
-            window_v = local_v[:, :, i]
-
-            # Apply RoPE to window_q and window_k
-            if self.rope:
-                # Compute frequencies for this window
-                window_q, window_k = self.rope(window_q, window_k)
-
-            # Calculate attention for this window
-            attn = self._calculate_attn_weights(window_q, window_k, d)
-            attn_i = torch.einsum('bhij, bhjd -> bhid', attn, window_v)
-            local_attn.append(attn_i)
-        local_attn = torch.cat(local_attn, dim=2).view(b, self.num_heads, -1, head_dim)
-
-        # Combine all attention outputs
-        combined_attn = torch.cat([global_attn, global_local_attn, local_attn], dim=2)
-        output = self._calculate_output(combined_attn, v, b, t, d)
-        return self.out_proj(output)
+            q, k = self._apply_rope(q, k, separate=True)
+
+        # Split Q into global and local parts
+        global_q = q[:, :, :self.num_global_tokens]  # (B, H, G, head_dim)
+        local_q = q[:, :, self.num_global_tokens:]   # (B, H, L, head_dim)
+        L = local_q.size(2)
+        S = k.size(2)
+
+        # Global attention: global_q attends to all K/V
+        global_attn = F.scaled_dot_product_attention(
+            global_q, k, v, attn_mask=mask if not self.is_causal else None,
+            dropout_p=self.dropout.p if self.training else 0, is_causal=self.is_causal
+        )
+
+        # Local attention: local_q attends to windowed K/V
+        # Vectorized window mask
+        indices = torch.arange(S, device=local_q.device)
+        local_pos = torch.arange(L, device=local_q.device)
+        local_window = (local_pos // self.window_size).unsqueeze(-1)  # (L, 1)
+        key_window = (indices // self.window_size).expand(L, -1)      # (L, S)
+        window_mask = (local_window == key_window).to(device=local_q.device)
+
+        local_attn = F.scaled_dot_product_attention(
+            local_q, k, v, attn_mask=window_mask if not self.is_causal else None,
+            dropout_p=self.dropout.p if self.training else 0, is_causal=self.is_causal
+        )
+
+        # Combine global and local attention outputs
+        attn = torch.cat([global_attn, local_attn], dim=2)  # (B, H, G+L, head_dim)
+
+        # Merge heads and project back
+        output = self._merge_heads(attn)  # (B, G+L, D)
+        output = self.out_proj(output)    # (B, G+L, D)
+
+        # Return only the local tokens (original query tokens)
+        return output[:, self.num_global_tokens:, :]
 
 
 class InfiniteAttention(MultiHeadAttention):
@@ -467,8 +493,10 @@ def init_experimental_attention(
         num_experts: int = None,
         num_query_experts: int = None,
         num_query_groups: int = None,
+        num_global_tokens: int = 16,
+        window_size: int = 128,
 ) -> MultiHeadAttention:
-    assert attention_type in ['gma', 'dma', 'sqa'], "Error, attention type should be one of: 'gma', 'dma', 'sqa'"
+    assert attention_type in ['gma', 'dma', 'sqa', 'flex'], "Error, attention type should be one of: 'gma', 'dma', 'sqa', 'flex'"
 
     if attention_type == "gma":
         return GroupedMoeAttention(
@@ -504,6 +532,21 @@ def init_experimental_attention(
             num_query_experts=num_query_experts,
             num_query_groups=num_query_groups,
         )
+    elif attention_type == "flex":
+        return FlexAttention(
+            embed_dim,
+            num_heads,
+            dropout=dropout,
+            rope=rope,
+            max_seq_len=max_seq_len,
+            rope_only_for_query=rope_only_for_query,
+            rope_only_for_keys=rope_only_for_keys,
+            use_flash_attention=use_flash_attention,
+            is_causal=is_causal,
+            use_bias=use_bias,
+            num_global_tokens=num_global_tokens,
+            window_size=window_size,
+        )
     else:
         return SparseQueryAttention(
             embed_dim,

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/experimental/models.py

@@ -32,6 +32,8 @@ class ExperimentalAttentionTransformerConfig(TypedDict):
     att_num_experts: int
     att_num_query_experts: int
     att_num_query_groups: int
+    att_num_global_tokens: int
+    att_window_size: int
 
 
 class ExperimentalAttentionTransformer(nn.Module, PyTorchModelHubMixin, pipeline_tag="text-generation", license="apache-2.0"):
@@ -63,13 +65,15 @@ class ExperimentalAttentionTransformer(nn.Module, PyTorchModelHubMixin, pipeline
             att_num_experts: int = None,
             att_num_query_experts: int = None,
             att_num_query_groups: int = None,
+            att_num_global_tokens: int = 16,
+            att_window_size: int = 128,
             **kwargs
     ):
         super(ExperimentalAttentionTransformer, self).__init__(**kwargs)
         assert ff_activation in ['relu', 'gelu',
                                  'swish', 'silu', 'linear',
                                  'sigmoid'], 'Feed-forward activation could be "relu", "gelu", "swish", "silu", "linear", "sigmoid".'
-        assert att_type in ['mha', 'gqa', 'mqa', 'gma', 'dma', 'sqa'], 'Self-attention type could be "mha", "gqa", "mqa", "gma", "dma", "sqa".'
+        assert att_type in ['mha', 'gqa', 'mqa', 'gma', 'dma', 'sqa', 'flex'], 'Self-attention type could be "mha", "gqa", "mqa", "gma", "dma", "sqa", "flex".'
 
         embedding = nn.Embedding(vocab_size, embed_dim)
         rope = RotaryPositionalEmbedding(embed_dim // att_heads, seq_len)
@@ -84,8 +88,8 @@ class ExperimentalAttentionTransformer(nn.Module, PyTorchModelHubMixin, pipeline
             att_init = lambda: init_experimental_attention(embed_dim, att_heads, att_type, att_groups, rope=rope,
                                                            use_flash_attention=use_flash_attention, dropout=att_dropout,
                                                            max_seq_len=seq_len, is_causal=True, num_experts=att_num_experts,
-                                                           num_query_experts=att_num_query_experts,
-                                                           num_query_groups=att_num_query_groups)
+                                                           num_query_experts=att_num_query_experts, num_query_groups=att_num_query_groups,
+                                                           num_global_tokens=att_num_global_tokens, window_size=att_window_size)
 
         use_moe_att = att_type in ['gma', 'dma']
 

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/memory/attention.py

@@ -12,6 +12,7 @@ class StmMemoryAttention(nn.Module):
             per_slot_gate: bool = False,
             init_gate: float = 0.0,
             use_dynamic_gate: bool = False,
+            use_tanh_gate: bool = False,
             *args,
             **kwargs
     ):
@@ -24,6 +25,7 @@ class StmMemoryAttention(nn.Module):
         self.use_gated_residual = use_gated_residual
         self.per_slot_gate = per_slot_gate
         self.use_dynamic_gate = use_dynamic_gate
+        self.use_tanh_gate = use_tanh_gate
         if self.use_gated_residual:
             gate_shape = (self.num_layers, self.stm.stm_size, 1) if self.per_slot_gate else (self.num_layers,)
             self.gate = nn.Parameter(torch.full(gate_shape, init_gate))
@@ -37,10 +39,13 @@ class StmMemoryAttention(nn.Module):
         if self.use_dynamic_gate:
             mean_dim = -1 if self.per_slot_gate else [1, 2]
             gate_input = gate * (new_layer_stm + layer_stm).mean(dim=mean_dim, keepdim=True)
-            layer_gate = torch.sigmoid(gate_input)
+            layer_gate = torch.tanh(gate_input) if self.use_tanh_gate else torch.sigmoid(gate_input)
         else:
-            layer_gate = torch.sigmoid(gate)
-        return layer_gate * new_layer_stm + (1 - layer_gate) * layer_stm
+            layer_gate = torch.tanh(gate) if self.use_tanh_gate else torch.sigmoid(gate)
+        if self.use_tanh_gate:
+            return (1 + layer_gate) * new_layer_stm + (1 - layer_gate) * layer_stm
+        else:
+            return layer_gate * new_layer_stm + (1 - layer_gate) * layer_stm
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         new_stm = torch.zeros_like(self.stm.memory)

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/training/mrl.py

@@ -9,7 +9,7 @@ import random, os
 from ..transformers.sampler import BatchSampler
 from .callbacks import MrlTrainerCallback
 from .dataset import MrlCurriculumDataset
-from .utils import smart_concat, smart_concat_critic_states, TokenizedDict
+from .utils import smart_concat, smart_concat_critic_states, TokenizedDict, get_gradient_norms
 from .rl import RlAlgorithm
 from .reward import MrlRewardMode, MrlRewardModel
 from .models import MrlActorAction, MrlActorModel, MrlCriticModel
@@ -109,6 +109,7 @@ class MRLTrainer:
             use_ddp: bool = False,
             use_amp: bool = False,
             dtype: torch.dtype = torch.float32,
+            debug_mode: bool = False,
     ):
         """
         Trainer for Memory Reinforcement Learning (MRL) algorithm for reactive models and Attention-Based Memory System.
@@ -139,6 +140,7 @@ class MRLTrainer:
         self.shared_freeze_embeddings = config.get('freeze_embeddings', False)
         self.freeze_embeddings = self.shared_freeze_embeddings
         self.use_memory_warmup = config.get('use_memory_warmup', False)
+        self.debug_mode = debug_mode
         # Internal update epochs config
         self.shared_update_epochs = config.get('update_epochs', 10)
         self.update_epochs = self.shared_update_epochs
@@ -566,6 +568,14 @@ class MRLTrainer:
         else:
             return main_loss
 
+    def _log_gradients(self):
+        encoder_total, encoder_mean = get_gradient_norms(self.actor.encoder)
+        decoder_total, decoder_mean = get_gradient_norms(self.actor.decoder)
+        mem_att_total, mem_att_mean = get_gradient_norms(self.actor.memory_attention)
+        print(f"Encoder grad norm - total: {encoder_total:.4f}, mean: {encoder_mean:.4f}")
+        print(f"Decoder grad norm - total: {decoder_total:.4f}, mean: {decoder_mean:.4f}")
+        print(f"Memory attention grad norm - total: {mem_att_total:.4f}, mean: {mem_att_mean:.4f}")
+
     def update_actor(self, state: tuple[TokenizedDict, TokenizedDict, TokenizedDict], action: TokenizedDict,
                      advantages: torch.Tensor, old_log_probs: torch.Tensor, epoch: int) -> float:
         # 1. Reset actor gradients
@@ -596,6 +606,8 @@ class MRLTrainer:
             self.scaler.unscale_(self.optimizer)
             torch.nn.utils.clip_grad_norm_(self.actor.unique_parameters(), max_norm=1.0,
                                            error_if_nonfinite=False)
+            if self.debug_mode:
+                self._log_gradients()
             # 4.5 Run scaled optimization step
             self.scaler.step(self.optimizer)
             self.scaler.update()
@@ -613,6 +625,8 @@ class MRLTrainer:
             # 4.4 Clip gradient norms
             torch.nn.utils.clip_grad_norm_(self.actor.unique_parameters(), max_norm=1.0,
                                            error_if_nonfinite=False)
+            if self.debug_mode:
+                self._log_gradients()
             # 4.5 Run scaled optimization step
             self.optimizer.step()
         # 5. Get float loss value for callbacks/writer

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/training/rl.py

@@ -36,7 +36,7 @@ class PPOConfig(TypedDict):
 
 
 class PPOAlgorithm(RlAlgorithm):
-    def __init__(self, config: Optional[PPOConfig] = None):
+    def __init__(self, config: Optional[PPOConfig] = None, debug_mode: bool = False):
         super(PPOAlgorithm, self).__init__()
 
         if config is None:
@@ -49,7 +49,8 @@ class PPOAlgorithm(RlAlgorithm):
         self.entropy_coef = config.get('entropy_coef', 0.01)
         self.use_distributed_advantage_norm = config.get('use_distributed_advantage_norm', False)
         self.clip_critic_values = config.get('clip_critic_values', True)
-        self.critic_value_clip = config.get('critic_value_clip', 10.0)
+        self.critic_value_clip = config.get('critic_value_clip', 20.0)
+        self.debug_mode = debug_mode
 
     def critic_loss(self, values: torch.Tensor, ref_values: torch.Tensor) -> torch.Tensor:
         # Critic loss with clipped values
@@ -96,6 +97,14 @@ class PPOAlgorithm(RlAlgorithm):
 
         advantages = advantages.unsqueeze(-1)
 
+        if self.debug_mode:
+            print(
+                f"Logits stats: min={new_logits.min().item():.4f}, max={new_logits.max().item():.4f}, mean={new_logits.mean().item():.4f}")
+            print(
+                f"Ratio stats: min={ratio.min().item():.4f}, max={ratio.max().item():.4f}, mean={ratio.mean().item():.4f}")
+            print(
+                f"Advantage stats: min={advantages.min().item():.4f}, max={advantages.max().item():.4f}, mean={advantages.mean().item():.4f}")
+
         # c) Clipped surrogate loss
         surr1 = ratio * advantages
         surr2 = torch.clamp(ratio, 1.0 - self.clip_eps, 1.0 + self.clip_eps) * advantages

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/training/utils.py

@@ -1,4 +1,5 @@
 import torch
+import torch.nn as nn
 from typing import TypedDict
 
 
@@ -142,3 +143,13 @@ def smart_concat(query: TokenizedDict, answer: TokenizedDict, max_length: int, p
         'input_ids': combined_ids,
         'attention_mask': combined_mask
     }
+
+def get_gradient_norms(model: nn.Module):
+    total_norm = 0
+    for p in model.parameters():
+        if p.grad is not None:
+            param_norm = p.grad.data.norm(2)
+            total_norm += param_norm.item() ** 2
+    total_norm = total_norm ** 0.5
+    mean_norm = total_norm / len(list(model.parameters()))
+    return total_norm, mean_norm

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/transformers/attention.py

@@ -69,12 +69,14 @@ class MultiHeadAttention(nn.Module):
         v = self.v_proj(value).view(b, -1, self.num_heads, d // self.num_heads).transpose(1, 2)
         return q, k, v
 
-    def _apply_rope(self, q: torch.Tensor, k: torch.Tensor):
+    def _apply_rope(self, q: torch.Tensor, k: torch.Tensor, separate: bool = False):
         if self.rope is not None:
             if self.rope_only_for_query:
                 q = self.rope.forward_one(q)
             elif self.rope_only_for_keys:
                 k = self.rope.forward_one(k)
+            elif separate:
+                q, k = self.rope.forward_one(q), self.rope.forward_one(k)
             else:
                 q, k = self.rope(q, k)
         return q, k

{rxnn-0.2.51 → rxnn-0.2.53}/src/rxnn/transformers/layers.py

@@ -110,7 +110,7 @@ class ReactiveTransformerLayer(nn.Module):
         residual = x
         if not self.use_post_norm:
             x = self.norm2(x)
-        x = self.memory_cross_attention(x, stm, stm)
+        x = self.memory_cross_attention(x, stm, stm, mask=mask)
         x = residual + x
         if self.use_post_norm:
             x = self.norm2(x)