deeplotx 0.2.20__py3-none-any.whl → 0.3.1__py3-none-any.whl

deeplotx/__init__.py

@@ -3,7 +3,7 @@ import os
 
 __ROOT__ = os.path.dirname(os.path.abspath(__file__))
 
-from .encoder import BertEncoder, LongTextEncoder
+from .encoder import BertEncoder, LongTextEncoder, LongformerEncoder
 from .nn import LinearRegression, LogisticRegression, SoftmaxRegression
 from .trainer import TextBinaryClassifierTrainer
 

deeplotx/encoder/__init__.py

@@ -1,2 +1,3 @@
 from .bert_encoder import BertEncoder
 from .long_text_encoder import LongTextEncoder
+from .longformer_encoder import LongformerEncoder

deeplotx/encoder/bert_encoder.py

@@ -13,19 +13,20 @@ class BertEncoder(nn.Module):
     def __init__(self, model_name_or_path: str = DEFAULT_BERT):
         super().__init__()
         self.tokenizer = BertTokenizer.from_pretrained(pretrained_model_name_or_path=model_name_or_path,
-                                                       cache_dir=CACHE_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)
+                                              cache_dir=CACHE_PATH, _from_auto=True)
+        self.embed_dim = self.bert.config.max_position_embeddings
 
-    def forward(self, input_ids, attention_mask: torch.Tensor) -> torch.Tensor:
+    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, :]
 
-        num_chunks = math.ceil(input_ids.shape[-1] / 512)
+        num_chunks = math.ceil(input_ids.shape[-1] / self.embed_dim)
         chunks = chunk_results = []
         for i in range(num_chunks):
-            start_idx = i * 512
-            end_idx = min(start_idx + 512, input_ids.shape[-1])
+            start_idx = i * self.embed_dim
+            end_idx = min(start_idx + self.embed_dim, input_ids.shape[-1])
             chunks.append((input_ids[:, start_idx: end_idx], attention_mask[:, start_idx: end_idx]))
         ori_mode = self.bert.training
         self.bert.eval()

deeplotx/encoder/long_text_encoder.py

@@ -24,7 +24,7 @@ class LongTextEncoder(BertEncoder):
         return input_tup[0], super().forward(input_tup[1], attention_mask=input_tup[2])
 
     @override
-    def encode(self, text: str) -> torch.Tensor:
+    def encode(self, text: str, use_cache: bool = True) -> torch.Tensor:
         _text_to_show = text.replace("\n", str())
         logger.debug(f'Embedding \"{_text_to_show if len(_text_to_show) < 128 else _text_to_show[:128] + "..."}\".')
         # read cache
@@ -58,5 +58,6 @@ class LongTextEncoder(BertEncoder):
             fin_emb_tensor = torch.cat((fin_emb_tensor.detach().clone(), emb.detach().clone()), dim=-1)
         fin_emb_tensor = fin_emb_tensor.squeeze()
         # write cache
-        self._cache[_text_hash] = fin_emb_tensor
+        if use_cache:
+            self._cache[_text_hash] = fin_emb_tensor
         return fin_emb_tensor

deeplotx/encoder/longformer_encoder.py

@@ -0,0 +1,30 @@
+import torch
+from torch import nn
+from transformers import LongformerTokenizer, LongformerModel
+
+from deeplotx import __ROOT__
+
+CACHE_PATH = f'{__ROOT__}\\.cache'
+DEFAULT_LONGFORMER = 'allenai/longformer-base-4096'
+
+
+class LongformerEncoder(nn.Module):
+    def __init__(self, model_name_or_path: str = DEFAULT_LONGFORMER):
+        super().__init__()
+        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)
+
+    def forward(self, input_ids: torch.Tensor, attention_mask: torch.Tensor) -> torch.Tensor:
+        ori_mode = self.bert.training
+        self.bert.eval()
+        with torch.no_grad():
+            res = self.bert.forward(input_ids, attention_mask=attention_mask).last_hidden_state[:, 0, :]
+        self.bert.train(mode=ori_mode)
+        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)
+        return self.forward(_input_ids, _att_mask).squeeze()

deeplotx/nn/base_neural_network.py

@@ -1,3 +1,5 @@
+from abc import abstractmethod
+
 import torch
 from torch import nn
 
@@ -28,6 +30,7 @@ class BaseNeuralNetwork(nn.Module):
     def elastic_net(self, alpha: float = 1e-4, rho: float = 0.5) -> torch.Tensor:
         return alpha * (rho * self.l1(_lambda=1.) + (1 - rho) * self.l2(_lambda=1.))
 
+    @abstractmethod
     def forward(self, x) -> torch.Tensor: ...
 
     def predict(self, x) -> torch.Tensor:

deeplotx/similarity/__init__.py

