PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/normalize/act_normalizer.py

@@ -0,0 +1,95 @@
+"""[STEP] Normalizer"""
+import textwrap
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import Normalizer
+from ...actionable import Actionable
+from ...candidate import Candidate
+from ...data_type import DataType
+from ...dataset import Dataset
+from ...decorators.all import is_step
+
+
+@is_step('normalize')
+class ActNormalizer(Actionable):
+    """[STEP] Normalizer"""
+
+    name: str = "Normalizer"
+    _description: str = textwrap.dedent('''\
+        Normalizer scales each sample so its L1 or L2 norm equals one,
+        keeping per-sample magnitudes comparable.''')
+    _description_long: str = textwrap.dedent('''\
+        Normalizer rescales each row independently by dividing its values
+        by the L1 or L2 norm. This preserves the direction of each sample
+        while making their magnitudes comparable, which is helpful when
+        features represent frequencies, counts, or embeddings.''')
+    _usage: str = "Use when you need per-sample L1/L2 normalization for row magnitude comparability, especially for counts or embeddings. Applicable to numeric features where each row should be unit norm. Avoid when feature-wise scaling is needed; consider ActMinMaxScaler or ActRobustScaler."
+
+    def __init__(self):
+        self.columns: list[str] = None
+        self.normalizer: Normalizer = None
+
+        self.configuration = {
+            'norm': {
+                'description': 'Normalization type to apply to each sample.',
+                'default': 'l2',
+                'categorical': ['l1', 'l2']
+            },
+            'copy': {
+                'description': 'Set to False to perform normalization in-place when possible.',
+                'default': True,
+                'categorical': [True, False]
+            }
+        }
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if self.columns and not dataset.X.empty:
+            values = dataset.X[self.columns]
+            self.normalizer = Normalizer(**self.passthrough_parameters())
+            self.normalizer.fit(values)
+        else:
+            self.normalizer = None
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply normalization
+
+        :param pd.DataFrame X: DataFrame to transform
+        :return: Transformed dataset
+        """
+        if self.normalizer and self.columns:
+            columns = [column for column in self.columns if column in X.columns]
+            if not columns:
+                return X
+            X[columns] = self.normalizer.transform(X[columns])
+        return X
+
+    def suitable(self, dataset: Dataset) -> bool:
+        columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        return bool(columns) and not dataset.X.empty
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        if candidate is None:
+            return 0.0
+        columns = candidate.dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if not columns or candidate.dataset.X.empty:
+            return 0.0
+        values = candidate.dataset.X[columns]
+        if values.empty:
+            return 0.0
+        matrix = values.to_numpy(dtype=float, copy=True)
+        if np.isnan(matrix).any():
+            matrix = np.nan_to_num(matrix, nan=0.0)
+        if self.get_config('norm') == 'l1':
+            norms = np.sum(np.abs(matrix), axis=1)
+        else:
+            norms = np.linalg.norm(matrix, axis=1)
+        if norms.size == 0:
+            return 0.0
+        nonzero = norms > 0
+        if not nonzero.any():
+            return 0.0
+        norms = norms[nonzero]
+        mean_deviation = float(np.mean(np.abs(norms - 1.0)))
+        return min(1.0, mean_deviation)

iaml/actionables/normalize/act_robust_scaler.py

@@ -0,0 +1,111 @@
+"""[STEP] Robust Scaler"""
+import textwrap
+import pandas as pd
+from sklearn.preprocessing import RobustScaler
+from ...actionable import Actionable
+from ...candidate import Candidate
+from ...data_type import DataType
+from ...dataset import Dataset
+from ...decorators.all import is_step
+
+
+@is_step('normalize')
+class ActRobustScaler(Actionable):
+    """[STEP] Robust Scaler"""
+
+    name: str = "Robust Scaler"
+    _usage: str = "Use when numeric features have outliers or skew and you want robust scaling vs ActMinMaxScaler or ActMaxAbsScaler. Applicable to continuous numeric columns. Avoid when you need unit-norm vectors or the data has no outliers."
+    _description: str = textwrap.dedent('''\
+        RobustScaler centers and scales numeric data using the median and IQR
+        to reduce the impact of outliers.''')
+    _description_long: str = textwrap.dedent('''\
+        RobustScaler is a scaling technique that uses the median to center each
+        feature and the interquartile range (IQR) to scale it.
+        Because these statistics are resilient to extreme values, the transformation
+        is well suited for data sets that contain outliers.''')
+
+    def __init__(self):
+        self.columns: list[str] = None
+        self.scaler: RobustScaler = None
+
+        self.configuration = {
+            'with_centering': {
+                'description': 'Center data before scaling.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'with_scaling': {
+                'description': 'Scale data to the IQR.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'quantile_range_low': {
+                'description': 'Lower quantile used to compute the IQR.',
+                'default': 25.0,
+                'range': [0.0, 50.0]
+            },
+            'quantile_range_high': {
+                'description': 'Upper quantile used to compute the IQR.',
+                'default': 75.0,
+                'range': [50.0, 100.0]
+            },
+            'unit_variance': {
+                'description': 'Scale data so that scaled features have unit variance.',
+                'default': False,
+                'categorical': [True, False]
+            }
+        }
+
+    def _build_scaler(self) -> RobustScaler:
+        params = self.passthrough_parameters()
+        low = float(params.pop('quantile_range_low'))
+        high = float(params.pop('quantile_range_high'))
+        if low >= high:
+            low, high = 25.0, 75.0
+        params['quantile_range'] = (low, high)
+        return RobustScaler(**params)
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if self.columns:
+            values = dataset.X[self.columns]
+            self.scaler = self._build_scaler()
+            self.scaler.fit(values)
+        else:
+            self.scaler = None
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply robust scaler
+
+        :param pd.DataFrame X: DataFrame to transform
+        :return: Transformed dataset
+        """
+        if self.scaler and self.columns:
+            columns = [column for column in self.columns if column in X.columns]
+            if not columns:
+                return X
+            X[columns] = self.scaler.transform(X[columns])
+        return X
+
+    def suitable(self, dataset: Dataset) -> bool:
+        columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        return bool(columns) and not dataset.X.empty
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        if candidate is None:
+            return 0.0
+        columns = candidate.dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if not columns or candidate.dataset.X.empty:
+            return 0.0
+        values = candidate.dataset.X[columns]
+        q1 = values.quantile(0.25)
+        q3 = values.quantile(0.75)
+        iqr = q3 - q1
+        if (iqr == 0).all():
+            return 0.1
+        lower = q1 - 1.5 * iqr
+        upper = q3 + 1.5 * iqr
+        outliers = ((values < lower) | (values > upper)).sum().sum()
+        total = values.size or 1
+        return min(1.0, outliers / total * 5.0)

