deeplotx 0.8.5__tar.gz → 0.8.7__tar.gz

{deeplotx-0.8.5 → deeplotx-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeplotx
-Version: 0.8.5
+Version: 0.8.7
 Summary: Easy-2-use long text NLP toolkit.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx/encoder/encoder.py

@@ -48,7 +48,7 @@ class Encoder(nn.Module):
             return self.encoder.forward(_input_tup[0], attention_mask=_input_tup[1]).last_hidden_state[:, 0, :]
 
         num_chunks = math.ceil(input_ids.shape[-1] / self.embed_dim)
-        chunks = chunk_results = []
+        chunks, chunk_results = [], []
         for i in range(num_chunks):
             start_idx = i * self.embed_dim
             end_idx = min(start_idx + self.embed_dim, input_ids.shape[-1])

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx/nn/base_neural_network.py

@@ -99,11 +99,14 @@ class BaseNeuralNetwork(nn.Module):
 
     def predict(self, x: torch.Tensor) -> torch.Tensor:
         x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
-        __train = self.training
-        self.training = False
+        training_state_dict = dict()
+        for m in self.modules():
+            training_state_dict[m] = m.training
+            m.training = False
         with torch.no_grad():
             res = self.forward(x)
-        self.training = __train
+        for m, training_state in training_state_dict.items():
+            m.training = training_state
         return res
 
     def save(self, model_name: str | None = None, model_dir: str = '.', _suffix: str = DEFAULT_SUFFIX):

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx/nn/feed_forward.py

@@ -28,7 +28,7 @@ class FeedForwardUnit(BaseNeuralNetwork):
         x = self.layer_norm(x)
         x = self.up_proj(x)
         x = self.parametric_relu(x)
-        if self._dropout_rate > .0:
+        if self._dropout_rate > .0 and self.training:
             x = torch.dropout(x, p=self._dropout_rate, train=self.training)
         return self.down_proj(x) + residual
 

deeplotx-0.8.7/deeplotx/nn/linear_regression.py

@@ -0,0 +1,29 @@
+from typing_extensions import override
+
+import torch
+from torch import nn
+
+from deeplotx.nn.base_neural_network import BaseNeuralNetwork
+from deeplotx.nn.multi_head_feed_forward import MultiHeadFeedForward
+
+
+class LinearRegression(BaseNeuralNetwork):
+    def __init__(self, input_dim: int, output_dim: int, num_heads: int = 1, num_layers: int = 1,
+                 expansion_factor: int | float = 1.5, bias: bool = True, dropout_rate: float = 0.1,
+                 model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None, **kwargs):
+        super().__init__(in_features=input_dim, out_features=output_dim, model_name=model_name, device=device, dtype=dtype)
+        self.multi_head_ffn_layers = nn.ModuleList([MultiHeadFeedForward(feature_dim=input_dim, num_heads=num_heads,
+                                                                         num_layers=kwargs.get('head_layers', 1),
+                                                                         expansion_factor=expansion_factor,
+                                                                         bias=bias, dropout_rate=dropout_rate,
+                                                                         device=self.device, dtype=self.dtype) for _ in range(num_layers)])
+        self.out_proj = nn.Linear(in_features=input_dim, out_features=output_dim,
+                                  bias=bias, device=self.device, dtype=self.dtype)
+
+    @override
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
+        residual = x
+        for ffn in self.multi_head_ffn_layers:
+            x = ffn(x)
+        return self.out_proj(x + residual)

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx/nn/logistic_regression.py

@@ -8,10 +8,10 @@ from deeplotx.nn.linear_regression import LinearRegression
 class LogisticRegression(LinearRegression):
     def __init__(self, input_dim: int, output_dim: int = 1, num_heads: int = 1, num_layers: int = 1,
                  expansion_factor: int | float = 1.5, bias: bool = True, dropout_rate: float = 0.1,
-                 model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None):
+                 model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None, **kwargs):
         super().__init__(input_dim=input_dim, output_dim=output_dim, num_heads=num_heads, num_layers=num_layers,
                          expansion_factor=expansion_factor, bias=bias, dropout_rate=dropout_rate,
-                         model_name=model_name, device=device, dtype=dtype)
+                         model_name=model_name, device=device, dtype=dtype, **kwargs)
 
     @override
     def forward(self, x: torch.Tensor) -> torch.Tensor:

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx/nn/recursive_sequential.py

@@ -4,7 +4,7 @@ import torch
 from torch import nn
 
 from deeplotx.nn.base_neural_network import BaseNeuralNetwork
-from deeplotx.nn.multi_head_feed_forward import MultiHeadFeedForward
+from deeplotx.nn.linear_regression import LinearRegression
 
 
 class RecursiveSequential(BaseNeuralNetwork):
@@ -20,11 +20,10 @@ class RecursiveSequential(BaseNeuralNetwork):
                             num_layers=recursive_layers, batch_first=True,
                             bias=True, bidirectional=True, device=self.device,
                             dtype=self.dtype)