@@ -0,0 +1,17 @@
+import numpy as np
+import torch
+
+bias = 1e-12
+
+
+def ndarray_adapter(*args) -> tuple | np.ndarray:
+    args = list(args)
+    for i, arg in enumerate(args):
+        match arg.__class__:
+            case torch.Tensor:
+                args[i] = arg.detach().cpu().numpy()
+            case List:
+                args[i] = np.asarray(arg)
+    if len(args) > 1:
+        return tuple(args)
+    return args[0]

deeplotx/similarity/distribution.py

@@ -0,0 +1,32 @@
+import numpy as np
+import torch
+
+from deeplotx.similarity import bias, ndarray_adapter
+
+
+def cross_entropy(p: torch.Tensor | np.ndarray, q: torch.Tensor | np.ndarray) -> np.float32:
+    p, q = ndarray_adapter(p, q)
+    q = np.clip(q, bias, 1 - bias)
+    return -1 * (np.sum(p * np.log(q)) / p.shape[0])
+
+
+def kl_divergence(p: torch.Tensor | np.ndarray, q: torch.Tensor | np.ndarray) -> np.float32:
+    p, q = ndarray_adapter(p, q)
+    q = np.where(q == 0, bias, q)
+    p = p / np.sum(p)
+    q = q / np.sum(q)
+    return np.sum(p * np.log(p / q))
+
+
+def js_divergence(p: torch.Tensor | np.ndarray, q: torch.Tensor | np.ndarray) -> np.float32:
+    p, q = ndarray_adapter(p, q)
+    m = (p + q) / 2
+    return (kl_divergence(p, m) + kl_divergence(q, m)) / 2
+
+
+def hellinger_distance(p: torch.Tensor | np.ndarray, q: torch.Tensor | np.ndarray) -> np.float32:
+    p, q = ndarray_adapter(p, q)
+    p = p / np.sum(p)
+    q = q / np.sum(q)
+    squared_diff = (np.sqrt(p) - np.sqrt(q)) ** 2
+    return np.sqrt(np.sum(squared_diff)) / np.sqrt(2)

deeplotx/similarity/set.py

@@ -0,0 +1,19 @@
+from deeplotx.similarity import bias
+
+
+def jaccard_similarity(set1: set, set2: set) -> float:
+    return (len(set1.intersection(set2)) + bias) / (len(set1.union(set2)) + bias)
+
+
+def overlap_coefficient(set1: set, set2: set) -> float:
+    return (len(set1.intersection(set2)) + bias) / (min(len(set1), len(set2)) + bias)
+
+
+def dice_coefficient(set1: set, set2: set) -> float:
+    return (2 * len(set1.intersection(set2)) + bias) / (len(set1) + len(set2) + bias)
+
+
+def ochiai_similarity(set1: set, set2: set) -> float:
+    intersection = len(set1.intersection(set2))
+    product = len(set1) ** 0.5 * len(set2) ** 0.5
+    return (intersection + bias) / (product + bias)

deeplotx/similarity/vector.py

@@ -0,0 +1,36 @@
+import numpy as np
+import torch
+
+from deeplotx.similarity import ndarray_adapter
+
+
+def l2_normalize(x: torch.Tensor | np.ndarray) -> np.ndarray:
+    x = ndarray_adapter(x)
+    return x / np.sqrt(np.sum(np.multiply(x, x)))
+
+
+def z_score_normalize(x: torch.Tensor | np.ndarray) -> np.ndarray:
+    x = ndarray_adapter(x)
+    mean = np.mean(x)
+    std_dev = np.std(x)
+    return (x - mean) / std_dev
+
+
+def euclidean_similarity(p: torch.Tensor | np.ndarray, q: torch.Tensor | np.ndarray) -> np.float32:
+    p, q = ndarray_adapter(p, q)
+    distance = p - q
+    distance = np.sum(np.multiply(distance, distance))
+    return np.sqrt(distance)
+
+
+def cosine_similarity(p: torch.Tensor | np.ndarray, q: torch.Tensor | np.ndarray) -> np.float32:
+    p, q = ndarray_adapter(p, q)
+    a = np.matmul(np.transpose(p), q)
+    b = np.sum(np.multiply(p, p))
+    c = np.sum(np.multiply(q, q))
+    return 1 - (a / (np.sqrt(b) * np.sqrt(c)))
+
+
+def chebyshev_similarity(p: torch.Tensor | np.ndarray, q: torch.Tensor | np.ndarray) -> np.float32:
+    p, q = ndarray_adapter(p, q)
+    return np.max(np.abs(p - q))

