deeplotx 0.4.7__tar.gz → 0.4.9__tar.gz

deeplotx-0.4.9/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: deeplotx
+Version: 0.4.9
+Summary: Easy-2-use long text NLP toolkit.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: hf-xet>=1.0.5
+Requires-Dist: jupyter
+Requires-Dist: numpy
+Requires-Dist: protobuf>=6.31.1
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: torch
+Requires-Dist: transformers
+Requires-Dist: typing-extensions>=4.13.2
+Dynamic: license-file
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vortezwohl/DeepLoTX)
+
+# Deep Long Text Learning Kit
+
+> Author: 吴子豪
+
+**开箱即用的长文本语义建模框架**
+
+## 安装
+
+- 使用 pip
+
+    ```
+    pip install -U deeplotx
+    ```
+
+- 使用 uv (推荐)
+
+    ```
+    uv add -U deeplotx
+    ```
+  
+- 从 github 安装最新特性
+
+    ```
+    pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
+    ```
+
+## 核心功能
+
+- ### 长文本嵌入
+
+    - **基于通用 BERT 的长文本嵌入** (最大支持长度, 无限长, 通过 max_length 定义)
+
+        ```python
+        from deeplotx import LongTextEncoder
+
+        # 最大文本长度为 2048 个 tokens, 块大小为 512 个 tokens, 块间重叠部分为 64 个 tokens.
+        encoder = LongTextEncoder(
+            max_length=2048,
+            chunk_size=512,
+            overlapping=64
+        )
+        # 对 "我是吴子豪, 这是一个测试文本." 计算嵌入, 并展平.
+        encoder.encode('我是吴子豪, 这是一个测试文本.', flatten=True, use_cache=True)
+        ```
+
+        输出:
+        ```
+        tensor([ 0.5163,  0.2497,  0.5896,  ..., -0.9815, -0.3095,  0.4232])
+        ```
+
+    - **基于 Longformer 的长文本嵌入** (最大支持长度 4096 个 tokens)
+
+        ```python
+        from deeplotx import LongformerEncoder
+
+        encoder = LongformerEncoder()
+        encoder.encode('我是吴子豪, 这是一个测试文本.')
+        ```
+
+- ### 相似性计算
+
+    - **基于向量的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        vector_0, vector_1 = [1, 2, 3, 4], [4, 3, 2, 1]
+        # 欧几里得距离
+        distance_0 = sim.euclidean_similarity(vector_0, vector_1)
+        print(distance_0)
+        # 余弦距离
+        distance_1 = sim.cosine_similarity(vector_0, vector_1)
+        print(distance_1)
+        # 切比雪夫距离
+        distance_2 = sim.chebyshev_similarity(vector_0, vector_1)
+        print(distance_2)
+        ```
+
+        输出:
+        ```
+        4.47213595499958
+        0.33333333333333337
+        3
+        ```
+
+    - **基于集合的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        set_0, set_1 = {1, 2, 3, 4}, {4, 5, 6, 7}
+        # 杰卡德距离
+        distance_0 = sim.jaccard_similarity(set_0, set_1)
+        print(distance_0)
+        # Ochiai 距离
+        distance_1 = sim.ochiai_similarity(set_0, set_1)
+        print(distance_1)
+        # Dice 系数
+        distance_2 = sim.dice_coefficient(set_0, set_1)
+        print(distance_2)
+        # Overlap 系数
+        distance_3 = sim.overlap_coefficient(set_0, set_1)
+        print(distance_3)
+        ```
+
+        输出:
+        ```
+        0.1428571428572653
+        0.2500000000001875
+        0.25000000000009376
+        0.2500000000001875
+        ```
+
+    - **基于概率分布的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        dist_0, dist_1 = [0.3, 0.2, 0.1, 0.4], [0.2, 0.1, 0.3, 0.4]
+        # 交叉熵
+        distance_0 = sim.cross_entropy(dist_0, dist_1)
+        print(distance_0)
+        # KL 散度
+        distance_1 = sim.kl_divergence(dist_0, dist_1)
+        print(distance_1)
+        # JS 散度
+        distance_2 = sim.js_divergence(dist_0, dist_1)
+        print(distance_2)
+        # Hellinger 距离
+        distance_3 = sim.hellinger_distance(dist_0, dist_1)
+        print(distance_3)
+        ```
+
+        输出:
+        ```
+        0.3575654913778237
+        0.15040773967762736
+        0.03969123741566945
+        0.20105866986400994
+        ```
+
+- ### 预定义深度神经网络
+
+    ```python
+    from deeplotx import (
+        LinearRegression,  # 线性回归
+        LogisticRegression,  # 逻辑回归 / 二分类 / 多标签分类
+        SoftmaxRegression,  # Softmax 回归 / 多分类
+        RecursiveSequential,  # 序列模型 / 循环神经网络
+        AutoRegression  # 自回归模型
+    )
+    ```
+
+    基础网络结构:
+
+    ```python
+    from typing_extensions import override
+
+    import torch
+    from torch import nn
+
+    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)
+
+        @override
+        def forward(self, x) -> torch.Tensor:
+            fc1_out = self.parametric_relu_1(self.fc1(x))
+            x = nn.LayerNorm(normalized_shape=1024, eps=1e-9)(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 = 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)
+            x = self.parametric_relu_4(self.fc4(x)) + self.fc1_to_fc4_res(fc1_out)
+            x = self.fc5(x)
+            return x
+    ```

deeplotx-0.4.9/README.md

@@ -0,0 +1,194 @@
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vortezwohl/DeepLoTX)
+
+# Deep Long Text Learning Kit
+
+> Author: 吴子豪
+
+**开箱即用的长文本语义建模框架**
+
+## 安装
+
+- 使用 pip
+
+    ```
+    pip install -U deeplotx
+    ```
+
+- 使用 uv (推荐)
+
+    ```
+    uv add -U deeplotx
+    ```
+  
+- 从 github 安装最新特性
+
+    ```
+    pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
+    ```
+
+## 核心功能
+
+- ### 长文本嵌入
+
+    - **基于通用 BERT 的长文本嵌入** (最大支持长度, 无限长, 通过 max_length 定义)
+
+        ```python
+        from deeplotx import LongTextEncoder
+
+        # 最大文本长度为 2048 个 tokens, 块大小为 512 个 tokens, 块间重叠部分为 64 个 tokens.
+        encoder = LongTextEncoder(
+            max_length=2048,
+            chunk_size=512,
+            overlapping=64
+        )
+        # 对 "我是吴子豪, 这是一个测试文本." 计算嵌入, 并展平.
+        encoder.encode('我是吴子豪, 这是一个测试文本.', flatten=True, use_cache=True)
+        ```
+
+        输出:
+        ```
+        tensor([ 0.5163,  0.2497,  0.5896,  ..., -0.9815, -0.3095,  0.4232])
+        ```
+
+    - **基于 Longformer 的长文本嵌入** (最大支持长度 4096 个 tokens)
+
+        ```python
+        from deeplotx import LongformerEncoder
+
+        encoder = LongformerEncoder()
+        encoder.encode('我是吴子豪, 这是一个测试文本.')
+        ```
+
+- ### 相似性计算
+
+    - **基于向量的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        vector_0, vector_1 = [1, 2, 3, 4], [4, 3, 2, 1]
+        # 欧几里得距离
+        distance_0 = sim.euclidean_similarity(vector_0, vector_1)
+        print(distance_0)
+        # 余弦距离
+        distance_1 = sim.cosine_similarity(vector_0, vector_1)
+        print(distance_1)
+        # 切比雪夫距离
+        distance_2 = sim.chebyshev_similarity(vector_0, vector_1)
+        print(distance_2)
+        ```
+
+        输出:
+        ```
+        4.47213595499958
+        0.33333333333333337
+        3
+        ```
+
+    - **基于集合的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        set_0, set_1 = {1, 2, 3, 4}, {4, 5, 6, 7}
+        # 杰卡德距离
+        distance_0 = sim.jaccard_similarity(set_0, set_1)
+        print(distance_0)
+        # Ochiai 距离
+        distance_1 = sim.ochiai_similarity(set_0, set_1)
+        print(distance_1)
+        # Dice 系数
+        distance_2 = sim.dice_coefficient(set_0, set_1)
+        print(distance_2)
+        # Overlap 系数
+        distance_3 = sim.overlap_coefficient(set_0, set_1)
+        print(distance_3)
+        ```
+
+        输出:
+        ```
+        0.1428571428572653
+        0.2500000000001875
+        0.25000000000009376
+        0.2500000000001875
+        ```
+
+    - **基于概率分布的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        dist_0, dist_1 = [0.3, 0.2, 0.1, 0.4], [0.2, 0.1, 0.3, 0.4]
+        # 交叉熵
+        distance_0 = sim.cross_entropy(dist_0, dist_1)
+        print(distance_0)
+        # KL 散度
+        distance_1 = sim.kl_divergence(dist_0, dist_1)
+        print(distance_1)
+        # JS 散度
+        distance_2 = sim.js_divergence(dist_0, dist_1)
+        print(distance_2)
+        # Hellinger 距离
+        distance_3 = sim.hellinger_distance(dist_0, dist_1)
+        print(distance_3)
+        ```
+
+        输出:
+        ```
+        0.3575654913778237
+        0.15040773967762736
+        0.03969123741566945
+        0.20105866986400994
+        ```
+
+- ### 预定义深度神经网络
+
+    ```python
+    from deeplotx import (
+        LinearRegression,  # 线性回归
+        LogisticRegression,  # 逻辑回归 / 二分类 / 多标签分类
+        SoftmaxRegression,  # Softmax 回归 / 多分类
+        RecursiveSequential,  # 序列模型 / 循环神经网络
+        AutoRegression  # 自回归模型
+    )
+    ```
+
+    基础网络结构:
+
+    ```python
+    from typing_extensions import override
+
+    import torch
+    from torch import nn
+
+    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)
+
+        @override
+        def forward(self, x) -> torch.Tensor:
+            fc1_out = self.parametric_relu_1(self.fc1(x))
+            x = nn.LayerNorm(normalized_shape=1024, eps=1e-9)(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 = 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)
+            x = self.parametric_relu_4(self.fc4(x)) + self.fc1_to_fc4_res(fc1_out)
+            x = self.fc5(x)
+            return x
+    ```