iaml/actionables/normalize/act_standard_scaler.py

@@ -0,0 +1,55 @@
+"""[STEP] Standard Scaler"""
+import textwrap
+from sklearn.preprocessing import StandardScaler
+import pandas as pd
+from ...actionable import Actionable
+from ...dataset import Dataset
+from ...candidate import Candidate
+from ...data_type import DataType
+from ...decorators.all import is_step
+
+@is_step('normalize')
+class ActStandardScaler(Actionable):
+    """[STEP] Standard Scaler"""
+
+    name: str = "Standard Scaler"
+    _description: str = textwrap.dedent('''\
+        StandardScaler helps computers understand complex data by transforming
+        it into numbers centered around zero with a standard deviation of one.''')
+    _description_long: str = textwrap.dedent('''\
+        StandardScaler is a machine learning technique used to standardize numerical
+        features by removing the mean and scaling to unit variance.
+        It works by calculating the mean and standard deviation for each feature in the training data,
+        then transforming all values such that they have a mean of zero and a variance of one.
+        This transformation helps to center data and is particularly useful in algorithms that assume
+        normality of features, like many machine learning models.''')
+
+    def __init__(self):
+        self.columns: list[str] = None
+        self.scaler: StandardScaler = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if self.columns:
+            values = dataset.X[self.columns]
+            self.scaler = StandardScaler()
+            self.scaler.fit(values)
+        else:
+            self.scaler = None
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply standard scaler
+
+        :param pd.DataFrame X: DataFrame to transform
+        :return: Transformed dataset
+        """
+        if self.scaler and self.columns:
+            columns = [column for column in self.columns if column in X.columns]
+            if not columns:
+                return X
+            X[columns] = self.scaler.transform(X[columns])
+        return X
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5

iaml/actionables/predictors/__init__.py

@@ -0,0 +1,6 @@
+"""
+Predictors Actionables
+"""
+from .classifier import *
+from .regressor import *
+from .survival import *

iaml/actionables/predictors/_xgboost.py

@@ -0,0 +1,16 @@
+"""Feature-name adaptation shared by the XGBoost predictors."""
+import pandas as pd
+
+
+_FEATURE_NAME_ESCAPES = str.maketrans({"%": "%25", "[": "%5B", "]": "%5D", "<": "%3C"})
+
+
+def xgboost_features(X):
+    """Escape names without collisions, preserving data and native name validation."""
+    if not isinstance(X, pd.DataFrame):
+        return X
+
+    renamed = X.copy(deep=False)
+    # Escaping '%' also distinguishes a literal escape sequence from its source.
+    renamed.rename(columns=lambda name: str(name).translate(_FEATURE_NAME_ESCAPES), inplace=True)
+    return renamed

iaml/actionables/predictors/classifier/__init__.py

@@ -0,0 +1,26 @@
+"""
+Classifier Predictors Actionables
+"""
+
+from .act_svm_svc import ActSVMSVC
+from .act_randomforest import ActRandomForest
+from .act_xgboost import ActXGBoost
+from .act_catboost_classifier import ActCatBoost
+from .act_gaussian_nb import ActGaussianNb
+from .act_knn import ActKNN
+from .act_logistic_regression import ActLogisticRegression
+from .act_bernoulli_nb import ActBernoulliNb
+from .act_extra_trees_classifier import ActExtraTreesClassifier
+from .act_linear_discriminant_analysis import ActLinearDiscriminantAnalysis
+from .act_mlp_classifier import ActMLPClassifier
+from .act_multinomial_nb import ActMultinomialNB
+from .act_quadratic_discriminant_analysis import ActQuadraticDiscriminantAnalysis
+from .act_decision_tree_classifier import ActDecisionTreeClassifier
+from .act_hist_gradient_boosting_classifier import ActHistGradientBoostingClassifier
+from .act_sgd_classifier import ActSGDClassifier
+from .act_ridge_classifier import ActRidgeClassifier
+from .act_linear_svc import ActLinearSVC
+from .act_passive_aggressive_classifier import ActPassiveAggressiveClassifier
+from .act_bagging_classifier import ActBaggingClassifier
+from .act_complement_nb import ActComplementNB
+from .act_light_gbm_classifier import ActLightGBMClassifier

iaml/actionables/predictors/classifier/act_bagging_classifier.py

@@ -0,0 +1,113 @@
+"""[STEP] Bagging Classifier"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import BaggingClassifier
+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 ActBaggingClassifier(Predictor):
+    """[STEP] Bagging Classifier"""
+
+    name: str = "Bagging Classifier"
+    _description: str = textwrap.dedent('''\
+        BaggingClassifier is an ensemble method that combines multiple
+        base learners trained on bootstrapped samples to reduce variance.''')
+    _description_long: str = textwrap.dedent('''\
+        BaggingClassifier (Bootstrap Aggregating) fits several base estimators on
+        random subsets of the training data and optionally on random subsets of
+        features. Predictions are aggregated by majority vote, yielding a more
+        stable classifier that is less sensitive to noise.''')
+    _usage: str = "Use when you need variance reduction on numeric features and want a simple ensemble, versus ActExtraTreesClassifier. Applicable to tabular binary/multiclass/multilabel numeric data. Avoid when you need a single interpretable tree or can use ActDecisionTreeClassifier."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1996,
+            'name': 'Bagging Predictors',
+            'authors': [
+                'Leo Breiman'
+            ],
+            'doi': 'https://doi.org/10.1023/A:1018054314350',
+            'publisher': 'Machine Learning Vol. 24 page 123--140'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'n_estimators': {
+                'description': 'Number of base estimators in the ensemble.',
+                'default': 50,
+                'range': [5, 500]
+            },
+            'max_samples': {
+                'description': 'Fraction of samples to draw for each base estimator.',
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            },
+            'max_features': {
+                'description': 'Fraction of features to draw for each base estimator.',
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            },
+            'bootstrap': {
+                'description': 'Whether samples are drawn with replacement.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'bootstrap_features': {
+                'description': 'Whether features are drawn with replacement.',
+                'default': False,
+                'categorical': [True, False]
+            },
+            'oob_score': {
+                'description': textwrap.dedent('''\
+                    Whether to use out-of-bag samples to estimate generalization.'''),
+                'default': False,
+                'categorical': [True, False]
+            },
+            'random_state': {
+                'description': 'Random state for reproducibility.',
+                'default': 42
+            }
+        }
+        self.model: BaggingClassifier = 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):
+        self.columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if not self.columns:
+            raise ValueError(
+                "BaggingClassifier requires at least one numeric feature."
+            )
+
+        params = self.passthrough_parameters()
+        if params.get('oob_score') and not params.get('bootstrap', True):
+            raise ValueError("oob_score=True requires bootstrap=True.")
+        self.model = BaggingClassifier(**params)
+        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_bernoulli_nb.py

