PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/predictors/classifier/act_svm_svc.py

@@ -0,0 +1,88 @@
+"""[STEP]  SVM Classifier"""
+import textwrap
+from typing import Any
+from sklearn import svm
+from ....predictor import Predictor
+from ....candidate import Candidate
+from ....dataset import Dataset
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActSVMSVC(Predictor):
+    """[STEP]  SVM Classifier"""
+
+    name: str = "SVM Classification"
+    _description: str = textwrap.dedent('''\
+        SVM Classifier is a machine learning algorithm that models the relationship
+        between input features and a categorical output variable using a support vector machine
+        (SVM). It can handle non-linearly separable data by using a kernel function to map the data
+        into a higher-dimensional space.''')
+    _description_long: str = textwrap.dedent('''\
+        SVM Classifier is a type of classification algorithm that models the
+        relationship between input features and a categorical output variable using a support vecto
+        machine (SVM). It works by finding the optimal hyperplane or boundary that separates the
+        data into different classes with the maximum margin.''')
+    _usage: str = "Use when tabular classes need nonlinear boundaries on small-to-medium data; consider ActCatBoost or ActExtraTreesClassifier for baseline alternatives. Applicable to binary, multiclass, or multilabel targets. Avoid when data is huge, very sparse, or interpretability is required."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1999,
+            'name': 'Probabilistic Outputs for Support Vector Machines and Comparisons to \
+                Regularized Likelihood Methods',
+            'authors': [
+                'John C. Platt'
+            ],
+            'doi': "https://api.semanticscholar.org/CorpusID:56563878",
+            'publisher': 'Microsoft Research'
+        },
+        {
+            'year': 2001,
+            'name': 'LIBSVM: A Library for Support Vector Machines',
+            'authors': [
+                'Chih-Chung Chang',
+                'Chih-Jen Lin'
+            ],
+            'doi': 'https://doi.org/10.1145/1961189.1961199',
+            'publisher': 'ACM Transactions on Intelligen Systems and Technology Vol.2 page 1--27'
+        },
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'kernel': {
+                'description': 'Kernel to use in the SVM',
+                'default': 'rbf',
+                'categorical': ['linear', 'poly', 'rbf', 'sigmoid']
+            },
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            },
+            'class_weight': {
+                'description': 'Can be set on "balanced" to improve results on unbalanced data',
+                'default': None,
+                'categorical': [None, 'balanced']
+            },
+            'tol': {
+                'description': 'The stopping criterion.',
+                'default': 0.001,
+                'range': [1e-05, 0.1]
+            }
+        }
+        self.model: svm.SVC = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = svm.SVC(
+            probability = True, # Enable predict_proba.
+            **self.passthrough_parameters()
+            )
+        self.model.fit(dataset.X, dataset.y)
+
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target in \
+            ['binary', 'multiclass',  'multilabel-indicator']
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/classifier/act_xgboost.py