{deeplotx-0.4.7 → deeplotx-0.4.9}/deeplotx/encoder/bert_encoder.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import math
 
@@ -9,21 +10,26 @@ from deeplotx import __ROOT__
 
 CACHE_PATH = os.path.join(__ROOT__, '.cache')
 DEFAULT_BERT = 'bert-base-uncased'
+logger = logging.getLogger('deeplotx.embedding')
 
 
 class BertEncoder(nn.Module):
-    def __init__(self, model_name_or_path: str = DEFAULT_BERT):
+    def __init__(self, model_name_or_path: str = DEFAULT_BERT, device: str | None = None):
         super().__init__()
+        self.device = device if device is not None else torch.device('cuda' if torch.cuda.is_available() else 'cpu')
         self.tokenizer = BertTokenizer.from_pretrained(pretrained_model_name_or_path=model_name_or_path,
                                                        cache_dir=CACHE_PATH, _from_auto=True)
         self.bert = BertModel.from_pretrained(pretrained_model_name_or_path=model_name_or_path,
-                                              cache_dir=CACHE_PATH, _from_auto=True)
+                                              cache_dir=CACHE_PATH, _from_auto=True).to(self.device)
         self.embed_dim = self.bert.config.max_position_embeddings
+        logger.debug(f'{BertEncoder.__name__} initialized on device: {self.device}.')
 
     def forward(self, input_ids: torch.Tensor, attention_mask: torch.Tensor) -> torch.Tensor:
         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):