-        self.ffn = MultiHeadFeedForward(feature_dim=recursive_hidden_dim * 2, num_heads=kwargs.get('ffn_heads', 1),
-                                        num_layers=ffn_layers, expansion_factor=ffn_expansion_factor,
-                                        bias=bias, dropout_rate=dropout_rate, device=self.device, dtype=self.dtype)
-        self.__proj = nn.Linear(in_features=recursive_hidden_dim * 2, out_features=output_dim, bias=bias,
-                                device=self.device, dtype=self.dtype)
+        self.out_proj = LinearRegression(input_dim=recursive_hidden_dim * 2, output_dim=output_dim,
+                                         num_heads=kwargs.get('ffn_heads', 1), head_layers=kwargs.get('ffn_head_layers', 1),
+                                         num_layers=ffn_layers, expansion_factor=ffn_expansion_factor,
+                                         bias=bias, dropout_rate=dropout_rate, device=self.device, dtype=self.dtype)
 
     def initial_state(self, batch_size: int = 1) -> tuple[torch.Tensor, torch.Tensor]:
         zeros = torch.zeros(self.lstm.num_layers * 2, batch_size, self.lstm.hidden_size, device=self.device, dtype=self.dtype)
@@ -37,16 +36,17 @@ class RecursiveSequential(BaseNeuralNetwork):
                  self.ensure_device_and_dtype(state[1], device=self.device, dtype=self.dtype))
         x, (hidden_state, cell_state) = self.lstm(x, state)
         x = x[:, -1, :]
-        residual = x
-        x = self.ffn(x) + residual
-        x = self.__proj(x)
+        x = self.out_proj(x)
         return x, (hidden_state, cell_state)
 
     @override
     def predict(self, x: torch.Tensor) -> torch.Tensor:
-        __train = self.training
-        self.training = False
+        training_state_dict = dict()
+        for m in self.modules():
+            training_state_dict[m] = m.training
+            m.training = False
         with torch.no_grad():
             res = self.forward(x.unsqueeze(0), self.initial_state(batch_size=1))[0]
-        self.training = __train
+        for m, training_state in training_state_dict.items():
+            m.training = training_state
         return res

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx/nn/roformer_encoder.py

@@ -27,8 +27,8 @@ class RoFormerEncoder(BaseNeuralNetwork):
                                device=self.device, dtype=self.dtype)
         self.layer_norm = nn.LayerNorm(normalized_shape=feature_dim, eps=1e-9,
                                        device=self.device, dtype=self.dtype)
-        self.__proj = nn.Linear(in_features=feature_dim * 2, out_features=feature_dim,
-                                bias=bias, device=self.device, dtype=self.dtype)
+        self.out_proj = nn.Linear(in_features=feature_dim * 2, out_features=feature_dim,
+                                  bias=bias, device=self.device, dtype=self.dtype)
 
     @override
     def forward(self, x: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
@@ -37,4 +37,4 @@ class RoFormerEncoder(BaseNeuralNetwork):
             mask = self.ensure_device_and_dtype(mask, device=self.device, dtype=self.dtype)
         attn = self.attn(x=self.layer_norm(x), y=None, mask=mask)
         x = torch.concat([attn, x], dim=-1)
-        return self.__proj(self.ffn(x))
+        return self.out_proj(self.ffn(x))

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx/nn/softmax_regression.py

@@ -8,10 +8,10 @@ from deeplotx.nn.linear_regression import LinearRegression
 class SoftmaxRegression(LinearRegression):
     def __init__(self, input_dim: int, output_dim: int, num_heads: int = 1, num_layers: int = 1,
                  expansion_factor: int | float = 1.5, bias: bool = True, dropout_rate: float = 0.1,
-                 model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None):
+                 model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None, **kwargs):
         super().__init__(input_dim=input_dim, output_dim=output_dim, num_heads=num_heads, num_layers=num_layers,
                          expansion_factor=expansion_factor, bias=bias, dropout_rate=dropout_rate,
-                         model_name=model_name, device=device, dtype=dtype)
+                         model_name=model_name, device=device, dtype=dtype, **kwargs)
 
     @override
     def forward(self, x: torch.Tensor) -> torch.Tensor:

{deeplotx-0.8.5 → deeplotx-0.8.7}/deeplotx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeplotx
-Version: 0.8.5
+Version: 0.8.7
 Summary: Easy-2-use long text NLP toolkit.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{deeplotx-0.8.5 → deeplotx-0.8.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deeplotx"
-version = "0.8.5"
+version = "0.8.7"
 description = "Easy-2-use long text NLP toolkit."
 readme = "README.md"
 requires-python = ">=3.10"

deeplotx-0.8.5/deeplotx/nn/linear_regression.py

@@ -1,26 +0,0 @@
-from typing_extensions import override
-
-import torch
-from torch import nn
-
-from deeplotx.nn.base_neural_network import BaseNeuralNetwork
-from deeplotx.nn.multi_head_feed_forward import MultiHeadFeedForward
-
-
-class LinearRegression(BaseNeuralNetwork):
-    def __init__(self, input_dim: int, output_dim: int, num_heads: int = 1, num_layers: int = 1,
-                 expansion_factor: int | float = 1.5, bias: bool = True, dropout_rate: float = 0.1,
-                 model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None):
-        super().__init__(in_features=input_dim, out_features=output_dim, model_name=model_name, device=device, dtype=dtype)
-        self.ffn = MultiHeadFeedForward(feature_dim=input_dim, num_heads=num_heads,
-                                        num_layers=num_layers, expansion_factor=expansion_factor,
-                                        bias=bias, dropout_rate=dropout_rate, device=self.device, dtype=self.dtype)
-        self.proj = nn.Linear(in_features=input_dim, out_features=output_dim,
-                              bias=bias, device=self.device, dtype=self.dtype)
-
-    @override
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
-        residual = x
-        x = self.ffn(x) + residual
-        return self.proj(x)