adamops 0.1.0__py3-none-any.whl

adamops/models/ensembles.py

@@ -0,0 +1,228 @@
+"""
+AdamOps Ensemble Models Module
+
+Provides voting, stacking, blending, and weighted averaging ensembles.
+"""
+
+from typing import Any, Dict, List, Optional, Tuple, Union
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import VotingClassifier, VotingRegressor, StackingClassifier, StackingRegressor
+from sklearn.linear_model import LogisticRegression, Ridge
+from sklearn.model_selection import cross_val_predict
+
+from adamops.utils.logging import get_logger
+from adamops.models.modelops import CLASSIFICATION_MODELS, REGRESSION_MODELS
+
+logger = get_logger(__name__)
+
+
+class VotingEnsemble:
+    """Voting ensemble for classification or regression."""
+    
+    def __init__(self, estimators: List[Tuple[str, Any]], voting: str = "soft",
+                 weights: Optional[List[float]] = None, task: str = "classification"):
+        self.estimators = estimators
+        self.voting = voting
+        self.weights = weights
+        self.task = task
+        
+        if task == "classification":
+            self.model = VotingClassifier(estimators, voting=voting, weights=weights)
+        else:
+            self.model = VotingRegressor(estimators, weights=weights)
+    
+    def fit(self, X, y):
+        self.model.fit(X, y)
+        return self
+    
+    def predict(self, X):
+        return self.model.predict(X)
+    
+    def predict_proba(self, X):
+        if self.task == "classification" and hasattr(self.model, "predict_proba"):
+            return self.model.predict_proba(X)
+        raise ValueError("Not available for regression")
+
+
+class StackingEnsemble:
+    """Stacking ensemble with meta-learner."""
+    
+    def __init__(self, estimators: List[Tuple[str, Any]], 
+                 final_estimator: Optional[Any] = None,
+                 task: str = "classification", cv: int = 5):
+        self.estimators = estimators
+        self.task = task
+        self.cv = cv
+        
+        if final_estimator is None:
+            final_estimator = LogisticRegression() if task == "classification" else Ridge()
+        
+        if task == "classification":
+            self.model = StackingClassifier(
+                estimators, final_estimator=final_estimator, cv=cv
+            )
+        else:
+            self.model = StackingRegressor(
+                estimators, final_estimator=final_estimator, cv=cv
+            )
+    
+    def fit(self, X, y):
+        self.model.fit(X, y)
+        return self
+    
+    def predict(self, X):
+        return self.model.predict(X)
+
+
+class BlendingEnsemble:
+    """Blending ensemble (holdout-based stacking)."""
+    
+    def __init__(self, estimators: List[Tuple[str, Any]],
+                 final_estimator: Optional[Any] = None,
+                 task: str = "classification", blend_ratio: float = 0.2):
+        self.estimators = estimators
+        self.task = task
+        self.blend_ratio = blend_ratio
+        self.final_estimator = final_estimator or (
+            LogisticRegression() if task == "classification" else Ridge()
+        )
+        self.fitted_estimators = []
+    
+    def fit(self, X, y):
+        from sklearn.model_selection import train_test_split
+        
+        # Split for blending
+        X_train, X_blend, y_train, y_blend = train_test_split(
+            X, y, test_size=self.blend_ratio, random_state=42
+        )
+        
+        # Fit base models and get blend predictions
+        blend_features = []
+        self.fitted_estimators = []
+        
+        for name, estimator in self.estimators:
+            estimator.fit(X_train, y_train)
+            self.fitted_estimators.append((name, estimator))
+            
+            if self.task == "classification" and hasattr(estimator, "predict_proba"):
+                preds = estimator.predict_proba(X_blend)[:, 1]
+            else:
+                preds = estimator.predict(X_blend)
+            blend_features.append(preds)
+        
+        # Stack blend predictions
+        blend_X = np.column_stack(blend_features)
+        
+        # Fit meta-learner
+        self.final_estimator.fit(blend_X, y_blend)
+        
+        return self
+    
+    def predict(self, X):
+        # Get predictions from base models
+        features = []
+        for name, estimator in self.fitted_estimators:
+            if self.task == "classification" and hasattr(estimator, "predict_proba"):
+                preds = estimator.predict_proba(X)[:, 1]
+            else:
+                preds = estimator.predict(X)
+            features.append(preds)
+        
+        meta_X = np.column_stack(features)
+        return self.final_estimator.predict(meta_X)
+
+
+class WeightedAverageEnsemble:
+    """Weighted average ensemble."""
+    
+    def __init__(self, estimators: List[Tuple[str, Any]], 
+                 weights: Optional[List[float]] = None,
+                 task: str = "classification"):
+        self.estimators = estimators
+        self.weights = weights or [1.0 / len(estimators)] * len(estimators)
+        self.task = task
+        self.fitted_estimators = []
+    
+    def fit(self, X, y):
+        self.fitted_estimators = []
+        for name, estimator in self.estimators:
+            estimator.fit(X, y)
+            self.fitted_estimators.append((name, estimator))
+        return self
+    
+    def predict(self, X):
+        predictions = []
+        for (name, estimator), weight in zip(self.fitted_estimators, self.weights):
+            pred = estimator.predict(X)
+            predictions.append(pred * weight)
+        
+        weighted_sum = sum(predictions)
+        
+        if self.task == "classification":
+            return (weighted_sum > 0.5).astype(int)
+        return weighted_sum
+    
+    def predict_proba(self, X):
+        if self.task != "classification":
+            raise ValueError("Not available for regression")
+        
+        probas = []
+        for (name, estimator), weight in zip(self.fitted_estimators, self.weights):
+            if hasattr(estimator, "predict_proba"):
+                probas.append(estimator.predict_proba(X) * weight)
+        
+        return sum(probas)
+
+
+def create_voting_ensemble(
+    algorithms: List[str], task: str = "classification",
+    voting: str = "soft", weights: Optional[List[float]] = None
+) -> VotingEnsemble:
+    """Create voting ensemble from algorithm names."""
+    models = CLASSIFICATION_MODELS if task == "classification" else REGRESSION_MODELS
+    estimators = [(alg, models[alg]()) for alg in algorithms if alg in models]
+    return VotingEnsemble(estimators, voting=voting, weights=weights, task=task)
+
+
+def create_stacking_ensemble(
+    algorithms: List[str], task: str = "classification",
+    final_estimator: Optional[Any] = None, cv: int = 5
+) -> StackingEnsemble:
+    """Create stacking ensemble from algorithm names."""
+    models = CLASSIFICATION_MODELS if task == "classification" else REGRESSION_MODELS
+    estimators = [(alg, models[alg]()) for alg in algorithms if alg in models]
+    return StackingEnsemble(estimators, final_estimator, task, cv)
+
+
+def auto_ensemble(
+    X, y, task: str = "classification", top_n: int = 3, cv: int = 5
+) -> Tuple[Any, Dict]:
+    """
+    Automatically select and create best ensemble.
+    
+    Returns:
+        (ensemble, results): Best ensemble and evaluation results.
+    """
+    from adamops.models.modelops import compare_models
+    
+    # Compare base models
+    comparison = compare_models(X, y, task, cv=cv)
+    top_algorithms = comparison.head(top_n)["algorithm"].tolist()
+    
+    logger.info(f"Selected top {top_n} algorithms: {top_algorithms}")
+    
+    # Create and evaluate ensembles
+    results = {}
+    
+    # Voting
+    voting = create_voting_ensemble(top_algorithms, task)
+    voting.fit(X, y)
+    results["voting"] = voting
+    
+    # Stacking
+    stacking = create_stacking_ensemble(top_algorithms, task, cv=cv)
+    stacking.fit(X, y)
+    results["stacking"] = stacking
+    
+    return stacking, {"algorithms": top_algorithms, "ensembles": list(results.keys())}

adamops/models/modelops.py

@@ -0,0 +1,308 @@
+"""
+AdamOps ModelOps Module
+
+Provides model training for regression, classification, and clustering.
+"""
+
+from typing import Any, Dict, List, Optional, Tuple, Union
+import numpy as np
+import pandas as pd
+import joblib
+from pathlib import Path
+
+from sklearn.linear_model import Ridge, Lasso, ElasticNet, LogisticRegression
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.ensemble import (
+    GradientBoostingClassifier, GradientBoostingRegressor,
+    RandomForestClassifier, RandomForestRegressor
+)
+from sklearn.naive_bayes import GaussianNB
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
+from sklearn.mixture import GaussianMixture
+
+try:
+    import xgboost as xgb
+    XGB_AVAILABLE = True
+except ImportError:
+    XGB_AVAILABLE = False
+
+try:
+    import lightgbm as lgb
+    LGB_AVAILABLE = True
+except ImportError:
+    LGB_AVAILABLE = False
+
+from adamops.utils.logging import get_logger
+from adamops.utils.helpers import infer_task_type
+
+logger = get_logger(__name__)
+
+
+# Model Registry
+REGRESSION_MODELS = {
+    "ridge": Ridge,
+    "lasso": Lasso,
+    "elasticnet": ElasticNet,
+    "decision_tree": DecisionTreeRegressor,
+    "random_forest": RandomForestRegressor,
+    "gradient_boosting": GradientBoostingRegressor,
+    "knn": KNeighborsRegressor,
+}
+
+CLASSIFICATION_MODELS = {
+    "logistic": LogisticRegression,
+    "decision_tree": DecisionTreeClassifier,
+    "random_forest": RandomForestClassifier,
+    "gradient_boosting": GradientBoostingClassifier,
+    "naive_bayes": GaussianNB,
+    "knn": KNeighborsClassifier,
+}
+
+CLUSTERING_MODELS = {
+    "kmeans": KMeans,
+    "dbscan": DBSCAN,
+    "hierarchical": AgglomerativeClustering,
+    "gmm": GaussianMixture,
+}
+
+# Add XGBoost if available
+if XGB_AVAILABLE:
+    REGRESSION_MODELS["xgboost"] = xgb.XGBRegressor
+    CLASSIFICATION_MODELS["xgboost"] = xgb.XGBClassifier
+
+# Add LightGBM if available
+if LGB_AVAILABLE:
+    REGRESSION_MODELS["lightgbm"] = lgb.LGBMRegressor
+    CLASSIFICATION_MODELS["lightgbm"] = lgb.LGBMClassifier
+
+
+class TrainedModel:
+    """Wrapper for trained models with metadata."""
+    
+    def __init__(self, model: Any, task: str, algorithm: str, params: Dict,
+                 feature_names: Optional[List[str]] = None):
+        self.model = model
+        self.task = task
+        self.algorithm = algorithm
+        self.params = params
+        self.feature_names = feature_names
+        self.is_fitted = True
+    
+    def predict(self, X: Union[pd.DataFrame, np.ndarray]) -> np.ndarray:
+        """Make predictions."""
+        return self.model.predict(X)
+    
+    def predict_proba(self, X: Union[pd.DataFrame, np.ndarray]) -> np.ndarray:
+        """Predict probabilities (classification only)."""
+        if hasattr(self.model, 'predict_proba'):
+            return self.model.predict_proba(X)
+        raise ValueError("Model does not support probability predictions")
+    
+    def save(self, filepath: Union[str, Path]) -> None:
+        """Save model to file."""
+        filepath = Path(filepath)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(self, filepath)
+        logger.info(f"Model saved to {filepath}")
+    
+    @classmethod
+    def load(cls, filepath: Union[str, Path]) -> "TrainedModel":
+        """Load model from file."""
+        return joblib.load(filepath)
+
+
+def get_available_models(task: str = "classification") -> List[str]:
+    """Get list of available models for a task."""
+    if task == "classification":
+        return list(CLASSIFICATION_MODELS.keys())
+    elif task == "regression":
+        return list(REGRESSION_MODELS.keys())
+    elif task == "clustering":
+        return list(CLUSTERING_MODELS.keys())
+    return []
+
+
+def train(
+    X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray],
+    task: str = "auto", algorithm: str = "random_forest",
+    params: Optional[Dict] = None, random_state: int = 42
+) -> TrainedModel:
+    """
+    Train a model.
+    
+    Args:
+        X: Features.
+        y: Target.
+        task: 'classification', 'regression', or 'auto'.
+        algorithm: Model algorithm name.
+        params: Model hyperparameters.
+        random_state: Random seed.
+    
+    Returns:
+        TrainedModel: Trained model wrapper.
+    """
+    # Auto-detect task type
+    if task == "auto":
+        task = infer_task_type(y)
+        logger.info(f"Auto-detected task: {task}")
+    
+    # Get model class
+    if task in ["classification", "multiclass"]:
+        if algorithm not in CLASSIFICATION_MODELS:
+            raise ValueError(f"Unknown classification algorithm: {algorithm}")
+        model_class = CLASSIFICATION_MODELS[algorithm]
+    elif task == "regression":
+        if algorithm not in REGRESSION_MODELS:
+            raise ValueError(f"Unknown regression algorithm: {algorithm}")
+        model_class = REGRESSION_MODELS[algorithm]
+    else:
+        raise ValueError(f"Unknown task: {task}")
+    
+    # Set default params
+    default_params = {"random_state": random_state}
+    if params:
+        default_params.update(params)
+    
+    # Filter params for model
+    import inspect
+    sig = inspect.signature(model_class)
+    valid_params = {k: v for k, v in default_params.items() if k in sig.parameters}
+    
+    # Create and train model
+    logger.info(f"Training {algorithm} for {task}")
+    model = model_class(**valid_params)
+    model.fit(X, y)
+    
+    feature_names = X.columns.tolist() if isinstance(X, pd.DataFrame) else None
+    
+    return TrainedModel(
+        model=model, task=task, algorithm=algorithm,
+        params=valid_params, feature_names=feature_names
+    )
+
+
+def train_regression(
+    X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray],
+    algorithm: str = "ridge", params: Optional[Dict] = None
+) -> TrainedModel:
+    """Train a regression model."""
+    return train(X, y, task="regression", algorithm=algorithm, params=params)
+
+
+def train_classification(
+    X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray],
+    algorithm: str = "random_forest", params: Optional[Dict] = None
+) -> TrainedModel:
+    """Train a classification model."""
+    return train(X, y, task="classification", algorithm=algorithm, params=params)
+
+
+def train_clustering(
+    X: Union[pd.DataFrame, np.ndarray], algorithm: str = "kmeans",
+    n_clusters: int = 3, params: Optional[Dict] = None
+) -> Tuple[Any, np.ndarray]:
+    """
+    Train a clustering model.
+    
+    Returns:
+        (model, labels): Fitted model and cluster labels.
+    """
+    if algorithm not in CLUSTERING_MODELS:
+        raise ValueError(f"Unknown clustering algorithm: {algorithm}")
+    
+    model_class = CLUSTERING_MODELS[algorithm]
+    default_params = {}
+    
+    # Set n_clusters for algorithms that support it
+    if algorithm in ["kmeans", "hierarchical"]:
+        default_params["n_clusters"] = n_clusters
+    elif algorithm == "gmm":
+        default_params["n_components"] = n_clusters
+    
+    if params:
+        default_params.update(params)
+    
+    logger.info(f"Training {algorithm} clustering")
+    model = model_class(**default_params)
+    
+    if algorithm == "gmm":
+        model.fit(X)
+        labels = model.predict(X)
+    else:
+        labels = model.fit_predict(X)
+    
+    return model, labels
+
+
+def cross_validate(
+    X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray],
+    task: str = "classification", algorithm: str = "random_forest",
+    cv: int = 5, scoring: Optional[str] = None, params: Optional[Dict] = None
+) -> Dict[str, Any]:
+    """
+    Cross-validate a model.
+    
+    Returns:
+        Dict with train_scores, test_scores, and mean/std values.
+    """
+    from sklearn.model_selection import cross_validate as sklearn_cv
+    
+    # Get model
+    if task == "classification":
+        model = CLASSIFICATION_MODELS[algorithm]()
+    else:
+        model = REGRESSION_MODELS[algorithm]()
+    
+    if params:
+        model.set_params(**params)
+    
+    if scoring is None:
+        scoring = "accuracy" if task == "classification" else "r2"
+    
+    logger.info(f"Cross-validating {algorithm} with {cv} folds")
+    
+    results = sklearn_cv(model, X, y, cv=cv, scoring=scoring, return_train_score=True)
+    
+    return {
+        "train_scores": results["train_score"].tolist(),
+        "test_scores": results["test_score"].tolist(),
+        "train_mean": float(results["train_score"].mean()),
+        "train_std": float(results["train_score"].std()),
+        "test_mean": float(results["test_score"].mean()),
+        "test_std": float(results["test_score"].std()),
+        "fit_time": float(results["fit_time"].mean()),
+    }
+
+
+def compare_models(
+    X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray],
+    task: str = "classification", algorithms: Optional[List[str]] = None,
+    cv: int = 5, scoring: Optional[str] = None
+) -> pd.DataFrame:
+    """
+    Compare multiple models.
+    
+    Returns:
+        DataFrame with model comparison results.
+    """
+    if algorithms is None:
+        algorithms = list(CLASSIFICATION_MODELS.keys()) if task == "classification" \
+            else list(REGRESSION_MODELS.keys())
+    
+    results = []
+    for algo in algorithms:
+        try:
+            cv_results = cross_validate(X, y, task, algo, cv, scoring)
+            results.append({
+                "algorithm": algo,
+                "cv_mean": cv_results["test_mean"],
+                "cv_std": cv_results["test_std"],
+                "train_mean": cv_results["train_mean"],
+                "fit_time": cv_results["fit_time"],
+            })
+        except Exception as e:
+            logger.warning(f"Failed to train {algo}: {e}")
+    
+    df = pd.DataFrame(results).sort_values("cv_mean", ascending=False)
+    return df