deeplotx 0.9.0__py3-none-any.whl → 0.9.3__py3-none-any.whl

deeplotx/__init__.py

@@ -4,7 +4,8 @@ import os
 __ROOT__ = os.path.dirname(os.path.abspath(__file__))
 
 from .encoder import Encoder, LongTextEncoder, LongformerEncoder
-from .ner import BertNER, NamedEntity
+from .ner.n2g import Name2Gender, Gender
+from .ner import BertNER, NamedEntity, NamedPerson
 from .nn import (
     FeedForward,
     MultiHeadFeedForward,

deeplotx/ner/__init__.py

@@ -1,3 +1,3 @@
-from .named_entity import NamedEntity
+from .named_entity import NamedEntity, NamedPerson
 from .base_ner import BaseNER
 from .bert_ner import BertNER

deeplotx/ner/base_ner.py

@@ -1,7 +1,7 @@
-from deeplotx.ner.named_entity import NamedEntity
+from deeplotx.ner.named_entity import NamedEntity, NamedPerson
 
 
 class BaseNER:
     def __init__(self): ...
 
-    def extract_entities(self, s: str, *args, **kwargs) -> list[NamedEntity]: ...
+    def __call__(self, s: str, *args, **kwargs) -> list[NamedEntity | NamedPerson]: ...

deeplotx/ner/bert_ner.py

@@ -6,11 +6,13 @@ import torch
 from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
 
 from deeplotx import __ROOT__
+from deeplotx.ner.n2g import Name2Gender
 from deeplotx.ner.base_ner import BaseNER
-from deeplotx.ner.named_entity import NamedEntity
+from deeplotx.ner.named_entity import NamedEntity, NamedPerson
 
 CACHE_PATH = os.path.join(__ROOT__, '.cache')
 DEFAULT_BERT_NER = 'Davlan/xlm-roberta-base-ner-hrl'
+N2G_MODEL: list[Name2Gender] = []
 logger = logging.getLogger('deeplotx.ner')
 
 
@@ -44,9 +46,9 @@ class BertNER(BaseNER):
         self._ner_pipeline = pipeline(task='ner', model=self.encoder, tokenizer=self.tokenizer, trust_remote_code=True)
         logger.debug(f'{BaseNER.__name__} initialized on device: {self.device}.')
 
-    def extract_entities(self, s: str, prob_threshold: float = .0, *args, **kwargs) -> list[NamedEntity]:
+    def _fast_extract(self, s: str, with_gender: bool = True, prob_threshold: float = .0) -> list[NamedEntity]:
         assert prob_threshold <= 1., f'prob_threshold ({prob_threshold}) cannot be larger than 1.'
-        s = ' ' + s
+        s = f' {s} '
         raw_entities = self._ner_pipeline(s)
         entities = []
         for ent in raw_entities:
@@ -69,4 +71,65 @@ class BertNER(BaseNER):
             ent[0] = ent[0].strip()
             if ent[1].upper().startswith('B'):
                 ent[1] = ent[1].upper()[1:].strip('-')
-        return [NamedEntity(*_) for _ in entities if _[2] >= prob_threshold]
+        entities = [NamedEntity(*_) for _ in entities if _[2] >= prob_threshold]
+        if not with_gender:
+            return entities
+        if len(N2G_MODEL) < 1:
+            N2G_MODEL.append(Name2Gender())
+        n2g_model = N2G_MODEL[0]
+        for i, ent in enumerate(entities):
+            if ent.type.upper() == 'PER':
+                gender, gender_prob = n2g_model(ent.text, return_probability=True)
+                entities[i] = NamedPerson(text=ent.text,
+                                          type=ent.type,
+                                          base_probability=ent.base_probability,
+                                          gender=gender,
+                                          gender_probability=gender_prob)
+        return entities
+
+    def _slow_extract(self, s: str, with_gender: bool = True, prob_threshold: float = .0, deduplicate: bool = True) -> list[NamedEntity]:
+        _entities = self._fast_extract(s, with_gender=with_gender, prob_threshold=prob_threshold) if len(s) < 512 else []
+        if len(s) >= 512:
+            window_size: int = 512
+            offset = window_size // 6
+            for _offset in [- offset, offset]:
+                _window_size = window_size + _offset
+                for i in range(0, len(s) + _window_size, _window_size):
+                    _entities.extend(self._fast_extract(s[i: i + _window_size], with_gender=with_gender, prob_threshold=prob_threshold))
+        _tmp_entities = sorted(_entities, key=lambda x: len(x.text), reverse=True)
+        for _ent_i in _tmp_entities:
+            for _ent_j in _entities:
+                if (_ent_j.text in _ent_i.text
+                        and len(_ent_j.text) != len(_ent_i.text)
+                        and _ent_j in _tmp_entities):
+                    _tmp_entities.remove(_ent_j)
+        while True:
+            for _ent in _tmp_entities:
+                if _ent.text not in s or len(_ent.text) < 2:
+                    _tmp_entities.remove(_ent)
+            _continue = False
+            for _ent in _tmp_entities:
+                if _ent.text not in s or len(_ent.text) < 2:
+                    _continue = True
+                    break
+            if not _continue:
+                break
+        if not deduplicate:
+            return _tmp_entities
+        _fin_entities = dict()
+        texts = set([text.text for text in _tmp_entities])
+        for text in texts:
+            for _ent in _tmp_entities:
+                if _ent.text == text:
+                    if _ent.text not in _fin_entities.keys():
+                        _fin_entities[_ent.text] = _ent
+                    else:
+                        if _ent.base_probability > _fin_entities[_ent.text].base_probability:
+                            _fin_entities[_ent.text] = _ent
+        return [v for k, v in _fin_entities.items()]
+
+    def __call__(self, s: str, with_gender: bool = True, prob_threshold: float = .0, fast_mode: bool = False, *args, **kwargs):
+        if fast_mode:
+            return self._fast_extract(s=s, with_gender=with_gender, prob_threshold=prob_threshold)
+        else:
+            return self._slow_extract(s=s, with_gender=with_gender, prob_threshold=prob_threshold, deduplicate=True)

deeplotx/ner/n2g/__init__.py

@@ -0,0 +1,91 @@
+import os
+
+import requests
+import gdown
+import torch
+from name4py import Gender
+
+from deeplotx import __ROOT__
+from deeplotx.encoder.encoder import Encoder
+from deeplotx.nn.logistic_regression import LogisticRegression
+from deeplotx.nn.base_neural_network import BaseNeuralNetwork
+
+
+__CACHE_DIR__ = os.path.join(__ROOT__, '.cache', '.n2g')
+ENCODER = Encoder(model_name_or_path='FacebookAI/xlm-roberta-base')
+BASE_MODEL = 'name2gender-base'
+SMALL_MODEL = 'name2gender-small'
+_MIN_FILE_SIZE = 1024 * 5
+
+
+def download_model(model_name: str):
+    quiet = bool(os.getenv('QUIET_DOWNLOAD', False))
+    os.makedirs(__CACHE_DIR__, exist_ok=True)
+    _proxies = {
+        'http': os.getenv('HTTP_PROXY', os.getenv('http_proxy')),
+        'https': os.getenv('HTTPS_PROXY', os.getenv('https_proxy'))
+    }
+    model_name = f'{model_name}.dlx'
+    model_path = os.path.join(__CACHE_DIR__, model_name)
+    base_url = 'https://github.com/vortezwohl/Name2Gender'
+    if not os.path.exists(model_path):
+        url = f'{base_url}/releases/download/RESOURCE/{model_name}'
+        if requests.get(url=base_url, proxies=_proxies).status_code == 200:
+            try:
+                gdown.download(
+                    url=url,
+                    output=model_path,
+                    quiet=quiet,
+                    proxy=_proxies.get('https'),
+                    speed=8192 * 1024,
+                    resume=True
+                )
+                if os.path.getsize(model_path) < _MIN_FILE_SIZE:
+                    raise FileNotFoundError(f"Model \"{model_name}\" doesn't exists.")
+            except Exception as e:
+                os.remove(model_path)
+                raise e
+        else:
+            raise ConnectionError(f'Failed to download model {model_name}.')
+
+
+def load_model(model_name: str = 'name2gender-small', dtype: torch.dtype | None = torch.float16) -> BaseNeuralNetwork:
+    n2g_model = None
+    match model_name:
+        case 'name2gender-base' | 'n2g-base' | 'base':
+            download_model(BASE_MODEL)
+            n2g_model = LogisticRegression(input_dim=768, output_dim=1,
+                                           num_heads=12, num_layers=4,
+                                           head_layers=1, expansion_factor=2,
+                                           model_name=BASE_MODEL, dtype=dtype)
+        case 'name2gender-small' | 'n2g-base' | 'small':
+            download_model(SMALL_MODEL)
+            n2g_model = LogisticRegression(input_dim=768, output_dim=1,
+                                           num_heads=6, num_layers=2,
+                                           head_layers=1, expansion_factor=1.5,
+                                           model_name=SMALL_MODEL, dtype=dtype)
+        case _:
+            download_model(SMALL_MODEL)
+            n2g_model = LogisticRegression(input_dim=768, output_dim=1,
+                                           num_heads=6, num_layers=2,
+                                           head_layers=1, expansion_factor=1.5,
+                                           model_name=SMALL_MODEL, dtype=dtype)
+    return n2g_model.load(model_dir=__CACHE_DIR__)
+
+
+class Name2Gender:
+    def __init__(self, model: BaseNeuralNetwork | None = None):
+        super().__init__()
+        if model is None:
+            model = load_model(SMALL_MODEL)
+        self._model = model
+
+    def __call__(self, name: str, return_probability: bool = False, threshold: float = .5) -> tuple[Gender, float] | Gender:
+        assert len(name) > 0, f'name ({name}) cannot be empty.'
+        name = f'{name[0].upper()}{name[1:]}'
+        emb = ENCODER.encode(name)
+        prob = self._model.predict(emb).item()
+        gender = Gender.Male if prob >= threshold else Gender.Female
+        if return_probability:
+            return gender, prob if gender == Gender.Male else (1. - prob)
+        return gender

deeplotx/ner/named_entity.py

@@ -1,8 +1,16 @@
 from dataclasses import dataclass
 
+from deeplotx.ner.n2g import Gender
+
 
 @dataclass
 class NamedEntity:
     text: str
     type: str
-    probability: float
+    base_probability: float
+
+
+@dataclass
+class NamedPerson(NamedEntity):
+    gender: Gender
+    gender_probability: float

{deeplotx-0.9.0.dist-info → deeplotx-0.9.3.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: deeplotx
-Version: 0.9.0
-Summary: Easy-2-use long text NLP toolkit.
+Version: 0.9.3
+Summary: An out-of-the-box long-text NLP framework.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -16,121 +16,198 @@ Requires-Dist: torch
 Requires-Dist: transformers
 Requires-Dist: typing-extensions
 Requires-Dist: vortezwohl>=0.0.8
-Requires-Dist: name2gender>=0.0.4a0
+Requires-Dist: name4py>=0.1.4
 Dynamic: license-file
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vortezwohl/DeepLoTX)
 
-# Deep Long Text Learning Kit
+# *Deep Long Text Learning*
 
-> Author: 吴子豪
+*An out-of-the-box long-text NLP framework.*
 
-**开箱即用的长文本语义建模框架**
+> Author: [vortezwohl](https://github.com/vortezwohl)
 
-## 安装
+## Installation
 
-- 使用 pip
+- **With pip**
 
     ```
     pip install -U deeplotx
     ```
 
-- 使用 uv (推荐)
+- **With uv (recommended)**
 
     ```
     uv add -U deeplotx
     ```
   
-- 从 github 安装最新特性
+- **Get the latest features from GitHub**
 
     ```
     pip install -U git+https://github.com/vortezwohl/DeepLoTX.git
     ```
 
-## 核心功能
+## Quick start
 
-- ### 长文本嵌入
+- ### Named entity recognition
 
-    - **基于通用 BERT 的长文本嵌入** (最大支持长度, 无限长, 可通过 max_length 限制长度)
+    > *Multilingual is supported.*
+
+    > *Gender recognition is supported.*
+
+    Import dependencies
+
+    ```python
+    from deeplotx import BertNER
+
+    ner = BertNER()
+    ```
+
+    ```python
+    ner('你好, 我的名字是吴子豪, 来自福建福州.')
+    ```
+
+    stdout:
+
+    ```
+    [NamedPerson(text='吴子豪', type='PER', base_probability=0.9995428418719051, gender=<Gender.Male: 'male'>, gender_probability=0.9970703125),
+    NamedEntity(text='福建', type='LOC', base_probability=0.9986373782157898),
+    NamedEntity(text='福州', type='LOC', base_probability=0.9993632435798645)]
+    ```
+
+    ```python
+    ner("Hi, i'm Vortez Wohl, author of DeeploTX.")
+    ```
+
+    stdout:
+
+    ```
+    [NamedPerson(text='Vortez Wohl', type='PER', base_probability=0.9991965342072855, gender=<Gender.Male: 'male'>, gender_probability=0.87255859375)]
+    ```
+
+- ### Gender recognition
+
+    > *Multilingual is supported.*
+
+    > *Integrated from [Name2Gender](https://github.com/vortezwohl/Name2Gender)*
+
+    Import dependencies
+
+    ```python
+    from deeplotx import Name2Gender
+
+    n2g = Name2Gender()
+    ```
+
+    Recognize gender of "Elon Musk":
+
+    ```python
+    n2g('Elon Musk')
+    ```
+
+    stdout:
+
+    ```
+    <Gender.Male: 'male'>
+    ```
+
+    Recognize gender of "Anne Hathaway":
+
+    ```python
+    n2g('Anne Hathaway')
+    ```
+
+    stdout:
+
+    ```
+    <Gender.Female: 'female'>
+    ```
+
+    Recognize gender of "吴彦祖":
+
+    ```python
+    n2g('吴彦祖', return_probability=True)
+    ```
+
+    stdout:
+
+    ```
+    (<Gender.Male: 'male'>, 1.0)
+    ```
+
+- ### Long text embedding
+
+    - **BERT based long text embedding**
 
         ```python
         from deeplotx import LongTextEncoder
 
-        # 块大小为 448 个 tokens, 块间重叠部分为 32 个 tokens.
         encoder = LongTextEncoder(
             chunk_size=448,
             overlapping=32
         )
-        # 对 "我是吴子豪, 这是一个测试文本." 计算嵌入, 并堆叠.
         encoder.encode('我是吴子豪, 这是一个测试文本.', flatten=False)
         ```
 
-        输出:
+        stdout:
         ```
         tensor([ 2.2316e-01,  2.0300e-01,  ...,  1.5578e-01, -6.6735e-02])
         ```
 
-    - **基于 Longformer 的长文本嵌入** (最大支持长度 4096 个 tokens)
+    - **Longformer based long text embedding**
 
         ```python
         from deeplotx import LongformerEncoder
 
         encoder = LongformerEncoder()
-        encoder.encode('我是吴子豪, 这是一个测试文本.')
+        encoder.encode('Thank you for using DeepLoTX.')
         ```
 
-        输出:
+        stdout:
         ```
         tensor([-2.7490e-02,  6.6503e-02, ..., -6.5937e-02,  6.7802e-03])
         ```
 
-- ### 相似性计算
+- ### Similarities calculation
 
-    - **基于向量的相似性**
+    - **Vector based**
 
         ```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)
         ```
 
-        输出:
+        stdout:
         ```
         4.47213595499958
         0.33333333333333337
         3
         ```
 
-    - **基于集合的相似性**
+    - **Set based**
 
         ```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)
         ```
 
-        输出:
+        stdout:
         ```
         0.1428571428572653
         0.2500000000001875
@@ -138,27 +215,23 @@ Dynamic: license-file
         0.2500000000001875
         ```
 
-    - **基于概率分布的相似性**
+    - **Distribution based**
 
         ```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)
         ```
 
-        输出:
+        stdout:
         ```
         0.3575654913778237
         0.15040773967762736
@@ -166,27 +239,27 @@ Dynamic: license-file
         0.20105866986400994
         ```
 
-- ### 预定义深度神经网络
+- ### Pre-defined neural networks
 
     ```python
     from deeplotx import (
-        FeedForward,  # 前馈神经网络
-        MultiHeadFeedForward,  # 多头前馈神经网络
-        LinearRegression,  # 线性回归
-        LogisticRegression,  # 逻辑回归 / 二分类 / 多标签分类
-        SoftmaxRegression,  # Softmax 回归 / 多分类
-        RecursiveSequential,  # 序列模型 / 循环神经网络
-        LongContextRecursiveSequential,  # 长上下文序列模型 / 自注意力融合循环神经网络
-        RoPE,  # RoPE 位置编码
-        Attention,  # 自注意力 / 交叉注意力
-        MultiHeadAttention,  # 并行多头注意力
-        RoFormerEncoder,  # Roformer (Transformer + RoPE) 编码器模型
-        AutoRegression,  # 自回归模型 / 循环神经网络
-        LongContextAutoRegression  # 长上下文自回归模型 / 自注意力融合循环神经网络
+        FeedForward, 
+        MultiHeadFeedForward, 
+        LinearRegression, 
+        LogisticRegression, 
+        SoftmaxRegression, 
+        RecursiveSequential, 
+        LongContextRecursiveSequential, 
+        RoPE, 
+        Attention, 
+        MultiHeadAttention, 
+        RoFormerEncoder, 
+        AutoRegression, 
+        LongContextAutoRegression 
     )
     ```
 
-    基础网络结构:
+    The fundamental FFN (MLPs):
 
     ```python
     from typing_extensions import override
@@ -244,7 +317,7 @@ Dynamic: license-file
             return x
     ```
 
-    注意力模块:
+    Attention:
 
     ```python
     from typing_extensions import override
@@ -297,46 +370,34 @@ Dynamic: license-file
             return torch.matmul(self._attention(x, y, mask), v)
     ```
 
-- ### 使用预定义训练器实现文本二分类任务
+- ### Text binary classification task with predefined trainer
 
     ```python
     from deeplotx import TextBinaryClassifierTrainer, LongTextEncoder
     from deeplotx.util import get_files, read_file
 
-    # 定义向量编码策略 (默认使用 FacebookAI/xlm-roberta-base 作为嵌入模型)
     long_text_encoder = LongTextEncoder(
-        max_length=2048,  # 最大文本大小, 超出截断
-        chunk_size=448,  # 块大小 (按 Token 计)
-        overlapping=32,  # 块间重叠大小 (按 Token 计)
-        cache_capacity=512  # 缓存大小
+        max_length=2048, 
+        chunk_size=448, 
+        overlapping=32, 
+        cache_capacity=512 
     )
-
     trainer = TextBinaryClassifierTrainer(
         long_text_encoder=long_text_encoder,
         batch_size=2,
-        train_ratio=0.9  # 训练集和验证集比例
+        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, encoder_layers=2,  # 2 层 Roformer 编码器
-                        attn_heads=8,  # 8 个注意力头
-                        recursive_layers=2)  # 2 层 Bi-LSTM
-
-    # 保存模型权重
+                        rho=.2, encoder_layers=2, 
+                        attn_heads=8, 
+                        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.9.0.dist-info → deeplotx-0.9.3.dist-info}/RECORD

@@ -1,12 +1,13 @@
-deeplotx/__init__.py,sha256=_CAKf1HvuHxUMoEYmYGaH8aSQVK99_LIXSzoF7vIviU,1301
+deeplotx/__init__.py,sha256=x4CbJuW20al6S5KkKyrReeuwNGv04JGoqtGUyx-ACtg,1356
 deeplotx/encoder/__init__.py,sha256=BrsF5_4O-4pfihYF2wjExDOoAY-03kGJTH-Mhez4tsE,129
 deeplotx/encoder/encoder.py,sha256=wVRl3p_7eg7qT_tJEit5qnmZx7dXkMVLxAtao5vImkk,4201
 deeplotx/encoder/long_text_encoder.py,sha256=4oRa9FqfGNZ8-gq14UKuhDkZC0A1Xi-wKmbQsn-uZ58,3966
 deeplotx/encoder/longformer_encoder.py,sha256=7Lm65AUD3qwbrzrhJ3dPZkyHeNRSapga3f-5QJCxV5A,3538
-deeplotx/ner/__init__.py,sha256=NhLSZ6Urvv9jokdZOKC5vQd0STKmm2gMrdcMgvjQULc,101
-deeplotx/ner/base_ner.py,sha256=OwD9fTuTu1xq2lC2NUnJ0MDJ3KGhUiBCXw9ySYg4eQQ,185
-deeplotx/ner/bert_ner.py,sha256=179cqfodG-eyOOD8s8QgnFprDQRBukuFByqLoMH4d6c,4420
-deeplotx/ner/named_entity.py,sha256=NfwdnLntkMrfPeZnIuWYbVnAvf2sdKQU1naodqRy0b0,125
+deeplotx/ner/__init__.py,sha256=Rss1pup9HzHZCG8U9ub8niWa9zRjWCy3Z7zg378KZQg,114
+deeplotx/ner/base_ner.py,sha256=pZTl50OrHH_FJm4rKp9iuixeOE6FX_AzgDXD32aXsN0,204
+deeplotx/ner/bert_ner.py,sha256=I8yFsarsLEQv0vcnNU2JIc0-LuPJcxaO-mLhDFCh1PI,7704
+deeplotx/ner/named_entity.py,sha256=c6XufIwH6yloJ-ccUjagf4mBl1XbbYDT8xyEJJ_-ZNs,269
+deeplotx/ner/n2g/__init__.py,sha256=b6fOWJVLaOCtoz8Qlp8NWQbL5lUSbn6H3-8fnVNIPi0,3940
 deeplotx/nn/__init__.py,sha256=YILwbxb-NHdiJjfOwBKH8F7PuZSDZSrGpTznPDucTro,710
 deeplotx/nn/attention.py,sha256=R-i-Rd7gnsh6hwXDeYfqLQOJvfSZIGfQbFzRlC91XLo,2879
 deeplotx/nn/auto_regression.py,sha256=j_R7WGPq9REngjpLuX5c0AaNqOpgGm2Vfrolw-XjWXw,877
@@ -32,8 +33,8 @@ deeplotx/trainer/text_binary_classification_trainer.py,sha256=TFxOX8rWU_zKliI9zm
 deeplotx/util/__init__.py,sha256=5CH4MTeSgsmCe3LPMfvKoSBpwh6jDSBuHVElJvzQzgs,90
 deeplotx/util/hash.py,sha256=qbNU3RLBWGQYFVte9WZBAkZ1BkdjCXiKLDaKPN54KFk,662
 deeplotx/util/read_file.py,sha256=ptzouvEQeeW8KU5BrWNJlXw-vFXVrpS9SkAUxsu6A8A,612
-deeplotx-0.9.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-deeplotx-0.9.0.dist-info/METADATA,sha256=9dx6Tz81e9YWTnsy-1VPw30ts9oJUcQD0Kohm36_HKA,13230
-deeplotx-0.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deeplotx-0.9.0.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
-deeplotx-0.9.0.dist-info/RECORD,,
+deeplotx-0.9.3.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+deeplotx-0.9.3.dist-info/METADATA,sha256=Fg0KzWIxFcMtuTfmuQ9BBJDFXjNTWtl9l3Cuuc1sX3I,13472
+deeplotx-0.9.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deeplotx-0.9.3.dist-info/top_level.txt,sha256=hKg4pVDXZ-WWxkRfJFczRIll1Sv7VyfKCmzHLXbuh1U,9
+deeplotx-0.9.3.dist-info/RECORD,,