src/classical_classifiers.py

from typing import Dict, Any, Optional, Union, Tuple
import numpy as np
import pandas as pd
from sklearn.base import BaseEstimator, ClassifierMixin
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, BaggingClassifier, VotingClassifier, StackingClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
from sklearn.preprocessing import LabelEncoder

XGBClassifier = None
CatBoostClassifier = None
LGBMClassifier = None

try:
    from xgboost import XGBClassifier
except ImportError:
    pass

try:
    from catboost import CatBoostClassifier
except ImportError:
    pass

try:
    from lightgbm import LGBMClassifier
except ImportError:
    pass


def get_logistic_regression(

    penalty: str = "l2",

    C: float = 1.0,

    max_iter: int = 1000,

    solver: str = "liblinear",  # supports l1

    random_state: int = 42

) -> LogisticRegression:
    if penalty not in ("l1", "l2", "elasticnet", "none"):
        raise ValueError("penalty must be 'l1', 'l2', 'elasticnet', or 'none'")
    if penalty == "l1" and solver not in ("liblinear", "saga"):
        solver = "liblinear"
    return LogisticRegression(
        penalty=penalty,
        C=C,
        max_iter=max_iter,
        solver=solver,
        random_state=random_state
    )


def get_svm_linear(C: float = 1.0, random_state: int = 42) -> SVC:
    return SVC(kernel="linear", C=C, probability=True, random_state=random_state)


def get_random_forest(

    n_estimators: int = 100,

    max_depth: Optional[int] = None,

    random_state: int = 42

) -> RandomForestClassifier:
    return RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        random_state=random_state
    )


def get_gradient_boosting(

    model_type: str = "xgb",

    **kwargs

) -> Union[XGBClassifier, "CatBoostClassifier", "LGBMClassifier"]:
    if model_type == "xgb":
        if XGBClassifier is None:
            raise ImportError("XGBoost not installed. Run: pip install xgboost")
        kwargs.setdefault("random_state", 42)
        return XGBClassifier(**kwargs)
    elif model_type == "cat":
        if CatBoostClassifier is None:
            raise ImportError("CatBoost not installed. Run: pip install catboost")
        kwargs.setdefault("verbose", False)
        kwargs.setdefault("random_seed", 42)
        return CatBoostClassifier(**kwargs)
    elif model_type == "lgb":
        if LGBMClassifier is None:
            raise ImportError("LightGBM not installed. Run: pip install lightgbm")
        kwargs.setdefault("random_state", 42)
        return LGBMClassifier(**kwargs)
    else:
        raise ValueError("model_type must be 'xgb', 'cat', or 'lgb'")


def get_bagging_classifier(

    base_estimator: str = "tree",

    n_estimators: int = 10,

    random_state: int = 42

) -> BaggingClassifier:
    if base_estimator == "tree":
        from sklearn.tree import DecisionTreeClassifier
        estimator = DecisionTreeClassifier(random_state=random_state)
    elif base_estimator == "lr":
        estimator = get_logistic_regression()
    else:
        raise ValueError("base_estimator must be 'tree' or 'lr'")
    return BaggingClassifier(
        estimator=estimator,
        n_estimators=n_estimators,
        random_state=random_state
    )


def get_stacking_classifier(

    final_estimator: Optional[BaseEstimator] = None,

    cv: int = 5,

    random_state: int = 42

) -> StackingClassifier:
    estimators = [
        ("lr", get_logistic_regression()),
        ("svm", get_svm_linear()),
    ]
    if CatBoostClassifier is not None:
        estimators.append(("cat", get_gradient_boosting("cat", iterations=100)))

    if final_estimator is None:
        final_estimator = get_logistic_regression()

    return StackingClassifier(
        estimators=estimators,
        final_estimator=final_estimator,
        cv=cv,
        passthrough=False
    )


def get_voting_classifier(

    voting: str = "soft",

    use_catboost: bool = True

) -> VotingClassifier:
    clfs = [
        ("lr", get_logistic_regression()),
        ("svm", get_svm_linear()),
        ("rf", get_random_forest(n_estimators=50))
    ]
    if use_catboost and CatBoostClassifier is not None:
        clfs.append(("cat", get_gradient_boosting("cat", iterations=50, verbose=False)))

    return VotingClassifier(
        estimators=clfs,
        voting=voting
    )


def tpot_classifier(

    generations: int = 5,

    population_size: int = 20,

    cv: int = 5,

    random_state: int = 42,

    verbosity: int = 0

) -> Any:
    try:
        from tpot import TPOTClassifier
    except ImportError:
        raise ImportError("TPOT not installed. Run: pip install tpot")

    return TPOTClassifier(
        generations=generations,
        population_size=population_size,
        cv=cv,
        random_state=random_state,
        verbosity=verbosity,
        n_jobs=-1
    )


def h2o_classifier(

    max_runtime_secs: int = 300,

    seed: int = 42,

    exclude_algos: Optional[list] = None

) -> Any:
    try:
        import h2o
        from h2o.automl import H2OAutoML
    except ImportError:
        raise ImportError("H2O not installed. Run: pip install h2o")

    aml = H2OAutoML(
        max_runtime_secs=max_runtime_secs,
        seed=seed,
        exclude_algos=exclude_algos
    )
    return aml


def train_and_evaluate(

    model: Union[BaseEstimator, Any],

    X_train: Union[np.ndarray, pd.DataFrame],

    y_train: Union[np.ndarray, pd.Series],

    X_test: Union[np.ndarray, pd.DataFrame],

    y_test: Union[np.ndarray, pd.Series],

    is_h2o: bool = False

) -> Dict[str, Any]:
    if is_h2o:
        import h2o
        train_frame = X_train.cbind(y_train)
        test_frame = X_test.cbind(y_test)
        y_col = y_train.columns[0]

        model.train(x=X_train.columns.tolist(), y=y_col, training_frame=train_frame)
        perf = model.model_performance(test_frame)
        return {
            "accuracy": perf.accuracy()[0],
            "auc": perf.auc() if perf._has_auc() else None,
            "best_model": model.leader
        }
    else:
        model.fit(X_train, y_train)
        y_pred = model.predict(X_test)
        return {
            "accuracy": accuracy_score(y_test, y_pred),
            "report": classification_report(y_test, y_pred, output_dict=True),
            "model": model
        }