{deeplotx-0.4.7 → deeplotx-0.4.9}/deeplotx/encoder/long_text_encoder.py

@@ -13,8 +13,8 @@ logger = logging.getLogger('deeplotx.embedding')
 
 class LongTextEncoder(BertEncoder):
     def __init__(self, max_length: int, chunk_size: int = 256,
-                 overlapping: int = 0, model_name_or_path: str = DEFAULT_BERT):
-        super().__init__(model_name_or_path=model_name_or_path)
+                 overlapping: int = 0, model_name_or_path: str = DEFAULT_BERT, device: str | None = None):
+        super().__init__(model_name_or_path=model_name_or_path, device=device)
         self._max_length = max_length
         self._chunk_size = chunk_size
         self._overlapping = overlapping
@@ -28,8 +28,8 @@ 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=torch.float32)
-            for _emb in fin_embedding:
+            _fin_emb_tensor = torch.tensor([], dtype=tensors[0].dtype)
+            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,7 +55,7 @@ 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.long),
+            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)))
         with ThreadPoolExecutor(max_workers=min(num_chunks + 1, 3)) as executor:
             embeddings = list(executor.map(self.__chunk_embedding, chunks))

{deeplotx-0.4.7 → deeplotx-0.4.9}/deeplotx/encoder/longformer_encoder.py

