improve

README.md

@@ -19,11 +19,16 @@ text = "سلام من یک متن تست برای تست این تست هستم.
 print(tokenizer.encode(text))
 print(tokenizer.decode(tokenizer.encode(text)))
 ```
-output should be:
+this is the normal encoding of this text:
 ```
 [216, 179, 217, 132, 216, 167, 217, 133, 32, 217, 133, 217, 134, 32, 219, 140, 218, 169, 32, 217, 133, 216, 170, 217, 134, 32, 216, 170, 216, 179, 216, 170, 32, 216, 168, 216, 177, 216, 167, 219, 140, 32, 216, 170, 216, 179, 216, 170, 32, 216, 167, 219, 140, 217, 134, 32, 216, 170, 216, 179, 216, 170, 32, 217, 135, 216, 179, 216, 170, 217, 133, 46]
 سلام من یک متن تست برای تست این تست هستم.
 ```
+and here is what Mana tokenizer generate:
+```
+[30318, 377, 363, 4340, 5828, 513, 5828, 378, 5828, 14471, 46]
+سلام من یک متن تست برای تست این تست هستم.
+```
 
 You can also add special tokens:
 ```python

benchmark.py

@@ -0,0 +1,52 @@
+import tracemalloc
+import time
+from datetime import datetime
+from .mana_tokenizer import ManaTokenizer
+
+tokenizer = ManaTokenizer()
+
+# Example text for tokenization
+sample_text = "شرکت آسا پرداز آریسا در سال 96 با استقرار در شهرک علمی و فناوری اصفهان فعالیت رسمی خود را در زمینه سامانه های پردازش سریع (hpc) و رایانش ابری (cloud) آغاز کرد. این شرکت اولین ارائه دهنده تخصصی کاملاً مبتنی بر شتاب دهنده های گرافیکی برای محاسبات پردازش سریع در ایران است. این شرکت توانست در سال 1400 آزمایشگاه پردازشی_گرافیکی خیام را در شهرک علمی تحقیقاتی اصفهان ایجاد و تجهیز کند.این آزمایشگاه مجهز به بیش از 8600 هسته پردازشی و بیش از 800 هزار هسته پردازش گرافیکی کودا می باشد که در اختیار محققان,معماران,مهندسان و … ,برای انجام تمامی تحقیقات و پروژهای علمیشان قرار داده میشود.این آزمایشگاه دارای فضای ذخیره سازی 1.5 پتابایت همچنین فضای رم 15 هزار گیگابایتی میباشد. این آزمایشگاه مجهز به جدید ترین سرورها و پردازنده های گرافیکی روز دنیا می باشد که از تمامی نرم افزار های پیشرفته ی طراحی,معماری,مهندسی,شبیه سازی,حل مسائل پیش بینی مالی,بازی و سرگرمی,پزشکی و درمان پشتیبانی می کند."
+
+# Tokenize a sample text to verify tokenizer function
+encoded_sample = tokenizer.encode(sample_text)
+tokens2 = encoded_sample.tokens
+vocab_size2 = len(tokenizer.get_vocab())
+print(f"Mana Vocabulary: {vocab_size2}")
+print(f"Mana Algorithm: {tokenizer.__class__.__name__}")
+
+# Print current date and time
+current_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+print(f"Current Date and Time: {current_date}")
+ 
+# Batch benchmark function using batch_encode
+def benchmark_tokenizer_batch(tokenizer, texts):
+    start_time = time.time()
+    tokenizer.batch_encode(texts)  # Use batch encoding here
+    end_time = time.time()
+    return end_time - start_time
+
+# Large texts for benchmarking
+large_texts = ["سال 96 با استقرار در شهرک علمی و فناوری اصفهان فعالیت رسمی خود را در زمینه سامانه های پردازش سریع (hpc) و رایانش ابری (cloud) آغاز."] * 1000
+
+# Run the batch benchmark
+time2 = benchmark_tokenizer_batch(tokenizer, large_texts)
+print(f"Mana Batch Encode Time: {time2} seconds")
+
+# Batch memory usage function
+def memory_usage_tokenizer_batch(tokenizer, texts):
+    tracemalloc.start()
+    tokenizer.batch_encode(texts)  # Use batch encoding here
+    snapshot = tracemalloc.take_snapshot()
+    tracemalloc.stop()
+    
+    top_stats = snapshot.statistics('lineno')
+    return top_stats[0].size / 1024
+
+# Measure memory usage for batch encoding
+memory2 = memory_usage_tokenizer_batch(tokenizer, large_texts)
+print(f"Mana Batch Encode Memory Usage: {memory2} KB")
+
+# Calculate and print the total character count for large_texts
+total_chars_large_texts = sum(len(text) for text in large_texts)
+print(f"Total characters in large_texts: {total_chars_large_texts}")