@@ -0,0 +1,89 @@
+"""
+[STEP] Bernoulli NB
+"""
+
+import textwrap
+from sklearn.naive_bayes import BernoulliNB
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'classifier')
+class ActBernoulliNb(Predictor):
+    """
+    [STEP] Bernoulli NB
+    """
+    name = "Bernoulli NB"
+    _description = textwrap.dedent('''\
+        BernoulliNB is a tool that helps computers predict categories
+        by analyzing binary features, even if the input isn't strictly binary.''')
+    _description_long = textwrap.dedent('''\
+        BernoulliNB is a type of Naive Bayes classifier specifically
+        designed for binary features. While it's primarily meant for binary inputs,
+        scikit-learn implements it in a way that can handle non-binary data.''')
+    _usage = "Use when you have mostly binary or presence/absence features and want a fast baseline vs ActComplementNB. Applicable to sparse tabular or text-like data with binary indicators. Avoid when features are continuous or you need nonlinear interactions; try ActGaussianNb or ActCatBoost."
+    refs = [
+        {
+            'year': 1998,
+            'name': 'A Comparison of Event Models for Naive Bayes Text Classification',
+            'authors': [
+                'Andrew McCallum',
+                'Kamal Nigam'
+            ],
+            'doi': "https://www.semanticscholar.org/paper/ \
+                A-comparison-of-event-models-for-naive-bayes-text-McCallum-Nigam/ \
+                    04ce064505b1635583fa0d9cc07cac7e9ea993cc",
+            'publisher': (
+                'AAAI-98 workshop on learning for text categorization, '
+                '752, page 41--48. (1998)'
+            )
+        },
+        {
+            'year': 2006,
+            'name': 'Spam Filtering with Naive Bayes - Which Naive Bayes?',
+            'authors': [
+                'Vangelis Metsis',
+                'Ion Androutsopoulos',
+                'Georgios Paliouras'
+            ],
+            'doi': "https://www.semanticscholar.org/paper/ \
+                Spam-Filtering-with-Naive-Bayes-Which-Naive-Bayes-Metsis-Androutsopoulos/ \
+                    7f5ce28afc0c2eafd4a6ef711e399bee4056c3b8",
+            'publisher': (
+                'The Third Conference on Email and Anti-Spam 2006 (CEAS)'
+            )
+        }
+    ]
+    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: BernoulliNB = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = BernoulliNB(**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_catboost_classifier.py

@@ -0,0 +1,135 @@
+"""[STEP]  CatBoost"""
+import textwrap
+from typing import Any
+from catboost import CatBoostClassifier, CatBoostError
+from sklearn.preprocessing import LabelEncoder
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+from ....logger import Logger
+
+
+@is_step('predictor', 'tabular', 'classifier', 'minimal_predictor')
+class ActCatBoost(Predictor):
+    """[STEP]  CatBoost Classifier"""
+
+    name: str = "CatBoost Classifier"
+    _usage: str = "Use when you want high-accuracy tabular classification with categorical features, often stronger than ActDecisionTreeClassifier or ActExtraTreesClassifier. Applicable to binary or multiclass tabular data. Avoid when data is tiny, compute is tight, or you prefer ActGaussianNb."
+    _description: str = textwrap.dedent('''\
+        CatBoostClassifier is a powerful tool that helps computers make accurate
+        predictions by learning from both positive and negative examples simultaneously.''')
+    _description_long: str = textwrap.dedent('''\
+        CatBoostClassifier is a gradient boosting algorithm specifically
+        designed for classification tasks.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2017,
+            'name': 'CatBoost: unbiased boosting with categorical features',
+            'authors': [
+                'Liudmila Prokhorenkova',
+                'Gleb Gusev',
+                'Aleksandr Vorobev',
+                'Anna Veronika Dorogush',
+                'Andrey Gulin'
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.1706.09516',
+            'publisher': 'Advances in Neural Information Processing Systems 31 (NeurIPS 2018)'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'iterations': {
+                'description': 'The maximum number of trees that can be built.',
+                'default': 1000,
+                'range': [100, 10000]
+            },
+            'learning_rate': {
+                'description': 'The learning rate.',
+                'default': 0.03,
+                'range': [0.001, 1.0]
+            },
+            'depth': {
+                'description': 'Depth of the tree.',
+                'default': 6,
+                'range': [1, 16]
+            },
+            'l2_leaf_reg': {
+                'description': 'Coefficient at the L2 regularization term of the cost function.',
+                'default': 3,
+                'range': [0, 10]
+            },
+            'border_count': {
+                'description': 'The number of splits for numerical features.',
+                'default': 254,
+                'range': [1, 255]
+            },
+            'loss_function': {
+                'description': 'The metric to use in training.',
+                'default': 'Logloss',
+                'categorical': ['Logloss', 'CrossEntropy', 'MultiClass', 'MultiClassOneVsAll']
+            },
+            'eval_metric': {
+                'description': 'The metric to be used for validation data.',
+                'default': 'AUC',
+                'categorical': ['AUC', 'Accuracy', 'Logloss']
+            },
+            'bootstrap_type': {
+                'description': 'The method for sampling the weights of objects.',
+                'default': 'Bayesian',
+                'categorical': ['Bayesian', 'Bernoulli', 'MVS']
+            },
+            'leaf_estimation_iterations': {
+                'description': 'The number of iterations for leaf estimation.',
+                'default': 10,
+                'range': [1, 50]
+            }
+        }
+
+        self.model: CatBoostClassifier = None
+        self.label_encoder: LabelEncoder = LabelEncoder()
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        if dataset.type_of_target == 'binary':
+            self.configuration['loss_function']['categorical'] = ['Logloss', 'CrossEntropy']
+        else:
+            self.configuration['eval_metric']['categorical'] = ['AUC', 'Accuracy']
+            self.configuration['loss_function']['categorical'] = [
+                                                                'MultiClass',
+                                                                'MultiClassOneVsAll'
+                                                                ]
+        self.check_configuration()
+
+        self.model = CatBoostClassifier(verbose=0, **self.passthrough_parameters())
+        self.label_encoder.fit(dataset.y)
+        encoded_target = self.label_encoder.transform(dataset.y)
+        try:
+            self.model.fit(dataset.X, encoded_target)
+        except CatBoostError as exc:
+            self._log_failure(dataset, exc)
+            raise ValueError(f"CatBoostClassifier training failed: {exc}") from exc
+        except Exception as exc:  # pragma: no cover - defensive
+            self._log_failure(dataset, exc)
+            raise
+        return self
+
+    def _log_failure(self, dataset: Dataset, exc: Exception) -> None:
+        """Log enriched debug info when CatBoost crashes."""
+        shape = getattr(dataset.X, "shape", None)
+        message = (
+            "[CatBoostClassifier] crash detected "
+            f"(shape={shape}, target_len={len(dataset.y)}, "
+            f"params={self.passthrough_parameters()}): {exc}"
+        )
+        logger = Logger()
+        if logger.verbose <= 3 and logger.verbose != -1:
+            logger.console.log(message)
+        logger.error(message)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target in \
+            ['binary', 'multiclass',  'multilabel-indicator']
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral