rxnn 0.2.9__tar.gz → 0.2.11__tar.gz

{rxnn-0.2.9 → rxnn-0.2.11}/PKG-INFO

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

{rxnn-0.2.9 → rxnn-0.2.11}/pyproject.toml

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

{rxnn-0.2.9 → rxnn-0.2.11}/src/rxnn/memory/attention.py

@@ -36,7 +36,8 @@ class StmMemoryAttention(nn.Module):
             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, mask=mask)
             # self.stm.update_layer(i, new_layer_stm + layer_stm)
-            new_stm[i] = new_layer_stm + layer_stm # residual
-        self.stm.update_all(new_stm)
+            final_layer_stm = new_layer_stm + layer_stm # residual
+            self.stm.update_layer(i, final_layer_stm)
+        # self.stm.update_all(new_stm)
         return self.stm.memory
 

{rxnn-0.2.9 → rxnn-0.2.11}/src/rxnn/training/callbacks.py

@@ -577,7 +577,7 @@ class MrlPrintCallback(MrlTrainerCallback):
 
     def on_critic_updated(self, actor: nn.Module, critic: nn.Module, epoch: int, step: int,
                           critic_loss: float) -> None:
-        print(f'Epoch {epoch} | Step {step} - updated policy loss {critic_loss}')
+        print(f'Epoch {epoch} | Step {step} - updated critic loss {critic_loss}')
 
     def on_training_end(self, actor: nn.Module, critic: nn.Module, curriculum_config: dict) -> None:
         print(f'Finished training for {curriculum_config["steps"]} steps in {curriculum_config["strategy"]} strategy.')

{rxnn-0.2.9 → rxnn-0.2.11}/src/rxnn/training/dataset.py

@@ -936,7 +936,7 @@ class MrlCurriculumDataset(Dataset):
         else:
             subset = self.episodes[split_point:-1] if not from_start else self.episodes[0:split_point]
             self.episodes = self.episodes[0:split_point] if not from_start else self.episodes[split_point:-1]
-        return self.__class__(subset, query_field=self.query_field, answer_field=self.answer_field, interactions_field=self.interactions_field, **kwargs)
+        return self.__class__(subset, tokenizer=self.tokenizer, query_field=self.query_field, answer_field=self.answer_field, interactions_field=self.interactions_field, **kwargs)
 
     def pre_tokenize(self, verbose: bool = False, log_interval: int = 10_000, keep_order: bool = False):
         """

{rxnn-0.2.9 → rxnn-0.2.11}/src/rxnn/training/mrl.py

@@ -328,7 +328,8 @@ class MRLTrainer:
 
                         # 10. Update STM with generated response (except last interaction, it's not needed)
                         if not is_last_interaction:
-                            self.encode_and_update_stm(next_query, generated_answer)  # update with generated_answer on GPU
+                            self.encode_and_update_stm(next_query,
+                                                       generated_answer)  # update with generated_answer on GPU
 
                         # 11. Store trajectory step
                         trajectory: MrlTrajectoryStep = {
@@ -438,7 +439,7 @@ class MRLTrainer:
             critic_losses.append(critic_loss)
 
         # 7. Calculate mean loss for epoch callbacks
-        critic_mean_loss = torch.stack(critic_losses).mean().item()
+        critic_mean_loss = torch.tensor(critic_losses).mean().item()
 
         return critic_mean_loss
 

{rxnn-0.2.9 → rxnn-0.2.11}/src/rxnn/training/reward.py

@@ -103,9 +103,9 @@ class MrlRewardModel:
         if mode == MrlRewardMode.STANDARD or mode == MrlRewardMode.LONG_RANGE:
             bleu = self.batch_bleu(generated['input_ids'], reference['input_ids'], saved_data['input_ids'])
             cosine = self.batch_cosine(generated['input_ids'], reference['input_ids'], saved_data['input_ids'])
-            return (self.bleu_factor * torch.tensor(bleu) + self.cos_factor * cosine).tolist()
+            return (self.bleu_factor * torch.tensor(bleu, device=self.device) + self.cos_factor * cosine).tolist()
         else:
             bleu = self.batch_bleu(generated['input_ids'], reference['input_ids'], saved_data['input_ids'])
             cosine = self.negative_cosine(generated['input_ids'], reference['input_ids'], saved_data['input_ids'])
-            return (self.neg_bleu_factor * torch.tensor(bleu) + self.neg_cos_factor * cosine).tolist()
+            return (self.neg_bleu_factor * torch.tensor(bleu, device=self.device) + self.neg_cos_factor * cosine).tolist()
 

{rxnn-0.2.9 → rxnn-0.2.11}/src/rxnn/training/rl.py

@@ -54,16 +54,16 @@ class PPOAlgorithm(RlAlgorithm):
 
         return policy_loss
 
-    def _compute_gae(self, rewards: torch.Tensor, values: torch.Tensor, next_value: torch.Tensor) -> torch.Tensor:
-        advantages = torch.zeros_like(rewards, device=values.device)
-        last_advantage = 0
-        for t in reversed(range(rewards.size(0))):
-            delta = rewards[t] + self.gae_gamma * next_value - values[t]
-            advantages[t] = delta + self.gae_gamma * self.gae_lambda * last_advantage
-            last_advantage = advantages[t]
-        return advantages
+    # def _compute_gae(self, rewards: torch.Tensor, values: torch.Tensor, next_value: torch.Tensor) -> torch.Tensor:
+    #     advantages = torch.zeros_like(rewards, device=values.device)
+    #     last_advantage = 0
+    #     for t in reversed(range(rewards.size(0))):
+    #         delta = rewards[t] + self.gae_gamma * next_value - values[t]
+    #         advantages[t] = delta + self.gae_gamma * self.gae_lambda * last_advantage
+    #         last_advantage = advantages[t]
+    #     return advantages
 
     def calculate_advantages(self, rewards: torch.Tensor, values: torch.Tensor) -> torch.Tensor:
-        advantages = self._compute_gae(rewards, values[:-1], values[-1])
+        advantages = rewards - values
         normalized_advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)
         return normalized_advantages