rxnn 0.2.10__tar.gz → 0.2.12__tar.gz

{rxnn-0.2.10 → rxnn-0.2.12}/PKG-INFO

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

{rxnn-0.2.10 → rxnn-0.2.12}/pyproject.toml

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

{rxnn-0.2.10 → rxnn-0.2.12}/src/rxnn/memory/stm.py

@@ -42,7 +42,8 @@ class ShortTermMemory(nn.Module):
         self.memory[layer] = new_stm
 
     def update_all(self, new_stm: torch.Tensor):
-        self.memory.copy_(new_stm)
+        self.memory = new_stm
+        # self.memory.copy_(new_stm)
 
     def make_trainable(self):
         if not self.is_trainable:

{rxnn-0.2.10 → rxnn-0.2.12}/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.10 → rxnn-0.2.12}/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.10 → rxnn-0.2.12}/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.10 → rxnn-0.2.12}/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