PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/cleaning/act_word2vec.py

@@ -0,0 +1,150 @@
+"""[STEP] Vectorize textual columns with Word2Vec"""
+from typing import Any
+import textwrap
+import string
+import numpy as np
+import pandas as pd
+from gensim.models import Word2Vec
+from nltk.corpus import stopwords
+from nltk.stem import StemmerI, PorterStemmer
+from nltk.tokenize import word_tokenize
+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('cleaning')
+class ActWord2Vec(Actionable):
+    """[STEP] Vectorize textual column with Word2Vec"""
+
+    name: str = "Word2Vec"
+    _description: str = "Process Word2Vec algorithm over a list of columns"
+    _description_long: str = textwrap.dedent('''\
+        Word2Vec is a word embedding algorithm auto-supervised algorithm.
+        This means we don't need labelled data as the algorithm discove
+        the ground truth by himself''')
+    _usage: str = "Use when you want dense semantic text embeddings rather than sparse counts (vs ActCountVectorizer). Applicable to free-form text columns with enough tokens per row to learn embeddings. Avoid when text is short or ID-like, or when token-count interpretability is required."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2023,
+            'name': 'Efficient Estimation of Word Representations in Vector Space',
+            'authors': [
+                'Thomas Mikolov',
+                'Kai Chen',
+                'Greg Corrado',
+                'Jeffrey Dean'    
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.1301.3781',
+            'publisher': 'International Conference on Learning Representations'
+        }
+    ]
+
+    def __init__(self):
+        self.columns: list[tuple[str, Word2Vec]] = None
+        self.stop_words: set[str] | None = None
+        self.stemmer: StemmerI = PorterStemmer()
+
+    @staticmethod
+    def vectorize(words: str, model: Word2Vec):
+        """Convert the preprocessed text data to a vector representation using
+        the Word2Vec model by calculating the aveerage of the word vectors
+        present in the sentence and returns this average vector. This gives 
+        a vector representation of the whole sentence.
+
+        :param str words: The preprocessed text data as a string.
+        :param Word2Vec model: The Word2Vec model used for vectorization.
+        :return: The average vector representation of the input sentence.
+        """
+        vectors = [ model.wv[word] for word in words if word in model.wv ]
+        if len(vectors) > 0:
+            return np.mean(vectors, axis=0)
+
+        return np.zeros(model.vector_size)
+
+    def __preprocess(self, text: str) -> list[str]:
+        """Preprocesses the input text for Word2Vec processing tasks.
+
+        Steps:
+        1. Convert the text to lowercase.
+        2. Remove punctuation and special characters from the text.
+        3. Tokenize the text into words.
+        4. Remove stopwords from the tokenized words.
+        5. Apply stemming to the remaining tokens.
+
+        :param str text: The input text to be preprocessed.
+        :return: The preprocessed text.
+        """
+        text = text.lower()
+
+        table = str.maketrans('', '', string.punctuation)
+        text = text.translate(table)
+
+        # Punctuation has already been removed; sentence splitting is unnecessary.
+        tokens = word_tokenize(text, preserve_line=True)
+        tokens = [ self.stemmer.stem(word) for word in tokens if word not in self.stop_words ]
+
+        return tokens
+
+    def fit(self, dataset: Dataset) -> Actionable:
+        """Find columns to vectorize and fit the vectorizer.
+
+        :param Dataset dataset: Data.
+        :return: Transformed candidate.
+        :raises LookupError: The NLTK stopwords corpus is missing when processing text.
+        """
+        self.columns = []
+        self.explanations = []
+        text_columns = dataset.get_columns_names_by_type([DataType.TEXT])
+        if not text_columns or dataset.X.empty:
+            return self
+
+        if self.stop_words is None:
+            try:
+                self.stop_words = set(stopwords.words('english'))
+            except LookupError as exc:
+                raise LookupError(
+                    "Word2Vec requires the NLTK English stopwords corpus for text data. "
+                    "Install it with: python -m nltk.downloader stopwords"
+                ) from exc
+
+        for column in text_columns:
+            values = dataset.X[column].fillna('').apply(self.__preprocess)
+            vectorizer = Word2Vec(sentences = values,
+                                vector_size = 100,
+                                window = 5,
+                                min_count = 1,
+                                workers = 4)
+            self.columns.append((column, vectorizer))
+
+        feature_names = { c: list(v.wv.index_to_key) for c, v in self.columns }
+        self.explanations = [
+            f'Encoded text column **`{c}`** into **{len(v)}** new columns.'
+            for c, v in feature_names.items() if len(v) > 0
+        ]
+
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply Word2Vec vectorization to string data.
+
+        :param pd.DataFrame X: DataFrame to transform.
+        :return: Transformed dataset.
+        """
+        X = X.reset_index(drop=True)
+        for name, vectorizer in self.columns:
+            transformed = X[name].fillna('').apply(
+                lambda doc: self.vectorize(self.__preprocess(doc), vectorizer) # pylint: disable=cell-var-from-loop
+            )
+            features_names = [f"{name}_vec_{i}" for i in range(vectorizer.vector_size)]
+            vector_df = pd.DataFrame(transformed.tolist(), columns = features_names)
+            X = pd.concat([X, vector_df], axis = 1).drop([name], axis = 1)
+
+        return X
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.4
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return bool(dataset.get_columns_names_by_type([DataType.TEXT]))

iaml/actionables/features_precleaning/__init__.py

@@ -0,0 +1,12 @@
+"""
+Usualy first step of a pipeline, clean/transform features.
+Example : Convert SHORT_TEXT column into datetime if possible
+"""
+from .act_date_converter import ActDateConverter
+from .act_trim_space import ActTrimSpaces
+from .act_normalize_column_names import ActNormalizeColumnNames
+from .act_coerce_numeric_strings import ActCoerceNumericStrings
+from .act_drop_high_missing_columns import ActDropHighMissingColumns
+from .act_drop_duplicate_rows import ActDropDuplicateRows
+from .act_sentinel_to_na_n import ActSentinelToNaN
+from .act_drop_id_like_columns import ActDropIdLikeColumns

iaml/actionables/features_precleaning/act_coerce_numeric_strings.py

@@ -0,0 +1,194 @@
+"""[STEP] Coerce numeric strings to numeric values"""
+import textwrap
+from typing import Any
+import pandas as pd
+from ...actionable import Actionable
+from ...dataset import Dataset
+from ...data_type import DataType
+from ...candidate import Candidate
+from ...decorators.all import is_step
+
+
+@is_step('features_precleaning')
+class ActCoerceNumericStrings(Actionable):
+    """[STEP] Coerce numeric strings to numeric values"""
+
+    name: str = 'Coerce numeric strings'
+    _description: str = textwrap.dedent('''\
+        Convert text columns that look numeric (commas, spaces, %) into numeric values.''')
+    _usage: str = 'Use when text columns contain numeric-like strings with separators or %; prefer over ActDateConverter for dates. Applicable to text or categorical columns that are mostly numeric. Avoid when values are identifiers or mostly non-numeric; use ActSentinelToNaN for missing tokens.'
+    _description_long: str = textwrap.dedent('''\
+        This step attempts to coerce text or categorical columns into numeric values
+        by removing spaces, thousands separators and percent signs. A column is converted
+        only if the error ratio is below {authorized_error_ratio:.0%} of the non-missing
+        values in a sample of size {sample_size}.''')
+    refs: list[dict[str, Any]] = []
+
+    def __init__(self):
+        self.configuration = {
+            'authorized_error_ratio': {
+                'description': textwrap.dedent('''\
+                    Maximum ratio of non-convertible values allowed to coerce a column.'''),
+                'default': 0.1
+            },
+            'sample_size': {
+                'description': textwrap.dedent('''\
+                    Size of the sample used to detect numeric strings.
+                    Set to -1 to use the whole dataset.'''),
+                'default': 200
+            },
+            'percent_to_fraction': {
+                'description': 'Convert values with percent signs into fractions (divide by 100).',
+                'default': True
+            }
+        }
+        self.columns: list[tuple[str, str]] = None
+
+    def fit(self, dataset: Dataset) -> Actionable:
+        sample = self.__sample(dataset.X)
+        self.columns = []
+        explanations = []
+
+        for column in self.__candidate_columns(dataset):
+            strategy, ratio = self.__choose_strategy(sample[column])
+            if strategy is None:
+                continue
+            self.columns.append((column, strategy))
+            explanations.append(
+                f'Coerced column **`{column}`** to numeric using {strategy} decimal separator '
+                f'(success {ratio:.0%} on sample).'
+            )
+
+        self.explanations = explanations
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Coerce numeric-like strings into numeric values.
+
+        :param pd.DataFrame X: DataFrame to transform.
+        :return: Transformed DataFrame.
+        """
+        if not self.columns:
+            return X
+
+        for column, strategy in self.columns:
+            if column not in X.columns:
+                continue
+            X[column] = self.__convert_series(X[column], strategy)
+
+        return X
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        if candidate is None:
+            return 1.0
+        total = max(1, candidate.dataset.X.shape[1])
+        candidates = len(self.__candidate_columns(candidate.dataset))
+        return min(1.0, 0.5 + candidates / total)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        sample = self.__sample(dataset.X)
+        for column in self.__candidate_columns(dataset):
+            strategy, _ = self.__choose_strategy(sample[column])
+            if strategy is not None:
+                return True
+        return False
+
+    def __candidate_columns(self, dataset: Dataset) -> list[str]:
+        return dataset.get_columns_names_by_type(
+            [DataType.SHORT_TEXT, DataType.TEXT, DataType.CATEGORICAL]
+        )
+
+    def __sample(self, X: pd.DataFrame) -> pd.DataFrame:
+        if X.empty:
+            return X
+        sample_size = self.get_config('sample_size')
+        if sample_size is None or sample_size == 0:
+            return X
+        if sample_size < 0 or sample_size >= len(X):
+            return X
+        return X.sample(n=sample_size, random_state=42)
+
+    def __choose_strategy(self, series: pd.Series) -> tuple[str | None, float]:
+        non_null = series.notna().sum()
+        if non_null == 0:
+            return None, 0.0
+
+        ratios = {}
+        for strategy in ('dot', 'comma'):
+            converted = self.__convert_series(series, strategy)
+            ratios[strategy] = converted.notna().sum() / non_null
+
+        best = max(ratios, key=ratios.get)
+        best_ratio = ratios[best]
+        if best_ratio < 1 - self.get_config('authorized_error_ratio'):
+            return None, best_ratio
+
+        other = 'comma' if best == 'dot' else 'dot'
+        if abs(ratios[best] - ratios[other]) <= 0.02:
+            inferred = self.__infer_decimal_separator(series)
+            if ratios.get(inferred, 0) >= 1 - self.get_config('authorized_error_ratio'):
+                best = inferred
+
+        return best, best_ratio
+
+    def __normalize_strings(self, series: pd.Series) -> tuple[pd.Series, pd.Series]:
+        values = series.where(series.notna(), '')
+        values = values.astype(str).str.strip()
+        percent_mask = values.str.contains('%', regex=False, na=False)
+        values = values.str.replace('%', '', regex=False)
+        values = values.str.replace(r'\s+', '', regex=True)
+        return values, percent_mask
+
+    def __convert_series(self, series: pd.Series, strategy: str) -> pd.Series:
+        values, percent_mask = self.__normalize_strings(series)
+
+        if strategy == 'comma':
+            values = values.str.replace('.', '', regex=False)
+            values = values.str.replace(',', '.', regex=False)
+        else:
+            values = values.str.replace(',', '', regex=False)
+
+        numeric = pd.to_numeric(values, errors='coerce')
+        if self.get_config('percent_to_fraction'):
+            numeric = numeric.mask(percent_mask, numeric / 100)
+
+        return numeric
+
+    def __infer_decimal_separator(self, series: pd.Series) -> str:
+        values, _ = self.__normalize_strings(series)
+
+        has_comma = values.str.contains(',', regex=False, na=False)
+        has_dot = values.str.contains('.', regex=False, na=False)
+
+        both = has_comma & has_dot
+        if both.any():
+            last_comma = values[both].str.rfind(',')
+            last_dot = values[both].str.rfind('.')
+            comma_last = (last_comma > last_dot).sum()
+            dot_last = (last_dot > last_comma).sum()
+            if comma_last != dot_last:
+                return 'comma' if comma_last > dot_last else 'dot'
+
+        comma_only = has_comma & ~has_dot
+        dot_only = has_dot & ~has_comma
+
+        if comma_only.any() and not dot_only.any():
+            return self.__separator_preference(values[comma_only], ',')
+        if dot_only.any() and not comma_only.any():
+            return self.__separator_preference(values[dot_only], '.')
+        if comma_only.any() or dot_only.any():
+            return 'comma' if comma_only.sum() > dot_only.sum() else 'dot'
+
+        return 'dot'
+
+    def __separator_preference(self, values: pd.Series, separator: str) -> str:
+        after = values.str.rsplit(separator, n=1).str[-1]
+        decimal_like = after.str.len().isin([1, 2]).sum()
+        thousand_like = after.str.len().eq(3).sum()
+
+        if decimal_like > thousand_like:
+            return 'comma' if separator == ',' else 'dot'
+        if thousand_like > decimal_like:
+            return 'dot' if separator == ',' else 'comma'
+
+        return 'comma' if separator == ',' else 'dot'

