PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/predictors/classifier/act_light_gbm_classifier.py

@@ -0,0 +1,211 @@
+"""[STEP] LightGBM Classifier"""
+import textwrap
+from typing import Any
+
+try:
+    from lightgbm import LGBMClassifier
+    from lightgbm.basic import LightGBMError
+    _LGBM_ERRORS: tuple[type[Exception], ...] = (LightGBMError,)
+except ImportError:  # pragma: no cover - optional dependency
+    LGBMClassifier = None  # type: ignore
+    _LGBM_ERRORS = tuple()
+
+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', 'classifier')
+class ActLightGBMClassifier(Predictor):
+    """[STEP] LightGBM Classifier"""
+
+    name: str = "LightGBM Classifier"
+    _description: str = textwrap.dedent('''\
+        LightGBMClassifier is a gradient boosting algorithm that builds
+        decision trees efficiently for classification tasks.''')
+    _description_long: str = textwrap.dedent('''\
+        LightGBMClassifier trains an ensemble of decision trees using histogram-based
+        splits and leaf-wise growth. It is designed to be fast while preserving
+        accuracy on tabular classification problems.''')
+    _usage: str = "Use when you want fast gradient boosting on tabular classification; compare to ActCatBoost or ActExtraTreesClassifier. Applicable to numeric and categorical features with binary or multiclass targets. Avoid when you need a simple, interpretable model or very small data."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2017,
+            'name': 'LightGBM: A Highly Efficient Gradient Boosting Decision Tree',
+            'authors': [
+                'Guolin Ke',
+                'Qi Meng',
+                'Thomas Finley',
+                'Taifeng Wang',
+                'Wei Chen',
+                'Weidong Ma',
+                'Qiwei Ye',
+                'Tie-Yan Liu'
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.1712.01005',
+            'publisher': 'Advances in Neural Information Processing Systems 30 (NeurIPS 2017)'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'boosting_type': {
+                'description': 'Type of boosting algorithm.',
+                'default': 'gbdt',
+                'categorical': ['gbdt', 'dart']
+            },
+            'n_estimators': {
+                'description': 'Number of boosting iterations.',
+                'default': 200,
+                'range': [50, 1000]
+            },
+            'learning_rate': {
+                'description': 'Shrinkage rate applied to each tree.',
+                'default': 0.1,
+                'range': [0.01, 1.0]
+            },
+            'num_leaves': {
+                'description': 'Maximum number of leaves in one tree.',
+                'default': 31,
+                'range': [7, 255]
+            },
+            'max_depth': {
+                'description': 'Maximum depth of a tree, -1 means no limit.',
+                'default': -1,
+                'categorical': [-1, 3, 5, 10, 15]
+            },
+            'min_child_samples': {
+                'description': 'Minimum number of data in one leaf.',
+                'default': 20,
+                'range': [5, 200]
+            },
+            'subsample': {
+                'description': 'Fraction of data to use for each boosting iteration.',
+                'default': 1.0,
+                'range': [0.5, 1.0]
+            },
+            'subsample_freq': {
+                'description': 'Frequency for subsampling, 0 means disabled.',
+                'default': 0,
+                'range': [0, 10]
+            },
+            'colsample_bytree': {
+                'description': 'Fraction of features used for each tree.',
+                'default': 1.0,
+                'range': [0.5, 1.0]
+            },
+            'reg_alpha': {
+                'description': 'L1 regularization.',
+                'default': 0.0,
+                'range': [0.0, 1.0]
+            },
+            'reg_lambda': {
+                'description': 'L2 regularization.',
+                'default': 0.0,
+                'range': [0.0, 1.0]
+            },
+            'class_weight': {
+                'description': textwrap.dedent('''\
+                    The "balanced" mode uses values of y to adjust weights inversely
+                    proportional to class frequencies.'''),
+                'default': None,
+                'categorical': [None, 'balanced']
+            },
+            'random_state': {
+                'description': 'Random seed for reproducibility.',
+                'default': 42
+            },
+            'verbosity': {
+                'description': 'Controls the level of LightGBM verbosity.',
+                'default': -1,
+                'categorical': [-1, 0, 1]
+            }
+        }
+        self.model: LGBMClassifier = None
+        self.columns: list[str] = []
+        self.categorical_columns: list[str] = []
+        self._category_levels: dict[str, list] = {}
+
+    def _select_features(self, X):
+        if self.columns and hasattr(X, 'columns'):
+            return X[self.columns]
+        return X
+
+    def _prepare_features(self, X, fit: bool = False):
+        X_selected = self._select_features(X)
+        if not hasattr(X_selected, 'copy'):
+            return X_selected
+        X_prepared = X_selected.copy()
+        if self.categorical_columns:
+            for column in self.categorical_columns:
+                if column not in X_prepared.columns:
+                    continue
+                X_prepared[column] = X_prepared[column].astype('category')
+                if not fit and column in self._category_levels:
+                    X_prepared[column] = X_prepared[column].cat.set_categories(
+                        self._category_levels[column]
+                    )
+        if fit:
+            self._category_levels = {
+                column: list(X_prepared[column].cat.categories)
+                for column in self.categorical_columns
+                if column in X_prepared.columns and hasattr(X_prepared[column], 'cat')
+            }
+        return X_prepared
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        if LGBMClassifier is None:
+            raise ImportError(
+                "lightgbm is required for ActLightGBMClassifier. "
+                "Install with: pip install lightgbm"
+            )
+
+        self.columns = dataset.get_columns_names_by_type(
+            [DataType.NUMERIC, DataType.CATEGORICAL]
+        )
+        if not self.columns:
+            self.columns = dataset.features
+        self.categorical_columns = dataset.get_columns_names_by_type(DataType.CATEGORICAL)
+
+        X_prepared = self._prepare_features(dataset.X, fit=True)
+        self.model = LGBMClassifier(**self.passthrough_parameters())
+
+        categorical_features = []
+        if self.categorical_columns and hasattr(X_prepared, 'columns'):
+            categorical_features = [
+                col for col in self.categorical_columns if col in X_prepared.columns
+            ]
+
+        try:
+            if categorical_features:
+                self.model.fit(
+                    X_prepared,
+                    dataset.y,
+                    categorical_feature=categorical_features
+                )
+            else:
+                self.model.fit(X_prepared, dataset.y)
+        except _LGBM_ERRORS as exc:
+            raise ValueError(f"LightGBMClassifier training failed: {exc}") from exc
+        return self
+
+    def predict(self, X):
+        return super().predict(self._prepare_features(X))
+
+    def predict_proba(self, X):
+        return super().predict_proba(self._prepare_features(X))
+
+    def score(self, X, y=None, *args, **kwargs):
+        return self.model.score(self._prepare_features(X), y, *args, **kwargs)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        supported = dataset.get_columns_names_by_type(
+            [DataType.NUMERIC, DataType.CATEGORICAL]
+        )
+        return LGBMClassifier is not None and dataset.type_of_target in \
+            ['binary', 'multiclass', 'multilabel-indicator'] and bool(supported)
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/classifier/act_linear_discriminant_analysis.py

