PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/predictors/regressor/act_randomforest_regressor.py

@@ -0,0 +1,116 @@
+"""[STEP]  Random Forest Regressor"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import RandomForestRegressor
+from ....data_type import DataType
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActRandomForestRegressor(Predictor):
+    """[STEP]  Random Forest Regressor"""
+
+    name: str = "Random Forest Regressor"
+    _description: str = textwrap.dedent('''\
+        RandomForestRegressor is a machine learning algorithm that
+        models the relationship between input features and a continuous output
+        variable using a collection of decision trees.''')
+    _description_long: str = textwrap.dedent('''\
+        RandomForestRegressor is a type of ensemble learning algorithm
+        that models the relationship between input features and a continuous output variable
+        using a collection of decision trees. It works by building multiple decision trees on
+        random subsets of the input features and data, and then averaging the predictions of each
+        tree to make the final prediction.''')
+    _usage: str = "Use when you want a robust nonlinear tabular baseline; more stable than ActDecisionTreeRegressor. Applicable to continuous targets with numeric or encoded categorical features. Avoid when data is huge or latency is tight; consider ActExtraTreesRegressor."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2001,
+            'name': 'Random Forests',
+            'authors': ['Leo Breiman'],
+            'doi': 'https://doi.org/10.1023/A:1010933404324',
+            'publisher': 'Machine Learning Vol.45 page 5--32'
+        },
+        {
+            'year': 2006,
+            'name': 'Extremely Randomized Trees',
+            'authors': ['Pierre Geurts', 'Damien Ernst', 'Lous Wehenkel'],
+            'doi': 'https://doi.org/10.1007/s10994-006-6226-1',
+            'publisher': 'Machine Learning Vol.63 page 5--42'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            # 'max_depth': { # Disable before probably better with no limit in regression
+            #     'description': 'Max depth of each tree',
+            #     'default': 15,
+            #     'range': [1, 100]
+            # },
+            'n_estimators': {
+                'description': 'Number of threes',
+                'default': 100,
+                'range': [1, 500]
+            },
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            },
+            'min_samples_leaf': {
+                'description': 'The minimum number of samples required to be at a leaf node.',
+                'default': 1,
+                'range': [1, 15]
+            },
+            'max_features': {
+                'description': 'The number of features to consider when looking for the best split',
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            },
+            'min_samples_split': {
+                'description': 'The minimum number of samples required to split an internal node',
+                'default': 2,
+                'range': [2, 20]
+            },
+            'bootstrap': {
+                'description': textwrap.dedent('''\
+                    Whether bootstrap samples are used when building trees. If
+                    False, the whole dataset is used to build each tree.'''),
+                'default': False
+            },
+            'criterion': {
+                'description': 'The function to measure the quality of a split.',
+                'default': "squared_error",
+                'categorical': ["poisson", "friedman_mse", "absolute_error", "squared_error"]
+            }
+        }
+        self.model: RandomForestRegressor = 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 = RandomForestRegressor(**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 in ['continuous'] \
+            and bool(dataset.get_columns_names_by_type(DataType.NUMERIC))
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_ransac_regressor.py

@@ -0,0 +1,106 @@
+"""[STEP] RANSAC Regressor"""
+import textwrap
+from typing import Any
+from sklearn.linear_model import RANSACRegressor
+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 ActRANSACRegressor(Predictor):
+    """[STEP] RANSAC Regressor"""
+
+    name: str = "RANSAC Regressor"
+    _usage: str = "Use when outliers can skew a linear model and you need robustness vs ActElasticNetRegressor. Applicable to numeric tabular regression with moderate sample size. Avoid when data is clean or effects are highly nonlinear; consider ActDecisionTreeRegressor."
+    _description: str = textwrap.dedent('''\
+        RANSACRegressor fits a robust regression model by iteratively
+        sampling subsets of the data and keeping inliers.''')
+    _description_long: str = textwrap.dedent('''\
+        RANSACRegressor is a robust regression technique that repeatedly fits
+        a base estimator on random subsets, identifies inliers using a
+        residual threshold, and refits on the consensus set. This approach
+        reduces the influence of outliers in tabular regression problems.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1981,
+            'name': (
+                'Random Sample Consensus: A Paradigm for Model Fitting with '
+                'Applications to Image Analysis and Automated Cartography'
+            ),
+            'authors': [
+                'Martin A. Fischler',
+                'Robert C. Bolles'
+            ],
+            'doi': 'https://doi.org/10.1145/358669.358692',
+            'publisher': 'Communications of the ACM'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'min_samples': {
+                'description': textwrap.dedent('''\
+                    Minimum number of samples chosen for estimating the model.
+                    When None, uses the number of features plus one.'''),
+                'default': None
+            },
+            'residual_threshold': {
+                'description': textwrap.dedent('''\
+                    Maximum residual for a data sample to be classified as an inlier.
+                    When None, uses the median absolute deviation of the target.'''),
+                'default': None
+            },
+            'max_trials': {
+                'description': 'Maximum number of iterations for random sampling.',
+                'default': 100,
+                'range': [10, 500]
+            },
+            'stop_probability': {
+                'description': textwrap.dedent('''\
+                    Probability that at least one outlier-free sample has been chosen
+                    after max_trials iterations.'''),
+                'default': 0.99,
+                'range': [0.8, 0.999]
+            },
+            'loss': {
+                'description': 'Loss function used to classify inliers.',
+                'default': 'absolute_error',
+                'categorical': ['absolute_error', 'squared_error']
+            },
+            'random_state': {
+                'description': 'Random state for reproducibility.',
+                'default': 42
+            }
+        }
+        self.model: RANSACRegressor = 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 = RANSACRegressor(**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

iaml/actionables/predictors/regressor/act_ridge_regressor.py

@@ -0,0 +1,107 @@
+"""[STEP] Ridge Regressor"""
+import textwrap
+from typing import Any
+from sklearn.linear_model import Ridge
+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 ActRidgeRegressor(Predictor):
+    """[STEP] Ridge Regressor"""
+
+    name: str = "Ridge Regressor"
+    _description: str = textwrap.dedent('''\
+        Ridge regression applies L2 regularization to stabilize coefficients
+        when predictors are correlated.''')
+    _description_long: str = textwrap.dedent('''\
+        Ridge regression fits a linear model while penalizing large coefficients
+        with an L2 term. This reduces variance, improves numerical stability,
+        and provides robust predictions for tabular regression problems.''')
+    _usage: str = "Use when you need a stable linear regressor for correlated numeric features; compare ActElasticNetRegressor or ActARDRegression. Applicable to tabular regression with mostly numeric inputs. Avoid when strong nonlinear effects dominate or labels are not continuous."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1970,
+            'name': 'Ridge Regression: Biased Estimation for Nonorthogonal Problems',
+            'authors': [
+                'Arthur E. Hoerl',
+                'Robert W. Kennard'
+            ],
+            'doi': 'https://doi.org/10.2307/1267351',
+            'publisher': 'Technometrics Vol. 12, No. 1, page 55--67'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'alpha': {
+                'description': 'Regularization strength.',
+                'default': 1.0,
+                'range': [1e-04, 100.0]
+            },
+            'fit_intercept': {
+                'description': 'Whether to fit the intercept term.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'solver': {
+                'description': 'Solver to use in the ridge optimization.',
+                'default': 'auto',
+                'categorical': [
+                    'auto',
+                    'svd',
+                    'cholesky',
+                    'lsqr',
+                    'sparse_cg',
+                    'sag',
+                    'saga',
+                    'lbfgs'
+                ]
+            },
+            'tol': {
+                'description': 'Stopping criterion for iterative solvers.',
+                'default': 0.0001,
+                'range': [1e-05, 0.1]
+            },
+            'max_iter': {
+                'description': 'Maximum number of iterations for iterative solvers.',
+                'default': 1000,
+                'range': [50, 5000]
+            },
+            'random_state': {
+                'description': 'Random state for solvers that use randomness.',
+                'default': 42
+            }
+        }
+        self.model: Ridge = 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 = Ridge(**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

iaml/actionables/predictors/regressor/act_sgd_regressor.py

@@ -0,0 +1,106 @@
+"""[STEP] SGD Regressor"""
+from typing import Any
+import textwrap
+from sklearn.linear_model import SGDRegressor
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActSGDRegressor(Predictor):
+    """[STEP] SGD Regressor"""
+
+    name: str = "SGD Regressor"
+    _usage: str = "Use when you need a fast linear baseline on large tabular data, e.g., vs ActElasticNetRegressor. Applicable to scaled numeric features with a continuous target. Avoid when strong nonlinearities or best accuracy is needed; prefer ActCatBoostRegressor or ActExtraTreesRegressor."
+    _description: str = textwrap.dedent('''\
+        SGDRegressor is a machine learning algorithm that models
+        the relationship between input features and a continuous output variable
+        using stochastic gradient descent.''')
+    _description_long: str = textwrap.dedent('''\
+        SGDRegressor is a type of linear model that models the relationship
+        between input features and a continuous output variable using stochastic gradient descent.
+        It works by iteratively updating the model parameters in the direction of the negative
+        gradient of the loss function with respect to the parameters, using a single example
+        at a time.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1951,
+            'name': 'A Stochastic Approximation Method',
+            'authors': [
+                'Herbert Robbins',
+                'Sutton Monro'    
+            ],
+            'doi': 'https://doi.org/10.1214/aoms/1177729586',
+            'publisher': 'The annals of Mathematical Statistics Vol.22 No.3 page 400--407'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'alpha': {
+                'description': 'Constant that multiplies the regularization term.',
+                'default': 0.0001,
+                'range': [1e-07, 0.1]
+            },
+            'tol': {
+                'description': 'The stopping criterion.',
+                'default': 0.0001,
+                'range': [1e-05, 0.1]
+            },
+            'epsilon': {
+                'description': 'Epsilon in the epsilon-insensitive loss functions',
+                'default': 0.1,
+                'range': [1e-05, 0.1]
+            },
+            'eta0': {
+                'description': textwrap.dedent('''\
+                    The initial learning rate for the ‘constant’, ‘invscaling’
+                    or ‘adaptive’ schedules.'''),
+                'default': 0.01,
+                'range': [1e-07, 0.1]
+            },
+            'l1_ratio': {
+                'description': 'The Elastic Net mixing parameter',
+                'default': 0.15,
+                'range': [1e-09, 1.0]
+            },
+            'power_t': {
+                'description': 'The exponent for inverse scaling learning rate.',
+                'default': 0.25,
+                'range': [1e-05, 1.0]
+            },
+            'average': {
+                'description': textwrap.dedent('''\
+                    When set to True, computes the averaged SGD weights across
+                    all updates and stores the result in the coef_ attribute.'''),
+                'default': False
+            },
+            'loss': {
+                'description': 'The loss function to be used.',
+                'default': "squared_error",
+                'categorical': ["squared_error",
+                                "huber",
+                                "epsilon_insensitive",
+                                "squared_epsilon_insensitive"]
+            },
+            'penalty': {
+                'description': 'The penalty (aka regularization term) to be used.',
+                'default': "l2",
+                'categorical': ["l1", "l2", "elasticnet"]
+            }
+        }
+
+        self.model: SGDRegressor = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = SGDRegressor(**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_svm_svr.py

@@ -0,0 +1,81 @@
+"""[STEP]  SVM Regressor"""
+import textwrap
+from typing import Any
+from sklearn import svm
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActSVMSVR(Predictor):
+    """[STEP]  SVM Regressor"""
+
+    name: str = "SVM Regression"
+    _description: str = textwrap.dedent('''\
+        SVM Regressor is a machine learning algorithm that models the relationship
+        between input features and a continuous 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 Regressor is a type of regression algorithm that models the
+        relationship between input features and a continuous output variable using a support
+        vector machine (SVM). It works by finding the optimal hyperplane or boundary that predicts
+        the output variable with the minimum error.''')
+    _usage: str = "Use when you need kernel-based regression for moderate-sized non-linear data and want an alternative to ActElasticNetRegressor or ActDecisionTreeRegressor. Applicable to tabular continuous targets. Avoid when data are very large or interpretability is key."
+    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:5656387',
+            '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']
+            },
+            'epsilon': {
+                'description': 'Epsilon in the epsilon-SVR model.',
+                'default': 0.1,
+                'range': [1e-05, 0.1]
+            },
+            'tol': {
+                'description': 'The stopping criterion.',
+                'default': 0.001,
+                'range': [1e-05, 0.1]
+            }
+        }
+        self.model: svm.SVR = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = svm.SVR(
+            **self.passthrough_parameters()
+            )
+        self.model.fit(dataset.X, dataset.y)
+        return self
+
+    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_xgboost_regressor.py

@@ -0,0 +1,97 @@
+"""[STEP]  XGBoost Regressor"""
+import textwrap
+from typing import Any
+from xgboost import XGBRegressor
+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', 'regressor', 'minimal_predictor')
+class ActXGBoostRegressor(Predictor):
+    """[STEP]  XGBoost Regressor"""
+
+    name: str = "XGBoost Regressor"
+    _description: str = textwrap.dedent('''\
+        XGBoost predicts continuous targets using regularized gradient-boosted
+        decision trees.''')
+    _description_long: str = textwrap.dedent('''\
+        Uses XGBoost's histogram tree builder with a squared-error objective.
+        Trees are trained sequentially to improve the ensemble's predictions,
+        with row and column sampling available to control overfitting.''')
+    _usage: str = "Use when you want boosted-tree regression on tabular data, balancing against ActCatBoostRegressor or ActExtraTreesRegressor. Applicable to continuous targets with numeric or encoded categorical features. Avoid when you need native categorical handling or a very fast baseline."
+    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': 'ACM SIGKDD 2016, pages 785--794'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'max_depth': {
+                'description': 'Max depth of each tree',
+                'default': 6,
+                'range': [1, 16]
+            },
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            },
+            'learning_rate': {
+                'description': 'Learning rate',
+                'default': 0.1,
+                'range': [0.001, 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 estimators',
+                'default': 100,
+                'range': [1, 500]
+            },
+            'min_child_weight': {
+                'description': 'Minimum sum of instance Hessians required in a child',
+                'default': 1.0,
+                'range': [0.0, 20.0]
+            },
+            'colsample_bytree': {
+                'description': 'Fraction of feature columns sampled for each tree',
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            }
+        }
+        self.model: XGBRegressor = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = XGBRegressor(
+            **self.passthrough_parameters(),
+            objective='reg:squarederror',
+            tree_method='hist',
+            n_jobs=1,
+        )
+        self.model.fit(xgboost_features(dataset.X), dataset.y)
+        return self
+
+    def predict(self, X):
+        """Predict values using XGBoost-safe feature names."""
+        return super().predict(xgboost_features(X))
+
+    def score(self, X, y, sample_weight=None):
+        """Compute R² using XGBoost-safe feature names."""
+        return super().score(xgboost_features(X), y, sample_weight=sample_weight)
+
+    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/survival/__init__.py

@@ -0,0 +1,12 @@
+"""
+Survival Predictors Actionables
+"""
+from .act_cox import ActCox
+from .act_random_survival_forest import ActRandomSurvivalForest
+from .act_survival_component_wise_gboost import ActComponentwiseGradientBoostingSurvivalAnalysis
+from .act_extra_survival_trees import ActExtraSurvivalTrees
+from .act_survival_tree import ActSurvivalTree
+from .act_coxnet_survival_analysis import ActCoxnetSurvivalAnalysis
+from .act_fast_survival_svm import ActFastSurvivalSVM
+from .act_gradient_boosting_survival_analysis import ActGradientBoostingSurvivalAnalysis
+from .act_weibull_aft import ActWeibullAFT