iaml/actionables/features_precleaning/act_date_converter.py

@@ -0,0 +1,99 @@
+"""[STEP] Convert Short text to date if possible"""
+import textwrap
+import pandas as pd
+from ...actionable import Actionable
+from ...dataset import Dataset
+from ...data_type import DataType
+from ...candidate import Candidate
+from ...decorators.all import is_step
+
+
+@is_step('features_precleaning')
+class ActDateConverter(Actionable):
+    """[STEP] Convert Short text to date if possible"""
+
+    name: str = 'Text to Date Converter'
+    _description: str = 'Convert Text to Date if possible'
+    _description_long: str = textwrap.dedent('''\
+        Try to convert all text of a column to date. 
+        If more than {authorized_error_ratios}% of the rows return errors, then the
+        column is not converted. As converting to date is time consuming, we will
+        perform the test on {sample_size}.
+    ''')
+    _usage: str = 'Use when short text columns mostly contain parseable dates. Applicable to SHORT_TEXT columns with mixed date formats. Avoid when values are IDs or sentinels better handled by ActDropIdLikeColumns or ActSentinelToNaN.'
+
+    def __init__(self):
+        self.configuration = {
+            'authorized_error_ratios': {
+                'default': 0.05,
+                'description': 'Over this ratios, the column will not be converted into date'
+            },
+            'sample_size': {
+                'default': 200,
+                'description': textwrap.dedent('''\
+                    Convert date is time consuming. To save time, date
+                    detection will be done on a random sample.
+                    Set to -1 to detect on the whole dataset.''')
+            }
+        }
+
+        self.columns: list[str] = None
+
+    def fit(self, dataset: Dataset) -> Actionable:
+        sample_size = self.get_config('sample_size')
+        if sample_size > 0:
+            sample = dataset.X.sample(n=min(sample_size, len(dataset.X)))
+        else:
+            sample = dataset.X
+
+        self.columns = []
+        for column in dataset.get_columns_names_by_type(DataType.SHORT_TEXT):
+            threshold_count: float = sample[column].count() * \
+                (1 - self.get_config('authorized_error_ratios'))
+            new_columns: pd.DataFrame = sample[column].apply(self.__string_value_to_date)
+
+            if new_columns.count() >= threshold_count:
+                self.columns.append(column)
+
+        self.explanations = [
+            f'Convert text column **`{c}`** into datetime column.'
+            for c in self.columns
+        ]
+
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return bool(dataset.get_columns_names_by_type(DataType.SHORT_TEXT))
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply Text to date convert.
+
+        :param pd.DataFrame x: DataFrame to transform.
+        :return: Transformed dataset.
+        """
+        for column in self.columns:
+            X[column] = pd.to_datetime(X[column], errors='coerce')
+
+        return X
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5
+
+    def __string_value_to_date(self, value: str, date_formats = None) -> pd.Timestamp:
+        """Convert a string value (with date format) to a date.
+        
+        :param str value: String in a date format.
+        :return: Converted date.
+        """
+        if date_formats is None:
+            date_formats = [None]
+        elif isinstance(date_formats, list):
+            date_formats = list(date_formats)
+
+        for date_format in date_formats:
+            try:
+                return pd.to_datetime(value, format=date_format)
+            except ValueError:
+                pass # Let's try the next date format
+
+        return pd.NaT

iaml/actionables/features_precleaning/act_drop_bad_quality_rows.py

@@ -0,0 +1,77 @@
+"""Experimental row filter, available only through an explicit module import.
+
+Its missingness threshold, minimum sample policy and alignment of resampled data
+need integration tests before automatic use. See docs/component_status.rst.
+"""
+from typing import Any
+import textwrap
+import pandas as pd
+from ...actionable import Actionable
+from ...dataset import Dataset
+from ...candidate import Candidate
+from ...decorators.all import is_step
+
+@is_step('experimental')
+class ActDropBadQualityRows(Actionable):
+    """
+    [STEP] Drop Rows with a ratio of Empty Columns
+    """
+    name: str = "Drop Rows with Empty Columns"
+    _description: str = textwrap.dedent('''\
+        This step drops rows where the ratio of empty columns are over a threshold.
+        It helps clean the dataset by removing rows with a significant
+        amount of missing values.''')
+    _description_long: str = textwrap.dedent('''\
+        In datasets, missing data is a common issue. 
+        This step drops rows where the ratio of empty columns are over a threshold.
+        This ensures that rows with too many missing values
+        are not included in the analysis, improving the quality of the dataset.''')
+    refs: list[dict[str, Any]] = []
+
+    def __init__(self):
+        self.configuration = {
+            'empty_threshold': {
+                'description': textwrap.dedent('''\
+                    Row with less or equal proportion of empty column will be
+                    drop. 0 will never never drop a row'''),
+                'default': 0.3
+            },
+            'min_size': {
+                'description': textwrap.dedent('''\
+                    Minimal size of the resulting dataset. If new dataset is
+                    smaller than this value, old one will be restored'''),
+                'default': 20
+            }
+        }
+
+    def fit(self, dataset: Dataset):  # pylint: disable=unused-argument
+        return self
+
+    def __transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """Apply the dropping of rows with at least 40% empty columns.
+        
+        :param pd.DataFrame X: The dataframe to clean.
+        :return: The cleaned dataframe.
+        """
+        threshold = self.get_config('empty_threshold') * X.shape[1]  # 40% of the total columns
+        new_x = X.dropna(thresh=X.shape[1] - threshold)
+        return new_x if new_x.shape[0] >= self.get_config('min_size') else X
+
+    def resample(self, X: pd.DataFrame, y: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """Resample method to apply transformation to both X and y.
+        
+        :param pd.DataFrame X: Features to transform.
+        :param pd.DataFrame y: Labels to keep aligned.
+        :return: The transformed X and aligned y.
+        """
+        x_clean = self.__transform(X.reset_index(drop=True))
+        y_aligned = y[x_clean.index]  # Align y with the cleaned X
+        x_clean.reset_index(drop=True, inplace=True)
+
+        return x_clean, y_aligned
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 1
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.X.isnull().values.any()

iaml/actionables/features_precleaning/act_drop_duplicate_rows.py

@@ -0,0 +1,131 @@
+"""[STEP] Drop duplicate rows"""
+import textwrap
+from typing import Any
+import pandas as pd
+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('features_precleaning')
+class ActDropDuplicateRows(Actionable):
+    """[STEP] Drop duplicate rows"""
+
+    name: str = 'Drop duplicate rows'
+    _usage: str = "Use when duplicated feature rows indicate repeated records and you want one kept copy. Applicable to tabular data with aligned y; unlike ActDropIdLikeColumns, it drops rows not columns. Avoid when repeats are meaningful (time series, sampling) or counts must be preserved."
+    _description: str = textwrap.dedent('''\
+        Remove duplicated rows using keep={keep}.''')
+    _description_long: str = textwrap.dedent('''\
+        Duplicated rows can bias model training by repeating the same signal.
+        This step removes duplicates based on feature values and keeps y/groups aligned.''')
+    refs: list[dict[str, Any]] = []
+
+    def __init__(self):
+        self.configuration = {
+            'keep': {
+                'description': "Which duplicate to keep when removing duplicates.",
+                'default': 'first',
+                'categorical': ['first', 'last', False]
+            }
+        }
+        self.columns_to_check: list[str] = []
+        self.duplicate_count: int = 0
+        self.duplicate_ratio: float = 0.0
+
+    def fit(self, dataset: Dataset) -> Actionable:
+        self.columns_to_check = self.__candidate_columns(dataset)
+        if dataset.X.empty or not self.columns_to_check:
+            self.duplicate_count = 0
+            self.duplicate_ratio = 0.0
+            self.explanations = []
+            return self
+
+        duplicate_mask = dataset.X.duplicated(
+            subset=self.columns_to_check,
+            keep=self.get_config('keep')
+        )
+        self.duplicate_count = int(duplicate_mask.sum())
+        total_rows = len(dataset.X)
+        self.duplicate_ratio = self.duplicate_count / max(1, total_rows)
+
+        if self.duplicate_count:
+            self.explanations = [
+                f'Dropped {self.duplicate_count} duplicated rows '
+                f'({self.duplicate_ratio:.2%} of {total_rows}) using keep={self.get_config("keep")}.'
+            ]
+        else:
+            self.explanations = []
+
+        return self
+
+    def resample(self, X: pd.DataFrame, y: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """Drop duplicate rows and align y.
+
+        :param pd.DataFrame X: Features to clean.
+        :param pd.DataFrame y: Labels to align.
+        :return: Cleaned X and aligned y.
+        """
+        if X.empty:
+            return X, y
+
+        x_reset = X.reset_index(drop=True)
+        x_clean = self.__transform(x_reset)
+        if len(x_clean) == len(x_reset):
+            return X, y
+
+        if not self.__has_aligned_y(y, len(x_reset)):
+            x_clean.reset_index(drop=True, inplace=True)
+            return x_clean, y
+
+        y_aligned = y[x_clean.index]
+        x_clean.reset_index(drop=True, inplace=True)
+        return x_clean, y_aligned
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        if candidate is None:
+            return 1.0
+        columns = self.__candidate_columns(candidate.dataset)
+        if not columns or candidate.dataset.X.empty:
+            return 0.0
+        duplicate_ratio = candidate.dataset.X.duplicated(
+            subset=columns,
+            keep=self.get_config('keep')
+        ).mean()
+        return min(1.5, 0.5 + duplicate_ratio)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        columns = self.__candidate_columns(dataset)
+        if not columns or dataset.X.empty:
+            return False
+        return dataset.X.duplicated(
+            subset=columns,
+            keep=self.get_config('keep')
+        ).any()
+
+    def __transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        subset = self.__subset_columns(X)
+        if not subset:
+            return X
+        return X.drop_duplicates(subset=subset, keep=self.get_config('keep'))
+
+    def __subset_columns(self, X: pd.DataFrame) -> list[str]:
+        if self.columns_to_check:
+            return [column for column in self.columns_to_check if column in X.columns]
+        return list(X.columns)
+
+    def __candidate_columns(self, dataset: Dataset) -> list[str]:
+        columns = dataset.get_columns_names_by_type(list(DataType))
+        if len(columns) != dataset.X.shape[1]:
+            missing = [column for column in dataset.X.columns if column not in columns]
+            columns.extend(missing)
+        return columns
+
+    def __has_aligned_y(self, y: Any, rows_count: int) -> bool:
+        if y is None:
+            return False
+        try:
+            return len(y) == rows_count
+        except TypeError:
+            return False