deeplotx 0.4.11__tar.gz → 0.4.12b1__tar.gz

{deeplotx-0.4.11 → deeplotx-0.4.12b1}/PKG-INFO

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

{deeplotx-0.4.11 → deeplotx-0.4.12b1}/deeplotx/encoder/long_text_encoder.py

@@ -28,7 +28,7 @@ class LongTextEncoder(BertEncoder):
         def postprocess(tensors: list[torch.Tensor], _flatten: bool) -> torch.Tensor:
             if not _flatten:
                 return torch.stack(tensors, dim=0).squeeze()
-            _fin_emb_tensor = torch.tensor([], dtype=tensors[0].dtype)
+            _fin_emb_tensor = torch.tensor([], dtype=tensors[0].dtype, device=self.device)
             for _emb in tensors:
                 _fin_emb_tensor = torch.cat((_fin_emb_tensor.detach().clone(), _emb.detach().clone()), dim=-1)
             return _fin_emb_tensor.squeeze()
@@ -55,8 +55,8 @@ class LongTextEncoder(BertEncoder):
         for i in range(num_chunks):
             _tmp_left = max(i * self._chunk_size - self._overlapping, 0)
             _tmp_right = (i + 1) * self._chunk_size + self._overlapping
-            chunks.append((i, torch.tensor([_text_to_input_ids[_tmp_left: _tmp_right]], dtype=torch.int),
-                           torch.tensor([_text_to_input_ids_att_mask[_tmp_left: _tmp_right]], dtype=torch.int)))
+            chunks.append((i, torch.tensor([_text_to_input_ids[_tmp_left: _tmp_right]], dtype=torch.int, device=self.device),
+                           torch.tensor([_text_to_input_ids_att_mask[_tmp_left: _tmp_right]], dtype=torch.int, device=self.device)))
         with ThreadPoolExecutor(max_workers=min(num_chunks + 1, 3)) as executor:
             embeddings = list(executor.map(self.__chunk_embedding, chunks))
         embeddings.sort(key=lambda x: x[0])

{deeplotx-0.4.11 → deeplotx-0.4.12b1}/deeplotx/trainer/text_binary_classification_trainer.py

@@ -6,7 +6,7 @@ from torch import nn, optim
 from torch.utils.data import DataLoader, TensorDataset
 
 from deeplotx.encoder.long_text_encoder import LongTextEncoder
-from deeplotx.nn.logistic_regression import LogisticRegression
+from deeplotx.nn.recursive_sequential import RecursiveSequential
 from deeplotx.trainer.base_trainer import BaseTrainer
 
 logger = logging.getLogger('deeplotx.trainer')
@@ -16,23 +16,26 @@ class TextBinaryClassifierTrainer(BaseTrainer):
     def __init__(self, long_text_encoder: LongTextEncoder, batch_size: int = 2, train_ratio: float = 0.8):
         super().__init__(batch_size=batch_size, train_ratio=train_ratio)
         self._long_text_encoder = long_text_encoder
+        self.device = self._long_text_encoder.device
 
     @override
     def train(self, positive_texts: list[str], negative_texts: list[str],
-              num_epochs: int, learning_rate: float = 2e-5, balancing_dataset: bool = True,
+              num_epochs: int, learning_rate: float = 2e-6, balancing_dataset: bool = True,
               train_loss_threshold: float = 0.0, valid_loss_threshold: float = 0.0,
-              alpha: float = 1e-4, rho: float = 0.2) -> LogisticRegression:
+              alpha: float = 1e-4, rho: float = 0.2,
+              hidden_dim: int = 256, recursive_layers: int = 2) -> RecursiveSequential:
         if balancing_dataset:
             min_length = min(len(positive_texts), len(negative_texts))
             positive_texts = positive_texts[:min_length]
             negative_texts = negative_texts[:min_length]
         all_texts = positive_texts + negative_texts
-        labels = ([torch.tensor([1.0], dtype=torch.float32) for _ in range(len(positive_texts))]
-                  + [torch.tensor([0.0], dtype=torch.float32) for _ in range(len(negative_texts))])
-        text_embeddings = [self._long_text_encoder.encode(x) for x in all_texts]
+        text_embeddings = [self._long_text_encoder.encode(x, flatten=False, use_cache=True) for x in all_texts]
         feature_dim = text_embeddings[0].shape[-1]
