tov-tokenizer 0.1.0__tar.gz

tov_tokenizer-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: tov-tokenizer
+Version: 0.1.0
+Summary: Иерархический TOV-токенизатор с γ-кэшированием и λ-утечкой
+Author: Артём Мехед
+License: MIT
+Project-URL: Homepage, https://github.com/твой-логин/tov-tokenizer
+Project-URL: Repository, https://github.com/твой-логин/tov-tokenizer
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.19
+
+# TOV Tokenizer
+
+Иерархический токенизатор на основе Теории Относительности Всего (ТОВ).
+
+## Особенности
+
+- 🌳 Иерархическое дерево (предложения → слова → подслова → символы)
+- ⚡ γ-кэширование частых токенов
+- 🧹 λ-утечка для редких токенов
+- 🧠 Выбор токенов через потоки массы
+- 🔄 Сохранение/загрузка состояния
+
+## Установка
+
+```bash
+pip install tov-tokenizer

tov_tokenizer-0.1.0/README.md

@@ -0,0 +1,16 @@
+# TOV Tokenizer
+
+Иерархический токенизатор на основе Теории Относительности Всего (ТОВ).
+
+## Особенности
+
+- 🌳 Иерархическое дерево (предложения → слова → подслова → символы)
+- ⚡ γ-кэширование частых токенов
+- 🧹 λ-утечка для редких токенов
+- 🧠 Выбор токенов через потоки массы
+- 🔄 Сохранение/загрузка состояния
+
+## Установка
+
+```bash
+pip install tov-tokenizer

