adamops 0.1.0__py3-none-any.whl

adamops/deployment/exporters.py

@@ -0,0 +1,148 @@
+"""
+AdamOps Model Exporters Module
+
+Export models to ONNX, PMML, and other formats.
+"""
+
+from typing import Any, Dict, List, Optional, Tuple
+from pathlib import Path
+import joblib
+import pickle
+
+from adamops.utils.logging import get_logger
+from adamops.utils.helpers import ensure_dir
+
+logger = get_logger(__name__)
+
+
+def export_pickle(model: Any, filepath: str) -> str:
+    """Export model as pickle file."""
+    filepath = Path(filepath)
+    ensure_dir(filepath.parent)
+    
+    with open(filepath, 'wb') as f:
+        pickle.dump(model, f)
+    
+    logger.info(f"Exported model to {filepath}")
+    return str(filepath)
+
+
+def export_joblib(model: Any, filepath: str, compress: int = 3) -> str:
+    """Export model using joblib (better for large arrays)."""
+    filepath = Path(filepath)
+    ensure_dir(filepath.parent)
+    
+    joblib.dump(model, filepath, compress=compress)
+    logger.info(f"Exported model to {filepath}")
+    return str(filepath)
+
+
+def export_onnx(
+    model: Any, filepath: str, 
+    initial_types: Optional[List[Tuple[str, Any]]] = None,
+    n_features: Optional[int] = None
+) -> str:
+    """
+    Export sklearn model to ONNX format.
+    
+    Args:
+        model: Sklearn model.
+        filepath: Output path.
+        initial_types: Input type specification.
+        n_features: Number of input features.
+    """
+    try:
+        import onnx
+        from skl2onnx import convert_sklearn
+        from skl2onnx.common.data_types import FloatTensorType
+    except ImportError:
+        raise ImportError("onnx and skl2onnx required. Install with: pip install onnx skl2onnx")
+    
+    filepath = Path(filepath)
+    ensure_dir(filepath.parent)
+    
+    if initial_types is None:
+        if n_features is None:
+            raise ValueError("Either initial_types or n_features must be provided")
+        initial_types = [('input', FloatTensorType([None, n_features]))]
+    
+    onnx_model = convert_sklearn(model, initial_types=initial_types)
+    
+    with open(filepath, 'wb') as f:
+        f.write(onnx_model.SerializeToString())
+    
+    logger.info(f"Exported ONNX model to {filepath}")
+    return str(filepath)
+
+
+def export_pmml(model: Any, filepath: str, feature_names: Optional[List[str]] = None) -> str:
+    """Export model to PMML format."""
+    try:
+        from sklearn2pmml import sklearn2pmml
+        from sklearn2pmml.pipeline import PMMLPipeline
+    except ImportError:
+        raise ImportError("sklearn2pmml required. Install with: pip install sklearn2pmml")
+    
+    filepath = Path(filepath)
+    ensure_dir(filepath.parent)
+    
+    pipeline = PMMLPipeline([("model", model)])
+    sklearn2pmml(pipeline, str(filepath))
+    
+    logger.info(f"Exported PMML model to {filepath}")
+    return str(filepath)
+
+
+def load_model(filepath: str, format: str = "auto") -> Any:
+    """
+    Load a saved model.
+    
+    Args:
+        filepath: Model file path.
+        format: 'pickle', 'joblib', 'onnx', or 'auto'.
+    """
+    filepath = Path(filepath)
+    
+    if format == "auto":
+        suffix = filepath.suffix.lower()
+        if suffix in ['.pkl', '.pickle']:
+            format = "pickle"
+        elif suffix in ['.joblib']:
+            format = "joblib"
+        elif suffix == '.onnx':
+            format = "onnx"
+        else:
+            format = "joblib"  # Default
+    
+    if format == "pickle":
+        with open(filepath, 'rb') as f:
+            return pickle.load(f)
+    elif format == "joblib":
+        return joblib.load(filepath)
+    elif format == "onnx":
+        import onnxruntime as ort
+        return ort.InferenceSession(str(filepath))
+    else:
+        raise ValueError(f"Unknown format: {format}")
+
+
+def export(model: Any, filepath: str, format: str = "joblib", **kwargs) -> str:
+    """
+    Export model to specified format.
+    
+    Args:
+        model: Model to export.
+        filepath: Output path.
+        format: 'pickle', 'joblib', 'onnx', 'pmml'.
+    """
+    exporters = {
+        "pickle": export_pickle,
+        "joblib": export_joblib,
+        "onnx": export_onnx,
+        "pmml": export_pmml,
+    }
+    
+    if format not in exporters:
+        raise ValueError(f"Unknown format: {format}. Available: {list(exporters.keys())}")
+    
+    return exporters[format](model, filepath, **kwargs)