@@ -0,0 +1,111 @@
+"""[STEP] XGBoost classifier."""
+import textwrap
+from typing import Any
+
+from sklearn.metrics import accuracy_score
+from sklearn.preprocessing import LabelEncoder
+from sklearn.utils.multiclass import check_classification_targets
+from xgboost import XGBClassifier
+
+from .._xgboost import xgboost_features
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'classifier', 'minimal_predictor')
+class ActXGBoost(Predictor):
+    """[STEP] XGBoost classifier."""
+
+    name: str = "XGBoost"
+    _description: str = textwrap.dedent('''\
+        XGBoost trains an ensemble of boosted decision trees for binary
+        or multiclass classification.''')
+    _description_long: str = textwrap.dedent('''\
+        XGBoost adds trees sequentially to improve predictions, using regularized
+        gradient boosting and histogram-based split finding. Class labels are
+        encoded during training and restored when predicting.''')
+    _usage: str = "Use for boosted-tree classification on numeric or encoded tabular features. Supports binary and multiclass targets."
+    refs: list[dict[str, Any]] = [
+        {
+            'name': 'XGBoost: A Scalable Tree Boosting System',
+            'year': 2016,
+            'authors': ['Tianqi Chen', 'Carlos Guestrin'],
+            'doi': 'https://doi.org/10.1145/2939672.2939785',
+            'publisher': 'Proceedings of the 22nd ACM SIGKDD International Conference, pages 785–794'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'max_depth': {
+                'description': 'Maximum depth of each tree.',
+                'default': 6,
+                'range': [1, 16]
+            },
+            'random_state': {
+                'description': 'Random seed for reproducibility.',
+                'default': 42
+            },
+            'learning_rate': {
+                'description': 'Shrinkage applied to each boosting round.',
+                'default': 0.1,
+                'range': [1e-3, 1.0]
+            },
+            'subsample': {
+                'description': 'Fraction of training rows sampled for each tree.',
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            },
+            'n_estimators': {
+                'description': 'Number of boosting rounds.',
+                'default': 100,
+                'range': [1, 500]
+            },
+            'min_child_weight': {
+                'description': 'Minimum sum of instance Hessians needed in a child.',
+                'default': 1.0,
+                'range': [0.0, 20.0]
+            },
+            'colsample_bytree': {
+                'description': 'Fraction of features sampled for each tree.',
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            }
+        }
+        self.model: XGBClassifier = None
+        self.label_encoder = LabelEncoder()
+
+    def fit(self, dataset: Dataset):
+        check_classification_targets(dataset.y)
+        encoded_target = self.label_encoder.fit_transform(dataset.y)
+        # IAML schedules candidates in parallel; keep each estimator single-threaded.
+        self.model = XGBClassifier(
+            n_jobs=1, tree_method='hist', **self.passthrough_parameters()
+        )
+        self.model.fit(xgboost_features(dataset.X), encoded_target)
+        return self
+
+    def predict(self, X):
+        """Predict original class labels using XGBoost-safe feature names."""
+        return super().predict(xgboost_features(X))
+
+    def predict_proba(self, X):
+        """Predict class probabilities using XGBoost-safe feature names."""
+        return super().predict_proba(xgboost_features(X))
+
+    @property
+    def classes_(self):
+        """Original labels, in the order of predict_proba columns."""
+        return self.label_encoder.classes_
+
+    def score(self, X, y, sample_weight=None):
+        """Compute accuracy with the original class labels."""
+        return accuracy_score(y, self.predict(X), sample_weight=sample_weight)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target in ['binary', 'multiclass']
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5

iaml/actionables/predictors/regressor/__init__.py

@@ -0,0 +1,27 @@
+"""
+Regressor Predictors Actionables
+"""
+
+from .act_svm_svr import ActSVMSVR
+from .act_randomforest_regressor import ActRandomForestRegressor
+from .act_xgboost_regressor import ActXGBoostRegressor
+from .act_gboost_regressor import ActGBoostRegressor
+from .act_catboost_regressor import ActCatBoostRegressor
+from .act_knn_regressor import ActKNNRegressor
+from .act_linear_regression import ActLinearRegression
+from .act_extra_trees_regressor import ActExtraTreesRegressor
+from .act_ard_regression import ActARDRegression
+from .act_ada_boost_regressor import ActAdaBoostRegressor
+from .act_hist_gradient_boosting_regressor import ActHistGradientBoostingRegressor
+from .act_mlp_regressor import ActMLPRegressor
+from .act_sgd_regressor import ActSGDRegressor
+from .act_gaussian_process_regressor import ActGaussianProcessRegressor
+from .act_decision_tree_regressor import ActDecisionTreeRegressor
+from .act_ridge_regressor import ActRidgeRegressor
+from .act_lasso_regressor import ActLassoRegressor
+from .act_elastic_net_regressor import ActElasticNetRegressor
+from .act_huber_regressor import ActHuberRegressor
+from .act_ransac_regressor import ActRANSACRegressor
+from .act_quantile_regressor import ActQuantileRegressor
+from .act_poisson_regressor import ActPoissonRegressor
+from .act_light_gbm_regressor import ActLightGBMRegressor

iaml/actionables/predictors/regressor/act_ada_boost_regressor.py

@@ -0,0 +1,75 @@
+"""[STEP]  AdaBoost Regressor"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import AdaBoostRegressor
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActAdaBoostRegressor(Predictor):
+    """[STEP]  AdaBoost Regressor"""
+
+    name: str = "AdaBoost Regressor"
+    _description: str = textwrap.dedent('''\
+        AdaBoostRegressor is a powerful tool that combines many simple models
+        to make accurate predictions for continuous outcomes.''')
+    _description_long: str = textwrap.dedent('''\
+        AdaBoostRegressor is an ensemble learning technique
+        used for regression problems. It works by combining multiple weak learners
+        (simple models) into a strong learner.''')
+    _usage: str = "Use when regression needs boosting and you want an alternative to ActDecisionTreeRegressor or ActExtraTreesRegressor. Applicable to continuous targets with modest features and nonlinear signal. Avoid when data is very noisy, high-dimensional, or you need strong interpretability."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1995,
+            'name': (
+                'A desicion-theoretic generalization of on-line learning '
+                'and an application to boosting'
+            ),
+            'authors': [
+                'Yoav Freund',
+                'Robert E. Schapire'
+            ],
+            'doi': 'https://doi.org/10.1007/3-540-59119-2_166',
+            'publisher': 'Springer, Berlin, Heidelberg'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'learning_rate': {
+                'description': 'Weight applied to each regressor at each boosting iteration',
+                'default': 0.1,
+                'range': [0.01, 2.0]
+            },
+            'loss': {
+                'description': textwrap.dedent('''\
+                    The loss function to use when updating the weights after
+                    each boosting iteration.'''),
+                'default': "linear",
+                'categorical': ["linear", "square", "exponential"]
+            },
+            'n_estimators': {
+                'description': 'Number of threes',
+                'default': 50,
+                'range': [1, 500]
+            },
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            }
+        }
+        self.model: AdaBoostRegressor = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = AdaBoostRegressor(**self.passthrough_parameters())
+
+        self.model.fit(dataset.X, dataset.y)
+
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'continuous'
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_ard_regression.py

@@ -0,0 +1,95 @@
+"""
+[STEP] ARD Regression
+"""
+
+import textwrap
+from sklearn.linear_model import ARDRegression
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActARDRegression(Predictor):
+    """
+    [STEP] ARD Regression
+    """
+    name = "ARD Regression"
+    _description = textwrap.dedent('''\
+        ARDRegression is a powerful tool that helps computers make accurate
+        predictions by giving each feature its own importance weight.''')
+    _description_long = textwrap.dedent('''\
+        ARDRegression (Automatic Relevance Determination Regression)
+        is a Bayesian regression technique used for predicting continuous outcomes.
+        It works by assigning weights to each feature, allowing some features to be
+        more important than others.
+        These weights are determined automatically during training,
+        hence the "automatic relevance determination.''')
+    _usage = "Use when you want Bayesian linear regression with automatic relevance on tabular data, as a sparse alternative to ActElasticNetRegressor. Applicable to continuous targets with many features. Avoid when strong nonlinearity or interactions suggest ActExtraTreesRegressor."
+    refs = [
+        {
+            'year': 1996,
+            'name': 'Bayesian Non-Linear Modeling for the Prediction Competition',
+            'authors': ['David J. C. MacKay'],
+            'doi': 'https://doi.org/10.1007/978-94-015-8729-7_18',
+            'publisher': 'Springer, Dordrecht'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'alpha_1': {
+                'description': textwrap.dedent('''\
+                    Hyper-parameter : shape parameter for the Gamma
+                    distribution prior over the alpha parameter.'''),
+                'default': 1e-06,
+                'range': [1e-10, 0.001]
+            },
+            'alpha_2': {
+                'description': textwrap.dedent('''\
+                    Hyper-parameter : inverse scale parameter (rate parameter)
+                    for the Gamma distribution prior over the alpha parameter.'''),
+                'default': 1e-06,
+                'range': [1e-10, 0.001]
+            },
+            'lambda_1': {
+                'description': textwrap.dedent('''\
+                    Hyper-parameter : shape parameter for the Gamma
+                    distribution prior over the lambda parameter.'''),
+                'default': 1e-10,
+                'range': [1e-10, 0.001]
+            },
+            'lambda_2': {
+                'description': textwrap.dedent('''\
+                    Hyper-parameter : inverse scale parameter (rate parameter)
+                    for the Gamma distribution prior over the lambda parameter.'''),
+                'default': 1e-10,
+                'range': [1e-10, 0.001]
+            },
+            'threshold_lambda': {
+                'description': textwrap.dedent('''\
+                    Threshold for removing (pruning) weights with high
+                    precision from the computation.'''),
+                'default': 10000.0,
+                'range': [1000.0, 100000.0]
+            },
+            'tol': {
+                'description': 'Stop the algorithm if w has converged.',
+                'default': 0.001,
+                'range': [1e-05, 0.1]
+            }
+        }
+
+        self.model: ARDRegression = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = ARDRegression(**self.passthrough_parameters())
+
+        self.model.fit(dataset.X, dataset.y)
+
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'continuous'
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_catboost_regressor.py

@@ -0,0 +1,134 @@
+"""
+[STEP]  CatBoost Regressor
+"""
+import textwrap
+from typing import Any
+from catboost import CatBoostRegressor, CatBoostError
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+from ....logger import Logger
+
+@is_step('predictor', 'tabular', 'regressor', 'minimal_predictor')
+class ActCatBoostRegressor(Predictor):
+    """[STEP]  CatBoost Regressor"""
+
+    name: str = "CatBoost Regressor"
+    _usage: str = "Use when you need strong tabular regression with categorical features versus ActDecisionTreeRegressor. Applicable to continuous targets with mixed numeric/categorical columns. Avoid when interpretability, ultra-low latency, or tiny data dominate."
+    _description: str = textwrap.dedent('''\
+        CatBoostRegressor is a powerful tool that helps computers make accurate
+        predictions for continuous outcomes by learning from both positive and
+        negative examples simultaneously.''')
+    _description_long: str = textwrap.dedent('''\
+        CatBoostRegressor is a gradient boosting algorithm specifically
+        designed for regression tasks.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2017,
+            'name': 'CatBoost: unbiased boosting with categorical features',
+            'authors': [
+                'Liudmila Prokhorenkova',
+                'Gleb Gusev',
+                'Aleksandr Vorobev',
+                'Anna Veronika Dorogush',
+                'Andrey Gulin'
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.1706.09516',
+            'publisher': 'Advances in Neural Information Processing Systems 31 (NeurIPS 2018)'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'iterations': {
+                'description': 'The maximum number of trees that can be built.',
+                'default': 1000,
+                'range': [100, 10000]
+            },
+            'learning_rate': {
+                'description': 'The learning rate.',
+                'default': 0.03,
+                'range': [0.001, 1.0]
+            },
+            'depth': {
+                'description': 'Depth of the tree.',
+                'default': 6,
+                'range': [1, 16]
+            },
+            'l2_leaf_reg': {
+                'description': 'Coefficient at the L2 regularization term of the cost function.',
+                'default': 3,
+                'range': [0, 10]
+            },
+            'border_count': {
+                'description': 'The number of splits for numerical features.',
+                'default': 254,
+                'range': [1, 255]
+            },
+            'loss_function': {
+                'description': 'The metric to use in training.',
+                'default': 'RMSE',
+                'categorical': ['RMSE',
+                                'MAE',
+                                'Quantile',
+                                'LogLinQuantile',
+                                'Poisson',
+                                'MAPE']
+                                #, 'Lq']
+            },
+            'eval_metric': {
+                'description': 'The metric to be used for validation data.',
+                'default': 'RMSE',
+                'categorical': ['RMSE',
+                                'MAE',
+                                'R2',
+                                'Quantile',
+                                'LogLinQuantile',
+                                'Poisson',
+                                'MAPE']
+                                # , 'Lq']
+            },
+            'bootstrap_type': {
+                'description': 'The method for sampling the weights of objects.',
+                'default': 'Bayesian',
+                'categorical': ['Bayesian', 'Bernoulli', 'MVS']
+            },
+            'leaf_estimation_iterations': {
+                'description': 'The number of iterations for leaf estimation.',
+                'default': 10,
+                'range': [1, 50]
+            }
+        }
+        self.model: CatBoostRegressor = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = CatBoostRegressor(verbose=0, **self.passthrough_parameters())
+        try:
+            self.model.fit(dataset.X, dataset.y)
+        except CatBoostError as exc:
+            self._log_failure(dataset, exc)
+            raise ValueError(f"CatBoostRegressor training failed: {exc}") from exc
+        except Exception as exc:  # pragma: no cover - defensive
+            self._log_failure(dataset, exc)
+            raise
+        return self
+
+    def _log_failure(self, dataset: Dataset, exc: Exception) -> None:
+        """Log enriched debug info when CatBoost crashes."""
+        shape = getattr(dataset.X, "shape", None)
+        message = (
+            "[CatBoostRegressor] crash detected "
+            f"(shape={shape}, target_len={len(dataset.y)}, "
+            f"params={self.passthrough_parameters()}): {exc}"
+        )
+        logger = Logger()
+        if logger.verbose <= 3 and logger.verbose != -1:
+            logger.console.log(message)
+        logger.error(message)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target in ['continuous']
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_decision_tree_regressor.py

@@ -0,0 +1,111 @@
+"""[STEP]  Decision Tree Regressor"""
+import textwrap
+from typing import Any
+from sklearn.tree import DecisionTreeRegressor
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....data_type import DataType
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActDecisionTreeRegressor(Predictor):
+    """[STEP]  Decision Tree Regressor"""
+
+    name: str = "Decision Tree Regressor"
+    _description: str = textwrap.dedent('''\
+        DecisionTreeRegressor learns if-then rules in a tree structure
+        to predict a continuous target.''')
+    _description_long: str = textwrap.dedent('''\
+        DecisionTreeRegressor builds a regression tree by recursively splitting
+        features to reduce variance. The resulting tree is easy to inspect,
+        which makes it a strong baseline when interpretability matters.''')
+    _usage: str = "Use when you need an interpretable tree baseline; compare to ActExtraTreesRegressor for higher accuracy. Applicable to tabular numeric features with a continuous target. Avoid when linear effects dominate (ActElasticNetRegressor) or you need smoother generalization."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1984,
+            'name': 'Classification and Regression Trees',
+            'authors': [
+                'Leo Breiman',
+                'Jerome Friedman',
+                'Richard Olshen',
+                'Charles Stone'
+            ],
+            'publisher': 'Wadsworth'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'max_depth': {
+                'description': 'Maximum depth of the tree.',
+                'default': 5,
+                'range': [1, 50]
+            },
+            'min_samples_leaf': {
+                'description': 'Minimum number of samples required to be at a leaf node.',
+                'default': 1,
+                'range': [1, 20]
+            },
+            'min_samples_split': {
+                'description': 'Minimum number of samples required to split an internal node.',
+                'default': 2,
+                'range': [2, 50]
+            },
+            'max_features': {
+                'description': textwrap.dedent('''\
+                    The number of features to consider when looking for the best split.
+                    Use a float to specify a fraction of features.'''),
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            },
+            'criterion': {
+                'description': 'Function to measure the quality of a split.',
+                'default': 'squared_error',
+                'categorical': [
+                    'squared_error',
+                    'absolute_error',
+                    'friedman_mse',
+                    'poisson'
+                ]
+            },
+            'splitter': {
+                'description': 'Strategy used to choose the split at each node.',
+                'default': 'best',
+                'categorical': ['best', 'random']
+            },
+            'random_state': {
+                'description': 'Random state for reproducibility.',
+                'default': 42
+            }
+        }
+        self.model: DecisionTreeRegressor = None
+        self.columns: list[str] = []
+
+    def _select_features(self, X):
+        if self.columns and hasattr(X, 'columns'):
+            return X[self.columns]
+        return X
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if not self.columns:
+            self.columns = dataset.features
+
+        self.model = DecisionTreeRegressor(**self.passthrough_parameters())
+        self.model.fit(self._select_features(dataset.X), dataset.y)
+        return self
+
+    def predict(self, X):
+        return super().predict(self._select_features(X))
+
+    def score(self, X, y=None, *args, **kwargs):
+        return self.model.score(self._select_features(X), y, *args, **kwargs)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'continuous' \
+            and bool(dataset.get_columns_names_by_type(DataType.NUMERIC))
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral