PyPI - adamops - Versions diffs - 0.1.0__py3-none-any.whl - Mend

adamops 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

adamops/__init__.py +40 -0
adamops/cli.py +163 -0
adamops/data/__init__.py +24 -0
adamops/data/feature_engineering.py +284 -0
adamops/data/loaders.py +922 -0
adamops/data/preprocessors.py +227 -0
adamops/data/splitters.py +218 -0
adamops/data/validators.py +148 -0
adamops/deployment/__init__.py +21 -0
adamops/deployment/api.py +237 -0
adamops/deployment/cloud.py +191 -0
adamops/deployment/containerize.py +262 -0
adamops/deployment/exporters.py +148 -0
adamops/evaluation/__init__.py +24 -0
adamops/evaluation/comparison.py +133 -0
adamops/evaluation/explainability.py +143 -0
adamops/evaluation/metrics.py +233 -0
adamops/evaluation/reports.py +165 -0
adamops/evaluation/visualization.py +238 -0
adamops/models/__init__.py +21 -0
adamops/models/automl.py +277 -0
adamops/models/ensembles.py +228 -0
adamops/models/modelops.py +308 -0
adamops/models/registry.py +250 -0
adamops/monitoring/__init__.py +21 -0
adamops/monitoring/alerts.py +200 -0
adamops/monitoring/dashboard.py +117 -0
adamops/monitoring/drift.py +212 -0
adamops/monitoring/performance.py +195 -0
adamops/pipelines/__init__.py +15 -0
adamops/pipelines/orchestrators.py +183 -0
adamops/pipelines/workflows.py +212 -0
adamops/utils/__init__.py +18 -0
adamops/utils/config.py +457 -0
adamops/utils/helpers.py +663 -0
adamops/utils/logging.py +412 -0
adamops-0.1.0.dist-info/METADATA +310 -0
adamops-0.1.0.dist-info/RECORD +42 -0
adamops-0.1.0.dist-info/WHEEL +5 -0
adamops-0.1.0.dist-info/entry_points.txt +2 -0
adamops-0.1.0.dist-info/licenses/LICENSE +21 -0
adamops-0.1.0.dist-info/top_level.txt +1 -0

adamops/evaluation/reports.py ADDED Viewed

@@ -0,0 +1,165 @@
+"""
+AdamOps Reports Module
+Generates HTML/PDF reports for model evaluation.
+"""
+from typing import Any, Dict, List, Optional
+from pathlib import Path
+from datetime import datetime
+import json
+import numpy as np
+import pandas as pd
+from adamops.utils.logging import get_logger
+from adamops.evaluation.metrics import evaluate, classification_report
+logger = get_logger(__name__)
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{title}</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; }}
+        .container {{ max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
+        h1 {{ color: #333; border-bottom: 2px solid #4a90d9; padding-bottom: 10px; }}
+        h2 {{ color: #666; margin-top: 30px; }}
+        table {{ border-collapse: collapse; width: 100%; margin: 20px 0; }}
+        th, td {{ border: 1px solid #ddd; padding: 12px; text-align: left; }}
+        th {{ background: #4a90d9; color: white; }}
+        tr:nth-child(even) {{ background: #f9f9f9; }}
+        .metric {{ font-size: 24px; font-weight: bold; color: #4a90d9; }}
+        .metric-card {{ display: inline-block; padding: 20px; margin: 10px; background: #f0f7ff; border-radius: 8px; text-align: center; min-width: 150px; }}
+        .metric-label {{ color: #666; font-size: 14px; }}
+        .section {{ margin: 30px 0; }}
+        .footer {{ margin-top: 40px; padding-top: 20px; border-top: 1px solid #ddd; color: #999; font-size: 12px; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>{title}</h1>
+        <p>Generated: {timestamp}</p>
+        {content}
+        <div class="footer">Generated by AdamOps v0.1.0</div>
+    </div>
+</body>
+</html>
+"""
+class EvaluationReport:
+    """Model evaluation report generator."""
+    def __init__(self, model_name: str = "Model"):
+        self.model_name = model_name
+        self.sections = []
+        self.metrics = {}
+        self.timestamp = datetime.now().isoformat()
+    def add_metrics(self, metrics: Dict[str, float], title: str = "Performance Metrics"):
+        """Add metrics section."""
+        self.metrics.update(metrics)
+        cards = ""
+        for name, value in metrics.items():
+            if isinstance(value, float):
+                value_str = f"{value:.4f}"
+            else:
+                value_str = str(value)
+            cards += f'<div class="metric-card"><div class="metric">{value_str}</div><div class="metric-label">{name}</div></div>'
+        self.sections.append(f'<div class="section"><h2>{title}</h2>{cards}</div>')
+    def add_table(self, df: pd.DataFrame, title: str = "Results"):
+        """Add table section."""
+        table_html = df.to_html(index=False, classes='results-table')
+        self.sections.append(f'<div class="section"><h2>{title}</h2>{table_html}</div>')
+    def add_text(self, text: str, title: str = "Notes"):
+        """Add text section."""
+        self.sections.append(f'<div class="section"><h2>{title}</h2><p>{text}</p></div>')
+    def add_confusion_matrix(self, y_true: np.ndarray, y_pred: np.ndarray,
+                             labels: Optional[List[str]] = None):
+        """Add confusion matrix section."""
+        from sklearn.metrics import confusion_matrix
+        cm = confusion_matrix(y_true, y_pred)
+        cm_df = pd.DataFrame(cm,
+                            index=[f'Actual: {l}' for l in (labels or range(len(cm)))],
+                            columns=[f'Pred: {l}' for l in (labels or range(len(cm)))])
+        self.add_table(cm_df, "Confusion Matrix")
+    def add_classification_report(self, y_true: np.ndarray, y_pred: np.ndarray):
+        """Add classification report section."""
+        report = classification_report(y_true, y_pred, output_dict=True)
+        df = pd.DataFrame(report).T.reset_index().rename(columns={'index': 'class'})
+        self.add_table(df.round(4), "Classification Report")
+    def generate_html(self) -> str:
+        """Generate HTML report."""
+        content = "\n".join(self.sections)
+        return HTML_TEMPLATE.format(
+            title=f"{self.model_name} Evaluation Report",
+            timestamp=self.timestamp,
+            content=content
+        )
+    def save_html(self, filepath: str):
+        """Save HTML report to file."""
+        filepath = Path(filepath)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(self.generate_html())
+        logger.info(f"Report saved to {filepath}")
+    def save_json(self, filepath: str):
+        """Save report data as JSON."""
+        data = {
+            "model_name": self.model_name,
+            "timestamp": self.timestamp,
+            "metrics": self.metrics,
+        }
+        with open(filepath, 'w') as f:
+            json.dump(data, f, indent=2, default=str)
+def generate_report(
+    model_name: str, y_true: np.ndarray, y_pred: np.ndarray,
+    y_prob: Optional[np.ndarray] = None, task: str = "classification",
+    save_path: Optional[str] = None
+) -> EvaluationReport:
+    """
+    Generate evaluation report.
+    Args:
+        model_name: Name of the model.
+        y_true: True labels.
+        y_pred: Predicted labels.
+        y_prob: Probability predictions.
+        task: 'classification' or 'regression'.
+        save_path: Optional path to save HTML report.
+    Returns:
+        EvaluationReport object.
+    """
+    report = EvaluationReport(model_name)
+    # Add metrics
+    metrics = evaluate(y_true, y_pred, task, y_prob)
+    report.add_metrics(metrics)
+    # Add task-specific sections
+    if task == "classification":
+        report.add_confusion_matrix(y_true, y_pred)
+        report.add_classification_report(y_true, y_pred)
+    if save_path:
+        report.save_html(save_path)
+    return report

adamops/evaluation/visualization.py ADDED Viewed

@@ -0,0 +1,238 @@
+"""
+AdamOps Visualization Module
+Provides plotting for model evaluation: confusion matrices, ROC curves, etc.
+"""
+from typing import Any, Dict, List, Optional, Tuple, Union
+import numpy as np
+import pandas as pd
+try:
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    PLT_AVAILABLE = True
+except ImportError:
+    PLT_AVAILABLE = False
+from sklearn import metrics as sklearn_metrics
+from adamops.utils.logging import get_logger
+logger = get_logger(__name__)
+def _check_plt():
+    if not PLT_AVAILABLE:
+        raise ImportError("matplotlib and seaborn required. Install with: pip install matplotlib seaborn")
+def plot_confusion_matrix(
+    y_true: np.ndarray, y_pred: np.ndarray,
+    labels: Optional[List[str]] = None, normalize: bool = False,
+    figsize: Tuple[int, int] = (8, 6), cmap: str = "Blues",
+    title: str = "Confusion Matrix", save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot confusion matrix."""
+    _check_plt()
+    cm = sklearn_metrics.confusion_matrix(y_true, y_pred)
+    if normalize:
+        cm = cm.astype('float') / cm.sum(axis=1, keepdims=True)
+    fig, ax = plt.subplots(figsize=figsize)
+    sns.heatmap(cm, annot=True, fmt='.2f' if normalize else 'd',
+                cmap=cmap, xticklabels=labels, yticklabels=labels, ax=ax)
+    ax.set_xlabel('Predicted')
+    ax.set_ylabel('Actual')
+    ax.set_title(title)
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig
+def plot_roc_curve(
+    y_true: np.ndarray, y_prob: np.ndarray,
+    figsize: Tuple[int, int] = (8, 6), title: str = "ROC Curve",
+    save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot ROC curve."""
+    _check_plt()
+    if y_prob.ndim == 2:
+        y_prob = y_prob[:, 1]
+    fpr, tpr, _ = sklearn_metrics.roc_curve(y_true, y_prob)
+    auc = sklearn_metrics.roc_auc_score(y_true, y_prob)
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.plot(fpr, tpr, 'b-', label=f'ROC (AUC = {auc:.3f})')
+    ax.plot([0, 1], [0, 1], 'k--', label='Random')
+    ax.set_xlabel('False Positive Rate')
+    ax.set_ylabel('True Positive Rate')
+    ax.set_title(title)
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig
+def plot_precision_recall_curve(
+    y_true: np.ndarray, y_prob: np.ndarray,
+    figsize: Tuple[int, int] = (8, 6), save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot precision-recall curve."""
+    _check_plt()
+    if y_prob.ndim == 2:
+        y_prob = y_prob[:, 1]
+    precision, recall, _ = sklearn_metrics.precision_recall_curve(y_true, y_prob)
+    ap = sklearn_metrics.average_precision_score(y_true, y_prob)
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.plot(recall, precision, 'b-', label=f'PR (AP = {ap:.3f})')
+    ax.set_xlabel('Recall')
+    ax.set_ylabel('Precision')
+    ax.set_title('Precision-Recall Curve')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig
+def plot_feature_importance(
+    importance: np.ndarray, feature_names: List[str],
+    top_n: int = 20, figsize: Tuple[int, int] = (10, 8),
+    title: str = "Feature Importance", save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot feature importance."""
+    _check_plt()
+    indices = np.argsort(importance)[-top_n:]
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.barh(range(len(indices)), importance[indices], color='steelblue')
+    ax.set_yticks(range(len(indices)))
+    ax.set_yticklabels([feature_names[i] for i in indices])
+    ax.set_xlabel('Importance')
+    ax.set_title(title)
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig
+def plot_residuals(
+    y_true: np.ndarray, y_pred: np.ndarray,
+    figsize: Tuple[int, int] = (12, 5), save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot residuals for regression."""
+    _check_plt()
+    residuals = y_true - y_pred
+    fig, axes = plt.subplots(1, 2, figsize=figsize)
+    # Residuals vs Predicted
+    axes[0].scatter(y_pred, residuals, alpha=0.5)
+    axes[0].axhline(y=0, color='r', linestyle='--')
+    axes[0].set_xlabel('Predicted')
+    axes[0].set_ylabel('Residuals')
+    axes[0].set_title('Residuals vs Predicted')
+    # Residual distribution
+    axes[1].hist(residuals, bins=30, edgecolor='black', alpha=0.7)
+    axes[1].set_xlabel('Residuals')
+    axes[1].set_ylabel('Frequency')
+    axes[1].set_title('Residual Distribution')
+    plt.tight_layout()
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig
+def plot_actual_vs_predicted(
+    y_true: np.ndarray, y_pred: np.ndarray,
+    figsize: Tuple[int, int] = (8, 8), save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot actual vs predicted for regression."""
+    _check_plt()
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.scatter(y_true, y_pred, alpha=0.5)
+    min_val = min(y_true.min(), y_pred.min())
+    max_val = max(y_true.max(), y_pred.max())
+    ax.plot([min_val, max_val], [min_val, max_val], 'r--', label='Perfect')
+    ax.set_xlabel('Actual')
+    ax.set_ylabel('Predicted')
+    ax.set_title('Actual vs Predicted')
+    ax.legend()
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig
+def plot_learning_curve(
+    train_sizes: np.ndarray, train_scores: np.ndarray, val_scores: np.ndarray,
+    figsize: Tuple[int, int] = (8, 6), save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot learning curve."""
+    _check_plt()
+    fig, ax = plt.subplots(figsize=figsize)
+    train_mean = train_scores.mean(axis=1)
+    train_std = train_scores.std(axis=1)
+    val_mean = val_scores.mean(axis=1)
+    val_std = val_scores.std(axis=1)
+    ax.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, alpha=0.1)
+    ax.fill_between(train_sizes, val_mean - val_std, val_mean + val_std, alpha=0.1)
+    ax.plot(train_sizes, train_mean, 'o-', label='Training')
+    ax.plot(train_sizes, val_mean, 'o-', label='Validation')
+    ax.set_xlabel('Training Size')
+    ax.set_ylabel('Score')
+    ax.set_title('Learning Curve')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig
+def plot_model_comparison(
+    results: pd.DataFrame, metric: str = "cv_mean",
+    figsize: Tuple[int, int] = (10, 6), save_path: Optional[str] = None
+) -> plt.Figure:
+    """Plot model comparison bar chart."""
+    _check_plt()
+    fig, ax = plt.subplots(figsize=figsize)
+    results_sorted = results.sort_values(metric, ascending=True)
+    ax.barh(results_sorted['algorithm'], results_sorted[metric], color='steelblue')
+    ax.set_xlabel(metric)
+    ax.set_title('Model Comparison')
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches='tight')
+    return fig

adamops/models/__init__.py ADDED Viewed

@@ -0,0 +1,21 @@
+"""
+AdamOps Models Module
+Provides model training and management capabilities:
+- modelops: Train various ML models (regression, classification, clustering)
+- registry: Version and track models with metadata
+- ensembles: Create ensemble models (voting, stacking, blending)
+- automl: Automated model selection and hyperparameter tuning
+"""
+from adamops.models import modelops
+from adamops.models import registry
+from adamops.models import ensembles
+from adamops.models import automl
+__all__ = [
+    "modelops",
+    "registry",
+    "ensembles",
+    "automl",
+]

adamops/models/automl.py ADDED Viewed

@@ -0,0 +1,277 @@
+"""
+AdamOps AutoML Module
+Provides automated model selection and hyperparameter tuning.
+"""
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+import time
+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.utils.helpers import infer_task_type
+from adamops.models.modelops import (
+    CLASSIFICATION_MODELS, REGRESSION_MODELS, TrainedModel, train
+)
+logger = get_logger(__name__)
+try:
+    import optuna
+    optuna.logging.set_verbosity(optuna.logging.WARNING)
+    OPTUNA_AVAILABLE = True
+except ImportError:
+    OPTUNA_AVAILABLE = False
+# Default hyperparameter search spaces
+PARAM_SPACES = {
+    "random_forest": {
+        "n_estimators": ("int", 50, 300),
+        "max_depth": ("int", 3, 20),
+        "min_samples_split": ("int", 2, 20),
+        "min_samples_leaf": ("int", 1, 10),
+    },
+    "gradient_boosting": {
+        "n_estimators": ("int", 50, 300),
+        "max_depth": ("int", 3, 10),
+        "learning_rate": ("float", 0.01, 0.3),
+        "min_samples_split": ("int", 2, 20),
+    },
+    "xgboost": {
+        "n_estimators": ("int", 50, 300),
+        "max_depth": ("int", 3, 12),
+        "learning_rate": ("float", 0.01, 0.3),
+        "subsample": ("float", 0.6, 1.0),
+        "colsample_bytree": ("float", 0.6, 1.0),
+    },
+    "lightgbm": {
+        "n_estimators": ("int", 50, 300),
+        "max_depth": ("int", 3, 12),
+        "learning_rate": ("float", 0.01, 0.3),
+        "num_leaves": ("int", 20, 100),
+        "subsample": ("float", 0.6, 1.0),
+    },
+    "ridge": {
+        "alpha": ("float", 0.001, 100.0, "log"),
+    },
+    "lasso": {
+        "alpha": ("float", 0.001, 100.0, "log"),
+    },
+    "knn": {
+        "n_neighbors": ("int", 1, 30),
+        "weights": ("categorical", ["uniform", "distance"]),
+    },
+}
+class AutoMLResult:
+    """Results from AutoML run."""
+    def __init__(self):
+        self.best_model: Optional[TrainedModel] = None
+        self.best_score: float = 0.0
+        self.best_algorithm: str = ""
+        self.best_params: Dict = {}
+        self.leaderboard: List[Dict] = []
+        self.time_elapsed: float = 0.0
+    def summary(self) -> str:
+        lines = [
+            "=" * 50, "AutoML Results", "=" * 50,
+            f"Best Algorithm: {self.best_algorithm}",
+            f"Best Score: {self.best_score:.4f}",
+            f"Time Elapsed: {self.time_elapsed:.1f}s",
+            "", "Leaderboard:",
+        ]
+        for i, entry in enumerate(self.leaderboard[:10], 1):
+            lines.append(f"  {i}. {entry['algorithm']}: {entry['score']:.4f}")
+        return "\n".join(lines)
+def grid_search(
+    X, y, algorithm: str, param_grid: Dict[str, List],
+    task: str = "classification", cv: int = 5, scoring: Optional[str] = None
+) -> Tuple[Dict, float]:
+    """Grid search hyperparameter tuning."""
+    from sklearn.model_selection import GridSearchCV
+    models = CLASSIFICATION_MODELS if task == "classification" else REGRESSION_MODELS
+    if algorithm not in models:
+        raise ValueError(f"Unknown algorithm: {algorithm}")
+    model = models[algorithm]()
+    scoring = scoring or ("accuracy" if task == "classification" else "r2")
+    grid = GridSearchCV(model, param_grid, cv=cv, scoring=scoring, n_jobs=-1)
+    grid.fit(X, y)
+    return grid.best_params_, grid.best_score_
+def random_search(
+    X, y, algorithm: str, param_distributions: Dict,
+    task: str = "classification", cv: int = 5, n_iter: int = 50,
+    scoring: Optional[str] = None
+) -> Tuple[Dict, float]:
+    """Random search hyperparameter tuning."""
+    from sklearn.model_selection import RandomizedSearchCV
+    models = CLASSIFICATION_MODELS if task == "classification" else REGRESSION_MODELS
+    model = models[algorithm]()
+    scoring = scoring or ("accuracy" if task == "classification" else "r2")
+    search = RandomizedSearchCV(
+        model, param_distributions, n_iter=n_iter, cv=cv,
+        scoring=scoring, n_jobs=-1, random_state=42
+    )
+    search.fit(X, y)
+    return search.best_params_, search.best_score_
+def bayesian_search(
+    X, y, algorithm: str, task: str = "classification",
+    cv: int = 5, n_trials: int = 50, scoring: Optional[str] = None,
+    param_space: Optional[Dict] = None
+) -> Tuple[Dict, float]:
+    """Bayesian optimization with Optuna."""
+    if not OPTUNA_AVAILABLE:
+        raise ImportError("Optuna required. Install with: pip install optuna")
+    models = CLASSIFICATION_MODELS if task == "classification" else REGRESSION_MODELS
+    scoring = scoring or ("accuracy" if task == "classification" else "r2")
+    space = param_space or PARAM_SPACES.get(algorithm, {})
+    def objective(trial):
+        params = {}
+        for name, spec in space.items():
+            if spec[0] == "int":
+                params[name] = trial.suggest_int(name, spec[1], spec[2])
+            elif spec[0] == "float":
+                log = len(spec) > 3 and spec[3] == "log"
+                params[name] = trial.suggest_float(name, spec[1], spec[2], log=log)
+            elif spec[0] == "categorical":
+                params[name] = trial.suggest_categorical(name, spec[1])
+        model = models[algorithm](**params)
+        scores = cross_val_score(model, X, y, cv=cv, scoring=scoring)
+        return scores.mean()
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=n_trials, show_progress_bar=False)
+    return study.best_params, study.best_value
+def run(
+    X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray],
+    task: str = "auto", algorithms: Optional[List[str]] = None,
+    tuning: str = "bayesian", cv: int = 5, time_limit: int = 3600,
+    n_trials: int = 50, scoring: Optional[str] = None
+) -> AutoMLResult:
+    """
+    Run AutoML.
+    Args:
+        X: Features.
+        y: Target.
+        task: 'classification', 'regression', or 'auto'.
+        algorithms: Algorithms to try (None for all).
+        tuning: 'grid', 'random', 'bayesian', or 'none'.
+        cv: Cross-validation folds.
+        time_limit: Max time in seconds.
+        n_trials: Trials per algorithm for tuning.
+        scoring: Scoring metric.
+    Returns:
+        AutoMLResult: Results with best model and leaderboard.
+    """
+    start_time = time.time()
+    result = AutoMLResult()
+    # Auto-detect task
+    if task == "auto":
+        task = infer_task_type(y)
+        logger.info(f"Auto-detected task: {task}")
+    # Get algorithms
+    models = CLASSIFICATION_MODELS if task == "classification" else REGRESSION_MODELS
+    if algorithms is None:
+        algorithms = list(models.keys())
+    scoring = scoring or ("accuracy" if task == "classification" else "r2")
+    logger.info(f"Running AutoML with {len(algorithms)} algorithms")
+    for algo in algorithms:
+        if time.time() - start_time > time_limit:
+            logger.warning("Time limit reached")
+            break
+        try:
+            logger.info(f"Tuning {algo}...")
+            if tuning == "bayesian" and algo in PARAM_SPACES and OPTUNA_AVAILABLE:
+                best_params, score = bayesian_search(
+                    X, y, algo, task, cv, min(n_trials, 30), scoring
+                )
+            elif tuning == "none":
+                model = models[algo]()
+                scores = cross_val_score(model, X, y, cv=cv, scoring=scoring)
+                best_params, score = {}, scores.mean()
+            else:
+                # Default to random search
+                from scipy.stats import randint, uniform
+                param_dist = {}
+                if algo in PARAM_SPACES:
+                    for name, spec in PARAM_SPACES[algo].items():
+                        if spec[0] == "int":
+                            param_dist[name] = randint(spec[1], spec[2])
+                        elif spec[0] == "float":
+                            param_dist[name] = uniform(spec[1], spec[2] - spec[1])
+                if param_dist:
+                    best_params, score = random_search(
+                        X, y, algo, param_dist, task, cv, min(n_trials, 20), scoring
+                    )
+                else:
+                    model = models[algo]()
+                    scores = cross_val_score(model, X, y, cv=cv, scoring=scoring)
+                    best_params, score = {}, scores.mean()
+            result.leaderboard.append({
+                "algorithm": algo, "score": score, "params": best_params
+            })
+            if score > result.best_score:
+                result.best_score = score
+                result.best_algorithm = algo
+                result.best_params = best_params
+        except Exception as e:
+            logger.warning(f"Failed {algo}: {e}")
+    # Sort leaderboard
+    result.leaderboard.sort(key=lambda x: x["score"], reverse=True)
+    # Train best model
+    if result.best_algorithm:
+        result.best_model = train(
+            X, y, task, result.best_algorithm, result.best_params
+        )
+    result.time_elapsed = time.time() - start_time
+    logger.info(f"AutoML complete. Best: {result.best_algorithm} ({result.best_score:.4f})")
+    return result
+def quick_run(
+    X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray],
+    task: str = "auto"
+) -> TrainedModel:
+    """Quick AutoML run with defaults."""
+    result = run(X, y, task, tuning="none", n_trials=10)
+    return result.best_model