deeplotx 0.4.12b2__py3-none-any.whl → 0.4.12b3__py3-none-any.whl

deeplotx/encoder/bert_encoder.py

@@ -29,8 +29,6 @@ class BertEncoder(nn.Module):
         def _encoder(_input_tup: tuple[torch.Tensor, torch.Tensor]) -> torch.Tensor:
             return self.bert.forward(_input_tup[0], attention_mask=_input_tup[1]).last_hidden_state[:, 0, :]
 
-        input_ids = input_ids.to(self.device)
-        attention_mask = attention_mask.to(self.device)
         num_chunks = math.ceil(input_ids.shape[-1] / self.embed_dim)
         chunks = chunk_results = []
         for i in range(num_chunks):
@@ -45,6 +43,6 @@ class BertEncoder(nn.Module):
         return torch.cat(chunk_results, dim=-1)
 
     def encode(self, text: str) -> torch.Tensor:
-        _input_ids = torch.tensor([self.tokenizer.encode(text)], dtype=torch.long)
-        _att_mask = torch.tensor([[1] * _input_ids.shape[-1]], dtype=torch.int)
+        _input_ids = torch.tensor([self.tokenizer.encode(text)], dtype=torch.long, device=self.device)
+        _att_mask = torch.tensor([[1] * _input_ids.shape[-1]], dtype=torch.int, device=self.device)
         return self.forward(_input_ids, _att_mask).squeeze()

deeplotx/encoder/longformer_encoder.py

@@ -24,8 +24,6 @@ class LongformerEncoder(nn.Module):
         logger.debug(f'{LongformerEncoder.__name__} initialized on device: {self.device}.')
 
     def forward(self, input_ids: torch.Tensor, attention_mask: torch.Tensor) -> torch.Tensor:
-        input_ids = input_ids.to(self.device)
-        attention_mask = attention_mask.to(self.device)
         ori_mode = self.bert.training
         self.bert.eval()
         with torch.no_grad():
@@ -34,6 +32,6 @@ class LongformerEncoder(nn.Module):
         return res
 
     def encode(self, text: str) -> torch.Tensor:
-        _input_ids = torch.tensor([self.tokenizer.encode(text)], dtype=torch.long)
-        _att_mask = torch.tensor([[1] * _input_ids.shape[-1]], dtype=torch.int)
+        _input_ids = torch.tensor([self.tokenizer.encode(text)], dtype=torch.long, device=self.device)
+        _att_mask = torch.tensor([[1] * _input_ids.shape[-1]], dtype=torch.int, device=self.device)
         return self.forward(_input_ids, _att_mask).squeeze()

deeplotx/nn/auto_regression.py

@@ -1,9 +1,12 @@
+import torch
+
 from deeplotx.nn import RecursiveSequential
 
 
 class AutoRegression(RecursiveSequential):
     def __init__(self, feature_dim: int, hidden_dim: int | None = None,
-                 recursive_layers: int = 2, model_name: str | None = None):
+                 recursive_layers: int = 2, model_name: str | None = None,
+                 device: str | None = None, dtype: torch.dtype | None = None):
         super().__init__(input_dim=feature_dim, output_dim=feature_dim,
                          hidden_dim=hidden_dim, recursive_layers=recursive_layers,
-                         model_name=model_name)
+                         model_name=model_name, device=device, dtype=dtype)

deeplotx/nn/base_neural_network.py

@@ -5,11 +5,22 @@ from torch import nn
 
 
 class BaseNeuralNetwork(nn.Module):
-    def __init__(self, model_name: str | None = None):
+    def __init__(self, model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None):
         super().__init__()
         self._model_name = model_name \
             if model_name is not None \
             else self.__class__.__name__
+        self.device = torch.device(device) if device is not None \
+            else torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.dtype = dtype if dtype is not None else torch.float32
+
+    @staticmethod
+    def ensure_device_and_dtype(x: torch.Tensor, device: torch.device, dtype: torch.dtype) -> torch.Tensor:
+        if x.device != device:
+            x = x.to(device)
+        if x.dtype != dtype:
+            x = x.to(dtype)
+        return x
 
     def l1(self, _lambda: float = 1e-4) -> torch.Tensor:
         def _l1() -> torch.Tensor:

deeplotx/nn/linear_regression.py

@@ -7,26 +7,28 @@ from deeplotx.nn.base_neural_network import BaseNeuralNetwork
 
 
 class LinearRegression(BaseNeuralNetwork):
