rxnn 0.2.56__tar.gz → 0.2.58__tar.gz

{rxnn-0.2.56 → rxnn-0.2.58}/PKG-INFO

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

{rxnn-0.2.56 → rxnn-0.2.58}/pyproject.toml

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

{rxnn-0.2.56 → rxnn-0.2.58}/src/rxnn/memory/attention.py

@@ -47,7 +47,8 @@ class StmMemoryAttention(nn.Module):
         else:
             return layer_gate * new_layer_stm + (1 - layer_gate) * layer_stm
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
+    def forward(self, x: torch.Tensor, attention_mask: torch.Tensor = None) -> torch.Tensor:
+        mem_mask = attention_mask.unsqueeze(1).unsqueeze(1).bool() if attention_mask else None
         new_stm = torch.zeros_like(self.stm.memory)
         for i in range(self.num_layers):
             layer_stm = self.stm(i)
@@ -56,7 +57,7 @@ class StmMemoryAttention(nn.Module):
                 layer_stm = layer_stm.expand(x.size(0), -1, -1)
             encoded_layer_data = x[i]
             normalized_layer_stm = self.memory_norm_layers[i](layer_stm)
-            new_layer_stm = self.attention_layers[i](normalized_layer_stm, encoded_layer_data, encoded_layer_data)
+            new_layer_stm = self.attention_layers[i](normalized_layer_stm, encoded_layer_data, encoded_layer_data, mask=mem_mask)
             if self.use_gated_residual:
                 new_stm[i] = self._residual_gate(self.gate[i], layer_stm, new_layer_stm) # gated residual
             else:

{rxnn-0.2.56 → rxnn-0.2.58}/src/rxnn/rxt/models.py

@@ -306,8 +306,8 @@ class RxTAlphaMemoryAttention(nn.Module, PyTorchModelHubMixin, license="apache-2
     def clone_reset_memory(self):
         self.model.stm.clone_detach_reset()
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return self.model(x)
+    def forward(self, x: torch.Tensor, attention_mask: torch.Tensor = None) -> torch.Tensor:
+        return self.model(x, attention_mask=attention_mask)
 
 class RxTAlphaCriticEncoder(RxTAlphaComponentBase, pipeline_tag="text-classification", license="apache-2.0"):
     """RxT-Alpha (Reactive Transformer) encoder model"""

{rxnn-0.2.56 → rxnn-0.2.58}/src/rxnn/training/dataset.py

@@ -943,7 +943,7 @@ class MrlCurriculumDataset(Dataset):
         return self.get_tokenized_item(idx)
 
     def __len__(self) -> int:
-        return len(self.episodes)
+        return len(self.inputs if self.is_pre_tokenized else self.episodes)
 
     def get_subset(self, size: float, from_start: bool = False, **kwargs) -> "MRlCurriculumDataset":
         split_point = int(len(self.episodes) * ((1 - size) if not from_start else size))

{rxnn-0.2.56 → rxnn-0.2.58}/src/rxnn/training/models.py

@@ -204,7 +204,7 @@ class MrlActorModel(nn.Module):
             return self.decoder(x, attention_mask=attention_mask)
         else:
             _, ed = self.encoder(x, attention_mask=attention_mask)
-            return self.memory_attention(ed)
+            return self.memory_attention(ed, attention_mask=attention_mask)
 
 
 class MrlCriticModel(nn.Module, PyTorchModelHubMixin, license="apache-2.0", pipeline_tag="text-classification"):

{rxnn-0.2.56 → rxnn-0.2.58}/src/rxnn/training/mrl.py

@@ -36,6 +36,8 @@ class MrlConfig(TypedDict):
     freeze_embeddings: Optional[bool]
     embedding_lr: Optional[float]
     use_memory_warmup: Optional[bool]
+    debug_mode: Optional[bool]
+    debug_interval: Optional[int]
 
 
 class MrlStrategy(Enum):
@@ -109,7 +111,6 @@ 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.
@@ -140,7 +141,8 @@ 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
+        self.debug_mode = config.get('debug_mode', False)
+        self.debug_interval = config.get('debug_interval', 10)
         # Internal update epochs config
         self.shared_update_epochs = config.get('update_epochs', 10)
         self.update_epochs = self.shared_update_epochs
@@ -606,7 +608,7 @@ 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:
+            if self.debug_mode and self.epoch_step['train'] % self.debug_interval == 0:
                 self._log_gradients()
             # 4.5 Run scaled optimization step
             self.scaler.step(self.optimizer)
@@ -625,7 +627,7 @@ 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:
+            if self.debug_mode and self.epoch_step['train'] % self.debug_interval == 0:
                 self._log_gradients()
             # 4.5 Run scaled optimization step
             self.optimizer.step()

{rxnn-0.2.56 → rxnn-0.2.58}/src/rxnn/training/rl.py

@@ -33,10 +33,12 @@ class PPOConfig(TypedDict):
     use_distributed_advantage_norm: Optional[bool]
     clip_critic_values: Optional[bool]
     critic_value_clip: Optional[float]
+    debug_mode: Optional[bool]
+    debug_interval: Optional[int]
 
 
 class PPOAlgorithm(RlAlgorithm):
-    def __init__(self, config: Optional[PPOConfig] = None, debug_mode: bool = False):
+    def __init__(self, config: Optional[PPOConfig] = None):
         super(PPOAlgorithm, self).__init__()
 
         if config is None:
@@ -50,7 +52,9 @@ class PPOAlgorithm(RlAlgorithm):
         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', 20.0)
-        self.debug_mode = debug_mode
+        self.debug_mode = config.get('debug_mode', False)
+        self.debug_interval = config.get('debug_interval', 10)
+        self.debug_step = 0
 
     def critic_loss(self, values: torch.Tensor, ref_values: torch.Tensor) -> torch.Tensor:
         # Critic loss with clipped values
@@ -98,12 +102,16 @@ 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}")
+            if self.debug_step != 0 and self.debug_step % self.debug_interval == 0:
+                self.debug_step = 0
+                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}")
+            else:
+                self.debug_step += 1
 
         # c) Clipped surrogate loss
         surr1 = ratio * advantages

{rxnn-0.2.56 → rxnn-0.2.58}/src/rxnn/transformers/layers.py

@@ -110,7 +110,11 @@ class ReactiveTransformerLayer(nn.Module):
         residual = x
         if not self.use_post_norm:
             x = self.norm2(x)
-        x = self.memory_cross_attention(x, stm, stm, mask=mask)
+
+        if mask is not None:
+            mem_mask = mask.squeeze(1).unsqueeze(-1).expand(-1, -1, -1, stm.size(1))
+
+        x = self.memory_cross_attention(x, stm, stm, mask=mem_mask)
         x = residual + x
         if self.use_post_norm:
             x = self.norm2(x)