adamops/evaluation/__init__.py

@@ -0,0 +1,24 @@
+"""
+AdamOps Evaluation Module
+
+Provides model evaluation capabilities:
+- metrics: Compute classification, regression, and clustering metrics
+- visualization: Plot confusion matrices, ROC curves, feature importance
+- explainability: SHAP and LIME explanations
+- comparison: Compare multiple models
+- reports: Generate HTML/PDF reports
+"""
+
+from adamops.evaluation import metrics
+from adamops.evaluation import visualization
+from adamops.evaluation import explainability
+from adamops.evaluation import comparison
+from adamops.evaluation import reports
+
+__all__ = [
+    "metrics",
+    "visualization",
+    "explainability",
+    "comparison",
+    "reports",
+]

adamops/evaluation/comparison.py

@@ -0,0 +1,133 @@
+"""
+AdamOps Model Comparison Module
+
+Provides tools to compare multiple models.
+"""
+
+from typing import Any, Dict, List, Optional
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import cross_val_score
+
+from adamops.utils.logging import get_logger
+from adamops.evaluation.metrics import evaluate
+
+logger = get_logger(__name__)
+
+
+def compare_models(
+    models: Dict[str, Any], X_test: np.ndarray, y_test: np.ndarray,
+    task: str = "classification"
+) -> pd.DataFrame:
+    """
+    Compare multiple models on test data.
+    
+    Args:
+        models: Dict mapping model names to fitted models.
+        X_test: Test features.
+        y_test: Test labels.
+        task: 'classification' or 'regression'.
+    
+    Returns:
+        DataFrame with comparison results.
+    """
+    results = []
+    
+    for name, model in models.items():
+        y_pred = model.predict(X_test)
+        y_prob = None
+        
+        if hasattr(model, 'predict_proba') and task == "classification":
+            try:
+                y_prob = model.predict_proba(X_test)
+            except:
+                pass
+        
+        metrics = evaluate(y_test, y_pred, task, y_prob)
+        metrics['model'] = name
+        results.append(metrics)
+    
+    df = pd.DataFrame(results)
+    cols = ['model'] + [c for c in df.columns if c != 'model']
+    return df[cols]
+
+
+def compare_cv(
+    models: Dict[str, Any], X: np.ndarray, y: np.ndarray,
+    cv: int = 5, scoring: Optional[str] = None
+) -> pd.DataFrame:
+    """
+    Compare models using cross-validation.
+    
+    Returns:
+        DataFrame with CV scores for each model.
+    """
+    results = []
+    
+    for name, model in models.items():
+        scores = cross_val_score(model, X, y, cv=cv, scoring=scoring)
+        results.append({
+            'model': name,
+            'cv_mean': scores.mean(),
+            'cv_std': scores.std(),
+            'cv_min': scores.min(),
+            'cv_max': scores.max(),
+        })
+    
+    return pd.DataFrame(results).sort_values('cv_mean', ascending=False)
+
+
+def rank_models(comparison_df: pd.DataFrame, metrics: List[str], 
+                ascending: Optional[List[bool]] = None) -> pd.DataFrame:
+    """
+    Rank models by multiple metrics.
+    
+    Args:
+        comparison_df: Comparison DataFrame.
+        metrics: Metrics to rank by.
+        ascending: Whether each metric should be ascending (lower is better).
+    
+    Returns:
+        DataFrame with rankings.
+    """
+    df = comparison_df.copy()
+    
+    if ascending is None:
+        ascending = [False] * len(metrics)
+    
+    for metric, asc in zip(metrics, ascending):
+        df[f'{metric}_rank'] = df[metric].rank(ascending=asc)
+    
+    rank_cols = [f'{m}_rank' for m in metrics]
+    df['avg_rank'] = df[rank_cols].mean(axis=1)
+    
+    return df.sort_values('avg_rank')
+
+
+def statistical_test(
+    scores_a: np.ndarray, scores_b: np.ndarray, 
+    test: str = "wilcoxon"
+) -> Dict[str, float]:
+    """
+    Perform statistical test between two sets of scores.
+    
+    Args:
+        scores_a: Scores for model A.
+        scores_b: Scores for model B.
+        test: 'wilcoxon', 'ttest', or 'mannwhitney'.
+    
+    Returns:
+        Dict with statistic and p-value.
+    """
+    from scipy import stats
+    
+    if test == "wilcoxon":
+        stat, pval = stats.wilcoxon(scores_a, scores_b)
+    elif test == "ttest":
+        stat, pval = stats.ttest_rel(scores_a, scores_b)
+    elif test == "mannwhitney":
+        stat, pval = stats.mannwhitneyu(scores_a, scores_b)
+    else:
+        raise ValueError(f"Unknown test: {test}")
+    
+    return {"statistic": stat, "p_value": pval, "significant": pval < 0.05}