@@ -1,3 +1,4 @@
+import logging
 import os
 
 import torch
@@ -8,17 +9,22 @@ from deeplotx import __ROOT__
 
 CACHE_PATH = os.path.join(__ROOT__, '.cache')
 DEFAULT_LONGFORMER = 'allenai/longformer-base-4096'
+logger = logging.getLogger('deeplotx.embedding')
 
 
 class LongformerEncoder(nn.Module):
-    def __init__(self, model_name_or_path: str = DEFAULT_LONGFORMER):
+    def __init__(self, model_name_or_path: str = DEFAULT_LONGFORMER, device: str | None = None):
         super().__init__()
+        self.device = device if device is not None else torch.device('cuda' if torch.cuda.is_available() else 'cpu')
         self.tokenizer = LongformerTokenizer.from_pretrained(pretrained_model_name_or_path=model_name_or_path,
                                                              cache_dir=CACHE_PATH, _from_auto=True)
         self.bert = LongformerModel.from_pretrained(pretrained_model_name_or_path=model_name_or_path,
-                                                    cache_dir=CACHE_PATH, _from_auto=True)
+                                                    cache_dir=CACHE_PATH, _from_auto=True).to(self.device)
+        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():

deeplotx-0.4.9/deeplotx.egg-info/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: deeplotx
+Version: 0.4.9
+Summary: Easy-2-use long text NLP toolkit.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: hf-xet>=1.0.5
+Requires-Dist: jupyter
+Requires-Dist: numpy
+Requires-Dist: protobuf>=6.31.1
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: torch
+Requires-Dist: transformers
+Requires-Dist: typing-extensions>=4.13.2
+Dynamic: license-file
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vortezwohl/DeepLoTX)
+
+# Deep Long Text Learning Kit
+
+> Author: 吴子豪
+
+**开箱即用的长文本语义建模框架**
+
+## 安装
+
+- 使用 pip
+
+    ```
+    pip install -U deeplotx
+    ```
+
+- 使用 uv (推荐)
+
+    ```
+    uv add -U deeplotx
+    ```
+  
+- 从 github 安装最新特性
+
+    ```
+    pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
+    ```
+
+## 核心功能
+
+- ### 长文本嵌入
+
+    - **基于通用 BERT 的长文本嵌入** (最大支持长度, 无限长, 通过 max_length 定义)
+
+        ```python
+        from deeplotx import LongTextEncoder
+
+        # 最大文本长度为 2048 个 tokens, 块大小为 512 个 tokens, 块间重叠部分为 64 个 tokens.
+        encoder = LongTextEncoder(
+            max_length=2048,
+            chunk_size=512,
+            overlapping=64
+        )
+        # 对 "我是吴子豪, 这是一个测试文本." 计算嵌入, 并展平.
+        encoder.encode('我是吴子豪, 这是一个测试文本.', flatten=True, use_cache=True)
+        ```
+
+        输出:
+        ```
+        tensor([ 0.5163,  0.2497,  0.5896,  ..., -0.9815, -0.3095,  0.4232])
+        ```
+
+    - **基于 Longformer 的长文本嵌入** (最大支持长度 4096 个 tokens)
+
+        ```python
+        from deeplotx import LongformerEncoder
+
+        encoder = LongformerEncoder()
+        encoder.encode('我是吴子豪, 这是一个测试文本.')
+        ```
+
+- ### 相似性计算
+
+    - **基于向量的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        vector_0, vector_1 = [1, 2, 3, 4], [4, 3, 2, 1]
+        # 欧几里得距离
+        distance_0 = sim.euclidean_similarity(vector_0, vector_1)
+        print(distance_0)
+        # 余弦距离
+        distance_1 = sim.cosine_similarity(vector_0, vector_1)
+        print(distance_1)
+        # 切比雪夫距离
+        distance_2 = sim.chebyshev_similarity(vector_0, vector_1)
+        print(distance_2)
+        ```
+
+        输出:
+        ```
+        4.47213595499958
+        0.33333333333333337
+        3
+        ```
+
+    - **基于集合的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        set_0, set_1 = {1, 2, 3, 4}, {4, 5, 6, 7}
+        # 杰卡德距离
+        distance_0 = sim.jaccard_similarity(set_0, set_1)
+        print(distance_0)
+        # Ochiai 距离
+        distance_1 = sim.ochiai_similarity(set_0, set_1)
+        print(distance_1)
+        # Dice 系数
+        distance_2 = sim.dice_coefficient(set_0, set_1)
+        print(distance_2)
+        # Overlap 系数
+        distance_3 = sim.overlap_coefficient(set_0, set_1)
+        print(distance_3)
+        ```
+
+        输出:
+        ```
+        0.1428571428572653
+        0.2500000000001875
+        0.25000000000009376
+        0.2500000000001875
+        ```
+
+    - **基于概率分布的相似性**
+
+        ```python
+        import deeplotx.similarity as sim
+
+        dist_0, dist_1 = [0.3, 0.2, 0.1, 0.4], [0.2, 0.1, 0.3, 0.4]
+        # 交叉熵
+        distance_0 = sim.cross_entropy(dist_0, dist_1)
+        print(distance_0)
+        # KL 散度
+        distance_1 = sim.kl_divergence(dist_0, dist_1)
+        print(distance_1)
+        # JS 散度
+        distance_2 = sim.js_divergence(dist_0, dist_1)
+        print(distance_2)
+        # Hellinger 距离
+        distance_3 = sim.hellinger_distance(dist_0, dist_1)
+        print(distance_3)
+        ```
+
+        输出:
+        ```
+        0.3575654913778237
+        0.15040773967762736
+        0.03969123741566945
+        0.20105866986400994
+        ```
+
+- ### 预定义深度神经网络
+
+    ```python
+    from deeplotx import (
+        LinearRegression,  # 线性回归
+        LogisticRegression,  # 逻辑回归 / 二分类 / 多标签分类
+        SoftmaxRegression,  # Softmax 回归 / 多分类
+        RecursiveSequential,  # 序列模型 / 循环神经网络
+        AutoRegression  # 自回归模型
+    )
+    ```
+
+    基础网络结构:
+
+    ```python
+    from typing_extensions import override
+
+    import torch
+    from torch import nn
+
+    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)
+
+        @override
+        def forward(self, x) -> torch.Tensor:
+            fc1_out = self.parametric_relu_1(self.fc1(x))
+            x = nn.LayerNorm(normalized_shape=1024, eps=1e-9)(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 = 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)
+            x = self.parametric_relu_4(self.fc4(x)) + self.fc1_to_fc4_res(fc1_out)
+            x = self.fc5(x)
+            return x
+    ```