tov_tokenizer-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tov-tokenizer"
+version = "0.1.0"
+description = "Иерархический TOV-токенизатор с γ-кэшированием и λ-утечкой"
+readme = "README.md"
+authors = [
+    {name = "Артём Мехед"}
+]
+license = {text = "MIT"}
+requires-python = ">=3.7"
+dependencies = [
+    "numpy>=1.19",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/твой-логин/tov-tokenizer"
+Repository = "https://github.com/твой-логин/tov-tokenizer"

tov_tokenizer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tov_tokenizer-0.1.0/tov_tokenizer/__init__.py

@@ -0,0 +1,9 @@
+"""
+TOV Tokenizer — иерархический токенизатор с γ-кэшированием.
+"""
+
+from .core import TOVTokenizerTOV
+from .graph import TokenGraph, TokenNode
+
+__version__ = "0.1.0"
+__all__ = ["TOVTokenizerTOV", "TokenGraph", "TokenNode"]

tov_tokenizer-0.1.0/tov_tokenizer/core.py

@@ -0,0 +1,310 @@
+"""
+TOV Tokenizer: Токенизация через потоки массы.
+Полностью на основе Теории Относительности Всего.
+"""
+
+import sys
+import os
+import numpy as np
+import re
+from collections import defaultdict
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from .graph import TokenGraph, TokenNode
+
+class TOVTokenizerTOV:
+    """
+    Токенизатор, работающий через TOV-граф.
+    - Иерархическое дерево токенов
+    - Выбор токенов через потоки массы
+    - γ-кэширование
+    - λ-утечка редких токенов
+    """
+    
+    def __init__(self, vocab_size=5000, min_frequency=2):
+        self.vocab_size = vocab_size
+        self.min_frequency = min_frequency
+        self.graph = TokenGraph()
+        
+        # 👇 СПЕЦТОКЕНЫ ВСЕГДА В ПЕРВУЮ ОЧЕРЕДЬ
+        self.specials = ['<pad>', '<unk>', '<sos>', '<eos>', '<sep>']
+        self.token_to_id = {}
+        self.id_to_token = {}
+        
+        for i, spec in enumerate(self.specials):
+            self.token_to_id[spec] = i
+            self.id_to_token[i] = spec
+        
+        self.stats = {
+            'tokens_seen': 0,
+            'unique_tokens': 0,
+            'pruned_tokens': 0
+        }
+        
+    def train(self, texts):
+        """
+        Обучает токенизатор на текстах.
+        Строит иерархическое дерево.
+        """
+        print(f"\n🌳 ОБУЧЕНИЕ TOV-ТОКЕНИЗАТОРА")
+        print(f"   Текстов: {len(texts)}")
+        
+        for i, text in enumerate(texts):
+            if i % 100 == 0 and i > 0:
+                print(f"   Обработано {i}/{len(texts)} текстов")
+            self._add_text_to_graph(text)
+        
+        # Применяем λ-утечку
+        pruned = self.graph.prune_rare_tokens(
+            threshold=0.01, 
+            time_window=max(100, len(texts)//10)
+        )
+        self.stats['pruned_tokens'] = pruned
+        
+        # Строим словарь из частотных токенов
+        self._build_vocab_from_graph()
+        
+        print(f"✅ TOV-токенизатор готов:")
+        print(f"   • Узлов в графе: {len(self.graph.nodes)}")
+        print(f"   • Удалено редких: {pruned}")
+        print(f"   • Размер словаря: {len(self.token_to_id)}")
+    
+    def _add_text_to_graph(self, text):
+        """Добавляет текст в граф с иерархией"""
+        # Разбиваем на предложения
+        sentences = re.split(r'[.!?]+', text)
+        
+        for sent in sentences:
+            if not sent.strip():
+                continue
+            
+            # Добавляем предложение
+            sent_node = self.graph.add_token_node(
+                sent.strip(), sent[:30] + "...", "sentence"
+            )
+            self.graph.add_edge(str(self.graph.root.token_id), str(sent_node.token_id))
+            sent_node.update_frequency(self.graph.time_step)
+            
+            # Разбиваем на слова
+            words = re.findall(r'\w+', sent.lower())
+            
+            for word in words:
+                if len(word) < 2:
+                    continue
+                    
+                # Добавляем слово
+                word_node = self.graph.add_token_node(word, word, "word")
+                self.graph.add_edge(str(sent_node.token_id), str(word_node.token_id))
+                word_node.update_frequency(self.graph.time_step)
+                
+                # Разбиваем на подслова (2-4 символа)
+                subwords = self._generate_subwords(word)
+                for subword in subwords:
+                    sub_node = self.graph.add_token_node(subword, subword, "subword")
+                    self.graph.add_edge(str(word_node.token_id), str(sub_node.token_id))
+                    sub_node.update_frequency(self.graph.time_step)
+                
+                # Разбиваем на символы
+                for i, char in enumerate(word):
+                    char_node = self.graph.add_token_node(
+                        char, char, "char"
+                    )
+                    self.graph.add_edge(str(word_node.token_id), str(char_node.token_id))
+                    char_node.update_frequency(self.graph.time_step)
+            
+            self.graph.time_step += 1
+    
+    def _generate_subwords(self, word, min_len=2, max_len=4):
+        """Генерирует подслова для BPE-like токенизации"""
+        subwords = []
+        word_len = len(word)
+        for length in range(min_len, min(max_len, word_len) + 1):
+            for i in range(word_len - length + 1):
+                subword = word[i:i+length]
+                subwords.append(subword)
+        return list(set(subwords))  # уникальные
+    
+    def _build_vocab_from_graph(self):
+        """Строит словарь из графа, беря самые частотные узлы"""
+        if len(self.graph.nodes) <= 1:
+            print("⚠️ Граф пуст, использую только спецтокены")
+            return
+        
+        # Сортируем узлы по частоте
+        nodes_by_freq = sorted(
+            self.graph.nodes.values(),
+            key=lambda n: n.frequency if hasattr(n, 'frequency') else 0,
+            reverse=True
+        )
+        
+        # Обычные токены (начиная после спецтокенов)
+        idx = len(self.specials)
+        for node in nodes_by_freq:
+            if not hasattr(node, 'level') or node.level == 'root':
+                continue
+            if idx >= self.vocab_size:
+                break
+            if hasattr(node, 'token_str') and node.token_str not in self.token_to_id:
+                self.token_to_id[node.token_str] = idx
+                self.id_to_token[idx] = node.token_str
+                idx += 1
+    
+    def save(self, path):
+        """Сохраняет токенизатор в файл"""
+        import pickle
+        data = {
+            'vocab_size': self.vocab_size,
+            'min_frequency': self.min_frequency,
+            'token_to_id': self.token_to_id,
+            'id_to_token': self.id_to_token,
+            'specials': self.specials,
+            'stats': self.stats,
+            'graph': self.graph  # сохраняем весь граф
+        }
+        with open(path, 'wb') as f:
+            pickle.dump(data, f)
+        print(f"💾 Токенизатор сохранён в {path}")
+
+    def load(self, path):
+        """Загружает токенизатор из файла"""
+        import pickle
+        with open(path, 'rb') as f:
+            data = pickle.load(f)
+        
+        self.vocab_size = data['vocab_size']
+        self.min_frequency = data['min_frequency']
+        self.token_to_id = data['token_to_id']
+        self.id_to_token = data['id_to_token']
+        self.specials = data['specials']
+        self.stats = data['stats']
+        self.graph = data['graph']
+        
+        print(f"📂 Токенизатор загружен из {path}")
+        print(f"   Токенов: {len(self.token_to_id)}")
+        print(f"   Узлов в графе: {len(self.graph.nodes)}")
+
+    def encode(self, text, add_special_tokens=True):
+        """
+        Токенизирует текст через потоки массы.
+        """
+        tokens = []
+        
+        if add_special_tokens:
+            tokens.append(self.token_to_id['<sos>'])  # теперь точно есть
+        
+        # Разбиваем на предложения
+        sentences = re.split(r'[.!?]+', text)
+        
+        for sent in sentences:
+            if not sent.strip():
+                continue
+            
+            # Ищем узел предложения
+            sent_node = self._find_best_node(sent.strip(), 'sentence')
+            if sent_node and sent_node.token_str in self.token_to_id:
+                tokens.append(self.token_to_id[sent_node.token_str])
+            
+            # Разбиваем на слова
+            words = re.findall(r'\w+', sent.lower())
+            for word in words:
+                # Ищем узел слова
+                word_node = self._find_best_node(word, 'word')
+                if word_node and word_node.token_str in self.token_to_id:
+                    tokens.append(self.token_to_id[word_node.token_str])
+                else:
+                    # Если слова нет, разбиваем на символы
+                    for char in word:
+                        char_node = self._find_best_node(char, 'char')
+                        if char_node and char_node.token_str in self.token_to_id:
+                            tokens.append(self.token_to_id[char_node.token_str])
+                        else:
+                            tokens.append(1)  # <unk>
+        
+        if add_special_tokens:
+            tokens.append(self.token_to_id['<eos>'])
+        
+        return tokens
+    
+    def _find_best_node(self, token_str, level):
+        """Находит лучший узел через поток массы"""
+        candidates = []
+        for node_id, node in self.graph.nodes.items():
+            if (hasattr(node, 'level') and node.level == level and 
+                hasattr(node, 'token_str') and node.token_str == token_str):
+                candidates.append(node)
+        
+        if not candidates:
+            return None
+        
+        # Выбираем по потоку массы от корня
+        best_node = None
+        best_flow = -float('inf')
+        
+        for node in candidates:
+            flow = node.core.a * node.core.output_mass
+            if flow > best_flow:
+                best_flow = flow
+                best_node = node
+        
+        return best_node
+    
+    def decode(self, ids, skip_special=True):
+        """
+        Декодирует токены обратно в текст.
+        """
+        text = []
+        for i in ids:
+            token = self.id_to_token.get(i, '<unk>')
+            if skip_special and token.startswith('<'):
+                continue
+            text.append(token)
+        return ' '.join(text)
+    
+    def get_stats(self):
+        """Возвращает статистику токенизатора"""
+        stats = {
+            'vocab_size': len(self.token_to_id),
+            'graph_nodes': len(self.graph.nodes),
+            'tokens_seen': self.graph.time_step,
+            'pruned_tokens': self.stats['pruned_tokens']
+        }
+        
+        # Добавляем статистику графа
+        try:
+            graph_stats = self.graph.get_stats()
+            stats.update(graph_stats)
+        except:
+            pass
+        
+        return stats
+
+    def __len__(self):
+        """Возвращает размер словаря (нужно для len(tokenizer))"""
+        return len(self.token_to_id)
+
+# ===================== ТЕСТ =====================
+
+if __name__ == "__main__":
+    print("🚀 Тест TOVTokenizerTOV")
+    
+    # Тестовые тексты
+    texts = [
+        "привет, как дела?",
+        "нормально, а у тебя?",
+        "отлично! погнали дальше"
+    ]
+    
+    t = TOVTokenizerTOV(vocab_size=100)
+    t.train(texts)
+    
+    for text in texts:
+        encoded = t.encode(text)
+        decoded = t.decode(encoded)
+        print(f"\n📝 Оригинал: {text}")
+        print(f"   Токенов: {len(encoded)}")
+        print(f"   Декод: {decoded}")
+    
+    stats = t.get_stats()
+    print("\n📊 Статистика:")
+    for k, v in stats.items():
+        print(f"   {k}: {v}")

tov_tokenizer-0.1.0/tov_tokenizer/graph.py

@@ -0,0 +1,171 @@
+"""
+TOV Token Graph: Иерархическое дерево токенов.
+Предложение -> Слово -> Символ/Подслово.
+"""
+
+import sys
+import os
+import numpy as np
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Вместо импорта внешних классов, создадим минимальные версии прямо здесь
+class TOVCore:
+    """Минимальное ядро для токенизатора"""
+    def __init__(self, name="layer"):
+        self.name = name
+        self.a = 0.3
+        self.b = 0.4
+        self.c = 0.3
+        self.output_mass = 0.0
+        self.accumulated_mass = 0.0
+        self.gamma = 0.0
+        self.beta = 0.5
+        
+    def add_learned_mass(self, delta):
+        self.accumulated_mass += delta
+        self.output_mass = self.accumulated_mass * self.beta
+
+class TOVTreeNode:
+    """Минимальный узел для токенизатора"""
+    def __init__(self, token_id, embedding):
+        self.token_id = token_id
+        self.embedding = embedding
+        self.children = []
+        self.parent = None
+        self.core = TOVCore(f"node_{token_id}")
+        self.frequency = 0
+        self.last_seen = 0
+        
+    def add_child(self, child_node):
+        self.children.append(child_node)
+        child_node.parent = self
+
+class TokenNode(TOVTreeNode):
+    """Узел-токен с дополнительной информацией"""
+    def __init__(self, token_id, token_str, level, embedding=None):
+        super().__init__(token_id, embedding or np.zeros(20))
+        self.token_str = token_str
+        self.level = level  # 'root', 'sentence', 'word', 'subword', 'char'
+        self.frequency = 0
+        self.last_seen = 0
+
+    def update_frequency(self, time_step):
+        self.frequency += 1
+        self.last_seen = time_step
+        # Масса растёт с частотой
+        self.core.add_learned_mass(0.1)
+
+class TOVGraph:
+    """Минимальный граф для токенизатора"""
+    def __init__(self):
+        self.nodes = {}
+        self.root = None
+        
+    def add_node(self, name, embedding=None):
+        """Добавляет узел в граф"""
+        if embedding is None:
+            embedding = np.zeros(20)
+        node = TOVTreeNode(name, embedding)
+        self.nodes[name] = node
+        return node
+        
+    def add_edge(self, parent_id, child_id):
+        """Добавляет связь между узлами"""
+        if parent_id in self.nodes and child_id in self.nodes:
+            self.nodes[parent_id].add_child(self.nodes[child_id])
+
+class TokenGraph:
+    """Граф для иерархической токенизации"""
+    def __init__(self):
+        self.nodes = {}
+        self.token_map = {}  # token_str -> node_id
+        self.time_step = 0
+        self.root = self.add_token_node("<root>", "<root>", "root")
+
+    def add_token_node(self, token_str, display_str, level):
+        """Добавляет узел-токен в граф"""
+        token_id = hash(token_str) % 1000000  # простой хеш
+        node = TokenNode(token_id, display_str, level)
+        self.nodes[str(token_id)] = node
+        self.token_map[token_str] = str(token_id)
+        return node
+
+    def add_edge(self, parent_id, child_id):
+        """Добавляет связь между узлами"""
+        if parent_id in self.nodes and child_id in self.nodes:
+            self.nodes[parent_id].add_child(self.nodes[child_id])
+
+    def add_sequence(self, tokens, parent_node, level):
+        """Добавляет последовательность токенов как дочерние узлы"""
+        nodes = []
+        for token in tokens:
+            if token not in self.token_map:
+                node = self.add_token_node(token, token, level)
+            else:
+                node_id = self.token_map[token]
+                node = self.nodes[node_id]
+
+            self.add_edge(str(parent_node.token_id), str(node.token_id))
+            node.update_frequency(self.time_step)
+            nodes.append(node)
+
+        self.time_step += 1
+        return nodes
+
+    def prune_rare_tokens(self, threshold=0.01, time_window=1000):
+        """Удаляет редкие токены (λ-утечка)"""
+        current_time = self.time_step
+        to_prune = []
+
+        for node_id, node in self.nodes.items():
+            if not hasattr(node, 'level') or node.level == 'root':
+                continue
+
+            # Если токен не видели давно и частота низкая
+            age = current_time - node.last_seen
+            if age > time_window and node.frequency < threshold * time_window:
+                to_prune.append(node_id)
+
+        for node_id in to_prune:
+            # Удаляем из nodes
+            if node_id in self.nodes:
+                node = self.nodes[node_id]
+                # Удаляем из token_map
+                for token_str, tid in list(self.token_map.items()):
+                    if tid == node_id:
+                        del self.token_map[token_str]
+                # Удаляем сам узел
+                del self.nodes[node_id]
+
+        return len(to_prune)
+
+    def get_stats(self):
+        """Возвращает статистику графа"""
+        stats = {
+            'total_nodes': len(self.nodes),
+            'unique_tokens': len(self.token_map),
+            'time_step': self.time_step
+        }
+
+        # Считаем по уровням
+        level_counts = {}
+        for node in self.nodes.values():
+            if hasattr(node, 'level'):
+                level_counts[node.level] = level_counts.get(node.level, 0) + 1
+        stats['levels'] = level_counts
+
+        return stats
+
+# ===================== ТЕСТ =====================
+
+if __name__ == "__main__":
+    print("🚀 Тест TokenGraph")
+    g = TokenGraph()
+    print(f"✅ Граф создан")
+    print(f"   Узлов: {len(g.nodes)}")
+    print(f"   Корень: {g.root.token_id}")
+
+    stats = g.get_stats()
+    print(f"\n📊 Статистика:")
+    for k, v in stats.items():
+        print(f"   {k}: {v}")

tov_tokenizer-0.1.0/tov_tokenizer.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: tov-tokenizer
+Version: 0.1.0
+Summary: Иерархический TOV-токенизатор с γ-кэшированием и λ-утечкой
+Author: Артём Мехед
+License: MIT
+Project-URL: Homepage, https://github.com/твой-логин/tov-tokenizer
+Project-URL: Repository, https://github.com/твой-логин/tov-tokenizer
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.19
+
+# TOV Tokenizer
+
+Иерархический токенизатор на основе Теории Относительности Всего (ТОВ).
+
+## Особенности
+
+- 🌳 Иерархическое дерево (предложения → слова → подслова → символы)
+- ⚡ γ-кэширование частых токенов
+- 🧹 λ-утечка для редких токенов
+- 🧠 Выбор токенов через потоки массы
+- 🔄 Сохранение/загрузка состояния
+
+## Установка
+
+```bash
+pip install tov-tokenizer

tov_tokenizer-0.1.0/tov_tokenizer.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tov_tokenizer/__init__.py
+tov_tokenizer/core.py
+tov_tokenizer/graph.py
+tov_tokenizer.egg-info/PKG-INFO
+tov_tokenizer.egg-info/SOURCES.txt
+tov_tokenizer.egg-info/dependency_links.txt
+tov_tokenizer.egg-info/requires.txt
+tov_tokenizer.egg-info/top_level.txt

tov_tokenizer-0.1.0/tov_tokenizer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tov_tokenizer-0.1.0/tov_tokenizer.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.19

tov_tokenizer-0.1.0/tov_tokenizer.egg-info/top_level.txt

@@ -0,0 +1 @@
+tov_tokenizer