-    def __init__(self, input_dim: int, output_dim: int, model_name: str | None = None):
-        super().__init__(model_name=model_name)
-        self.fc1 = nn.Linear(input_dim, 1024)
-        self.fc1_to_fc4_res = nn.Linear(1024, 64)
-        self.fc2 = nn.Linear(1024, 768)
-        self.fc3 = nn.Linear(768, 128)
-        self.fc4 = nn.Linear(128, 64)
-        self.fc5 = nn.Linear(64, output_dim)
-        self.parametric_relu_1 = nn.PReLU(num_parameters=1, init=5e-3)
-        self.parametric_relu_2 = nn.PReLU(num_parameters=1, init=5e-3)
-        self.parametric_relu_3 = nn.PReLU(num_parameters=1, init=5e-3)
-        self.parametric_relu_4 = nn.PReLU(num_parameters=1, init=5e-3)
+    def __init__(self, input_dim: int, output_dim: int, model_name: str | None = None,
+                 device: str | None = None, dtype: torch.dtype | None = None):
+        super().__init__(model_name=model_name, device=device, dtype=dtype)
+        self.fc1 = nn.Linear(input_dim, 1024, device=self.device, dtype=self.dtype)
+        self.fc1_to_fc4_res = nn.Linear(1024, 64, device=self.device, dtype=self.dtype)
+        self.fc2 = nn.Linear(1024, 768, device=self.device, dtype=self.dtype)
+        self.fc3 = nn.Linear(768, 128, device=self.device, dtype=self.dtype)
+        self.fc4 = nn.Linear(128, 64, device=self.device, dtype=self.dtype)
+        self.fc5 = nn.Linear(64, output_dim, device=self.device, dtype=self.dtype)
+        self.parametric_relu_1 = nn.PReLU(num_parameters=1, init=5e-3, device=self.device, dtype=self.dtype)
+        self.parametric_relu_2 = nn.PReLU(num_parameters=1, init=5e-3, device=self.device, dtype=self.dtype)
+        self.parametric_relu_3 = nn.PReLU(num_parameters=1, init=5e-3, device=self.device, dtype=self.dtype)
+        self.parametric_relu_4 = nn.PReLU(num_parameters=1, init=5e-3, device=self.device, dtype=self.dtype)
 
     @override
     def forward(self, x) -> torch.Tensor:
+        x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
         fc1_out = self.parametric_relu_1(self.fc1(x))
-        x = nn.LayerNorm(normalized_shape=1024, eps=1e-9)(fc1_out)
+        x = nn.LayerNorm(normalized_shape=1024, eps=1e-9, device=self.device, dtype=self.dtype)(fc1_out)
         x = torch.dropout(x, p=0.2, train=self.training)
         x = self.parametric_relu_2(self.fc2(x))
-        x = nn.LayerNorm(normalized_shape=768, eps=1e-9)(x)
+        x = nn.LayerNorm(normalized_shape=768, eps=1e-9, device=self.device, dtype=self.dtype)(x)
         x = torch.dropout(x, p=0.2, train=self.training)
         x = self.parametric_relu_3(self.fc3(x))
         x = torch.dropout(x, p=0.2, train=self.training)

deeplotx/nn/logistic_regression.py

@@ -6,9 +6,11 @@ from deeplotx.nn.linear_regression import LinearRegression
 
 
 class LogisticRegression(LinearRegression):
-    def __init__(self, input_dim: int, output_dim: int = 1, model_name: str | None = None):
-        super().__init__(input_dim=input_dim, output_dim=output_dim, model_name=model_name)
+    def __init__(self, input_dim: int, output_dim: int = 1, model_name: str | None = None,
+                 device: str | None = None, dtype: torch.dtype | None = None):
+        super().__init__(input_dim=input_dim, output_dim=output_dim, model_name=model_name, device=device, dtype=dtype)
 
     @override
     def forward(self, x) -> torch.Tensor:
+        x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
         return torch.sigmoid(super().forward(x))

deeplotx/nn/recursive_sequential.py