{deeplotx-0.4.7 → deeplotx-0.4.9}/deeplotx.egg-info/requires.txt

@@ -1,6 +1,7 @@
 hf-xet>=1.0.5
 jupyter
 numpy
+protobuf>=6.31.1
 python-dotenv>=1.1.0
 torch
 transformers

{deeplotx-0.4.7 → deeplotx-0.4.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deeplotx"
-version = "0.4.7"
+version = "0.4.9"
 description = "Easy-2-use long text NLP toolkit."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -8,6 +8,7 @@ dependencies = [
     "hf-xet>=1.0.5",
     "jupyter",
     "numpy",
+    "protobuf>=6.31.1",
     "python-dotenv>=1.1.0",
     "torch",
     "transformers",

deeplotx-0.4.7/PKG-INFO

@@ -1,72 +0,0 @@
-Metadata-Version: 2.4
-Name: deeplotx
-Version: 0.4.7
-Summary: Easy-2-use long text NLP toolkit.
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: hf-xet>=1.0.5
-Requires-Dist: jupyter
-Requires-Dist: numpy
-Requires-Dist: python-dotenv>=1.1.0
-Requires-Dist: torch
-Requires-Dist: transformers
-Requires-Dist: typing-extensions>=4.13.2
-Dynamic: license-file
-
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vortezwohl/LoTC)
-
-# DeepLoTX
-
-An Easy-2-use long text NLP toolkit
-
-## Installation
-
-- Install with pip
-
-    ```
-    pip install -U deeplotx
-    ```
-
-- Install with uv
-
-    ```
-    uv add -U deeplotx
-    ```
-  
-- Install from github
-
-    ```
-    pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
-    ```
-
-## Quick Start
-
-To train a binary classifier from text files:
-
-```python
-from deeplotx.util import get_files, read_file
-from deeplotx import TextBinaryClassifierTrainer, LongTextEncoder
-
-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.save()
-
-model = model.load()
-model.predict(long_text_encoder.encode('这是一个测试文本.').squeeze())
-```

deeplotx-0.4.7/README.md

@@ -1,56 +0,0 @@
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vortezwohl/LoTC)
-
-# DeepLoTX
-
-An Easy-2-use long text NLP toolkit
-
-## Installation
-
-- Install with pip
-
-    ```
-    pip install -U deeplotx
-    ```
-
-- Install with uv
-
-    ```
-    uv add -U deeplotx
-    ```
-  
-- Install from github
-
-    ```
-    pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
-    ```
-
-## Quick Start
-
-To train a binary classifier from text files:
-
-```python
-from deeplotx.util import get_files, read_file
-from deeplotx import TextBinaryClassifierTrainer, LongTextEncoder
-
-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.save()
-
-model = model.load()
-model.predict(long_text_encoder.encode('这是一个测试文本.').squeeze())
-```

deeplotx-0.4.7/deeplotx.egg-info/PKG-INFO

@@ -1,72 +0,0 @@
-Metadata-Version: 2.4
-Name: deeplotx
-Version: 0.4.7
-Summary: Easy-2-use long text NLP toolkit.
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: hf-xet>=1.0.5
-Requires-Dist: jupyter
-Requires-Dist: numpy
-Requires-Dist: python-dotenv>=1.1.0
-Requires-Dist: torch
-Requires-Dist: transformers
-Requires-Dist: typing-extensions>=4.13.2
-Dynamic: license-file
-
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vortezwohl/LoTC)
-
-# DeepLoTX
-
-An Easy-2-use long text NLP toolkit
-
-## Installation
-
-- Install with pip
-
-    ```
-    pip install -U deeplotx
-    ```
-
-- Install with uv
-
-    ```
-    uv add -U deeplotx
-    ```
-  
-- Install from github
-
-    ```
-    pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
-    ```
-
-## Quick Start
-
-To train a binary classifier from text files:
-
-```python
-from deeplotx.util import get_files, read_file
-from deeplotx import TextBinaryClassifierTrainer, LongTextEncoder
-
-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.save()
-
-model = model.load()
-model.predict(long_text_encoder.encode('这是一个测试文本.').squeeze())
-```