PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/imbalance/act_smote_tomek.py

@@ -0,0 +1,182 @@
+"""[STEP] SMOTETomek"""
+import inspect
+import textwrap
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from imblearn.combine import SMOTETomek
+from imblearn.over_sampling import SMOTE
+from imblearn.under_sampling import TomekLinks
+
+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('imbalance')
+class ActSMOTETomek(Actionable):
+    """[STEP] SMOTETomek"""
+
+    name: str = "SMOTE Tomek"
+    _description: str = textwrap.dedent('''\
+        SMOTETomek balances data by creating synthetic minority samples
+        and removing Tomek links from overlapping classes.''')
+    _description_long: str = textwrap.dedent('''\
+        SMOTETomek combines SMOTE oversampling with Tomek links cleaning.
+        It generates synthetic minority samples, then removes nearest neighbor
+        pairs from different classes to reduce overlap and noise.''')
+    _usage: str = "Use when imbalanced numeric data has overlap and want SMOTE plus Tomek cleanup vs ActSMOTE. Applicable to binary or multiclass, all-numeric features. Avoid when categorical/text/date fields exist, minority has <2 samples, or you want pure undersampling like ActRandomUnderSampler."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2002,
+            'name': 'SMOTE: Synthetic Minority Over-sampling Technique',
+            'authors': [
+                'Nitesh V. Chawla',
+                'Kevin W. Bowyer',
+                'Lawrence O. Hall',
+                'W. Philip Kegelmeyer'
+            ],
+            'doi': 'https://doi.org/10.1613/jair.953',
+            'publisher': 'Journal of Artificial Intelligence Research Vol.16 page 321--357'
+        },
+        {
+            'year': 1976,
+            'name': 'Two Modifications of CNN',
+            'authors': [
+                'Ivan Tomek'
+            ],
+            'publisher': 'IEEE Transactions on Systems, Man, and Cybernetics Vol.6 No.11 '
+                         'page 769--772'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'sampling_strategy': {
+                'description': 'Sampling strategy to balance classes.',
+                'default': 'auto',
+                'categorical': ['minority', 'auto']
+            },
+            'k_neighbors': {
+                'description': 'Number of nearest neighbors used to create synthetic samples.',
+                'default': 5,
+                'range': [1, 20]
+            },
+            'random_state': {
+                'description': 'Random seed used for reproducibility.',
+                'default': 42
+            }
+        }
+        self.resampler: SMOTETomek | None = None
+        self.categorical_columns: list[str] = []
+        self.numeric_columns: list[str] = []
+        self._effective_k_neighbors: int | None = None
+
+    def fit(self, dataset: Dataset) -> Actionable:
+        self.resampler = None
+        self.categorical_columns = dataset.get_columns_names_by_type(DataType.CATEGORICAL)
+        self.numeric_columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        self._effective_k_neighbors = None
+
+        if dataset.X.empty or dataset.type_of_target not in ['binary', 'multiclass']:
+            return self
+
+        if dataset.y is None or len(dataset.y) == 0:
+            return self
+
+        unsupported = dataset.get_columns_names_by_type(
+            [DataType.TEXT, DataType.SHORT_TEXT, DataType.DATE]
+        )
+        if unsupported:
+            return self
+
+        if self.categorical_columns:
+            return self
+
+        if not self.numeric_columns:
+            return self
+
+        _, counts = np.unique(dataset.y, return_counts=True)
+        if len(counts) < 2:
+            return self
+
+        min_count = int(counts.min())
+        if min_count <= 1:
+            return self
+
+        max_k = min_count - 1
+        k_neighbors = min(int(self.get_config('k_neighbors')), max_k)
+        k_neighbors = max(1, k_neighbors)
+        self._effective_k_neighbors = k_neighbors
+
+        smote_params = {
+            'k_neighbors': k_neighbors
+        }
+        smote_sig = inspect.signature(SMOTE).parameters
+        if 'sampling_strategy' in smote_sig:
+            smote_params['sampling_strategy'] = self.get_config('sampling_strategy')
+        if 'random_state' in smote_sig:
+            smote_params['random_state'] = self.get_config('random_state')
+        smote = SMOTE(**smote_params)
+
+        tomek = TomekLinks()
+
+        smotetomek_params: dict[str, Any] = {}
+        smotetomek_sig = inspect.signature(SMOTETomek).parameters
+        if 'smote' in smotetomek_sig:
+            smotetomek_params['smote'] = smote
+        if 'tomek' in smotetomek_sig:
+            smotetomek_params['tomek'] = tomek
+        if 'sampling_strategy' in smotetomek_sig and 'smote' not in smotetomek_params:
+            smotetomek_params['sampling_strategy'] = self.get_config('sampling_strategy')
+        if 'random_state' in smotetomek_sig and 'smote' not in smotetomek_params:
+            smotetomek_params['random_state'] = self.get_config('random_state')
+
+        self.resampler = SMOTETomek(**smotetomek_params)
+        self.resampler.fit(dataset.X, dataset.y)
+        return self
+
+    def resample(self, X: pd.DataFrame, y: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """Apply SMOTETomek.
+
+        :param pd.DataFrame X: Features to resample
+        :param pd.DataFrame y: Labels to resample
+        :return: Resampled X and y
+        """
+        if self.resampler is None:
+            return X, y
+        return self.resampler.fit_resample(X, y)
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        if candidate is None or candidate.dataset.y is None:
+            return 0.0
+        y = candidate.dataset.y
+        if len(y) == 0:
+            return 0.0
+        _, counts = np.unique(y, return_counts=True)
+        if len(counts) < 2:
+            return 0.0
+        imbalance = 1.0 - (counts.min() / counts.max())
+        return float(min(1.0, max(0.0, imbalance)))
+
+    def suitable(self, dataset: Dataset) -> bool:
+        if dataset.type_of_target not in ['binary', 'multiclass']:
+            return False
+        if dataset.X.empty or dataset.y is None or len(dataset.y) == 0:
+            return False
+        if dataset.get_columns_names_by_type(DataType.CATEGORICAL):
+            return False
+        if not dataset.get_columns_names_by_type(DataType.NUMERIC):
+            return False
+        unsupported = dataset.get_columns_names_by_type(
+            [DataType.TEXT, DataType.SHORT_TEXT, DataType.DATE]
+        )
+        if unsupported:
+            return False
+        _, counts = np.unique(dataset.y, return_counts=True)
+        if len(counts) < 2:
+            return False
+        return counts.min() > 1

iaml/actionables/imbalance/act_smoteenn.py

@@ -0,0 +1,193 @@
+"""[STEP] SMOTEENN"""
+import inspect
+import textwrap
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from imblearn.combine import SMOTEENN
+from imblearn.over_sampling import SMOTE
+from imblearn.under_sampling import EditedNearestNeighbours
+
+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('imbalance')
+class ActSMOTEENN(Actionable):
+    """[STEP] SMOTEENN"""
+
+    name: str = "SMOTE ENN"
+    _description: str = textwrap.dedent('''\
+        SMOTEENN balances data by creating synthetic minority samples and
+        removing ambiguous samples with Edited Nearest Neighbors.''')
+    _description_long: str = textwrap.dedent('''\
+        SMOTEENN combines SMOTE oversampling with Edited Nearest Neighbors
+        cleaning. It adds synthetic minority samples, then removes samples
+        that disagree with their neighbors to reduce noise and class overlap.''')
+    _usage: str = "Use when imbalance with noisy borders needs SMOTE plus cleaning vs ActSMOTE. Applicable to numeric-only binary or multiclass data with >=2 samples per class. Avoid when categorical/text features, very small minorities, or you want pure under-sampling like ActNearMiss."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2004,
+            'name': 'A Study of the Behavior of Several Methods for Balancing '
+                    'Machine Learning Training Data',
+            'authors': [
+                'Gustavo E. A. P. A. Batista',
+                'Ronaldo C. Prati',
+                'Maria Carolina Monard'
+            ],
+            'doi': 'https://doi.org/10.1145/1007730.1007735',
+            'publisher': 'ACM SIGKDD Explorations Newsletter Vol.6 No.1 page 20--29'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'sampling_strategy': {
+                'description': 'Sampling strategy to balance classes.',
+                'default': 'auto',
+                'categorical': ['minority', 'auto']
+            },
+            'k_neighbors': {
+                'description': 'Number of nearest neighbors used to create synthetic samples.',
+                'default': 5,
+                'range': [1, 20]
+            },
+            'n_neighbors': {
+                'description': 'Number of neighbors used by Edited Nearest Neighbors.',
+                'default': 3,
+                'range': [1, 20]
+            },
+            'kind_sel': {
+                'description': 'Rule used by Edited Nearest Neighbors to select samples.',
+                'default': 'all',
+                'categorical': ['all', 'mode'],
+                'passthrough': False
+            },
+            'random_state': {
+                'description': 'Random seed used for reproducibility.',
+                'default': 42
+            }
+        }
+        self.resampler: SMOTEENN | None = None
+        self.categorical_columns: list[str] = []
+        self.numeric_columns: list[str] = []
+        self._effective_k_neighbors: int | None = None
+        self._effective_n_neighbors: int | None = None
+
+    def fit(self, dataset: Dataset) -> Actionable:
+        self.resampler = None
+        self.categorical_columns = dataset.get_columns_names_by_type(DataType.CATEGORICAL)
+        self.numeric_columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        self._effective_k_neighbors = None
+        self._effective_n_neighbors = None
+
+        if dataset.X.empty or dataset.type_of_target not in ['binary', 'multiclass']:
+            return self
+
+        if dataset.y is None or len(dataset.y) == 0:
+            return self
+
+        unsupported = dataset.get_columns_names_by_type(
+            [DataType.TEXT, DataType.SHORT_TEXT, DataType.DATE]
+        )
+        if unsupported:
+            return self
+
+        if self.categorical_columns:
+            return self
+
+        if not self.numeric_columns:
+            return self
+
+        _, counts = np.unique(dataset.y, return_counts=True)
+        if len(counts) < 2:
+            return self
+
+        min_count = int(counts.min())
+        if min_count <= 1:
+            return self
+
+        max_k = min_count - 1
+        k_neighbors = min(int(self.get_config('k_neighbors')), max_k)
+        k_neighbors = max(1, k_neighbors)
+        self._effective_k_neighbors = k_neighbors
+
+        total_count = int(len(dataset.y))
+        max_neighbors = max(1, total_count - 1)
+        n_neighbors = min(int(self.get_config('n_neighbors')), max_neighbors)
+        n_neighbors = max(1, n_neighbors)
+        self._effective_n_neighbors = n_neighbors
+
+        smote = SMOTE(
+            sampling_strategy=self.get_config('sampling_strategy'),
+            k_neighbors=k_neighbors,
+            random_state=self.get_config('random_state')
+        )
+
+        enn_params = {
+            'n_neighbors': n_neighbors
+        }
+        if 'kind_sel' in inspect.signature(EditedNearestNeighbours).parameters:
+            enn_params['kind_sel'] = self.get_config('kind_sel')
+        enn = EditedNearestNeighbours(**enn_params)
+
+        smoteenn_params = {}
+        smoteenn_sig = inspect.signature(SMOTEENN).parameters
+        if 'smote' in smoteenn_sig:
+            smoteenn_params['smote'] = smote
+        if 'enn' in smoteenn_sig:
+            smoteenn_params['enn'] = enn
+        if 'sampling_strategy' in smoteenn_sig and 'smote' not in smoteenn_params:
+            smoteenn_params['sampling_strategy'] = self.get_config('sampling_strategy')
+        if 'random_state' in smoteenn_sig and 'smote' not in smoteenn_params:
+            smoteenn_params['random_state'] = self.get_config('random_state')
+
+        self.resampler = SMOTEENN(**smoteenn_params)
+        self.resampler.fit(dataset.X, dataset.y)
+        return self
+
+    def resample(self, X: pd.DataFrame, y: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """Apply SMOTEENN.
+
+        :param pd.DataFrame X: Features to resample
+        :param pd.DataFrame y: Labels to resample
+        :return: Resampled X and y
+        """
+        if self.resampler is None:
+            return X, y
+        return self.resampler.fit_resample(X, y)
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        if candidate is None or candidate.dataset.y is None:
+            return 0.0
+        y = candidate.dataset.y
+        if len(y) == 0:
+            return 0.0
+        _, counts = np.unique(y, return_counts=True)
+        if len(counts) < 2:
+            return 0.0
+        imbalance = 1.0 - (counts.min() / counts.max())
+        return float(min(1.0, max(0.0, imbalance)))
+
+    def suitable(self, dataset: Dataset) -> bool:
+        if dataset.type_of_target not in ['binary', 'multiclass']:
+            return False
+        if dataset.X.empty or dataset.y is None or len(dataset.y) == 0:
+            return False
+        if dataset.get_columns_names_by_type(DataType.CATEGORICAL):
+            return False
+        if not dataset.get_columns_names_by_type(DataType.NUMERIC):
+            return False
+        unsupported = dataset.get_columns_names_by_type(
+            [DataType.TEXT, DataType.SHORT_TEXT, DataType.DATE]
+        )
+        if unsupported:
+            return False
+        _, counts = np.unique(dataset.y, return_counts=True)
+        if len(counts) < 2:
+            return False
+        return counts.min() > 1

iaml/actionables/imbalance/act_tomek_links.py

@@ -0,0 +1,138 @@
+"""[STEP] Tomek Links"""
+import inspect
+import textwrap
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from imblearn.under_sampling import TomekLinks
+
+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('imbalance')
+class ActTomekLinks(Actionable):
+    """[STEP] Tomek Links"""
+
+    name: str = "Tomek Links"
+    _description: str = textwrap.dedent('''\
+        TomekLinks cleans class boundaries by removing samples that form
+        nearest-neighbor pairs across classes.''')
+    _description_long: str = textwrap.dedent('''\
+        TomekLinks identifies pairs of samples from different classes that are
+        each other's nearest neighbors (Tomek links). Removing the majority
+        samples in these pairs reduces overlap and cleans noisy boundaries.''')
+    _usage: str = "Use when you want light boundary cleaning instead of heavier ActNearMiss. Applicable to numeric-only binary or multiclass data. Avoid when data includes categorical/text/date or you need to add samples (ActSMOTE)."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1976,
+            'name': 'Two Modifications of CNN',
+            'authors': [
+                'Ivan Tomek'
+            ],
+            'publisher': 'IEEE Transactions on Systems, Man, and Cybernetics Vol.6 No.11 '
+                         'page 769--772'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'sampling_strategy': {
+                'description': 'Sampling strategy to remove Tomek link pairs.',
+                'default': 'auto',
+                'categorical': ['auto', 'majority', 'all']
+            }
+        }
+        self.resampler: TomekLinks | None = None
+        self.categorical_columns: list[str] = []
+        self.numeric_columns: list[str] = []
+        self.imbalance_ratio: float = 0.0
+
+    def fit(self, dataset: Dataset) -> Actionable:
+        self.resampler = None
+        self.categorical_columns = dataset.get_columns_names_by_type(DataType.CATEGORICAL)
+        self.numeric_columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        self.imbalance_ratio = 0.0
+
+        if dataset.X.empty or dataset.type_of_target not in ['binary', 'multiclass']:
+            return self
+
+        if dataset.y is None or len(dataset.y) == 0:
+            return self
+
+        unsupported = dataset.get_columns_names_by_type(
+            [DataType.TEXT, DataType.SHORT_TEXT, DataType.DATE]
+        )
+        if unsupported:
+            return self
+
+        if self.categorical_columns:
+            return self
+
+        if not self.numeric_columns:
+            return self
+
+        _, counts = np.unique(dataset.y, return_counts=True)
+        if len(counts) < 2:
+            return self
+
+        max_count = int(counts.max())
+        min_count = int(counts.min())
+        if max_count <= 0 or min_count <= 0:
+            return self
+
+        self.imbalance_ratio = 1.0 - (min_count / max_count)
+
+        params = self.passthrough_parameters()
+        sig_params = inspect.signature(TomekLinks).parameters
+        params = {key: value for key, value in params.items() if key in sig_params}
+
+        self.resampler = TomekLinks(**params)
+        self.resampler.fit(dataset.X, dataset.y)
+        return self
+
+    def resample(self, X: pd.DataFrame, y: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """Apply Tomek Links.
+
+        :param pd.DataFrame X: Features to resample
+        :param pd.DataFrame y: Labels to resample
+        :return: Resampled X and y
+        """
+        if self.resampler is None:
+            return X, y
+        return self.resampler.fit_resample(X, y)
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        if candidate is None or candidate.dataset.y is None:
+            return 0.0
+        y = candidate.dataset.y
+        if len(y) == 0:
+            return 0.0
+        _, counts = np.unique(y, return_counts=True)
+        if len(counts) < 2:
+            return 0.0
+        imbalance = 1.0 - (counts.min() / counts.max())
+        return float(min(1.0, max(0.0, imbalance)))
+
+    def suitable(self, dataset: Dataset) -> bool:
+        if dataset.type_of_target not in ['binary', 'multiclass']:
+            return False
+        if dataset.X.empty or dataset.y is None or len(dataset.y) == 0:
+            return False
+        if dataset.get_columns_names_by_type(DataType.CATEGORICAL):
+            return False
+        if not dataset.get_columns_names_by_type(DataType.NUMERIC):
+            return False
+        unsupported = dataset.get_columns_names_by_type(
+            [DataType.TEXT, DataType.SHORT_TEXT, DataType.DATE]
+        )
+        if unsupported:
+            return False
+        _, counts = np.unique(dataset.y, return_counts=True)
+        if len(counts) < 2:
+            return False
+        return True

iaml/actionables/normalize/__init__.py

@@ -0,0 +1,6 @@
+"""Normalize and scaler Actionables"""
+from .act_minmax_scaler import ActMinMaxScaler
+from .act_standard_scaler import ActStandardScaler
+from .act_robust_scaler import ActRobustScaler
+from .act_max_abs_scaler import ActMaxAbsScaler
+from .act_normalizer import ActNormalizer

iaml/actionables/normalize/act_max_abs_scaler.py

@@ -0,0 +1,78 @@
+"""[STEP] Max Abs Scaler"""
+import textwrap
+from sklearn.preprocessing import MaxAbsScaler
+import pandas as pd
+from ...actionable import Actionable
+from ...dataset import Dataset
+from ...candidate import Candidate
+from ...decorators.all import is_step
+from ...data_type import DataType
+
+
+@is_step('normalize')
+class ActMaxAbsScaler(Actionable):
+    """[STEP] Max Abs Scaler"""
+
+    name: str = "Max Abs Scaler"
+    _description: str = textwrap.dedent('''\
+        MaxAbsScaler rescales numeric data by dividing by the maximum absolute value,
+        keeping values within a [-1, 1] range.''')
+    _description_long: str = textwrap.dedent('''\
+        MaxAbsScaler scales each numeric feature by its maximum absolute value
+        observed in the training data. This keeps values within [-1, 1] while
+        preserving sparsity because it does not center the data.
+        It is a good fit for sparse datasets where zeros should remain zeros.''')
+    _usage: str = "Use when numeric features are sparse and you want scale to [-1, 1] without centering; compare ActMinMaxScaler. Applicable to numeric data with many zeros or sparse matrices. Avoid when you need centering or heavy outlier handling; consider ActNormalizer or ActRobustScaler."
+
+    def __init__(self):
+        self.columns: list[str] = None
+        self.scaler: MaxAbsScaler = None
+
+        self.configuration = {
+            'copy': {
+                'description': 'Set to False to perform scaling 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.scaler = MaxAbsScaler(**self.passthrough_parameters())
+            self.scaler.fit(values)
+        else:
+            self.scaler = None
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply max abs 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]
+        total = values.size - values.isna().sum().sum()
+        if total <= 0:
+            return 0.0
+        zeros = (values == 0).sum().sum()
+        zero_ratio = zeros / total
+        return min(1.0, zero_ratio * 1.5)

iaml/actionables/normalize/act_minmax_scaler.py

@@ -0,0 +1,56 @@
+"""[STEP] Min Max Scaler"""
+import textwrap
+from sklearn.preprocessing import MinMaxScaler
+import pandas as pd
+from ...actionable import Actionable
+from ...dataset import Dataset
+from ...candidate import Candidate
+from ...decorators.all import is_step
+from ...data_type import DataType
+
+@is_step('normalize')
+class ActMinMaxScaler(Actionable):
+    """[STEP] Min Max Scaler"""
+
+    name: str = "Min Max Scaler"
+    _usage: str = "Use when you need bounded scaling of numeric features for scale-sensitive models; unlike ActNormalizer, keeps feature ranges. Applicable to continuous numeric columns with stable min/max. Avoid when outliers or range drift dominate; consider ActRobustScaler."
+    _description: str = textwrap.dedent('''\
+        MinMaxScaler is a tool that helps computers understand complex relationships
+        between things by turning them into simpler numbers within a fixed range.''')
+    _description_long: str = textwrap.dedent('''\
+        MinMaxScaler is a machine learning technique used to scale numerical
+        features to a fixed range, typically between zero and one.
+        It works by finding the minimum and maximum values for each feature in the training data,
+        then scaling all values to fall between those extremes.
+        This transformation helps ensure that all features are on the same scale,
+        which can improve the performance of many machine learning algorithms.''')
+
+    def __init__(self):
+        self.columns: list[str] = None
+        self.scaler: MinMaxScaler = 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 = MinMaxScaler()
+            self.scaler.fit(values)
+        else:
+            self.scaler = None
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply min max 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