@@ -10,21 +10,27 @@ from deeplotx.nn import LinearRegression
 class RecursiveSequential(BaseNeuralNetwork):
     def __init__(self, input_dim: int, output_dim: int,
                  hidden_dim: int | None = None, recursive_layers: int = 2,
-                 model_name: str | None = None):
-        super().__init__(model_name=model_name)
+                 model_name: str | None = None, device: str | None = None,
+                 dtype: torch.dtype | None = None):
+        super().__init__(model_name=model_name, device=device, dtype=dtype)
         if hidden_dim is None:
             hidden_dim = input_dim
         self.lstm = nn.LSTM(input_size=input_dim, hidden_size=hidden_dim,
                             num_layers=recursive_layers, batch_first=True,
-                            bias=True, bidirectional=True)
-        self.regressive_head = LinearRegression(input_dim=hidden_dim * 2, output_dim=output_dim)
+                            bias=True, bidirectional=True, device=self.device,
+                            dtype=self.dtype)
+        self.regressive_head = LinearRegression(input_dim=hidden_dim * 2, output_dim=output_dim,
+                                                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).to(next(self.parameters()).device)
+        zeros = torch.zeros(self.lstm.num_layers * 2, batch_size, self.lstm.hidden_size, device=self.device, dtype=self.dtype)
         return zeros, zeros
 
     @override
     def forward(self, x, state: tuple[torch.Tensor, torch.Tensor]) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
+        x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
+        state = (self.ensure_device_and_dtype(state[0], device=self.device, dtype=self.dtype),
+                 self.ensure_device_and_dtype(state[1], device=self.device, dtype=self.dtype))
         x, (hidden_state, cell_state) = self.lstm(x, state)
         x = self.regressive_head(x[:, -1, :])
         return x, (hidden_state, cell_state)

deeplotx/nn/softmax_regression.py

@@ -6,9 +6,11 @@ from deeplotx.nn.linear_regression import LinearRegression
 
 
 class SoftmaxRegression(LinearRegression):
-    def __init__(self, input_dim: int, output_dim: int, model_name: str | None = None):
-        super().__init__(input_dim=input_dim, output_dim=output_dim, model_name=model_name)
+    def __init__(self, input_dim: int, output_dim: int, model_name: str | None = None,
+                 device: str | None = None, dtype: torch.dtype | None = None):
+        super().__init__(input_dim=input_dim, output_dim=output_dim, model_name=model_name, device=device, dtype=dtype)
 
     @override
     def forward(self, x) -> torch.Tensor:
-        return torch.softmax(super().forward(x), dim=-1, dtype=torch.float32)
+        x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
+        return torch.softmax(super().forward(x), dim=-1, dtype=self.dtype)

deeplotx/trainer/text_binary_classification_trainer.py

@@ -48,8 +48,8 @@ class TextBinaryClassifierTrainer(BaseTrainer):
         if self.model is None:
             self.model = RecursiveSequential(input_dim=feature_dim, output_dim=1,
                                              hidden_dim=hidden_dim,
-                                             recursive_layers=recursive_layers)
-        self.model.to(self.device)
+                                             recursive_layers=recursive_layers,
+                                             device=self.device, dtype=dtype)
         loss_function = nn.BCELoss()
         optimizer = optim.Adamax(self.model.parameters(), lr=learning_rate)
         for epoch in range(num_epochs):

{deeplotx-0.4.12b2.dist-info → deeplotx-0.4.12b3.dist-info}/METADATA

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

{deeplotx-0.4.12b2.dist-info → deeplotx-0.4.12b3.dist-info}/RECORD

@@ -1,27 +1,27 @@
 deeplotx/__init__.py,sha256=wMN_AI14V-0BPbQghYpvd2y7eUGfhr7jKTTuur-5Upg,1002
 deeplotx/encoder/__init__.py,sha256=EM-xrTsHoGaiiFpj-iFAxilMHXC_sQKWYrcq1qCnI3U,138
-deeplotx/encoder/bert_encoder.py,sha256=IZsmkcmK6ulwTS4zubljW5uvq2r1Ik03nYG6jqcgQL8,2441
+deeplotx/encoder/bert_encoder.py,sha256=uLqGcXH6AGY6CcjjbYbh09VWYqSpsg-y-jHYB6Fmp3w,2377
 deeplotx/encoder/long_text_encoder.py,sha256=hl_O8kR9o1kcII9YfSx2rf_Pk0l_Rv7LNbsS9UsTU0c,3373
-deeplotx/encoder/longformer_encoder.py,sha256=vsDIiS9kLzvAalDnCGfTuAd2gfqDBgKUqPj6tPgF-BM,1886
+deeplotx/encoder/longformer_encoder.py,sha256=A8FXqd4mdHxSn_o_R689XtpT73ISDT788EgMQRGLC2g,1822
 deeplotx/nn/__init__.py,sha256=oQ-vYXyuaGelfCOs2im_gZXAiiBlCCVXh1uw9yjvRMs,253