adamops/evaluation/explainability.py

@@ -0,0 +1,143 @@
+"""
+AdamOps Explainability Module
+
+Provides SHAP and LIME model explanations.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+import numpy as np
+import pandas as pd
+from adamops.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+try:
+    import shap
+    SHAP_AVAILABLE = True
+except ImportError:
+    SHAP_AVAILABLE = False
+
+try:
+    import lime
+    import lime.lime_tabular
+    LIME_AVAILABLE = True
+except ImportError:
+    LIME_AVAILABLE = False
+
+
+class ShapExplainer:
+    """SHAP-based model explainer."""
+    
+    def __init__(self, model: Any, X: Union[pd.DataFrame, np.ndarray],
+                 feature_names: Optional[List[str]] = None):
+        if not SHAP_AVAILABLE:
+            raise ImportError("SHAP required. Install with: pip install shap")
+        
+        self.model = model
+        self.X = X
+        self.feature_names = feature_names or (
+            X.columns.tolist() if isinstance(X, pd.DataFrame) else None
+        )
+        
+        # Auto-select explainer type
+        model_type = type(model).__name__.lower()
+        if 'tree' in model_type or 'forest' in model_type or 'xgb' in model_type or 'lgb' in model_type:
+            self.explainer = shap.TreeExplainer(model)
+        else:
+            background = shap.sample(X, min(100, len(X)))
+            self.explainer = shap.KernelExplainer(model.predict, background)
+    
+    def explain(self, X: Optional[np.ndarray] = None) -> Any:
+        """Generate SHAP values."""
+        X = X if X is not None else self.X[:100]
+        return self.explainer(X)
+    
+    def plot_summary(self, X: Optional[np.ndarray] = None, max_display: int = 20):
+        """Plot SHAP summary."""
+        shap_values = self.explain(X)
+        shap.summary_plot(shap_values, feature_names=self.feature_names, max_display=max_display)
+    
+    def plot_waterfall(self, idx: int = 0, X: Optional[np.ndarray] = None):
+        """Plot waterfall for single prediction."""
+        shap_values = self.explain(X)
+        shap.waterfall_plot(shap_values[idx])
+    
+    def plot_force(self, idx: int = 0, X: Optional[np.ndarray] = None):
+        """Plot force plot for single prediction."""
+        shap_values = self.explain(X)
+        shap.force_plot(shap_values[idx])
+    
+    def get_feature_importance(self, X: Optional[np.ndarray] = None) -> pd.DataFrame:
+        """Get feature importance from SHAP values."""
+        shap_values = self.explain(X)
+        importance = np.abs(shap_values.values).mean(axis=0)
+        
+        return pd.DataFrame({
+            'feature': self.feature_names or [f'f{i}' for i in range(len(importance))],
+            'importance': importance
+        }).sort_values('importance', ascending=False)
+
+
+class LimeExplainer:
+    """LIME-based model explainer."""
+    
+    def __init__(self, model: Any, X_train: Union[pd.DataFrame, np.ndarray],
+                 feature_names: Optional[List[str]] = None,
+                 mode: str = "classification"):
+        if not LIME_AVAILABLE:
+            raise ImportError("LIME required. Install with: pip install lime")
+        
+        self.model = model
+        self.mode = mode
+        
+        if isinstance(X_train, pd.DataFrame):
+            feature_names = feature_names or X_train.columns.tolist()
+            X_train = X_train.values
+        
+        self.explainer = lime.lime_tabular.LimeTabularExplainer(
+            X_train, feature_names=feature_names, mode=mode, discretize_continuous=True
+        )
+    
+    def explain(self, instance: np.ndarray, num_features: int = 10):
+        """Explain a single prediction."""
+        if self.mode == "classification":
+            return self.explainer.explain_instance(
+                instance, self.model.predict_proba, num_features=num_features
+            )
+        else:
+            return self.explainer.explain_instance(
+                instance, self.model.predict, num_features=num_features
+            )
+    
+    def explain_multiple(self, X: np.ndarray, num_features: int = 10) -> List:
+        """Explain multiple instances."""
+        return [self.explain(x, num_features) for x in X]
+
+
+def explain_shap(model: Any, X: Union[pd.DataFrame, np.ndarray], **kwargs) -> ShapExplainer:
+    """Create SHAP explainer."""
+    return ShapExplainer(model, X, **kwargs)
+
+
+def explain_lime(model: Any, X_train: Union[pd.DataFrame, np.ndarray], **kwargs) -> LimeExplainer:
+    """Create LIME explainer."""
+    return LimeExplainer(model, X_train, **kwargs)
+
+
+def get_feature_importance(model: Any, feature_names: Optional[List[str]] = None) -> pd.DataFrame:
+    """Get feature importance from model."""
+    importance = None
+    
+    if hasattr(model, 'feature_importances_'):
+        importance = model.feature_importances_
+    elif hasattr(model, 'coef_'):
+        importance = np.abs(model.coef_).flatten()
+    
+    if importance is None:
+        raise ValueError("Model does not have feature_importances_ or coef_")
+    
+    names = feature_names or [f'feature_{i}' for i in range(len(importance))]
+    
+    return pd.DataFrame({
+        'feature': names, 'importance': importance
+    }).sort_values('importance', ascending=False)

adamops/evaluation/metrics.py

@@ -0,0 +1,233 @@
+"""
+AdamOps Evaluation Metrics Module
+
+Provides classification, regression, and clustering metrics.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+import numpy as np
+import pandas as pd
+from sklearn import metrics as sklearn_metrics
+
+from adamops.utils.logging import get_logger
+from adamops.utils.helpers import infer_task_type
+
+logger = get_logger(__name__)
+
+
+# =============================================================================
+# Classification Metrics
+# =============================================================================
+
+def classification_metrics(
+    y_true: np.ndarray, y_pred: np.ndarray, 
+    y_prob: Optional[np.ndarray] = None, average: str = "weighted"
+) -> Dict[str, float]:
+    """
+    Compute classification metrics.
+    
+    Args:
+        y_true: True labels.
+        y_pred: Predicted labels.
+        y_prob: Probability predictions (for ROC-AUC).
+        average: Averaging method for multiclass.
+    
+    Returns:
+        Dict with accuracy, precision, recall, f1, etc.
+    """
+    results = {
+        "accuracy": sklearn_metrics.accuracy_score(y_true, y_pred),
+        "precision": sklearn_metrics.precision_score(y_true, y_pred, average=average, zero_division=0),
+        "recall": sklearn_metrics.recall_score(y_true, y_pred, average=average, zero_division=0),
+        "f1": sklearn_metrics.f1_score(y_true, y_pred, average=average, zero_division=0),
+    }
+    
+    # Binary classification specific
+    unique_classes = np.unique(y_true)
+    if len(unique_classes) == 2:
+        results["mcc"] = sklearn_metrics.matthews_corrcoef(y_true, y_pred)
+        
+        if y_prob is not None:
+            if y_prob.ndim == 2:
+                y_prob = y_prob[:, 1]
+            results["roc_auc"] = sklearn_metrics.roc_auc_score(y_true, y_prob)
+            results["pr_auc"] = sklearn_metrics.average_precision_score(y_true, y_prob)
+    
+    # Multiclass with probabilities
+    elif y_prob is not None and len(unique_classes) > 2:
+        try:
+            results["roc_auc_ovr"] = sklearn_metrics.roc_auc_score(
+                y_true, y_prob, multi_class="ovr", average=average
+            )
+        except ValueError:
+            pass
+    
+    return results
+
+
+def confusion_matrix(
+    y_true: np.ndarray, y_pred: np.ndarray, labels: Optional[List] = None
+) -> np.ndarray:
+    """Compute confusion matrix."""
+    return sklearn_metrics.confusion_matrix(y_true, y_pred, labels=labels)
+
+
+def classification_report(
+    y_true: np.ndarray, y_pred: np.ndarray, 
+    target_names: Optional[List[str]] = None, output_dict: bool = True
+) -> Union[str, Dict]:
+    """Generate classification report."""
+    return sklearn_metrics.classification_report(
+        y_true, y_pred, target_names=target_names, output_dict=output_dict
+    )
+
+
+# =============================================================================
+# Regression Metrics
+# =============================================================================
+
+def regression_metrics(y_true: np.ndarray, y_pred: np.ndarray) -> Dict[str, float]:
+    """
+    Compute regression metrics.
+    
+    Returns:
+        Dict with mse, rmse, mae, r2, mape, etc.
+    """
+    mse = sklearn_metrics.mean_squared_error(y_true, y_pred)
+    
+    results = {
+        "mse": mse,
+        "rmse": np.sqrt(mse),
+        "mae": sklearn_metrics.mean_absolute_error(y_true, y_pred),
+        "r2": sklearn_metrics.r2_score(y_true, y_pred),
+        "explained_variance": sklearn_metrics.explained_variance_score(y_true, y_pred),
+    }
+    
+    # MAPE (avoid division by zero)
+    mask = y_true != 0
+    if mask.any():
+        mape = np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])) * 100
+        results["mape"] = mape
+    
+    # SMAPE
+    denom = np.abs(y_true) + np.abs(y_pred)
+    mask = denom != 0
+    if mask.any():
+        smape = np.mean(2 * np.abs(y_true[mask] - y_pred[mask]) / denom[mask]) * 100
+        results["smape"] = smape
+    
+    # Adjusted R2
+    n = len(y_true)
+    p = 1  # Assumes 1 feature, should be passed in for accuracy
+    if n > p + 1:
+        results["adjusted_r2"] = 1 - (1 - results["r2"]) * (n - 1) / (n - p - 1)
+    
+    return results
+
+
+# =============================================================================
+# Clustering Metrics
+# =============================================================================
+
+def clustering_metrics(
+    X: np.ndarray, labels: np.ndarray, 
+    y_true: Optional[np.ndarray] = None
+) -> Dict[str, float]:
+    """
+    Compute clustering metrics.
+    
+    Args:
+        X: Feature data.
+        labels: Cluster labels.
+        y_true: True labels (if available).
+    
+    Returns:
+        Dict with silhouette, davies_bouldin, calinski_harabasz, etc.
+    """
+    results = {}
+    
+    # Internal metrics (don't need ground truth)
+    n_labels = len(np.unique(labels))
+    if n_labels > 1 and n_labels < len(X):
+        results["silhouette"] = sklearn_metrics.silhouette_score(X, labels)
+        results["davies_bouldin"] = sklearn_metrics.davies_bouldin_score(X, labels)
+        results["calinski_harabasz"] = sklearn_metrics.calinski_harabasz_score(X, labels)
+    
+    # External metrics (need ground truth)
+    if y_true is not None:
+        results["adjusted_rand"] = sklearn_metrics.adjusted_rand_score(y_true, labels)
+        results["normalized_mutual_info"] = sklearn_metrics.normalized_mutual_info_score(y_true, labels)
+        results["homogeneity"] = sklearn_metrics.homogeneity_score(y_true, labels)
+        results["completeness"] = sklearn_metrics.completeness_score(y_true, labels)
+        results["v_measure"] = sklearn_metrics.v_measure_score(y_true, labels)
+    
+    return results
+
+
+# =============================================================================
+# Unified Evaluation Interface
+# =============================================================================
+
+def evaluate(
+    y_true: np.ndarray, y_pred: np.ndarray,
+    task: str = "auto", y_prob: Optional[np.ndarray] = None,
+    X: Optional[np.ndarray] = None
+) -> Dict[str, float]:
+    """
+    Unified evaluation function.
+    
+    Args:
+        y_true: True values/labels.
+        y_pred: Predicted values/labels.
+        task: 'classification', 'regression', 'clustering', or 'auto'.
+        y_prob: Probability predictions.
+        X: Feature data (for clustering).
+    
+    Returns:
+        Dict with relevant metrics.
+    """
+    if task == "auto":
+        task = infer_task_type(y_true)
+    
+    if task in ["classification", "multiclass"]:
+        return classification_metrics(y_true, y_pred, y_prob)
+    elif task == "regression":
+        return regression_metrics(y_true, y_pred)
+    elif task == "clustering":
+        if X is None:
+            raise ValueError("X required for clustering metrics")
+        return clustering_metrics(X, y_pred, y_true)
+    else:
+        raise ValueError(f"Unknown task: {task}")
+
+
+def evaluate_model(
+    model: Any, X_test: np.ndarray, y_test: np.ndarray,
+    task: str = "auto"
+) -> Dict[str, float]:
+    """Evaluate a model on test data."""
+    y_pred = model.predict(X_test)
+    y_prob = None
+    
+    if hasattr(model, "predict_proba"):
+        try:
+            y_prob = model.predict_proba(X_test)
+        except:
+            pass
+    
+    return evaluate(y_test, y_pred, task, y_prob)
+
+
+def results_to_dataframe(results: Dict[str, float]) -> pd.DataFrame:
+    """Convert results dict to DataFrame."""
+    return pd.DataFrame([results]).T.reset_index().rename(
+        columns={"index": "metric", 0: "value"}
+    )
+
+
+def compare_results(
+    results_list: List[Dict[str, float]], names: List[str]
+) -> pd.DataFrame:
+    """Compare multiple evaluation results."""
+    data = {name: results for name, results in zip(names, results_list)}
+    return pd.DataFrame(data).T