torchtextclassifiers 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

torchTextClassifiers/utilities/__init__.py

@@ -1,3 +0,0 @@
-"""
-Init script.
-"""

torchTextClassifiers/utilities/plot_explainability.py

@@ -0,0 +1,184 @@
+from typing import List, Optional
+
+import numpy as np
+import torch
+
+try:
+    from matplotlib import pyplot as plt
+
+    HAS_PYPLOT = True
+except ImportError:
+    HAS_PYPLOT = False
+
+
+def map_attributions_to_char(attributions, offsets, text):
+    """
+    Maps token-level attributions to character-level attributions based on token offsets.
+    Args:
+        attributions (np.ndarray): Array of shape (top_k, seq_len) or (seq_len,) containing token-level attributions.
+               Output from:
+                >>> ttc.predict(X, top_k=top_k, explain=True)["attributions"]
+        offsets (list of tuples): List of (start, end) offsets for each token in the original text.
+                Output from:
+                >>> ttc.predict(X, top_k=top_k, explain=True)["offset_mapping"]
+                Also from:
+                >>> ttc.tokenizer.tokenize(text, return_offsets_mapping=True)["offset_mapping"]
+        text (str): The original input text.
+
+    Returns:
+        np.ndarray: Array of shape (top_k, text_len) containing character-level attributions.
+            text_len is the number of characters in the original text.
+
+    """
+
+    if isinstance(text, list):
+        raise ValueError("text must be a single string, not a list of strings.")
+
+    assert isinstance(text, str), "text must be a string."
+
+    if isinstance(attributions, torch.Tensor):
+        attributions = attributions.cpu().numpy()
+
+    if attributions.ndim == 1:
+        attributions = attributions[None, :]
+
+    attributions_per_char = np.zeros((attributions.shape[0], len(text)))  # top_k, text_len
+
+    for token_idx, (start, end) in enumerate(offsets):
+        if start == end:  # skip special tokens
+            continue
+        attributions_per_char[:, start:end] = attributions[:, token_idx][:, None]
+
+    return np.exp(attributions_per_char) / np.sum(
+        np.exp(attributions_per_char), axis=1, keepdims=True
+    )  # softmax normalization
+
+
+def map_attributions_to_word(attributions, word_ids):
+    """
+    Maps token-level attributions to word-level attributions based on word IDs.
+    Args:
+        attributions (np.ndarray): Array of shape (top_k, seq_len) or (seq_len,) containing token-level attributions.
+               Output from:
+                >>> ttc.predict(X, top_k=top_k, explain=True)["attributions"]
+        word_ids (list of int or None): List of word IDs for each token in the original text.
+                Output from:
+                >>> ttc.predict(X, top_k=top_k, explain=True)["word_ids"]
+
+    Returns:
+        np.ndarray: Array of shape (top_k, num_words) containing word-level attributions.
+            num_words is the number of unique words in the original text.
+    """
+
+    word_ids = np.array(word_ids)
+
+    # Convert None to -1 for easier processing (PAD tokens)
+    word_ids_int = np.array([x if x is not None else -1 for x in word_ids], dtype=int)
+
+    # Filter out PAD tokens from attributions and word_ids
+    attributions = attributions[
+        torch.arange(attributions.shape[0])[:, None],
+        torch.tensor(np.where(word_ids_int != -1)[0])[None, :],
+    ]
+    word_ids_int = word_ids_int[word_ids_int != -1]
+    unique_word_ids = np.unique(word_ids_int)
+    num_unique_words = len(unique_word_ids)
+
+    top_k = attributions.shape[0]
+    attr_with_word_id = np.concat(
+        (attributions[:, :, None], np.tile(word_ids_int[None, :], reps=(top_k, 1))[:, :, None]),
+        axis=-1,
+    )  # top_k, seq_len, 2
+    # last dim is 2: 0 is the attribution of the token, 1 is the word_id the token is associated to
+
+    word_attributions = np.zeros((top_k, num_unique_words))
+    for word_id in unique_word_ids:
+        mask = attr_with_word_id[:, :, 1] == word_id  # top_k, seq_len
+        word_attributions[:, word_id] = (attr_with_word_id[:, :, 0] * mask).sum(
+            axis=1
+        )  # zero-out non-matching tokens and sum attributions for all tokens belonging to the same word
+
+    # assert word_attributions.sum(axis=1) == attributions.sum(axis=1), "Sum of word attributions per top_k must equal sum of token attributions per top_k."
+    return np.exp(word_attributions) / np.sum(
+        np.exp(word_attributions), axis=1, keepdims=True
+    )  # softmax normalization
+
+
+def plot_attributions_at_char(
+    text: str,
+    attributions_per_char: np.ndarray,
+    figsize=(10, 2),
+    titles: Optional[List[str]] = None,
+):
+    """
+    Plots character-level attributions as a heatmap.
+    Args:
+        text (str): The original input text.
+        attributions_per_char (np.ndarray): Array of shape (top_k, text_len) containing character-level attributions.
+               Output from map_attributions_to_char function.
+        title (str): Title of the plot.
+        figsize (tuple): Figure size for the plot.
+    """
+
+    if not HAS_PYPLOT:
+        raise ImportError(
+            "matplotlib is required for plotting. Please install it to use this function."
+        )
+    top_k = attributions_per_char.shape[0]
+
+    all_plots = []
+    for i in range(top_k):
+        fig, ax = plt.subplots(figsize=figsize)
+        ax.bar(range(len(text)), attributions_per_char[i])
+        ax.set_xticks(np.arange(len(text)))
+        ax.set_xticklabels(list(text), rotation=90)
+        title = titles[i] if titles is not None else f"Attributions for Top {i+1} Prediction"
+        ax.set_title(title)
+        ax.set_xlabel("Characters in Text")
+        ax.set_ylabel("Top Predictions")
+        all_plots.append(fig)
+
+    return all_plots
+
+
+def plot_attributions_at_word(
+    text, attributions_per_word, figsize=(10, 2), titles: Optional[List[str]] = None
+):
+    """
+    Plots word-level attributions as a heatmap.
+    Args:
+        text (str): The original input text.
+        attributions_per_word (np.ndarray): Array of shape (top_k, num_words) containing word-level attributions.
+               Output from map_attributions_to_word function.
+        title (str): Title of the plot.
+        figsize (tuple): Figure size for the plot.
+    """
+
+    if not HAS_PYPLOT:
+        raise ImportError(
+            "matplotlib is required for plotting. Please install it to use this function."
+        )
+
+    words = text.split()
+    top_k = attributions_per_word.shape[0]
+    all_plots = []
+    for i in range(top_k):
+        fig, ax = plt.subplots(figsize=figsize)
+        ax.bar(range(len(words)), attributions_per_word[i])
+        ax.set_xticks(np.arange(len(words)))
+        ax.set_xticklabels(words, rotation=90)
+        title = titles[i] if titles is not None else f"Attributions for Top {i+1} Prediction"
+        ax.set_title(title)
+        ax.set_xlabel("Words in Text")
+        ax.set_ylabel("Attributions")
+        all_plots.append(fig)
+
+    return all_plots
+
+
+def figshow(figure):
+    # https://stackoverflow.com/questions/53088212/create-multiple-figures-in-pyplot-but-only-show-one
+    for i in plt.get_fignums():
+        if figure != plt.figure(i):
+            plt.close(plt.figure(i))
+    plt.show()