mana_tokenizer.py

@@ -1,13 +1,14 @@
+import torch
 from .base import Tokenizer
 from .helper import get_stats, merge_batch_get_stats
 from heapq import nlargest
 import time
 
 MANA_SPECIAL_TOKENS = {
-    '<|end|>': 100257,
-    '<|user|>': 100258,
-    '<|assistant|>': 100259,
-    '<|system|>': 100260
+    '<|end|>': 265712,
+    '<|user|>': 265713,
+    '<|assistant|>': 265714,
+    '<|system|>': 265715
 }
 
 class ManaTokenizer(Tokenizer):
@@ -17,9 +18,80 @@ class ManaTokenizer(Tokenizer):
         - special_tokens: str -> int dictionary of special tokens
           example: {'<|endoftext|>': 100257}
         """
-        self.register_special_tokens(MANA_SPECIAL_TOKENS)
         super().__init__(pattern, multiprocess, store_dict, stop_list_size, freq_cutoff)
+        self.register_special_tokens(MANA_SPECIAL_TOKENS)
+        self.load("mana_tokenizer/mana.model")
+        self.padding_side = "right"
+        self.pad_token_id = self.special_tokens.get('<|end|>')
+        
+    @property
+    def tokens(self):
+        """Property to retrieve token IDs for a given text."""
+        return self._tokens
+    
+    @property
+    def attention_masks(self):
+        """Property to retrieve attention masks for a given text."""
+        return self._attention_masks
+    
+    def encode(self, text, allowed_special="none_raise"):
+        """Override encode to include attention masks."""
+        encoded_ids = super().encode(text, allowed_special=allowed_special)
+        self._tokens = encoded_ids
+        self._attention_masks = torch.ones(len(encoded_ids), dtype=torch.int32)
+        return self
+    
+    def batch_encode(self, texts, padding=True):
+        """
+        Encode a list of texts with dynamic padding and attention masks.
+        Handles left padding and attention masking.
+        
+        Parameters:
+            texts (list of str): List of texts to encode.
+            padding (bool): If True, pad sequences to the max length in the batch.
+
+        Returns:
+            dict: A dictionary containing input_ids and attention_mask tensors.
+        """
+        # Ensure encode method returns a dict with 'input_ids' and 'attention_mask'
+        encoded_texts = [{"input_ids": self.encode(text).tokens, "attention_mask": [1] * len(self.encode(text).tokens)}
+                        for text in texts]
+        
+        max_len = max(len(t["input_ids"]) for t in encoded_texts) if padding else None
+
+        # Apply padding with left alignment
+        input_ids = []
+        attention_masks = []
+        for encoding in encoded_texts:
+            ids = encoding["input_ids"]
+            attn_mask = encoding["attention_mask"]
+            if padding and len(ids) < max_len:
+                pad_len = max_len - len(ids)
+                if self.padding_side == "left":
+                    ids = [self.pad_token_id] * pad_len + ids
+                    attn_mask = [0] * pad_len + attn_mask
+                else:
+                    ids = ids + [self.pad_token_id] * pad_len
+                    attn_mask = attn_mask + [0] * pad_len
+            input_ids.append(ids)
+            attention_masks.append(attn_mask)
+
+        # Convert to tensors
+        input_ids = torch.tensor(input_ids, dtype=torch.long)
+        attention_masks = torch.tensor(attention_masks, dtype=torch.long)
+
+        return {"input_ids": input_ids, "attention_mask": attention_masks}
 
+        
+    def get_vocab(self):
+        """Function to return the vocabulary dictionary."""
+        return self.vocab
+    
+    @property
+    def vocab_size(self):
+        """Property to return the vocabulary size."""
+        return len(self.vocab)
+    
     def train(self, data, vocab_size, cap_divisor=2, max_batch_size=0, verbose=False):
         t0 = time.time()
         ids = self._import_data(data)   # [(bytes, int)] -> text chunks and their counts