{deeplotx-0.2.20.dist-info → deeplotx-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeplotx
-Version: 0.2.20
+Version: 0.3.1
 Summary: Easy-2-use long text classifier trainers.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -21,13 +21,19 @@ Dynamic: license-file
 - Install with pip
 
     ```
-    pip install git+https://github.com/vortezwohl/DeepLoTX.git
+    pip install -U deeplotx
     ```
 
 - Install with uv
 
     ```
-    uv add git+https://github.com/vortezwohl/DeepLoTX.git
+    uv add -U deeplotx
+    ```
+  
+- Install from github
+
+    ```
+    pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
     ```
 
 ## Quick Start

deeplotx-0.3.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+deeplotx/__init__.py,sha256=C6N717chqnk3jqh9nuh9oM5hPldX9mCusCn-LqGWJJg,935
+deeplotx/encoder/__init__.py,sha256=EM-xrTsHoGaiiFpj-iFAxilMHXC_sQKWYrcq1qCnI3U,138
+deeplotx/encoder/bert_encoder.py,sha256=A-B7Gj94xv6UhvsFTBH7tnkAdGHRhfUZA2QjSnTKB6c,1970
+deeplotx/encoder/long_text_encoder.py,sha256=V6VxaHW6bMMaZHgU1UZ8n19UfSIV2f2sarWXquiFffQ,3018
+deeplotx/encoder/longformer_encoder.py,sha256=mZpC5TrGHQo98-ydGtVQQ9KRHgCGl1sRoxcQs7r4SSo,1409
+deeplotx/nn/__init__.py,sha256=9gh8rhKqVWtJyvryU_wHPTLEQIorwOBhAQRc0DtNamM,153
+deeplotx/nn/base_neural_network.py,sha256=Rkwu58mXXcuusf-59yLX89MywQx-EvTsSXOvlzUptRE,1621
+deeplotx/nn/linear_regression.py,sha256=D4mEWVOq6q1Fm2otm57rgZ_E06HJLZBV5k636PprAf4,1520
+deeplotx/nn/logistic_regression.py,sha256=QAtZp2oyqOW8-1pJWVcahsSM83bzfA68EHObg-wSHHY,463
+deeplotx/nn/softmax_regression.py,sha256=eUn3mVNlye9ewVdw3McPHZuKbUvvaamsUgFIJMVMgBU,487
+deeplotx/similarity/__init__.py,sha256=JA1om2zeDcQVS1R04nDMdP6yegxdLJ14WF63pSTL3oo,418
+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=5O-5dwVMCj5EDX9gjJwCA468OR4UozJ7V8b-JxeUB0s,4080
+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.3.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+deeplotx-0.3.1.dist-info/METADATA,sha256=GzIi1llGFDTLvHDLF3GOQ4G6MafM10M-7IeosZwZlaY,1616
+deeplotx-0.3.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+deeplotx-0.3.1.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
+deeplotx-0.3.1.dist-info/RECORD,,

{deeplotx-0.2.20.dist-info → deeplotx-0.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

deeplotx-0.2.20.dist-info/RECORD

@@ -1,20 +0,0 @@
-deeplotx/__init__.py,sha256=Bhxc6HRnuhPZCMNlBc6oKcFTpJbWRGrZmt00vVOsNf0,916
-deeplotx/encoder/__init__.py,sha256=x7k8IE0FXvDl7kCJGWPsetOHFdvNCiCXHbYOdvo7_JQ,87
-deeplotx/encoder/bert_encoder.py,sha256=rdT8YgZzvRoqYqtzPW95ilagSQTAQgUl7mMVetGKxCY,1822
-deeplotx/encoder/long_text_encoder.py,sha256=yEEtTVZYHJ0W3OSbh7BHm6xI33nJmVYlSrgD5RVcJLY,2967
-deeplotx/nn/__init__.py,sha256=9gh8rhKqVWtJyvryU_wHPTLEQIorwOBhAQRc0DtNamM,153
-deeplotx/nn/base_neural_network.py,sha256=MXuID5bagdHyrFOkoybW1oiXAY2d4FGnzZoR37LZfUI,1566
-deeplotx/nn/linear_regression.py,sha256=D4mEWVOq6q1Fm2otm57rgZ_E06HJLZBV5k636PprAf4,1520
-deeplotx/nn/logistic_regression.py,sha256=QAtZp2oyqOW8-1pJWVcahsSM83bzfA68EHObg-wSHHY,463
-deeplotx/nn/softmax_regression.py,sha256=eUn3mVNlye9ewVdw3McPHZuKbUvvaamsUgFIJMVMgBU,487
-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=5O-5dwVMCj5EDX9gjJwCA468OR4UozJ7V8b-JxeUB0s,4080
-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.2.20.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-deeplotx-0.2.20.dist-info/METADATA,sha256=NQgRWucDSAI4awAJNf9984IujFRo9PurR1qrqpmWIzA,1573
-deeplotx-0.2.20.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-deeplotx-0.2.20.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
-deeplotx-0.2.20.dist-info/RECORD,,