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

torchTextClassifiers/classifiers/simple_text_classifier.py

@@ -1,191 +0,0 @@
-"""
-Simple text classifier example that doesn't require a tokenizer.
-
-This demonstrates how to create a classifier wrapper that uses 
-different text preprocessing approaches.
-"""
-
-from typing import Optional, Dict, Any
-from dataclasses import dataclass, asdict
-import numpy as np
-import torch
-import torch.nn as nn
-from sklearn.feature_extraction.text import TfidfVectorizer
-from torch.utils.data import Dataset, DataLoader
-import pytorch_lightning as pl
-from torch.optim import Adam
-
-from .base import BaseClassifierWrapper, BaseClassifierConfig
-
-
-@dataclass
-class SimpleTextConfig(BaseClassifierConfig):
-    """Configuration for simple text classifier using TF-IDF."""
-    
-    hidden_dim: int = 128
-    num_classes: Optional[int] = None
-    max_features: int = 10000
-    learning_rate: float = 1e-3
-    dropout_rate: float = 0.1
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return asdict(self)
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "SimpleTextConfig":
-        return cls(**data)
-
-
-class SimpleTextDataset(Dataset):
-    """Dataset for simple text classifier."""
-    
-    def __init__(self, features: np.ndarray, labels: np.ndarray):
-        self.features = torch.FloatTensor(features)
-        self.labels = torch.LongTensor(labels)
-    
-    def __len__(self):
-        return len(self.features)
-    
-    def __getitem__(self, idx):
-        return self.features[idx], self.labels[idx]
-
-
-class SimpleTextModel(nn.Module):
-    """Simple neural network for text classification using TF-IDF features."""
-    
-    def __init__(self, input_dim: int, hidden_dim: int, num_classes: int, dropout_rate: float = 0.1):
-        super().__init__()
-        
-        self.network = nn.Sequential(
-            nn.Linear(input_dim, hidden_dim),
-            nn.ReLU(),
-            nn.Dropout(dropout_rate),
-            nn.Linear(hidden_dim, hidden_dim // 2),
-            nn.ReLU(),
-            nn.Dropout(dropout_rate),
-            nn.Linear(hidden_dim // 2, num_classes)
-        )
-    
-    def forward(self, x):
-        return self.network(x)
-
-
-class SimpleTextModule(pl.LightningModule):
-    """Lightning module for simple text classifier."""
-    
-    def __init__(self, model: nn.Module, learning_rate: float = 1e-3):
-        super().__init__()
-        self.model = model
-        self.learning_rate = learning_rate
-        self.loss_fn = nn.CrossEntropyLoss()
-        
-    def forward(self, x):
-        return self.model(x)
-    
-    def training_step(self, batch, batch_idx):
-        features, labels = batch
-        logits = self(features)
-        loss = self.loss_fn(logits, labels)
-        self.log('train_loss', loss)
-        return loss
-    
-    def validation_step(self, batch, batch_idx):
-        features, labels = batch
-        logits = self(features)
-        loss = self.loss_fn(logits, labels)
-        self.log('val_loss', loss)
-        return loss
-    
-    def configure_optimizers(self):
-        return Adam(self.parameters(), lr=self.learning_rate)
-
-
-class SimpleTextWrapper(BaseClassifierWrapper):
-    """Wrapper for simple text classifier that uses TF-IDF instead of tokenization."""
-    
-    def __init__(self, config: SimpleTextConfig):
-        super().__init__(config)
-        self.config: SimpleTextConfig = config
-        self.vectorizer: Optional[TfidfVectorizer] = None
-        
-    def prepare_text_features(self, training_text: np.ndarray) -> None:
-        """Prepare TF-IDF vectorizer instead of tokenizer."""
-        self.vectorizer = TfidfVectorizer(
-            max_features=self.config.max_features,
-            lowercase=True,
-            stop_words='english'
-        )
-        # Fit the vectorizer on training text
-        self.vectorizer.fit(training_text)
-    
-    def _build_pytorch_model(self) -> None:
-        """Build the PyTorch model."""
-        if self.vectorizer is None:
-            raise ValueError("Must call prepare_text_features first")
-        
-        input_dim = len(self.vectorizer.get_feature_names_out())
-        
-        self.pytorch_model = SimpleTextModel(
-            input_dim=input_dim,
-            hidden_dim=self.config.hidden_dim,
-            num_classes=self.config.num_classes,
-            dropout_rate=self.config.dropout_rate
-        )
-    
-    def _check_and_init_lightning(self, **kwargs) -> None:
-        """Initialize Lightning module."""
-        self.lightning_module = SimpleTextModule(
-            model=self.pytorch_model,
-            learning_rate=self.config.learning_rate
-        )
-    
-    def predict(self, X: np.ndarray, **kwargs) -> np.ndarray:
-        """Make predictions."""
-        if not self.trained:
-            raise Exception("Model must be trained first.")
-        
-        # Extract text from X (assuming first column is text)
-        text_data = X[:, 0] if X.ndim > 1 else X
-        
-        # Transform text to TF-IDF features
-        features = self.vectorizer.transform(text_data).toarray()
-        features_tensor = torch.FloatTensor(features)
-        
-        self.pytorch_model.eval()
-        with torch.no_grad():
-            logits = self.pytorch_model(features_tensor)
-            predictions = torch.argmax(logits, dim=1)
-        
-        return predictions.numpy()
-    
-    def validate(self, X: np.ndarray, Y: np.ndarray, **kwargs) -> float:
-        """Validate the model."""
-        predictions = self.predict(X)
-        accuracy = (predictions == Y).mean()
-        return float(accuracy)
-    
-    def create_dataset(self, texts: np.ndarray, labels: np.ndarray, categorical_variables: Optional[np.ndarray] = None):
-        """Create dataset."""
-        # Transform text to TF-IDF features
-        features = self.vectorizer.transform(texts).toarray()
-        return SimpleTextDataset(features, labels)
-    
-    def create_dataloader(self, dataset, batch_size: int, num_workers: int = 0, shuffle: bool = True):
-        """Create dataloader."""
-        return DataLoader(dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle)
-    
-    def load_best_model(self, checkpoint_path: str) -> None:
-        """Load best model from checkpoint."""
-        self.lightning_module = SimpleTextModule.load_from_checkpoint(
-            checkpoint_path,
-            model=self.pytorch_model,
-            learning_rate=self.config.learning_rate
-        )
-        self.pytorch_model = self.lightning_module.model
-        self.trained = True
-        self.pytorch_model.eval()
-    
-    @classmethod
-    def get_config_class(cls):
-        """Return the configuration class."""
-        return SimpleTextConfig

torchTextClassifiers/factories.py

@@ -1,34 +0,0 @@
-"""Generic factories for different classifier types."""
-
-from typing import Dict, Any, Optional, Type, Callable
-from .classifiers.base import BaseClassifierConfig
-
-# Registry of config factories for different classifier types
-CONFIG_FACTORIES: Dict[str, Callable[[dict], BaseClassifierConfig]] = {}
-
-
-def register_config_factory(classifier_type: str, factory_func: Callable[[dict], BaseClassifierConfig]):
-    """Register a config factory for a classifier type."""
-    CONFIG_FACTORIES[classifier_type] = factory_func
-
-
-def create_config_from_dict(classifier_type: str, config_dict: dict) -> BaseClassifierConfig:
-    """Create a config object from dictionary based on classifier type."""
-    if classifier_type not in CONFIG_FACTORIES:
-        raise ValueError(f"Unsupported classifier type: {classifier_type}")
-    
-    return CONFIG_FACTORIES[classifier_type](config_dict)
-
-
-# Register FastText factory
-def _register_fasttext_factory():
-    """Register FastText config factory."""
-    try:
-        from .classifiers.fasttext.core import FastTextFactory
-        register_config_factory("fasttext", FastTextFactory.from_dict)
-    except ImportError:
-        pass  # FastText module not available
-
-
-# Auto-register available factories
-_register_fasttext_factory()

torchTextClassifiers/utilities/checkers.py

@@ -1,108 +0,0 @@
-import logging
-import json
-from typing import Optional, Union, Type, List
-
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-
-def check_X(X):
-    assert isinstance(X, np.ndarray), (
-        "X must be a numpy array of shape (N,d), with the first column being the text and the rest being the categorical variables."
-    )
-
-    try:
-        if X.ndim > 1:
-            text = X[:, 0].astype(str)
-        else:
-            text = X[:].astype(str)
-    except ValueError:
-        logger.error("The first column of X must be castable in string format.")
-
-    if len(X.shape) == 1 or (len(X.shape) == 2 and X.shape[1] == 1):
-        no_cat_var = True
-    else:
-        no_cat_var = False
-
-    if not no_cat_var:
-        try:
-            categorical_variables = X[:, 1:].astype(int)
-        except ValueError:
-            logger.error(
-                f"Columns {1} to {X.shape[1] - 1} of X_train must be castable in integer format."
-            )
-    else:
-        categorical_variables = None
-
-    return text, categorical_variables, no_cat_var
-
-
-def check_Y(Y):
-    assert isinstance(Y, np.ndarray), "Y must be a numpy array of shape (N,) or (N,1)."
-    assert len(Y.shape) == 1 or (len(Y.shape) == 2 and Y.shape[1] == 1), (
-        "Y must be a numpy array of shape (N,) or (N,1)."
-    )
-
-    try:
-        Y = Y.astype(int)
-    except ValueError:
-        logger.error("Y must be castable in integer format.")
-
-    return Y
-
-
-def validate_categorical_inputs(
-    categorical_vocabulary_sizes: List[int],
-    categorical_embedding_dims: Union[List[int], int],
-    num_categorical_features: int = None,
-):
-    if categorical_vocabulary_sizes is None:
-        logger.warning("No categorical_vocabulary_sizes. It will be inferred later.")
-        return None, None, None
-
-    else:
-        if not isinstance(categorical_vocabulary_sizes, list):
-            raise TypeError("categorical_vocabulary_sizes must be a list of int")
-
-        if isinstance(categorical_embedding_dims, list):
-            if len(categorical_vocabulary_sizes) != len(categorical_embedding_dims):
-                raise ValueError(
-                    "Categorical vocabulary sizes and their embedding dimensions must have the same length"
-                )
-
-        if num_categorical_features is not None:
-            if len(categorical_vocabulary_sizes) != num_categorical_features:
-                raise ValueError(
-                    "len(categorical_vocabulary_sizes) must be equal to num_categorical_features"
-                )
-        else:
-            num_categorical_features = len(categorical_vocabulary_sizes)
-
-    assert num_categorical_features is not None, (
-        "num_categorical_features should be inferred at this point."
-    )
-
-    # "Transform" embedding dims into a suitable list, or stay None
-    if categorical_embedding_dims is not None:
-        if isinstance(categorical_embedding_dims, int):
-            categorical_embedding_dims = [categorical_embedding_dims] * num_categorical_features
-        elif not isinstance(categorical_embedding_dims, list):
-            raise TypeError("categorical_embedding_dims must be an int or a list of int")
-
-    assert isinstance(categorical_embedding_dims, list) or categorical_embedding_dims is None, (
-        "categorical_embedding_dims must be a list of int at this point"
-    )
-
-    return categorical_vocabulary_sizes, categorical_embedding_dims, num_categorical_features
-
-
-class NumpyJSONEncoder(json.JSONEncoder):
-    def default(self, obj):
-        if isinstance(obj, np.integer):
-            return int(obj)
-        if isinstance(obj, np.floating):
-            return float(obj)
-        if isinstance(obj, np.ndarray):
-            return obj.tolist()
-        return super().default(obj)

torchTextClassifiers/utilities/preprocess.py

@@ -1,82 +0,0 @@
-"""
-Processing fns.
-"""
-
-import string
-
-import numpy as np
-
-try:
-    import nltk
-    from nltk.corpus import stopwords as ntlk_stopwords
-    from nltk.stem.snowball import SnowballStemmer
-
-    HAS_NLTK = True
-except ImportError:
-    HAS_NLTK = False
-
-try:
-    import unidecode
-
-    HAS_UNIDECODE = True
-except ImportError:
-    HAS_UNIDECODE = False
-
-
-def clean_text_feature(text: list[str], remove_stop_words=True):
-    """
-    Cleans a text feature.
-
-    Args:
-        text (list[str]): List of text descriptions.
-        remove_stop_words (bool): If True, remove stopwords.
-
-    Returns:
-        list[str]: List of cleaned text descriptions.
-
-    """
-    if not HAS_NLTK:
-        raise ImportError(
-            "nltk is not installed and is required for preprocessing. Run 'pip install torchFastText[preprocess]'."
-        )
-    if not HAS_UNIDECODE:
-        raise ImportError(
-            "unidecode is not installed and is required for preprocessing. Run 'pip install torchFastText[preprocess]'."
-        )
-
-    # Define stopwords and stemmer
-
-    nltk.download("stopwords", quiet=True)
-    stopwords = tuple(ntlk_stopwords.words("french")) + tuple(string.ascii_lowercase)
-    stemmer = SnowballStemmer(language="french")
-
-    # Remove of accented characters
-    text = np.vectorize(unidecode.unidecode)(np.array(text))
-
-    # To lowercase
-    text = np.char.lower(text)
-
-    # Remove one letter words
-    def mylambda(x):
-        return " ".join([w for w in x.split() if len(w) > 1])
-
-    text = np.vectorize(mylambda)(text)
-
-    # Remove duplicate words and stopwords in texts
-    # Stem words
-    libs_token = [lib.split() for lib in text.tolist()]
-    libs_token = [
-        sorted(set(libs_token[i]), key=libs_token[i].index) for i in range(len(libs_token))
-    ]
-    if remove_stop_words:
-        text = [
-            " ".join([stemmer.stem(word) for word in libs_token[i] if word not in stopwords])
-            for i in range(len(libs_token))
-        ]
-    else:
-        text = [
-            " ".join([stemmer.stem(word) for word in libs_token[i]]) for i in range(len(libs_token))
-        ]
-
-    # Return clean DataFrame
-    return text