torchtextclassifiers-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.3
+Name: torchtextclassifiers
+Version: 0.1.0
+Summary: A text classification toolkit to easily build, train and evaluate deep learning text classifiers using PyTorch.
+Keywords: fastText,text classification,NLP,automatic coding,deep learning
+Author: Cédric Couralet, Meilame Tayebjee
+Author-email: Cédric Couralet <cedric.couralet@insee.fr>, Meilame Tayebjee <meilame.tayebjee@insee.fr>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: pytorch-lightning>=2.4.0
+Requires-Dist: unidecode ; extra == 'explainability'
+Requires-Dist: nltk ; extra == 'explainability'
+Requires-Dist: captum ; extra == 'explainability'
+Requires-Dist: tokenizers>=0.22.1 ; extra == 'huggingface'
+Requires-Dist: transformers>=4.57.1 ; extra == 'huggingface'
+Requires-Dist: datasets>=4.3.0 ; extra == 'huggingface'
+Requires-Dist: unidecode ; extra == 'preprocess'
+Requires-Dist: nltk ; extra == 'preprocess'
+Requires-Python: >=3.11
+Provides-Extra: explainability
+Provides-Extra: huggingface
+Provides-Extra: preprocess
+Description-Content-Type: text/markdown
+
+# torchTextClassifiers
+
+A unified, extensible framework for text classification with categorical variables built on [PyTorch](https://pytorch.org/) and [PyTorch Lightning](https://lightning.ai/docs/pytorch/stable/).
+
+## 🚀 Features
+
+- **Mixed input support**: Handle text data alongside categorical variables seamlessly.
+- **Unified yet highly customizable**:
+    - Use any tokenizer from HuggingFace or the original fastText's ngram tokenizer.
+    - Manipulate the components (`TextEmbedder`, `CategoricalVariableNet`, `ClassificationHead`) to easily create custom architectures - including **self-attention**. All of them are `torch.nn.Module` !
+    - The `TextClassificationModel` class combines these components and can be extended for custom behavior.
+- **PyTorch Lightning**: Automated training with callbacks, early stopping, and logging
+- **Easy experimentation**: Simple API for training, evaluating, and predicting with minimal code:
+    - The `torchTextClassifiers` wrapper class orchestrates the tokenizer and the model for you
+- **Additional features**: explainability using Captum
+
+
+## 📦 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/InseeFrLab/torchTextClassifiers.git
+cd torchtextClassifiers
+
+# Install with uv (recommended)
+uv sync
+
+# Or install with pip
+pip install -e .
+```
+
+## 📝 Usage
+
+Checkout the [notebook](notebooks/example.ipynb) for a quick start.
+
+## 📚 Examples
+
+See the [examples/](examples/) directory for:
+- Basic text classification
+- Multi-class classification
+- Mixed features (text + categorical)
+- Advanced training configurations
+- Prediction and explainability
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

torchtextclassifiers-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+torchTextClassifiers/__init__.py,sha256=TM2AjZ4KDqpgwMKiT0X5daNZvLDj6WECz_OFf8M4lgA,906
+torchTextClassifiers/dataset/__init__.py,sha256=dyCz48pO6zRC-2qh4753Hj70W2MZGXdX3RbgutvyOng,76
+torchTextClassifiers/dataset/dataset.py,sha256=n7V4JNtcuqb2ugx7hxkAohEPHqEuxv46jYU47KiUbno,3295
+torchTextClassifiers/model/__init__.py,sha256=lFY1Mb1J0tFhe4_PsDOEHhnVl3dXj59K4Zxnwy2KkS4,146
+torchTextClassifiers/model/components/__init__.py,sha256=-IT_6fCHZkRw6Hu7GdVeCt685P4PuGaY6VdYQV5M8mE,447
+torchTextClassifiers/model/components/attention.py,sha256=hhSMh_CvpR-hiP8hoCg4Fr_TovGlJpC_RHs3iW-Pnpc,4199
+torchTextClassifiers/model/components/categorical_var_net.py,sha256=no0QDidKCw1rlbJzD7S-Srhzn5P6vETGRT5Er-gzMnM,5699
+torchTextClassifiers/model/components/classification_head.py,sha256=lPndu5FPC-bOZ2H4Yq0EnzWrOzPFJdBb_KUx5wyZBb4,1445
+torchTextClassifiers/model/components/text_embedder.py,sha256=tY2pXAt4IvayyvRpjiKGg5vGz_Q2-p_TOL6Jg2p8hYE,9058
+torchTextClassifiers/model/lightning.py,sha256=z5mq10_hNp-UK66Aqpcablg3BDYnjF9Gch0HaGoJ6cM,5265
+torchTextClassifiers/model/model.py,sha256=jjGjvK7C2Wly0e4S6gTC8Ty8y-o8reU-aniBqYS73Cc,6100
+torchTextClassifiers/tokenizers/WordPiece.py,sha256=HMHYV2SiwShlhWMQ6LXH4MtZE5GSsaNA2DlD340ABGE,3289
+torchTextClassifiers/tokenizers/__init__.py,sha256=I8IQ2-t85RVlZFwLjDFF_Te2S9uiwlymQDWx-3GeF-Y,334
+torchTextClassifiers/tokenizers/base.py,sha256=OY6GIhI4KTdvvKq3VZowf64H7lAmdQyq4scZ10HxP3A,7570
+torchTextClassifiers/tokenizers/ngram.py,sha256=lHI8dtuCGWh0o7V58TJx_mTVIHm8udl6XuWccxgJPew,16375
+torchTextClassifiers/torchTextClassifiers.py,sha256=E2XVGAky_SMAw6BAMswA3c08rKyOpGEW_dv1BqQlJrU,21141
+torchTextClassifiers/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torchTextClassifiers/utilities/plot_explainability.py,sha256=8YhyiMupdiIZp4jT7uvlcJNf69Fyr9HXfjUiNyMSYxE,6931
+torchtextclassifiers-0.1.0.dist-info/WHEEL,sha256=ELhySV62sOro8I5wRaLaF3TWxhBpkcDkdZUdAYLy_Hk,78
+torchtextclassifiers-0.1.0.dist-info/METADATA,sha256=fvPTUIS-M4LgURVzC1CUTb8IrKyZiBzWRAE1heTafEE,2988
+torchtextclassifiers-0.1.0.dist-info/RECORD,,

{torchtextclassifiers-0.0.1.dist-info → torchtextclassifiers-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.3
+Generator: uv 0.9.3
 Root-Is-Purelib: true
 Tag: py3-none-any

torchTextClassifiers/classifiers/base.py

@@ -1,83 +0,0 @@
-from typing import Optional, Union, Type, List, Dict, Any
-from dataclasses import dataclass, field, asdict
-from abc import ABC, abstractmethod
-import numpy as np
-
-class BaseClassifierConfig(ABC):
-    """Abstract base class for classifier configurations."""
-    
-    @abstractmethod
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert configuration to dictionary."""
-        pass
-    
-    @classmethod
-    @abstractmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "BaseClassifierConfig":
-        """Create configuration from dictionary."""
-        pass
-
-class BaseClassifierWrapper(ABC):
-    """Abstract base class for classifier wrappers.
-    
-    Each classifier wrapper is responsible for its own text processing approach.
-    Some may use tokenizers, others may use different preprocessing methods.
-    """
-    
-    def __init__(self, config: BaseClassifierConfig):
-        self.config = config
-        self.pytorch_model = None
-        self.lightning_module = None
-        self.trained: bool = False
-        self.device = None
-        # Remove tokenizer from base class - it's now wrapper-specific
-    
-    @abstractmethod
-    def prepare_text_features(self, training_text: np.ndarray) -> None:
-        """Prepare text features for the classifier.
-        
-        This could involve tokenization, vectorization, or other preprocessing.
-        Each classifier wrapper implements this according to its needs.
-        """
-        pass
-    
-    @abstractmethod
-    def _build_pytorch_model(self) -> None:
-        """Build the PyTorch model."""
-        pass
-    
-    @abstractmethod
-    def _check_and_init_lightning(self, **kwargs) -> None:
-        """Initialize Lightning module."""
-        pass
-    
-    @abstractmethod
-    def predict(self, X: np.ndarray, **kwargs) -> np.ndarray:
-        """Make predictions."""
-        pass
-    
-    @abstractmethod
-    def validate(self, X: np.ndarray, Y: np.ndarray, **kwargs) -> float:
-        """Validate the model."""
-        pass
-    
-    @abstractmethod
-    def create_dataset(self, texts: np.ndarray, labels: np.ndarray, categorical_variables: Optional[np.ndarray] = None):
-        """Create dataset for training/validation."""
-        pass
-    
-    @abstractmethod
-    def create_dataloader(self, dataset, batch_size: int, num_workers: int = 0, shuffle: bool = True):
-        """Create dataloader from dataset."""
-        pass
-    
-    @abstractmethod
-    def load_best_model(self, checkpoint_path: str) -> None:
-        """Load best model from checkpoint."""
-        pass
-    
-    @classmethod
-    @abstractmethod
-    def get_config_class(cls) -> Type[BaseClassifierConfig]:
-        """Return the configuration class for this wrapper."""
-        pass

torchTextClassifiers/classifiers/fasttext/__init__.py

@@ -1,25 +0,0 @@
-"""FastText classifier package.
-
-Provides FastText text classification with PyTorch Lightning integration.
-This folder contains 4 main files:
-- core.py: Configuration, losses, and factory methods
-- tokenizer.py: NGramTokenizer implementation
-- model.py: PyTorch model, Lightning module, and dataset
-- wrapper.py: High-level wrapper interface
-"""
-
-from .core import FastTextConfig, OneVsAllLoss, FastTextFactory
-from .tokenizer import NGramTokenizer
-from .model import FastTextModel, FastTextModule, FastTextModelDataset
-from .wrapper import FastTextWrapper
-
-__all__ = [
-    "FastTextConfig",
-    "OneVsAllLoss", 
-    "FastTextFactory",
-    "NGramTokenizer",
-    "FastTextModel",
-    "FastTextModule", 
-    "FastTextModelDataset",
-    "FastTextWrapper",
-]

torchTextClassifiers/classifiers/fasttext/core.py

@@ -1,269 +0,0 @@
-"""FastText classifier core components.
-
-This module contains the core components for FastText classification:
-- Configuration dataclass
-- Loss functions
-- Factory methods for creating classifiers
-
-Consolidates what was previously in config.py, losses.py, and factory.py.
-"""
-
-from dataclasses import dataclass, field, asdict
-from abc import ABC, abstractmethod
-from ..base import BaseClassifierConfig
-from typing import Optional, List, TYPE_CHECKING, Union, Dict, Any
-import numpy as np
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-if TYPE_CHECKING:
-    from ...torchTextClassifiers import torchTextClassifiers
-
-
-# ============================================================================
-# Configuration
-# ============================================================================
-
-@dataclass
-class FastTextConfig(BaseClassifierConfig):
-    """Configuration for FastText classifier."""
-    # Embedding matrix
-    embedding_dim: int
-    sparse: bool
-
-    # Tokenizer-related
-    num_tokens: int
-    min_count: int
-    min_n: int
-    max_n: int
-    len_word_ngrams: int
-
-    # Optional parameters
-    num_classes: Optional[int] = None
-    num_rows: Optional[int] = None
-
-    # Categorical variables
-    categorical_vocabulary_sizes: Optional[List[int]] = None
-    categorical_embedding_dims: Optional[Union[List[int], int]] = None
-    num_categorical_features: Optional[int] = None
-
-    # Model-specific parameters
-    direct_bagging: Optional[bool] = True
-    
-    # Training parameters
-    learning_rate: float = 4e-3
-
-    def to_dict(self) -> Dict[str, Any]:
-        return asdict(self)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "FastTextConfig":
-        return cls(**data)
-
-
-# ============================================================================
-# Loss Functions
-# ============================================================================
-
-class OneVsAllLoss(nn.Module):
-    def __init__(self):
-        super(OneVsAllLoss, self).__init__()
-
-    def forward(self, logits, targets):
-        """
-        Compute One-vs-All loss
-
-        Args:
-            logits: Tensor of shape (batch_size, num_classes) containing classification scores
-            targets: Tensor of shape (batch_size) containing true class indices
-
-        Returns:
-            loss: Mean loss value across the batch
-        """
-
-        num_classes = logits.size(1)
-
-        # Convert targets to one-hot encoding
-        targets_one_hot = F.one_hot(targets, num_classes=num_classes).float()
-
-        # For each sample, treat the true class as positive and all others as negative
-        # Using binary cross entropy for each class
-        loss = F.binary_cross_entropy_with_logits(
-            logits,  # Raw logits
-            targets_one_hot,  # Target probabilities
-            reduction="none",  # Don't reduce yet to allow for custom weighting if needed
-        )
-
-        # Sum losses across all classes for each sample, then take mean across batch
-        return loss.sum(dim=1).mean()
-
-
-# ============================================================================
-# Factory Methods
-# ============================================================================
-
-class FastTextFactory:
-    """Factory class for creating FastText classifiers with convenience methods.
-    
-    This factory provides static methods for creating FastText classifiers with
-    common configurations. It handles the complexities of configuration creation
-    and classifier initialization, offering a simplified API for users.
-    
-    All methods return fully initialized torchTextClassifiers instances that are
-    ready for building and training.
-    """
-    
-    @staticmethod
-    def create_fasttext(
-        embedding_dim: int,
-        sparse: bool,
-        num_tokens: int,
-        min_count: int,
-        min_n: int,
-        max_n: int,
-        len_word_ngrams: int,
-        **kwargs
-    ) -> "torchTextClassifiers":
-        """Create a FastText classifier with the specified configuration.
-        
-        This is the primary method for creating FastText classifiers. It creates
-        a configuration object with the provided parameters and initializes a
-        complete classifier instance.
-        
-        Args:
-            embedding_dim: Dimension of word embeddings
-            sparse: Whether to use sparse embeddings
-            num_tokens: Maximum number of tokens in vocabulary
-            min_count: Minimum count for tokens to be included in vocabulary
-            min_n: Minimum length of character n-grams
-            max_n: Maximum length of character n-grams
-            len_word_ngrams: Length of word n-grams to use
-            **kwargs: Additional configuration parameters (e.g., num_classes,
-                     categorical_vocabulary_sizes, etc.)
-                     
-        Returns:
-            torchTextClassifiers: Initialized FastText classifier instance
-            
-        Example:
-            >>> from torchTextClassifiers.classifiers.fasttext.core import FastTextFactory
-            >>> classifier = FastTextFactory.create_fasttext(
-            ...     embedding_dim=100,
-            ...     sparse=False,
-            ...     num_tokens=10000,
-            ...     min_count=2,
-            ...     min_n=3,
-            ...     max_n=6,
-            ...     len_word_ngrams=2,
-            ...     num_classes=3
-            ... )
-        """
-        from ...torchTextClassifiers import torchTextClassifiers
-        from .wrapper import FastTextWrapper
-        
-        config = FastTextConfig(
-            embedding_dim=embedding_dim,
-            sparse=sparse,
-            num_tokens=num_tokens,
-            min_count=min_count,
-            min_n=min_n,
-            max_n=max_n,
-            len_word_ngrams=len_word_ngrams,
-            **kwargs
-        )
-        wrapper = FastTextWrapper(config)
-        return torchTextClassifiers(wrapper)
-    
-    @staticmethod
-    def build_from_tokenizer(
-        tokenizer,  # NGramTokenizer
-        embedding_dim: int,
-        num_classes: Optional[int],
-        categorical_vocabulary_sizes: Optional[List[int]] = None,
-        sparse: bool = False,
-        **kwargs
-    ) -> "torchTextClassifiers":
-        """Create FastText classifier from an existing trained tokenizer.
-        
-        This method is useful when you have a pre-trained tokenizer and want to
-        create a classifier that uses the same vocabulary and tokenization scheme.
-        The resulting classifier will have its tokenizer and model architecture
-        pre-built.
-        
-        Args:
-            tokenizer: Pre-trained NGramTokenizer instance
-            embedding_dim: Dimension of word embeddings
-            num_classes: Number of output classes
-            categorical_vocabulary_sizes: Sizes of categorical feature vocabularies
-            sparse: Whether to use sparse embeddings
-            **kwargs: Additional configuration parameters
-            
-        Returns:
-            torchTextClassifiers: Classifier with pre-built tokenizer and model
-            
-        Raises:
-            ValueError: If the tokenizer is missing required attributes
-            
-        Example:
-            >>> # Assume you have a pre-trained tokenizer
-            >>> classifier = FastTextFactory.build_from_tokenizer(
-            ...     tokenizer=my_tokenizer,
-            ...     embedding_dim=100,
-            ...     num_classes=2,
-            ...     sparse=False
-            ... )
-            >>> # The classifier is ready for training without building
-            >>> classifier.train(X_train, y_train, X_val, y_val, ...)
-        """
-        from ...torchTextClassifiers import torchTextClassifiers
-        from .wrapper import FastTextWrapper
-        
-        # Ensure the tokenizer has required attributes
-        required_attrs = ["min_count", "min_n", "max_n", "num_tokens", "word_ngrams"]
-        if not all(hasattr(tokenizer, attr) for attr in required_attrs):
-            missing_attrs = [attr for attr in required_attrs if not hasattr(tokenizer, attr)]
-            raise ValueError(f"Missing attributes in tokenizer: {missing_attrs}")
-        
-        config = FastTextConfig(
-            num_tokens=tokenizer.num_tokens,
-            embedding_dim=embedding_dim,
-            min_count=tokenizer.min_count,
-            min_n=tokenizer.min_n,
-            max_n=tokenizer.max_n,
-            len_word_ngrams=tokenizer.word_ngrams,
-            sparse=sparse,
-            num_classes=num_classes,
-            categorical_vocabulary_sizes=categorical_vocabulary_sizes,
-            **kwargs
-        )
-        
-        wrapper = FastTextWrapper(config)
-        classifier = torchTextClassifiers(wrapper)
-        classifier.classifier.tokenizer = tokenizer
-        classifier.classifier._build_pytorch_model()
-        
-        return classifier
-    
-    @staticmethod
-    def from_dict(config_dict: dict) -> FastTextConfig:
-        """Create FastText configuration from dictionary.
-        
-        This method is used internally by the configuration factory system
-        to recreate FastText configurations from serialized data.
-        
-        Args:
-            config_dict: Dictionary containing configuration parameters
-            
-        Returns:
-            FastTextConfig: Reconstructed configuration object
-            
-        Example:
-            >>> config_dict = {
-            ...     'embedding_dim': 100,
-            ...     'num_tokens': 5000,
-            ...     'min_count': 1,
-            ...     # ... other parameters
-            ... }
-            >>> config = FastTextFactory.from_dict(config_dict)
-        """
-        return FastTextConfig.from_dict(config_dict)