-deeplotx/nn/auto_regression.py,sha256=o82C9TREZbhGdj2knSVGTXhjJne0LGEqc7BllByJJWE,449
-deeplotx/nn/base_neural_network.py,sha256=xWKG4FX6Jzdlrfc1HOW1aO9uh0Af3D-dB5Jl7eCxsAk,1635
-deeplotx/nn/linear_regression.py,sha256=D4mEWVOq6q1Fm2otm57rgZ_E06HJLZBV5k636PprAf4,1520
-deeplotx/nn/logistic_regression.py,sha256=QAtZp2oyqOW8-1pJWVcahsSM83bzfA68EHObg-wSHHY,463
-deeplotx/nn/recursive_sequential.py,sha256=03cAeOQMKv_mpNTZMRVrtEm7IlLir-KJs3AcqFj7Vl4,1387
-deeplotx/nn/softmax_regression.py,sha256=eUn3mVNlye9ewVdw3McPHZuKbUvvaamsUgFIJMVMgBU,487
+deeplotx/nn/auto_regression.py,sha256=7P63opWCWMqE2DigwbsL6kfXtFtJPz00Yo1RqflBz4A,572
+deeplotx/nn/base_neural_network.py,sha256=yEyF5C-Z3bp4Ddx6GbvqpBxXyFdbSChmP6SgyTzjQmM,2180
+deeplotx/nn/linear_regression.py,sha256=_LQFrOKBbQxvuNzb_B8Mr6PAQJUg-pFeu3h7_jQz04o,2166
+deeplotx/nn/logistic_regression.py,sha256=j8QGe0e7In97RMOXApJRID85qf1rOUCOk3V368CBfqs,653
+deeplotx/nn/recursive_sequential.py,sha256=YCQUUcTBsZUeyO7CLjUO1EISYX1SXPnW6asR6ZBQAb4,1926
+deeplotx/nn/softmax_regression.py,sha256=SlhvHho-Oufp7adAjm1t1ygidu-FrnHQ9aleMXyS_s8,674
 deeplotx/similarity/__init__.py,sha256=s3u-KSgxjnMcWpIItKgXNltFMPQ7YY3CqsqHI-5F1c8,724
 deeplotx/similarity/distribution.py,sha256=wQGouuuW531pZeBRKBujXsdsoz4fDnPw7_GW81jwepc,1066
 deeplotx/similarity/set.py,sha256=zhGFxtSIXlWqvipBYzoiPahp4g0boAIoUiMfG0wl07A,686
 deeplotx/similarity/vector.py,sha256=WVbDHqykt-fvuILVrhUCtIFAOEjY_zvttrXGM9eylG0,1125
 deeplotx/trainer/__init__.py,sha256=Fl5DR9UecQc5VtBcczU9sx_HtPNoFohpuELOh-Jrsks,77
 deeplotx/trainer/base_trainer.py,sha256=z0MeAT-rRYmjeBXt0ckt7J1itYArR0Cx02wHesXUoZE,385
-deeplotx/trainer/text_binary_classification_trainer.py,sha256=CRu7YM5sbox1GsCyWwsZtxD68TSnzLV91QaHLHm9tdU,4648
+deeplotx/trainer/text_binary_classification_trainer.py,sha256=Wq_pGO78zgdXxFeBjam4yp__-dTvsuwl4H81HSl_kjE,4691
 deeplotx/util/__init__.py,sha256=JxqAK_WOOHcYVSTHBT1-WuBwWrPEVDTV3titeVWvNUM,74
 deeplotx/util/hash.py,sha256=wwsC6kOQvbpuvwKsNQOARd78_wePmW9i3oaUuXRUnpc,352
 deeplotx/util/read_file.py,sha256=ptzouvEQeeW8KU5BrWNJlXw-vFXVrpS9SkAUxsu6A8A,612
-deeplotx-0.4.12b2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-deeplotx-0.4.12b2.dist-info/METADATA,sha256=p9kV3wW3YuzsWrxPuPw93qytbz_7GvdR9fkRcFq1rNY,6287
-deeplotx-0.4.12b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deeplotx-0.4.12b2.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
-deeplotx-0.4.12b2.dist-info/RECORD,,
+deeplotx-0.4.12b3.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+deeplotx-0.4.12b3.dist-info/METADATA,sha256=HZY8s697peX3onvVr5bjdHqwKJk2YyMOadMLGk-QvSc,6287
+deeplotx-0.4.12b3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deeplotx-0.4.12b3.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
+deeplotx-0.4.12b3.dist-info/RECORD,,