PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/predictors/classifier/act_multinomial_nb.py

@@ -0,0 +1,76 @@
+"""
+[STEP] Multinomial NB
+"""
+
+import textwrap
+from sklearn.naive_bayes import MultinomialNB
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActMultinomialNB(Predictor):
+    """
+    [STEP] Multinomial NB
+    """
+    name = "Multinomial NB"
+    _usage = "Use when non-negative counts or frequencies drive class signal and you want a fast baseline vs ActComplementNB or ActBernoulliNb. Applicable to tabular bag-of-words or count features for binary or multiclass targets. Avoid when features include negatives, strong feature interactions, or need nonlinear splits."
+    _description = textwrap.dedent('''\
+        MultinomialNB is a machine learning algorithm that models
+        the relationship between input features and a categorical output variable
+        using a multinomial distribution.''')
+    _description_long = textwrap.dedent('''\
+        MultinomialNB is a type of naive Bayes algorithm that models
+        the relationship between input features and a categorical output variable using
+        a multinomial distribution. It works by assuming that the input features are
+        independent and follow a multinomial distribution, where each feature is represented
+        by the number of times it appears in a document or bag-of-words representation.''')
+    refs = [
+        {
+            'year': 2008,
+            'name': 'Introduction to Information Retrieval',
+            'authors': [
+                'Christopher D. Manning',
+                'Prabhakar Raghaban',
+                'Hinrich Schütze'
+            ],
+            'doi': "https://doi.org/10.1017/CBO9780511809071",
+            'publisher': 'Cambridge University Press'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'alpha': {
+                'description': textwrap.dedent('''\
+                    Additive (Laplace/Lidstone) smoothing parameter (set
+                    alpha=0 and force_alpha=True, 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]
+            }
+        }
+
+        self.model: MultinomialNB = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = MultinomialNB(**self.passthrough_parameters())
+
+        self.model.fit(dataset.X, dataset.y)
+
+        return self
+
+
+    def suitable(self, dataset: Dataset) -> bool:
+        # Negative values are not supported
+        return not((dataset.X < 0).any().any()) \
+            and dataset.type_of_target in ['binary', 'multiclass']
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/classifier/act_passive_aggressive_classifier.py

@@ -0,0 +1,141 @@
+"""[STEP] Passive Aggressive Classifier"""
+import textwrap
+from typing import Any
+import numpy as np
+from sklearn.linear_model import PassiveAggressiveClassifier
+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 ActPassiveAggressiveClassifier(Predictor):
+    """[STEP] Passive Aggressive Classifier"""
+
+    name: str = "Passive Aggressive Classifier"
+    _usage: str = "Use when you need a fast online linear classifier for large or streaming data. Applicable to numeric tabular binary/multiclass or multilabel targets. Avoid when patterns are nonlinear or categorical-heavy; prefer ActDecisionTreeClassifier or ActExtraTreesClassifier."
+    _description: str = textwrap.dedent('''\
+        PassiveAggressiveClassifier is an online linear classifier that updates
+        only on misclassified samples, making it suitable for streaming or
+        large-scale data.''')
+    _description_long: str = textwrap.dedent('''\
+        PassiveAggressiveClassifier is an online learning algorithm that performs
+        aggressive updates when samples are misclassified and stays passive otherwise.
+        It learns a linear decision boundary efficiently with hinge-style losses and
+        supports multiclass problems with a one-vs-rest strategy.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Online Passive-Aggressive Algorithms',
+            'authors': [
+                'Koby Crammer',
+                'Ofer Dekel',
+                'Joseph Keshet',
+                'Shai Shalev-Shwartz',
+                'Yoram Singer'
+            ],
+            'doi': 'https://doi.org/10.5555/1248547.1248566',
+            'publisher': 'Advances in Neural Information Processing Systems 19'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'C': {
+                'description': 'Maximum step size (regularization strength).',
+                'default': 1.0,
+                'range': [1e-03, 100.0]
+            },
+            'loss': {
+                'description': 'The loss function to be used.',
+                'default': 'hinge',
+                'categorical': ['hinge', 'squared_hinge']
+            },
+            'max_iter': {
+                'description': 'Maximum number of passes over the training data.',
+                'default': 1000,
+                'range': [100, 5000]
+            },
+            'tol': {
+                'description': 'The stopping criterion.',
+                'default': 0.001,
+                'range': [1e-05, 0.1]
+            },
+            'fit_intercept': {
+                'description': 'Whether to fit the intercept term.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'shuffle': {
+                'description': 'Whether to shuffle the training data after each epoch.',
+                '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']
+            },
+            'average': {
+                'description': textwrap.dedent('''\
+                    When set to True, computes the averaged weights across all updates.'''),
+                'default': False,
+                'categorical': [True, False]
+            },
+            'random_state': {
+                'description': 'Random state for reproducibility.',
+                'default': 42
+            }
+        }
+        self.model: PassiveAggressiveClassifier = None
+        self.columns: list[str] = []
+        self.target_type: str | None = None
+
+    def _select_features(self, X):
+        if self.columns and hasattr(X, 'columns'):
+            return X[self.columns]
+        return X
+
+    def _decision_function_proba(self, scores: np.ndarray) -> np.ndarray:
+        if scores.ndim == 1:
+            probs_pos = 1.0 / (1.0 + np.exp(-scores))
+            return np.column_stack([1.0 - probs_pos, probs_pos])
+        if self.target_type == 'multilabel-indicator':
+            return 1.0 / (1.0 + np.exp(-scores))
+        max_scores = np.max(scores, axis=1, keepdims=True)
+        exp_scores = np.exp(scores - max_scores)
+        return exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
+
+    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.target_type = dataset.type_of_target
+        self.model = PassiveAggressiveClassifier(**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):
+        if self.model is None:
+            raise AttributeError("Model is not fitted")
+        scores = self.model.decision_function(self._select_features(X))
+        return self._decision_function_proba(np.asarray(scores))
+
+    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_quadratic_discriminant_analysis.py

@@ -0,0 +1,72 @@
+"""
+[STEP] Quadratic Discriminant Analysis
+"""
+
+import textwrap
+from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActQuadraticDiscriminantAnalysis(Predictor):
+    """
+    [STEP] Quadratic Discriminant Analysis
+    """
+    name = "Quadratic Discriminant Analysis"
+    _usage = "Use when class covariances differ and you want a fast probabilistic baseline vs ActDecisionTreeClassifier or ActExtraTreesClassifier. Applicable to tabular numeric features for binary or multiclass targets. Avoid when data are highly non-Gaussian, sparse, or p>>n."
+    _description = textwrap.dedent('''\
+        QuadraticDiscriminantAnalysis is a machine learning algorithm
+        that models the relationship between input features and a categorical
+        output variable using a quadratic function.''')
+    _description_long = textwrap.dedent('''\
+        QuadraticDiscriminantAnalysis is a type of discriminant analysis
+        algorithm that models the relationship between input features and a categorical output
+        variable using a quadratic function.
+        It works by estimating the covariance matrices of the classes and using
+        them to calculate the probability density functions for each class.
+        The class with the highest probability density function is then used to make
+        the prediction.''')
+    refs = [
+        {
+            'year': 1965,
+            'name': 'Geometrical and Statistical Properties of Systems of Linear Inequalities \
+                with Applications in Pattern Recognition',
+            'authors': ['Thomas M. Cover'],
+            'doi': 'https://doi.org/10.1109/PGEC.1965.264137',
+            'publisher': 'IEEE Transactions on Electronic Computers Vol.EC-14 page 326--334'
+        },
+        {
+            'year': 2016,
+            'name': 'Linear vs. quadratic discriminant analysis classifier: a tutorial',
+            'authors': ['Alaa Tharwat'],
+            'doi': 'https://www.inderscienceonline.com/doi/abs/10.1504/IJAPR.2016.079050',
+            'publisher': 'International Journal of Applied Pattern Recognition \
+                Vol.3, No.2 page 145--180'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'reg_param': {
+                'description': 'Regularizes the per-class covariance estimates by transforming S2',
+                'default': 0.0001,
+                'range': [0.0001, 1.0]
+            }
+        }
+        self.model: QuadraticDiscriminantAnalysis = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = QuadraticDiscriminantAnalysis(**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_randomforest.py

@@ -0,0 +1,113 @@
+"""[STEP]  Random Forest"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import RandomForestClassifier
+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 ActRandomForest(Predictor):
+    """[STEP]  Random Forest"""
+
+    name: str = "Random Forest"
+    _usage: str = "Use when you need a solid tabular classifier baseline and prefer it over ActExtraTreesClassifier for stability. Applicable to binary, multiclass, or multilabel tabular data with tree-ready features. Avoid when data is extremely sparse text or you need native categorical handling."
+    _description: str = textwrap.dedent('''\
+        RandomForestClassifier is a machine learning algorithm that models
+        the relationship between input features and a categorical output variable using
+        a collection of decision trees.''')
+    _description_long: str = textwrap.dedent('''\
+        RandomForestClassifier is a type of ensemble learning algorithm that
+        models the relationship between input features and a categorical 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 using a majority vote to make
+        the final prediction.''')
+    refs: tuple[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'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'max_depth': {
+                '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': "gini",
+                'categorical': ['gini', 'entropy', 'log_loss']
+            }
+        }
+        self.model: RandomForestClassifier = 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 = RandomForestClassifier(**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_ridge_classifier.py

@@ -0,0 +1,116 @@
+"""[STEP] Ridge Classifier"""
+import textwrap
+from typing import Any
+from sklearn.linear_model import RidgeClassifier
+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 ActRidgeClassifier(Predictor):
+    """[STEP] Ridge Classifier"""
+
+    name: str = "Ridge Classifier"
+    _usage: str = "Use when you need a fast linear L2 baseline on numeric tabular data, vs ActDecisionTreeClassifier or ActExtraTreesClassifier. Applicable to binary/multiclass targets with mostly numeric features. Avoid when data is mostly categorical, highly nonlinear, or ActCatBoost fits better."
+    _description: str = textwrap.dedent('''\
+        RidgeClassifier is a linear classifier that applies L2
+        regularization to reduce sensitivity to noisy features.''')
+    _description_long: str = textwrap.dedent('''\
+        RidgeClassifier fits a linear decision boundary by solving a
+        regularized least squares problem. The L2 penalty stabilizes
+        coefficients when features are correlated and improves robustness
+        to noise in tabular datasets.''')
+    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]
+            },
+            '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 solvers that use randomness.',
+                'default': 42
+            }
+        }
+        self.model: RidgeClassifier = 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 = RidgeClassifier(**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_sgd_classifier.py

@@ -0,0 +1,149 @@
+"""[STEP] SGD Classifier"""
+import textwrap
+from typing import Any
+import numpy as np
+from sklearn.linear_model import SGDClassifier
+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 ActSGDClassifier(Predictor):
+    """[STEP] SGD Classifier"""
+
+    name: str = "SGD Classifier"
+    _description: str = textwrap.dedent('''\
+        SGDClassifier is a linear classifier optimized with stochastic gradient
+        descent, suitable for large-scale classification tasks.''')
+    _description_long: str = textwrap.dedent('''\
+        SGDClassifier learns a linear decision boundary using stochastic gradient
+        descent. It supports hinge loss (linear SVM) and logistic loss for
+        probabilistic classification, making it efficient on large datasets.''')
+    _usage: str = "Use when you need a fast linear classifier for large numeric tabular data, as a baseline vs ActDecisionTreeClassifier or ActExtraTreesClassifier. Applicable to binary, multiclass, or multilabel targets with numeric features. Avoid when data are mostly categorical or require complex nonlinear boundaries."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2010,
+            'name': 'Large-Scale Machine Learning with Stochastic Gradient Descent',
+            'authors': [
+                'Leon Bottou'
+            ],
+            'doi': 'https://doi.org/10.1145/1796439.1796440',
+            'publisher': 'Proceedings of COMPSTAT 2010'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'loss': {
+                'description': 'The loss function to be used.',
+                'default': 'log_loss',
+                'categorical': ['log_loss', 'hinge']
+            },
+            'penalty': {
+                'description': 'The penalty (regularization term) to be used.',
+                'default': 'l2',
+                'categorical': ['l2', 'l1', 'elasticnet']
+            },
+            'alpha': {
+                'description': 'Constant that multiplies the regularization term.',
+                'default': 0.0001,
+                'range': [1e-07, 0.1]
+            },
+            'l1_ratio': {
+                'description': 'The Elastic Net mixing parameter.',
+                'default': 0.15,
+                'range': [1e-09, 1.0]
+            },
+            'max_iter': {
+                'description': 'Maximum number of passes over the training data.',
+                'default': 1000,
+                'range': [100, 5000]
+            },
+            'tol': {
+                'description': 'The stopping criterion.',
+                'default': 0.001,
+                'range': [1e-05, 0.1]
+            },
+            'learning_rate': {
+                'description': 'Learning rate schedule.',
+                'default': 'optimal',
+                'categorical': ['optimal', 'invscaling', 'constant', 'adaptive']
+            },
+            'eta0': {
+                'description': textwrap.dedent('''\
+                    The initial learning rate for the "constant", "invscaling"
+                    or "adaptive" schedules.'''),
+                'default': 0.01,
+                'range': [1e-07, 0.1]
+            },
+            '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']
+            },
+            '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
+            },
+            'random_state': {
+                'description': 'Random state for reproducibility.',
+                'default': 42
+            }
+        }
+        self.model: SGDClassifier = None
+        self.columns: list[str] = []
+        self.target_type: str | None = None
+
+    def _select_features(self, X):
+        if self.columns and hasattr(X, 'columns'):
+            return X[self.columns]
+        return X
+
+    def _decision_function_proba(self, scores: np.ndarray) -> np.ndarray:
+        if scores.ndim == 1:
+            probs_pos = 1.0 / (1.0 + np.exp(-scores))
+            return np.column_stack([1.0 - probs_pos, probs_pos])
+        if self.target_type == 'multilabel-indicator':
+            return 1.0 / (1.0 + np.exp(-scores))
+        max_scores = np.max(scores, axis=1, keepdims=True)
+        exp_scores = np.exp(scores - max_scores)
+        return exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
+
+    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.target_type = dataset.type_of_target
+        self.model = SGDClassifier(**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):
+        if self.model is None:
+            raise AttributeError("Model is not fitted")
+        if getattr(self.model, 'loss', None) in ['log_loss', 'modified_huber']:
+            return self.model.predict_proba(self._select_features(X))
+        scores = self.model.decision_function(self._select_features(X))
+        return self._decision_function_proba(np.asarray(scores))
+
+    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