docstrings on tokenizer

src/tokenizer.py

@@ -21,31 +21,62 @@ from transformers import PreTrainedTokenizerFast
 
 
 class SegmentationTokenizer:
-    def __init__(
-        self,
-        vocab_size=32_768,
-        min_frequency=2,
-        max_length=1024
-    ):
+    """
+    Wrapper class for training and using a BPE-based tokenizer for text segmentation.
+
+    This class supports:
+    - Training a Byte Pair Encoding (BPE) tokenizer from an iterator
+    - Saving and loading the tokenizer
+    - Tokenizing text with padding and truncation
+    - Computing the unknown-token (UNK) rate over a corpus
+    """
+
+    def __init__(self, vocab_size=32_768, min_frequency=2, max_length=1024):
+        """
+        Initialize the segmentation tokenizer.
+
+        Args:
+            vocab_size (int): Maximum vocabulary size for the BPE tokenizer.
+            min_frequency (int): Minimum token frequency to be included in the vocabulary.
+            max_length (int): Maximum sequence length for tokenization.
+        """
         self.max_length = max_length
 
-        # Raw tokenizer (training)
+        # Raw tokenizer used only during training
         self.raw_tokenizer = tokenizers.Tokenizer(
             BPE(unk_token="[UNK]")
         )
         self.raw_tokenizer.normalizer = NFKC()
         self.raw_tokenizer.pre_tokenizer = Whitespace()
 
+        # Trainer configuration for BPE
         self.trainer = BpeTrainer(
             vocab_size=vocab_size,
             min_frequency=min_frequency,
             special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]"]
         )
 
-        self._hf_tokenizer = None  # created after training
+        # Hugging Face fast tokenizer (created after loading)
+        self._hf_tokenizer = None
 
-    # ---------- TRAINING ----------
-    def build_iterator(self, dataset, batch_size=1024):
+    # ------------------------------------------------------------------
+    # Training utilities
+    # ------------------------------------------------------------------
+    @staticmethod
+    def build_iterator(dataset, batch_size=1024):
+        """
+        Build a batched text iterator from a dataset.
+
+        Each dataset item is expected to contain a "text" field,
+        which is a list of strings.
+
+        Args:
+            dataset (Iterable[dict]): Dataset containing text entries.
+            batch_size (int): Number of samples per batch.
+
+        Yields:
+            List[str]: A batch of concatenated text samples.
+        """
         batch = []
         for item in dataset:
             batch.append("\n".join(item["text"]).replace("\n\n", "\n"))
@@ -56,15 +87,39 @@ class SegmentationTokenizer:
             yield batch
 
     def train_from_iterator(self, iterator):
+        """
+        Train the raw tokenizer from an iterator of text batches.
+
+        Args:
+            iterator (Iterable[List[str]]): Iterator yielding batches of text.
+        """
         self.raw_tokenizer.train_from_iterator(
-            iterator, trainer=self.trainer
+            iterator,
+            trainer=self.trainer
         )
 
-    # ---------- IO ----------
+    # ------------------------------------------------------------------
+    # I/O
+    # ------------------------------------------------------------------
     def save(self, path):
+        """
+        Save the trained raw tokenizer to disk.
+
+        Args:
+            path (str): Path where the tokenizer file will be saved.
+        """
         self.raw_tokenizer.save(path)
 
     def load(self, tokenizer_path):
+        """
+        Load a tokenizer from disk as a Hugging Face fast tokenizer.
+
+        Args:
+            tokenizer_path (str): Path to the saved tokenizer file.
+
+        Returns:
+            SegmentationTokenizer: Self, for chaining.
+        """
         self._hf_tokenizer = PreTrainedTokenizerFast(
             tokenizer_file=tokenizer_path,
             unk_token="[UNK]",
@@ -75,8 +130,19 @@ class SegmentationTokenizer:
         )
         return self
 
-    # ---------- TOKENIZATION  ----------
+    # ------------------------------------------------------------------
+    # Tokenization utilities
+    # ------------------------------------------------------------------
     def compute_unk_rate(self, corpus):
+        """
+        Compute the proportion of unknown tokens ([UNK]) in a corpus.
+
+        Args:
+            corpus (Iterable[str]): Collection of input texts.
+
+        Returns:
+            float: UNK token rate in the corpus.
+        """
         unk_id = self._hf_tokenizer.convert_tokens_to_ids("[UNK]")
 
         total_tokens = 0
@@ -101,8 +167,18 @@ class SegmentationTokenizer:
         truncation=True
     ):
         """
-        text: str or List[str]
-        returns: dict with input_ids and attention_mask (torch.long)
+        Tokenize input text.
+
+        Args:
+            text (str or List[str]): Input text or batch of texts.
+            return_tensors (str): Tensor type to return (e.g., "pt").
+            padding (bool): Whether to pad sequences to max_length.
+            truncation (bool): Whether to truncate sequences to max_length.
+
+        Returns:
+            dict: Dictionary containing:
+                - input_ids (torch.LongTensor)
+                - attention_mask (torch.LongTensor)
         """
         if self._hf_tokenizer is None:
             raise RuntimeError("Tokenizer not loaded. Call .load() first.")
@@ -116,17 +192,29 @@ class SegmentationTokenizer:
         )
 
         return {
-            "input_ids": enc["input_ids"],           # torch.LongTensor
-            "attention_mask": enc["attention_mask"]  # torch.LongTensor
+            "input_ids": enc["input_ids"],
+            "attention_mask": enc["attention_mask"]
         }
 
+    # ------------------------------------------------------------------
+    # Properties and representations
+    # ------------------------------------------------------------------
     @property
     def vocab_size(self):
+        """
+        Get the vocabulary size of the loaded tokenizer.
+
+        Returns:
+            int: Vocabulary size.
+        """
         if self._hf_tokenizer is None:
             raise RuntimeError("Tokenizer not loaded.")
         return self._hf_tokenizer.vocab_size
 
     def __repr__(self):
+        """
+        String representation of the tokenizer.
+        """
         return f"<SegmentationTokenizer vocab_size={self.trainer.vocab_size}>"