-        inputs = torch.stack(text_embeddings)
-        labels = torch.stack(labels)
+        dtype = text_embeddings[0].dtype
+        labels = ([torch.tensor([1.], dtype=dtype, device=self.device) for _ in range(len(positive_texts))]
+                  + [torch.tensor([.0], dtype=dtype, device=self.device) for _ in range(len(negative_texts))])
+        inputs = torch.stack(text_embeddings).to(self.device)
+        labels = torch.stack(labels).to(self.device)
         dataset_size = len(labels)
         train_size = int(self._train_ratio * dataset_size)
         train_dataset = TensorDataset(inputs[:train_size], labels[:train_size])
@@ -43,14 +46,17 @@ class TextBinaryClassifierTrainer(BaseTrainer):
             logger.warning("The dimension of features doesn't match. A new model instance will be created.")
             self.model = None
         if self.model is None:
-            self.model = LogisticRegression(input_dim=feature_dim, output_dim=1)
+            self.model = RecursiveSequential(input_dim=feature_dim, output_dim=1,
+                                             hidden_dim=hidden_dim,
+                                             recursive_layers=recursive_layers)
+        self.model.to(self.device)
         loss_function = nn.BCELoss()
         optimizer = optim.Adamax(self.model.parameters(), lr=learning_rate)
         for epoch in range(num_epochs):
             self.model.train()
             total_loss = 0.0
             for batch_texts, batch_labels in train_loader:
-                outputs = self.model.forward(batch_texts)
+                outputs = torch.sigmoid(self.model.forward(batch_texts, self.model.initial_state(batch_texts.shape[0]))[0])
                 loss = loss_function(outputs, batch_labels) + self.model.elastic_net(alpha=alpha, rho=rho)
                 optimizer.zero_grad()
                 loss.backward()
@@ -61,7 +67,7 @@ class TextBinaryClassifierTrainer(BaseTrainer):
                 for batch_texts, batch_labels in valid_loader:
                     with torch.no_grad():
                         self.model.eval()
-                        outputs = self.model.forward(batch_texts)
+                        outputs = torch.sigmoid(self.model.forward(batch_texts, self.model.initial_state(batch_texts.shape[0]))[0])
                         loss = loss_function(outputs, batch_labels) + self.model.elastic_net(alpha=alpha, rho=rho)
                         total_valid_loss += loss.item()
                         self.model.train()

{deeplotx-0.4.11 → deeplotx-0.4.12b1}/deeplotx.egg-info/PKG-INFO

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

{deeplotx-0.4.11 → deeplotx-0.4.12b1}/deeplotx.egg-info/SOURCES.txt

@@ -27,4 +27,5 @@ deeplotx/trainer/base_trainer.py
 deeplotx/trainer/text_binary_classification_trainer.py
 deeplotx/util/__init__.py
 deeplotx/util/hash.py
-deeplotx/util/read_file.py
+deeplotx/util/read_file.py
+test/test.py

{deeplotx-0.4.11 → deeplotx-0.4.12b1}/pyproject.toml

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

deeplotx-0.4.12b1/test/test.py

@@ -0,0 +1,21 @@
+from deeplotx import TextBinaryClassifierTrainer, LongTextEncoder
+from deeplotx.util import get_files, read_file
+
+long_text_encoder = LongTextEncoder(
+    max_length=2048,
+    chunk_size=512,
+    overlapping=128
+)
+
+trainer = TextBinaryClassifierTrainer(
+    long_text_encoder=long_text_encoder,
+    batch_size=4,
+    train_ratio=0.9
+)
+
+pos_data_path = './data/pos'
+neg_data_path = './data/neg'
+pos_data = [read_file(x) for x in get_files(pos_data_path)]
+neg_data = [read_file(x) for x in get_files(neg_data_path)]
+model = trainer.train(pos_data, neg_data, num_epochs=20, learning_rate=2e-5, train_loss_threshold=1)
+model.predict(long_text_encoder.encode('这是一个测试文本.').squeeze())