PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/predictors/classifier/act_complement_nb.py

@@ -0,0 +1,106 @@
+"""[STEP] Complement NB"""
+
+import textwrap
+from typing import Any
+from sklearn.naive_bayes import ComplementNB
+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 ActComplementNB(Predictor):
+    """[STEP] Complement NB"""
+
+    name: str = "Complement NB"
+    _usage: str = "Use when you need a fast NB baseline for imbalanced count features vs ActBernoulliNb. Applicable to non-negative numeric data (counts/TF-IDF) for binary or multiclass classification. Avoid when features are negative/continuous or nonlinear patterns favor ActCatBoost."
+    _description: str = textwrap.dedent('''\
+        ComplementNB is a Naive Bayes variant tailored for imbalanced text
+        classification by using statistics from the complement of each class.''')
+    _description_long: str = textwrap.dedent('''\
+        ComplementNB modifies the traditional multinomial Naive Bayes formula
+        by estimating feature weights from the complement of each class. This
+        reduces the bias toward frequent classes, making it effective for
+        imbalanced text datasets and high-dimensional sparse features.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2003,
+            'name': 'Tackling the Poor Assumptions of Naive Bayes Text Classifiers',
+            'authors': [
+                'Jason D. M. Rennie',
+                'Lawrence Shih',
+                'Jaime Teevan',
+                'David R. Karger'
+            ],
+            'doi': 'https://dl.acm.org/doi/10.5555/944919.944939',
+            'publisher': (
+                'Proceedings of the 20th International Conference on Machine Learning '
+                '(ICML), pages 616--623'
+            )
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'alpha': {
+                'description': textwrap.dedent('''\
+                    Additive (Laplace/Lidstone) smoothing parameter (set
+                    alpha=0 for no smoothing).'''),
+                'default': 1.0,
+                'range': [0.01, 100.0]
+            },
+            'fit_prior': {
+                'description': textwrap.dedent('''\
+                    Whether to learn class prior probabilities or not. If
+                    false, a uniform prior will be used.'''),
+                'default': True,
+                'categorical': [True, False]
+            },
+            'norm': {
+                'description': textwrap.dedent('''\
+                    Whether to normalize by the total feature counts per class
+                    to reduce the influence of document length.'''),
+                'default': False,
+                'categorical': [True, False]
+            }
+        }
+        self.model: ComplementNB = 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 = ComplementNB(**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:
+        if dataset.type_of_target not in ['binary', 'multiclass']:
+            return False
+
+        columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if not columns:
+            return False
+
+        try:
+            return not (dataset.X[columns] < 0).any().any()
+        except (TypeError, ValueError):
+            return False
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/classifier/act_decision_tree_classifier.py

@@ -0,0 +1,117 @@
+"""[STEP]  Decision Tree Classifier"""
+import textwrap
+from typing import Any
+from sklearn.tree import DecisionTreeClassifier
+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 ActDecisionTreeClassifier(Predictor):
+    """[STEP]  Decision Tree Classifier"""
+
+    name: str = "Decision Tree Classifier"
+    _description: str = textwrap.dedent('''\
+        DecisionTreeClassifier is a tree-based algorithm that learns
+        if-then rules to predict a categorical target.''')
+    _description_long: str = textwrap.dedent('''\
+        DecisionTreeClassifier builds a tree by recursively splitting the data
+        on feature thresholds to reduce impurity. The resulting tree can be
+        inspected for interpretability.''')
+    _usage: str = "Use when you want a fast, interpretable baseline; compare ActExtraTreesClassifier or ActBaggingClassifier. Applicable to tabular classification with numeric features and binary or multiclass targets. Avoid when you need top accuracy or stability on noisy data."
+    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': 'gini',
+                'categorical': ['gini', 'entropy', 'log_loss']
+            },
+            'splitter': {
+                'description': 'Strategy used to choose the split at each node.',
+                'default': 'best',
+                'categorical': ['best', 'random']
+            },
+            '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: DecisionTreeClassifier = 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 = DecisionTreeClassifier(**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 predict_proba(self, X):
+        return super().predict_proba(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_extra_trees_classifier.py

@@ -0,0 +1,115 @@
+"""[STEP] Extra Trees Classifier"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import ExtraTreesClassifier
+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', 'classifier')
+class ActExtraTreesClassifier(Predictor):
+    """[STEP] Extra Trees Classifier"""
+
+    name: str = "Extra Trees Classifier"
+    _description: str = textwrap.dedent('''\
+        ExtraTreesClassifier is a machine learning algorithm that makes
+        predictions by combining the outputs of multiple decision trees.''')
+    _description_long: str = textwrap.dedent('''\
+        ExtraTreesClassifier is a type of ensemble learning algorithm that
+        belongs to the family of decision tree-based models. It works by building multiple
+        decision trees, where each tree is trained on a random subset of the input feature
+        and a random subset of the training data. At prediction time, the algorithm aggregates
+        the outputs of all the decision trees to make a final prediction.''')
+    _usage: str = "Use when you want a low-tuning tabular classifier, stronger than ActDecisionTreeClassifier and simpler than ActBaggingClassifier. Applicable to numeric/categorical tabular data for binary or multiclass. Avoid when you need calibrated probabilities or very sparse text features."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Extremely randomized trees',
+            'authors': [
+                'Pierre Geurts',
+                'Damien Ernst',
+                'Louis Wehenkel'
+            ],
+            'doi': 'https://doi.org/10.1007/s10994-006-6226-1',
+            'publisher': 'Machine Learning Vol. 63 page 3--42'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'max_depth': {
+                'description': 'Max depth of each tree',
+                'default': 15,
+                'range': [1, 100]
+            },
+            'min_samples_leaf': {
+                'description': 'The minimum number of samples required to be at a leaf node.',
+                'default': 1,
+                'range': [1, 15]
+            },
+            '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
+            },
+            'max_features': {
+                'description': 'The number of features to consider when looking for the best split',
+                'default': 'sqrt',
+                'categorical': ['sqrt', 'log2']
+            },
+            'criterion': {
+                'description': 'The function to measure the quality of a split.',
+                'default': "gini",
+                'categorical': ['gini', 'entropy']
+            },
+            'n_estimators': {
+                'description': 'Number of threes',
+                'default': 100,
+                'range': [1, 500]
+            },
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            }
+        }
+        self.model: ExtraTreesClassifier = 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 = ExtraTreesClassifier(**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 predict_proba(self, X):
+        return super().predict_proba(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_gaussian_nb.py

@@ -0,0 +1,53 @@
+"""[STEP] Gaussian NB"""
+
+import textwrap
+from typing import Any
+from sklearn.naive_bayes import GaussianNB
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActGaussianNb(Predictor):
+    """[STEP] Gaussian NB"""
+
+    name: str = " Gaussian NB"
+    _description: str = textwrap.dedent('''\
+        GaussianNB is a machine learning algorithm that makes predictions
+        based on the Gaussian (normal) distribution of the input features.''')
+    _description_long: str = textwrap.dedent('''\
+        GaussianNB is a type of naive Bayes classifier that assumes the
+        input features are independent and follow a Gaussian (normal) distribution.
+        It uses Bayes' theorem to calculate the probability of each class given the
+        input features and then makes a prediction based on the highest probability.
+        GaussianNB is particularly useful when the input features have a continuous
+        distribution and can be modeled well by a normal distribution.
+        It is a simple and fast algorithm that works well for many classification problems,
+        especially when the number of features is much larger than the number of samples.''')
+    _usage: str = "Use when you need a fast baseline for continuous features; consider ActBernoulliNb for binary features or ActCatBoost for higher accuracy. Applicable to tabular binary/multiclass tasks with roughly normal feature distributions. Avoid when features are strongly dependent or mostly categorical."
+    refs: list[dict[str, Any]] = []
+
+    def __init__(self):
+        self.configuration = {
+            'var_smoothing': {
+                'description': textwrap.dedent('''\
+                    Portion of the largest variance of all features that is
+                    added to variances for calculation stability.'''),
+                'default': 1e-9,
+                'range': [1e-11, 1e-4]
+            },
+        }
+        self.model: GaussianNB = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = GaussianNB(**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_hist_gradient_boosting_classifier.py

@@ -0,0 +1,144 @@
+"""[STEP] HistGradient Boosting Classifier"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import HistGradientBoostingClassifier
+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 ActHistGradientBoostingClassifier(Predictor):
+    """[STEP] HistGradient Boosting Classifier"""
+
+    name: str = "HistGradient Boosting Classifier"
+    _description: str = textwrap.dedent('''\
+        HistGradientBoostingClassifier is a gradient boosting method that
+        uses histogram-based binning to speed up training on large datasets.''')
+    _description_long: str = textwrap.dedent('''\
+        HistGradientBoostingClassifier builds a sequence of decision trees using
+        histograms of feature values to reduce computation. It supports
+        regularization and early stopping to control overfitting while keeping
+        training fast on large datasets.''')
+    _usage: str = "Use when you want strong tabular accuracy on large numeric data; compare ActCatBoost for categorical-heavy data or ActExtraTreesClassifier for simpler ensembles. Applicable to binary, multiclass, or multilabel-indicator targets with numeric features. Avoid when features are mostly categorical or a simple baseline like ActDecisionTreeClassifier is preferred."
+    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 = {
+            'learning_rate': {
+                'description': 'The learning rate, also known as shrinkage.',
+                'default': 0.1,
+                'range': [0.01, 1.0]
+            },
+            'max_iter': {
+                'description': 'The maximum number of boosting iterations.',
+                'default': 100,
+                'range': [50, 500]
+            },
+            'max_leaf_nodes': {
+                'description': 'The maximum number of leaves for each tree.',
+                'default': 31,
+                'range': [3, 2048]
+            },
+            'max_depth': {
+                'description': 'The maximum depth of each tree.',
+                'default': None,
+                'categorical': [None, 3, 5, 10, 15]
+            },
+            'min_samples_leaf': {
+                'description': 'The minimum number of samples per leaf.',
+                'default': 20,
+                'range': [1, 200]
+            },
+            'l2_regularization': {
+                'description': 'The L2 regularization parameter.',
+                'default': 1e-10,
+                'range': [1e-10, 1.0]
+            },
+            'max_bins': {
+                'description': 'The maximum number of bins to use for continuous features.',
+                'default': 255,
+                'range': [16, 255]
+            },
+            'validation_fraction': {
+                'description': 'The proportion of data used for early stopping.',
+                'default': 0.1,
+                'range': [0.05, 0.3]
+            },
+            'n_iter_no_change': {
+                'description': 'Used to determine when to early stop.',
+                'default': 10,
+                'range': [2, 20]
+            },
+            'tol': {
+                'description': 'The absolute tolerance to use when comparing scores.',
+                'default': 1e-4,
+                'range': [1e-8, 1e-2]
+            },
+            '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: HistGradientBoostingClassifier = 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 = HistGradientBoostingClassifier(
+            early_stopping=True,
+            **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 predict_proba(self, X):
+        return super().predict_proba(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_knn.py

@@ -0,0 +1,86 @@
+
+"""[STEP]  KNN"""
+import textwrap
+from typing import Any
+from sklearn.neighbors import KNeighborsClassifier
+from ....predictor import Predictor
+from ....candidate import Candidate
+from ....dataset import Dataset
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActKNN(Predictor):
+    """[STEP]  KNN"""
+
+    name: str = "KNN"
+    _usage: str = "Use when you want a simple distance-based baseline on small to medium data; compare ActDecisionTreeClassifier or ActCatBoost for stronger baselines. Applicable to tabular data with numeric features and meaningful distance metrics. Avoid when data is high-dimensional, very large, or needs fast prediction."
+    _description: str = textwrap.dedent('''\
+        KNeighborsClassifier is a machine learning algorithm that makes
+        predictions for classification tasks using k-nearest neighbors.''')
+    _description_long: str = textwrap.dedent('''\
+        KNeighborsClassifier is a type of instance-based learning
+        algorithm that makes predictions for new input features based on the labels
+        of the k-nearest neighbors in the training data.
+        It works by calculating the distance between the new input features and all
+        the training data, and then selecting the k-nearest neighbors based on that distance
+        The label for the new input features is then determined by a majority vote of the
+        labels of the k-nearest neighbors.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1951,
+            'name': 'Discriminatory Analysis, Nonparametric Discrimination: Consistency Properties',
+            'authors': [
+                'Evelyn Fix',
+                'Joseph Lawson Hodges Jr.'
+            ],
+            'doi': 'https://doi.org/10.2307/1403797',
+            'publisher': 'Technical Report 4, USAF School of Aviation Medicine, Randolph Field'
+        },
+        {
+            'year': 1967,
+            'name': 'Nearest neighbor pattern classification',
+            'authors': [
+                'Thomas M. Cover',
+                'Peter E. Hart'
+            ],
+            'doi': 'https://doi.org/10.1109/TIT.1967.1053964',
+            'publisher': 'IEEE Transactions on Information Theory. 13: page 21--27'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'metric': {
+                'description': 'Can be minkowski or manhattan',
+                'default': 'minkowski',
+                'categorical': ['minkowski', 'manhattan']
+            },
+            'n_neighbors': {
+                'description': 'Number of neighbors',
+                'default': 5,
+                'range': [1, 200],
+                'passthrough': False
+            },
+            'weights': {
+                'description': 'Weight function used in prediction.',
+                'default': 'uniform',
+                'categorical': ['uniform', 'distance']
+            }
+        }
+        self.model: KNeighborsClassifier = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = KNeighborsClassifier(
+            n_neighbors = min(self.get_config('n_neighbors'), dataset.X.shape[0]),
+            **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