@@ -0,0 +1,63 @@
+"""
+[STEP] Linear Discriminant Analysis
+"""
+import textwrap
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActLinearDiscriminantAnalysis(Predictor):
+    """
+    [STEP] Linear Discriminant Analysis
+    """
+    name = "Linear Discriminant Analysis"
+    _description = textwrap.dedent('''\
+        LinearDiscriminantAnalysis is a machine learning algorithm that finds
+        a linear combination of features that maximizes the separation between
+        classes for classification tasks.''')
+    _description_long = textwrap.dedent('''\
+        LinearDiscriminantAnalysis is a type of dimensionality reduction
+        algorithm that finds a linear combination of features that maximizes the
+        separation between classes for classification tasks.
+        It works by calculating the within-class and between-class scatter matrices,
+        and then finding the directions in the feature space that maximize the ratio of
+        the between-class scatter to the within-class scatter.''')
+    _usage = "Use when you need a fast linear classifier; simpler than ActCatBoost or ActExtraTreesClassifier. Applicable to tabular numeric data with binary or multiclass labels. Avoid when strong nonlinear patterns or categorical splits favor ActDecisionTreeClassifier."
+    refs = [
+        {
+            'year': 1936,
+            'name': 'The Use of Multiple Measurements in Taxonomic Problems',
+            'authors': [
+                'Sir Ronald Aylmer Fisher'
+            ],
+            'doi': 'https://doi.org/10.1111/j.1469-1809.1936.tb02137.x',
+            'publisher': 'Annals of Eugenics Vol.7 page 179--188'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'tol': {
+                'description': textwrap.dedent('''\
+                    Absolute threshold for a singular value of X to be
+                    considered significant, used to estimate the rank of X.'''),
+                'default': 0.0001,
+                'range': [1e-05, 0.1]
+            }
+        }
+        self.model: LinearDiscriminantAnalysis = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = LinearDiscriminantAnalysis(**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']
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/classifier/act_linear_svc.py

@@ -0,0 +1,134 @@
+"""[STEP] Linear SVC Classifier"""
+import textwrap
+from typing import Any
+from sklearn.svm import LinearSVC
+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', 'classifier')
+class ActLinearSVC(Predictor):
+    """[STEP] Linear SVC Classifier"""
+
+    name: str = "Linear SVC Classifier"
+    _description: str = textwrap.dedent('''\
+        LinearSVC is a fast linear support vector classifier for high-dimensional
+        feature spaces, fitting a linear decision boundary with a large margin.''')
+    _description_long: str = textwrap.dedent('''\
+        LinearSVC solves a linear SVM optimization problem with the liblinear
+        optimizer. It scales well to sparse and high-dimensional data and supports
+        multiclass classification via a one-vs-rest strategy.''')
+    _usage: str = "Use when you need a fast linear margin classifier for high-dimensional numeric or sparse data; compare ActComplementNB. Applicable to tabular numeric binary or multiclass targets. Avoid when strong non-linear patterns or tree ensembles like ActExtraTreesClassifier are needed."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1995,
+            'name': 'Support-Vector Networks',
+            'authors': [
+                'Corinna Cortes',
+                'Vladimir Vapnik'
+            ],
+            'doi': 'https://doi.org/10.1007/BF00994018',
+            'publisher': 'Machine Learning Vol. 20, No. 3, page 273--297'
+        },
+        {
+            'year': 2008,
+            'name': 'LIBLINEAR: A Library for Large Linear Classification',
+            'authors': [
+                'Rong-En Fan',
+                'Kai-Wei Chang',
+                'Cho-Jui Hsieh',
+                'Xiang-Rui Wang',
+                'Chih-Jen Lin'
+            ],
+            'doi': 'https://doi.org/10.1145/1390681.1390687',
+            'publisher': 'Journal of Machine Learning Research Vol. 9, page 1871--1874'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'C': {
+                'description': 'Inverse of regularization strength.',
+                'default': 1.0,
+                'range': [1e-03, 100.0]
+            },
+            'penalty': {
+                'description': textwrap.dedent('''\
+                    Specify the norm of the penalty. The "l1" penalty requires
+                    loss="squared_hinge" and dual=False.'''),
+                'default': 'l2',
+                'categorical': ['l2', 'l1']
+            },
+            'loss': {
+                'description': textwrap.dedent('''\
+                    Loss function. The "hinge" loss requires penalty="l2" and dual=True.'''),
+                'default': 'squared_hinge',
+                'categorical': ['squared_hinge', 'hinge']
+            },
+            'dual': {
+                'description': textwrap.dedent('''\
+                    Select the dual optimization problem. Prefer True when
+                    n_samples < n_features.'''),
+                'default': True,
+                'categorical': [True, False]
+            },
+            'tol': {
+                'description': 'The stopping criterion.',
+                'default': 0.0001,
+                'range': [1e-05, 0.1]
+            },
+            'max_iter': {
+                'description': 'Maximum number of iterations.',
+                'default': 1000,
+                'range': [100, 5000]
+            },
+            'fit_intercept': {
+                'description': 'Whether to fit the intercept term.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'class_weight': {
+                'description': textwrap.dedent('''\
+                    The "balanced" mode uses values of y to adjust weights inversely
+                    proportional to class frequencies.'''),
+                'default': None,
+                'categorical': [None, 'balanced']
+            },
+            'random_state': {
+                'description': 'Random state for reproducibility.',
+                'default': 42
+            }
+        }
+        self.model: LinearSVC = 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 = LinearSVC(**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 \
+            ['binary', 'multiclass', 'multilabel-indicator'] \
+            and bool(dataset.get_columns_names_by_type(DataType.NUMERIC))
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/classifier/act_logistic_regression.py

@@ -0,0 +1,92 @@
+"""[STEP]  Logistic Regression Classifier"""
+import textwrap
+from typing import Any
+from sklearn.linear_model import LogisticRegression
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'fast_predictor', 'classifier', 'baseline_predictor')
+class ActLogisticRegression(Predictor):
+    """[STEP]  Logistic Regression Classifier"""
+
+    name: str = "Logistic Regression Classifier"
+    _description: str = textwrap.dedent('''\
+        LogisticRegression is a machine learning algorithm
+        that models the relationship between input features and a binary
+        output variable using a logistic function.''')
+    _description_long: str = textwrap.dedent('''\
+        LogisticRegression is a type of classification algorithm that models
+        the relationship between input features and a binary
+        output variable using a logistic function.
+        It works by finding the best-fitting line or hyperplane that
+        maximizes the likelihood of the observed output variables given the input features.''')
+    _usage: str = "Use when you need a fast linear baseline over ActDecisionTreeClassifier. Applicable to tabular binary or multiclass data with numeric or one-hot inputs. Avoid when nonlinear interactions dominate or max accuracy is required; prefer ActCatBoost."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1944,
+            'name': 'Application of the Logistic Function to Bio-Essay',
+            'authors': [
+                'Joseph Berkson'
+            ],
+            'doi': 'https://doi.org/10.2307/2280041',
+            'publisher': (
+                'Journal of the American Statistical Association '
+                'Vol. 39, No. 227, page 357--365'
+            )
+        },
+        {
+            'year': 1951,
+            'name': 'Why I Prefer Logits to Probits',
+            'authors': [
+                'Joseph Berkson'
+            ],
+            'doi': 'https://doi.org/10.2307/3001655',
+            'publisher': (
+                'Biometrics '
+                'Vol. 7, No. 4, page 327--339'
+            )
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            },
+            'penalty': {
+                'description': 'Specify the norm of the penalty',
+                'default': 'l2',
+                'categorical': ['l2', None]
+            },
+            'tol': {
+                'description': 'The stopping criterion.',
+                'default': 0.0001,
+                'range': [1e-05, 0.1]
+            },
+            'class_weight': {
+                'description': textwrap.dedent('''\
+                    The “balanced” mode uses the values of y to automatically
+                    adjust weights inversely proportional to class frequencies.'''),
+                'default': None,
+                'categorical': [None, 'balanced']
+            }
+        }
+        self.model: LogisticRegression = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = LogisticRegression(
+            **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_mlp_classifier.py

@@ -0,0 +1,107 @@
+"""[STEP] MLP Classifier"""
+
+import textwrap
+from typing import Any
+from sklearn.neural_network import MLPClassifier
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActMLPClassifier(Predictor):
+    """[STEP] MLP Classifier"""
+
+    name: str = "MLP Classifier"
+    _description: str = textwrap.dedent('''\
+        MLPClassifier is a machine learning algorithm that models the relationship
+        between input features and a categorical output variable using a
+        multi-layer perceptron neural network.''')
+    _description_long: str = textwrap.dedent('''\
+        MLPClassifier is a type of neural network algorithm that models the
+        relationship between input features and a categorical output variable using a
+        multi-layer perceptron (MLP) neural network.
+        It works by transforming the input features through one or more hidden layers with
+        non-linear activation functions, and then using a final layer with a softmax activation
+        function to output a probability distribution over the classes.''')
+    _usage: str = "Use when you need a nonlinear tabular classifier and can tune, versus ActDecisionTreeClassifier or ActExtraTreesClassifier. Applicable to binary or multiclass tabular features. Avoid when data are small, very sparse, or you need fast, transparent models like ActBernoulliNb."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1989,
+            'name': 'Connectionist Learning Procedures',
+            'authors': [
+                'Geoffrey E. Hinton'
+            ],
+            'doi': 'https://doi.org/10.1016/0004-3702(89)90049-0',
+            'publisher': 'Artificial intelligence Vol. 40.1 page 185--234'
+        },
+        {
+            'year': 2010,
+            'name': 'Understanding the difficulty of training deep feedforward neural networks',
+            'authors': [
+                'Xavier Glorot',
+                'Yoshua Bengio'
+            ],
+            'doi': "https://www.semanticscholar.org/paper/\
+                Understanding-the-difficulty-of-training-deep-Glorot-Bengio/\
+                    ea9d2a2b4ce11aaf85136840c65f3bc9c03ab649",
+            'publisher': (
+                'Proceedings of the Thirteenth International Conference on '
+                'Artificial Intelligence and Statistics page 249--256'
+            )
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'activation': {
+                'description': 'Activation function for the hidden layer.',
+                'default': 'relu',
+                'categorical': ["tanh", "relu"]
+                },
+            'alpha': {
+                'description': textwrap.dedent('''\
+                    Strength of the L2 regularization term. The L2
+                    regularization term is divided by the sample size when
+                    added to the loss.'''),
+                'default': 0.0001,
+                'range': [1e-07, 0.1]
+                },
+            'hidden_layer_count': {
+                'description': 'NUmber of hidden layer',
+                'default': 1,
+                'range': [1, 4],
+                'passthrough': False
+                },
+            'node_per_layer': {
+                'description': 'Number of node per layer',
+                'default': 32,
+                'range': [16, 256],
+                'passthrough': False
+                },
+            'learning_rate_init': {
+                'description': 'Learning rate schedule for weight updates',
+                'default': 0.001,
+                'range': [0.0001, 0.5]
+                }
+            }
+        self.model: MLPClassifier = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = MLPClassifier(
+            hidden_layer_sizes=[self.get_config('node_per_layer') \
+                for i in range(self.get_config('hidden_layer_count'))],
+            early_stopping=True,
+            max_iter=400,
+            **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