deeplotx 0.4.15__py3-none-any.whl → 0.5.3__py3-none-any.whl

deeplotx/__init__.py

@@ -9,7 +9,10 @@ from .nn import (
     LogisticRegression,
     SoftmaxRegression,
     RecursiveSequential,
-    AutoRegression
+    LongContextRecursiveSequential,
+    SelfAttention,
+    AutoRegression,
+    LongContextAutoRegression
 )
 from .trainer import TextBinaryClassifierTrainer
 

deeplotx/nn/__init__.py

@@ -2,4 +2,7 @@ from .linear_regression import LinearRegression
 from .logistic_regression import LogisticRegression
 from .softmax_regression import SoftmaxRegression
 from .recursive_sequential import RecursiveSequential
+from .long_context_recursive_sequential import LongContextRecursiveSequential
+from .self_attention import SelfAttention
 from .auto_regression import AutoRegression
+from .long_context_auto_regression import LongContextAutoRegression

deeplotx/nn/base_neural_network.py

@@ -1,8 +1,11 @@
+import os
 from abc import abstractmethod
 
 import torch
 from torch import nn
 
+DEFAULT_SUFFIX = 'dlx'
+
 
 class BaseNeuralNetwork(nn.Module):
     def __init__(self, model_name: str | None = None, device: str | None = None, dtype: torch.dtype | None = None):
@@ -44,7 +47,7 @@ class BaseNeuralNetwork(nn.Module):
     @abstractmethod
     def forward(self, *args, **kwargs) -> torch.Tensor: ...
 
-    def predict(self, x) -> torch.Tensor:
+    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
@@ -53,10 +56,13 @@ class BaseNeuralNetwork(nn.Module):
         self.training = __train
         return res
 
-    def save(self):
-        torch.save(self.state_dict(), f'{self._model_name}.deeplotx')
+    def save(self, model_name: str | None = None, model_dir: str = '.', _suffix: str = DEFAULT_SUFFIX):
+        os.makedirs(model_dir, exist_ok=True)
+        model_file_name = f'{model_name}.{_suffix}' if model_name is not None else f'{self._model_name}.{_suffix}'
+        torch.save(self.state_dict(), os.path.join(model_dir, model_file_name))
         return self
 
-    def load(self):
-        self.load_state_dict(torch.load(f'{self._model_name}.deeplotx', map_location=self.device, weights_only=True))
+    def load(self, model_name: str | None = None, model_dir: str = '.', _suffix: str = DEFAULT_SUFFIX):
+        model_file_name = f'{model_name}.{_suffix}' if model_name is not None else f'{self._model_name}.{_suffix}'
+        self.load_state_dict(torch.load(os.path.join(model_dir, model_file_name), map_location=self.device, weights_only=True))
         return self

deeplotx/nn/linear_regression.py

@@ -22,7 +22,7 @@ class LinearRegression(BaseNeuralNetwork):
         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:
+    def forward(self, x: torch.Tensor) -> 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, device=self.device, dtype=self.dtype)(fc1_out)

deeplotx/nn/logistic_regression.py

@@ -11,6 +11,6 @@ class LogisticRegression(LinearRegression):
         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:
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
         return torch.sigmoid(super().forward(x))

deeplotx/nn/long_context_auto_regression.py

@@ -0,0 +1,12 @@
+import torch
+
+from deeplotx.nn import LongContextRecursiveSequential
+
+
+class LongContextAutoRegression(LongContextRecursiveSequential):
+    def __init__(self, feature_dim: int, hidden_dim: int | 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, device=device, dtype=dtype)

deeplotx/nn/long_context_recursive_sequential.py

@@ -0,0 +1,28 @@
+from typing_extensions import override
+
+import torch
+from torch import nn
+
+from deeplotx.nn.recursive_sequential import RecursiveSequential
+from deeplotx.nn.self_attention import SelfAttention
+
+
+class LongContextRecursiveSequential(RecursiveSequential):
+    def __init__(self, input_dim: int, output_dim: int,
+                 hidden_dim: int | None = None, recursive_layers: int = 2,
+                 model_name: str | None = None, device: str | None = None,
+                 dtype: torch.dtype | None = None):
+        super().__init__(input_dim=input_dim, output_dim=output_dim,
+                         hidden_dim=hidden_dim, recursive_layers=recursive_layers,
+                         model_name=model_name, device=device, dtype=dtype)
+        self._feature_dim = input_dim
+        self.self_attention = SelfAttention(feature_dim=input_dim)
+        self.proj = nn.Linear(in_features=input_dim * 2, out_features=input_dim,
+                              bias=True, device=self.device, dtype=self.dtype)
+
+    @override
+    def forward(self, x: torch.Tensor, 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)
+        x = torch.cat([self.self_attention(x), x], dim=-1)
+        x = nn.LayerNorm(normalized_shape=x.shape[-1], eps=1e-9, device=self.device, dtype=self.dtype)(x)
+        return super().forward(self.proj(x), state)

deeplotx/nn/recursive_sequential.py

@@ -27,7 +27,7 @@ class RecursiveSequential(BaseNeuralNetwork):
         return zeros, zeros
 
     @override
-    def forward(self, x, state: tuple[torch.Tensor, torch.Tensor]) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
+    def forward(self, x: torch.Tensor, 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))
@@ -36,7 +36,7 @@ class RecursiveSequential(BaseNeuralNetwork):
         return x, (hidden_state, cell_state)
 
     @override
-    def predict(self, x) -> torch.Tensor:
+    def predict(self, x: torch.Tensor) -> torch.Tensor:
         __train = self.training
         self.training = False
         with torch.no_grad():

deeplotx/nn/self_attention.py

@@ -0,0 +1,34 @@
+from typing_extensions import override
+
+import torch
+from torch import nn, softmax
+
+from deeplotx.nn.base_neural_network import BaseNeuralNetwork
+
+
+class SelfAttention(BaseNeuralNetwork):
+    def __init__(self, feature_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._feature_dim = feature_dim
+        self.q_proj = nn.Linear(in_features=self._feature_dim, out_features=self._feature_dim,
+                                bias=True, device=self.device, dtype=self.dtype)
+        self.k_proj = nn.Linear(in_features=self._feature_dim, out_features=self._feature_dim,
+                                bias=True, device=self.device, dtype=self.dtype)
+        self.v_proj = nn.Linear(in_features=self._feature_dim, out_features=self._feature_dim,
+                                bias=True, device=self.device, dtype=self.dtype)
+
+    def _attention(self, x: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
+        q, k = self.q_proj(x), self.k_proj(x)
+        attn = torch.matmul(q, k.transpose(-2, -1))
+        attn = attn / (self._feature_dim ** 0.5)
+        attn = attn.masked_fill(mask == 0, -1e9) if mask is not None else attn
+        return softmax(attn, dim=-1)
+
+    @override
+    def forward(self, x: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
+        x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
+        if mask is not None:
+            mask = self.ensure_device_and_dtype(mask, device=self.device, dtype=self.dtype)
+        v = self.v_proj(x)
+        return torch.matmul(self._attention(x, mask), v)

deeplotx/nn/softmax_regression.py

@@ -11,6 +11,6 @@ class SoftmaxRegression(LinearRegression):
         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:
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
         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

@@ -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.recursive_sequential import RecursiveSequential
+from deeplotx.nn.long_context_recursive_sequential import LongContextRecursiveSequential
 from deeplotx.trainer.base_trainer import BaseTrainer
 
 logger = logging.getLogger('deeplotx.trainer')
@@ -17,13 +17,15 @@ class TextBinaryClassifierTrainer(BaseTrainer):
         super().__init__(batch_size=batch_size, train_ratio=train_ratio)
         self._long_text_encoder = long_text_encoder
         self.device = self._long_text_encoder.device
+        self.train_dataset_loader = None
+        self.valid_dataset_loader = None
 
     @override
     def train(self, positive_texts: list[str], negative_texts: list[str],
               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,
-              hidden_dim: int = 256, recursive_layers: int = 2) -> RecursiveSequential:
+              hidden_dim: int = 256, recursive_layers: int = 2) -> LongContextRecursiveSequential:
         if balancing_dataset:
             min_length = min(len(positive_texts), len(negative_texts))
             positive_texts = positive_texts[:min_length]
@@ -40,22 +42,23 @@ class TextBinaryClassifierTrainer(BaseTrainer):
         train_size = int(self._train_ratio * dataset_size)
         train_dataset = TensorDataset(inputs[:train_size], labels[:train_size])
         valid_dataset = TensorDataset(inputs[train_size:], labels[train_size:])
-        train_loader = DataLoader(train_dataset, batch_size=self._batch_size, shuffle=True)
-        valid_loader = DataLoader(valid_dataset, batch_size=self._batch_size, shuffle=True)
+        self.train_dataset_loader = DataLoader(train_dataset, batch_size=self._batch_size, shuffle=True)
+        self.valid_dataset_loader = DataLoader(valid_dataset, batch_size=self._batch_size, shuffle=True)
+
         if self.model is not None and self.model.fc1.in_features != feature_dim:
             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 = RecursiveSequential(input_dim=feature_dim, output_dim=1,
-                                             hidden_dim=hidden_dim,
-                                             recursive_layers=recursive_layers,
-                                             device=self.device, dtype=dtype)
+            self.model = LongContextRecursiveSequential(input_dim=feature_dim, output_dim=1,
+                                                        hidden_dim=hidden_dim,
+                                                        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):
             self.model.train()
             total_loss = 0.0
-            for batch_texts, batch_labels in train_loader:
+            for batch_texts, batch_labels in self.train_dataset_loader:
                 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()
@@ -64,7 +67,7 @@ class TextBinaryClassifierTrainer(BaseTrainer):
                 total_loss += loss.item()
             if epoch % 3 == 0:
                 total_valid_loss = 0.0
-                for batch_texts, batch_labels in valid_loader:
+                for batch_texts, batch_labels in self.valid_dataset_loader:
                     with torch.no_grad():
                         self.model.eval()
                         outputs = torch.sigmoid(self.model.forward(batch_texts, self.model.initial_state(batch_texts.shape[0]))[0])
@@ -76,7 +79,8 @@ class TextBinaryClassifierTrainer(BaseTrainer):
                              f"Valid Loss: {total_valid_loss:.4f}")
                 if total_valid_loss < valid_loss_threshold:
                     break
-            logger.debug(f"Epoch {epoch + 1}/{num_epochs} | Train Loss: {total_loss:.4f}")
+            else:
+                logger.debug(f"Epoch {epoch + 1}/{num_epochs} | Train Loss: {total_loss:.4f}")
             if total_loss < train_loss_threshold:
                 break
         return self.model

{deeplotx-0.4.15.dist-info → deeplotx-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeplotx
-Version: 0.4.15
+Version: 0.5.3
 Summary: Easy-2-use long text NLP toolkit.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -166,7 +166,10 @@ Dynamic: license-file
         LogisticRegression,  # 逻辑回归 / 二分类 / 多标签分类
         SoftmaxRegression,  # Softmax 回归 / 多分类
         RecursiveSequential,  # 序列模型 / 循环神经网络
-        AutoRegression  # 自回归模型
+        LongContextRecursiveSequential,  # 长上下文序列模型 / 自注意力融合循环神经网络
+        SelfAttention,  # 自注意力模块
+        AutoRegression,  # 自回归模型 / 循环神经网络
+        LongContextAutoRegression  # 长上下文自回归模型 / 自注意力融合循环神经网络
     )
     ```
 
@@ -211,3 +214,84 @@ Dynamic: license-file
             x = self.fc5(x)
             return x
     ```
+
+    自注意力模块:
+
+    ```python
+    from typing_extensions import override
+
+    import torch
+    from torch import nn, softmax
+
+    from deeplotx.nn.base_neural_network import BaseNeuralNetwork
+
+
+    class SelfAttention(BaseNeuralNetwork):
+        def __init__(self, feature_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._feature_dim = feature_dim
+            self.q_proj = nn.Linear(in_features=self._feature_dim, out_features=self._feature_dim,
+                                    bias=True, device=self.device, dtype=self.dtype)
+            self.k_proj = nn.Linear(in_features=self._feature_dim, out_features=self._feature_dim,
+                                    bias=True, device=self.device, dtype=self.dtype)
+            self.v_proj = nn.Linear(in_features=self._feature_dim, out_features=self._feature_dim,
+                                    bias=True, device=self.device, dtype=self.dtype)
+
+        def _attention(self, x: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
+            q, k = self.q_proj(x), self.k_proj(x)
+            attn = torch.matmul(q, k.transpose(-2, -1))
+            attn = attn / (self._feature_dim ** 0.5)
+            attn = attn.masked_fill(mask == 0, -1e9) if mask is not None else attn
+            return softmax(attn, dim=-1)
+
+        @override
+        def forward(self, x: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
+            x = self.ensure_device_and_dtype(x, device=self.device, dtype=self.dtype)
+            if mask is not None:
+                mask = self.ensure_device_and_dtype(mask, device=self.device, dtype=self.dtype)
+            v = self.v_proj(x)
+            return torch.matmul(self._attention(x, mask), v)
+    ```
+
+- ### 使用预定义训练器实现文本二分类任务
+
+    ```python
+    from deeplotx import TextBinaryClassifierTrainer, LongTextEncoder
+    from deeplotx.util import get_files, read_file
+
+    # 定义向量编码策略 (默认使用 bert-base-uncased 作为嵌入模型)
+    long_text_encoder = LongTextEncoder(
+        max_length=2048,  # 最大文本大小, 超出截断
+        chunk_size=448,  # 块大小 (按 Token 计)
+        overlapping=32  # 块间重叠大小 (按 Token 计)
+    )
+
+    trainer = TextBinaryClassifierTrainer(
+        long_text_encoder=long_text_encoder,
+        batch_size=2,
+        train_ratio=0.9  # 训练集和验证集比例
+    )
+
+    # 读取数据
+    pos_data_path = 'path/to/pos_dir'
+    neg_data_path = 'path/to/neg_dir'
+    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=36, learning_rate=2e-5,  # 设置训练轮数和学习率
+                          balancing_dataset=True,  # 是否平衡数据集
+                          alpha=1e-4, rho=.2,  # 设置 elastic net 正则化的超参数 alpha 和 rho
+                          hidden_dim=256, recursive_layers=2)  # 设置循环神经网络的结构
+
+    # 保存模型权重
+    model.save(model_name='test_model', model_dir='model')
+
+    # 加载已保存的模型
+    model = model.load(model_name='test_model', model_dir='model')
+
+    # 使用训练好的模型进行预测
+    model.predict(long_text_encoder.encode('这是一个测试文本.', flatten=False))
+    ```

deeplotx-0.5.3.dist-info/RECORD

@@ -0,0 +1,30 @@
+deeplotx/__init__.py,sha256=3rVjGSRdcxpxZzHIQohT8dheB5mVdeXIrBkfH2yorcQ,1091
+deeplotx/encoder/__init__.py,sha256=EM-xrTsHoGaiiFpj-iFAxilMHXC_sQKWYrcq1qCnI3U,138
+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=A8FXqd4mdHxSn_o_R689XtpT73ISDT788EgMQRGLC2g,1822
+deeplotx/nn/__init__.py,sha256=CS0UwyYKa8wI6vu6FBIYxvm-HAmw39MTMFlZDtqi6UA,444
+deeplotx/nn/auto_regression.py,sha256=7P63opWCWMqE2DigwbsL6kfXtFtJPz00Yo1RqflBz4A,572
+deeplotx/nn/base_neural_network.py,sha256=o9s0NqxkDcFZdipX8UrlbBmwYHOg7wPmzbjBEeGw63s,2902
+deeplotx/nn/linear_regression.py,sha256=7TbbplBgY70b1l5lKvTJMzDWQ8khQfnRCyMjObhVdEc,2180
+deeplotx/nn/logistic_regression.py,sha256=YiSLAon8gLDtMXAkPQ210sauod24eyJYYH50fPhj6T8,667
+deeplotx/nn/long_context_auto_regression.py,sha256=Z67Enq1kc1bERIrQW4jHeDQQmisOXhhjrtaPklnHkyw,605
+deeplotx/nn/long_context_recursive_sequential.py,sha256=_fKpPA7wt6B0kPyyig4xuhmLxygK19FSLgxW1Xa453M,1487
+deeplotx/nn/recursive_sequential.py,sha256=8YHZ-IdLyMJN5QVWPMuizDxLodAE9Bgdg1_YtIxFw7o,2247
+deeplotx/nn/self_attention.py,sha256=fb34wXnfgAGYJEhqa1l9AxMa-AHcCTOLbUlAfaGIK7Q,1766
+deeplotx/nn/softmax_regression.py,sha256=BeVk0G2H3zKG6bsQgPRNWuTxnnNmVI2zFZtCHgARAAc,688
+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=BNBQdpaD8nB1dQv8naHNIravNcQC8JjOMqD-WRSrUH0,4931
+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.5.3.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+deeplotx-0.5.3.dist-info/METADATA,sha256=T5kkUvG4uoe6i9NKO6JiR8hT1A3sxjbrL-Xwnmn4Lrg,10868
+deeplotx-0.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deeplotx-0.5.3.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
+deeplotx-0.5.3.dist-info/RECORD,,

deeplotx-0.4.15.dist-info/RECORD

@@ -1,27 +0,0 @@
-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=uLqGcXH6AGY6CcjjbYbh09VWYqSpsg-y-jHYB6Fmp3w,2377
-deeplotx/encoder/long_text_encoder.py,sha256=hl_O8kR9o1kcII9YfSx2rf_Pk0l_Rv7LNbsS9UsTU0c,3373
-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=7P63opWCWMqE2DigwbsL6kfXtFtJPz00Yo1RqflBz4A,572
-deeplotx/nn/base_neural_network.py,sha256=oGlqY6ZZ3DGOXWQQ9nZ7ktJpfyIaUrSraGnFRbGD1jM,2384
-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=pHZChjzw9cuMQ0lmv42lxxVgxCU6D7owOgph0Irj-w4,2219
-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=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.15.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-deeplotx-0.4.15.dist-info/METADATA,sha256=HB6VHdLgyuMclJYLykBMnbnLa7s-rwfHyhrgjNdoRFQ,6955
-deeplotx-0.4.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deeplotx-0.4.15.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
-deeplotx-0.4.15.dist-info/RECORD,,