PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/predictors/regressor/act_elastic_net_regressor.py

@@ -0,0 +1,109 @@
+"""[STEP] Elastic Net Regressor"""
+import textwrap
+from typing import Any
+from sklearn.linear_model import ElasticNet
+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', 'regressor')
+class ActElasticNetRegressor(Predictor):
+    """[STEP] Elastic Net Regressor"""
+
+    name: str = "Elastic Net Regressor"
+    _description: str = textwrap.dedent('''\
+        ElasticNet regression combines L1 and L2 regularization to balance
+        sparsity and stability in linear models.''')
+    _description_long: str = textwrap.dedent('''\
+        ElasticNet regression fits a linear model with both L1 and L2 penalties.
+        The L1 term encourages sparsity by driving some coefficients to zero,
+        while the L2 term stabilizes coefficients when predictors are correlated,
+        making it a robust choice for tabular regression.''')
+    _usage: str = "Use when you need a sparse linear baseline for tabular regression and want a simpler choice than ActExtraTreesRegressor. Applicable to numeric-feature regression with correlated predictors. Avoid when strong nonlinear patterns dominate; consider ActCatBoostRegressor."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2005,
+            'name': 'Regularization and Variable Selection via the Elastic Net',
+            'authors': [
+                'Hui Zou',
+                'Trevor Hastie'
+            ],
+            'doi': 'https://doi.org/10.1111/j.1467-9868.2005.00503.x',
+            'publisher': 'Journal of the Royal Statistical Society Series B'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'alpha': {
+                'description': 'Regularization strength.',
+                'default': 1.0,
+                'range': [1e-04, 10.0]
+            },
+            'l1_ratio': {
+                'description': 'Mixing parameter between L1 and L2 penalty.',
+                'default': 0.5,
+                'range': [0.0, 1.0]
+            },
+            'fit_intercept': {
+                'description': 'Whether to fit the intercept term.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'max_iter': {
+                'description': 'Maximum number of iterations.',
+                'default': 1000,
+                'range': [100, 5000]
+            },
+            'tol': {
+                'description': 'Stopping criterion.',
+                'default': 0.0001,
+                'range': [1e-05, 0.1]
+            },
+            'selection': {
+                'description': 'Coordinate descent selection strategy.',
+                'default': 'cyclic',
+                'categorical': ['cyclic', 'random']
+            },
+            'positive': {
+                'description': 'Force coefficients to be positive.',
+                'default': False,
+                'categorical': [True, False]
+            },
+            'random_state': {
+                'description': 'Random state used when selection is "random".',
+                'default': 42
+            }
+        }
+        self.model: ElasticNet = 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 = ElasticNet(**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 == 'continuous' \
+            and bool(dataset.get_columns_names_by_type(DataType.NUMERIC))
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_extra_trees_regressor.py

@@ -0,0 +1,113 @@
+"""[STEP]  Extra Trees Regressor"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import ExtraTreesRegressor
+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', 'regressor')
+class ActExtraTreesRegressor(Predictor):
+    """[STEP]  Extra Trees Regressor"""
+
+    name: str = "Extra Trees Regressor"
+    _description: str = textwrap.dedent('''\
+        ExtraTreesRegressor is a machine learning algorithm that makes predictions
+        for regression tasks by combining the outputs of multiple decision trees.''')
+    _description_long: str = textwrap.dedent('''\
+        ExtraTreesRegressor is a type of ensemble learning algorithm
+        that belongs to the family of decision tree-based models.
+        It works by building multiple decision trees, where each tree is trained on a
+        random subset of the input features and a random subset of the training data.
+        At prediction time, the algorithm aggregates the outputs of all the
+        decision trees to make a final prediction.''')
+    _usage: str = "Use when you want a strong nonparametric tabular regressor, often a better default than ActDecisionTreeRegressor or ActAdaBoostRegressor. Applicable to numeric or mixed features with continuous targets. Avoid when data is tiny, very sparse/high-dimensional, or a linear/transparent model is required."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Extremely randomized trees',
+            'authors': [
+                'Pierre Geurts',
+                'Damien Ernst',
+                'Louis Wehenkel'
+            ],
+            'doi': 'https://doi.org/10.1007/s10994-006-6226-1',
+            'publisher': 'Machine Learning Vol. 63 page 3--42'
+        }
+    ]
+    def __init__(self):
+        self.configuration = {
+            'max_depth': {
+                'description': 'Max depth of each tree',
+                'default': 15,
+                'range': [1, 100]
+            },
+            'min_samples_leaf': {
+                'description': 'The minimum number of samples required to be at a leaf node.',
+                'default': 1,
+                'range': [1, 15]
+            },
+            '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': "squared_error",
+                'categorical': ["poisson", "friedman_mse", "absolute_error", "squared_error"]
+            },
+            'n_estimators': {
+                'description': 'Number of threes',
+                'default': 100,
+                'range': [1, 500]
+            },
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            }
+        }
+        self.model: ExtraTreesRegressor = 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 = ExtraTreesRegressor(**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 == 'continuous' \
+            and bool(dataset.get_columns_names_by_type(DataType.NUMERIC))
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_gaussian_process_regressor.py

@@ -0,0 +1,55 @@
+"""[STEP] Gaussian Process Regressor"""
+import textwrap
+from typing import Any
+from sklearn.gaussian_process import GaussianProcessRegressor
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActGaussianProcessRegressor(Predictor):
+    """[STEP] Gaussian Process Regressor"""
+
+    name: str = "Gaussian Process Regressor"
+    _description: str = textwrap.dedent('''\
+        GaussianProcessRegressor is a machine learning algorithm
+        that makes predictions for regression tasks using Gaussian processes.''')
+    _description_long: str = textwrap.dedent('''\
+        GaussianProcessRegressor is a powerful algorithm for regression tasks,
+        especially when the relationship between the input features and the output variable is
+        complex and non-linear, and when uncertainty estimates are important.''')
+    _usage: str = "Use when you need nonlinear regression with uncertainty on small tabular data; compare ActCatBoostRegressor or ActExtraTreesRegressor for larger data. Applicable to continuous-target tabular features. Avoid when datasets are large/high-dimensional or latency is strict."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Gaussian Processes for Machine Learning',
+            'authors': [
+                'Carl Edward Rasmussen',
+                'Christopher K. I. Williams'
+            ],
+            'doi': 'https://doi.org/10.7551/mitpress/3206.001.0001',
+            'publisher': 'MIT Press 2006'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'alpha': {
+                'description': 'Value added to the diagonal of the kernel matrix during fitting.',
+                'default': 1e-14,
+                'range': [1e-08, 1.0]
+                }
+            }
+        self.model: GaussianProcessRegressor = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = GaussianProcessRegressor(**self.passthrough_parameters())
+        self.model.fit(dataset.X, dataset.y)
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'continuous'
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_gboost_regressor.py

@@ -0,0 +1,95 @@
+"""[STEP] Gradient Boosting Regressor"""
+import textwrap
+from typing import Any
+
+from sklearn.ensemble import GradientBoostingRegressor
+
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'regressor', 'minimal_predictor')
+class ActGBoostRegressor(Predictor):
+    """[STEP] Gradient Boosting Regressor"""
+
+    name: str = "Gradient Boosting Regressor"
+    _usage: str = "Use when you want a boosting baseline for regression and prefer simpler tuning vs ActCatBoostRegressor. Applicable to tabular data with continuous targets and mixed features. Avoid when you need linear interpretability or very fast training; consider ActElasticNetRegressor."
+    _description: str = textwrap.dedent('''\
+        GradientBoostingRegressor learns an ensemble of weak learners (decision trees)
+        in a stage-wise manner to minimize the prediction error on continuous targets.''')
+    _description_long: str = textwrap.dedent('''\
+        Gradient Boosting is an additive modeling technique where each subsequent tree
+        attempts to correct the residuals of the previous ensemble. The regressor is
+        robust to different loss formulations and usually provides a strong baseline
+        for tabular regression tasks.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'name': 'Greedy Function Approximation: A Gradient Boosting Machine',
+            'year': 2001,
+            'authors': ['Jerome H. Friedman'],
+            'doi': 'https://doi.org/10.1214/aos/1013203451',
+            'publisher': 'The Annals of Statistics, Vol.29, No.5'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'max_depth': {
+                'description': 'Max depth of each tree',
+                'default': 15,
+                'range': [1, 100]
+            },
+            'random_state': {
+                'description': 'random_state',
+                'default': 42
+            },
+            'learning_rate': {
+                'description': 'Learning rate',
+                'default': 0.1,
+                'range': [1e-8, 5.0]
+            },
+            'n_estimators': {
+                'description': 'Number of estimators',
+                'default': 100,
+                'range': [1, 500]
+            },
+            'loss': {
+                'description': 'Loss function to optimize.',
+                'default': "squared_error",
+                'categorical': ['squared_error', 'absolute_error', 'huber', 'quantile']
+            },
+            'criterion': {
+                'description': 'Split quality metric',
+                'default': "friedman_mse",
+                'categorical': ['friedman_mse', 'squared_error']
+            },
+            'min_samples_leaf': {
+                'description': 'Minimum samples at leaf nodes.',
+                'default': 1,
+                'range': [1, 15]
+            },
+            'max_features': {
+                'description': 'Fraction of features per split.',
+                'default': 1.0,
+                'range': [0.1, 1.0]
+            },
+            'min_samples_split': {
+                'description': 'Minimum samples to split nodes.',
+                'default': 2,
+                'range': [2, 20]
+            }
+        }
+        self.model: GradientBoostingRegressor = None
+
+    def fit(self, dataset: Dataset):  # pylint: disable=unused-argument
+        self.model = GradientBoostingRegressor(**self.passthrough_parameters())
+        self.model.fit(dataset.X, dataset.y)
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'continuous'
+
+    def priorize(self, candidate: Candidate = None) -> float:  # pylint: disable=unused-argument
+        return 0.5

iaml/actionables/predictors/regressor/act_hist_gradient_boosting_regressor.py

@@ -0,0 +1,105 @@
+"""[STEP] HistGradient Boosting Regressor"""
+import textwrap
+from typing import Any
+from sklearn.ensemble import HistGradientBoostingRegressor
+from ....predictor import Predictor
+from ....dataset import Dataset
+from ....candidate import Candidate
+from ....decorators.all import is_step
+
+@is_step('predictor', 'tabular', 'regressor')
+class ActHistGradientBoostingRegressor(Predictor):
+    """[STEP] HistGradient Boosting Regressor"""
+
+    name: str = "HistGradient Boosting Regressor"
+    _description: str = textwrap.dedent('''\
+        HistGradientBoostingRegressor is a machine learning algorithm
+        that makes predictions for regression tasks using histogram-based gradient boosting.''')
+    _description_long: str = textwrap.dedent('''\
+        HistGradientBoostingRegressor is a type of gradient boosting
+        algorithm that uses histogram-based decision trees to model the relationship between
+        the input features and the output variable. It works by iteratively adding decision
+        trees to the model, where each tree is trained to correct the errors made by the
+        previous tree. The decision trees are constructed using histograms of the input
+        features, which allows for faster computation and more efficient memory
+        usage compared to other tree-based algorithms.
+        HistGradientBoostingRegressor also includes options for regularization,
+        such as L1 and L2 regularization, to prevent overfitting.''')
+    _usage: str = "Use when you need fast nonlinear tabular regression; leaner than ActCatBoostRegressor or ActExtraTreesRegressor. Applicable to medium to large tabular continuous targets with mostly numeric features. Avoid when data is tiny, mostly linear, or interpretability is critical."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Gaussian Processes for Machine Learning',
+            'authors': [
+                'Carl Edward Rasmussen',
+                'Christopher K. I. Williams'
+            ],
+            'doi': 'https://doi.org/10.7551/mitpress/3206.001.0001',
+            'publisher': 'MIT Press 2006'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'l2_regularization': {
+                'description': 'The L2 regularization parameter. \
+                    Use 0 for no regularization (default).',
+                'default': 1e-10,
+                'range': [1e-10, 1.0]
+                },
+            'quantile': {
+                'description': 'If loss is “quantile”, this parameter specifies which quantile to \
+                    be estimated and must be between 0 and 1.',
+                'default': 0.5,
+                'range': [0.1, 0.99]
+                },
+            'learning_rate': {
+                'description': 'The learning rate, also known as shrinkage.',
+                'default': 0.1,
+                'range': [0.01, 1.0]
+                },
+            'max_leaf_nodes': {
+                'description': 'The maximum number of leaves for each tree.',
+                'default': 31,
+                'range': [3, 2048]
+                },
+            'min_samples_leaf': {
+                'description': 'The minimum number of samples per leaf.',
+                'default': 20,
+                'range': [1, 200]
+                },
+            'loss': {
+                'description': 'The loss function to use in the boosting process.',
+                'default': "squared_error",
+                'categorical': ["absolute_error", "poisson", "quantile", "squared_error"]
+                },
+            'n_iter_no_change': {
+                'description': 'Used to determine when to “early stop”.',
+                'default': 4,
+                'range': [2, 15]
+                },
+            'tol': {
+                'description': 'The absolute tolerance to use when comparing \
+                    scores during early stopping',
+                'default': 1e-4,
+                'range': [1e-8, 1e-2]
+                },
+            'max_depth': {
+                'description': 'The maximum depth of each tree',
+                'default': 10,
+                'range': [8, 25]
+                }
+            }
+        self.model: HistGradientBoostingRegressor = None
+
+    def fit(self, dataset: Dataset): # pylint: disable=unused-argument
+        self.model = HistGradientBoostingRegressor(early_stopping=True,
+                                                   **self.passthrough_parameters())
+        self.model.fit(dataset.X, dataset.y)
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'continuous'
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_huber_regressor.py

@@ -0,0 +1,101 @@
+"""[STEP] Huber Regressor"""
+import textwrap
+from typing import Any
+from sklearn.linear_model import HuberRegressor
+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', 'regressor')
+class ActHuberRegressor(Predictor):
+    """[STEP] Huber Regressor"""
+
+    name: str = "Huber Regressor"
+    _description: str = textwrap.dedent('''\
+        HuberRegressor fits a linear model that is less sensitive to outliers
+        by combining squared and absolute error losses.''')
+    _description_long: str = textwrap.dedent('''\
+        HuberRegressor optimizes a loss that behaves like squared error for
+        small residuals and like absolute error for large residuals. This
+        makes it a robust choice for tabular regression when data can contain
+        outliers while retaining efficiency for clean data.''')
+    _usage: str = "Use when you need robust linear regression with outliers; prefer over ActElasticNetRegressor when outliers skew fits. Applicable to numeric tabular regression with mostly linear relationships. Avoid when nonlinear effects or categorical-heavy data suit ActCatBoostRegressor."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1964,
+            'name': 'Robust Estimation of a Location Parameter',
+            'authors': [
+                'Peter J. Huber'
+            ],
+            'doi': 'https://doi.org/10.1214/aoms/1177703732',
+            'publisher': 'Annals of Mathematical Statistics'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'epsilon': {
+                'description': textwrap.dedent('''\
+                    Threshold that controls the point where the loss switches
+                    from quadratic to linear.'''),
+                'default': 1.35,
+                'range': [1.01, 3.0]
+            },
+            'alpha': {
+                'description': 'L2 regularization strength.',
+                'default': 0.0001,
+                'range': [1e-07, 1.0]
+            },
+            'fit_intercept': {
+                'description': 'Whether to fit the intercept term.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'max_iter': {
+                'description': 'Maximum number of iterations.',
+                'default': 100,
+                'range': [50, 2000]
+            },
+            'tol': {
+                'description': 'Stopping criterion.',
+                'default': 1e-05,
+                'range': [1e-06, 0.1]
+            },
+            'warm_start': {
+                'description': 'Reuse solution from previous fit as initialization.',
+                'default': False,
+                'categorical': [True, False]
+            }
+        }
+        self.model: HuberRegressor = 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 = HuberRegressor(**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 == 'continuous' \
+            and bool(dataset.get_columns_names_by_type(DataType.NUMERIC))
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral

iaml/actionables/predictors/regressor/act_knn_regressor.py

@@ -0,0 +1,86 @@
+"""[STEP] KNN"""
+import textwrap
+from typing import Any
+from sklearn.neighbors import KNeighborsRegressor
+from ....predictor import Predictor
+from ....candidate import Candidate
+from ....dataset import Dataset
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'fast_predictor', 'regressor')
+class ActKNNRegressor(Predictor):
+    """[STEP] KNN"""
+
+    name: str = "KNN"
+    _usage: str = "Use when local neighbor patterns matter and you need a fast baseline; compare ActDecisionTreeRegressor or ActExtraTreesRegressor. Applicable to numeric tabular regression with moderate feature scales. Avoid when data is high-dimensional, very large, or needs extrapolation."
+    _description: str = textwrap.dedent('''\
+        KNeighborsRegressor is a machine learning algorithm that makes
+        predictions for regression tasks using k-nearest neighbors.''')
+    _description_long: str = textwrap.dedent('''\
+        KNeighborsRegressor is a type of instance-based learning
+        algorithm that makes predictions for new input features based on the values of
+        the k-nearest neighbors in the training data. It works by calculating the distance
+        between the new input features and all the training data, and then selecting
+        the k-nearest neighbors based on that distance. The output variable for the new
+        input features is then calculated as the average of the output variables
+        for the k-nearest neighbors.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1951,
+            'name': 'Discriminatory Analysis, Nonparametric Discrimination: Consistency Properties',
+            'authors': [
+                'Evelyn Fix',
+                'Joseph Lawson Hodges Jr.'
+            ],
+            'doi': 'https://doi.org/10.2307/1403797',
+            'publisher': 'Technical Report 4, USAF School of Aviation Medicine, Randolph Field'
+        },
+        {
+            'year': 1967,
+            'name': 'Nearest neighbor pattern classification',
+            'authors': [
+                'Thomas M. Cover',
+                'Peter E. Hart'
+            ],
+            'doi': 'https://doi.org/10.1109/TIT.1967.1053964',
+            'publisher': 'IEEE Transactions on Information Theory. 13: page 21--27'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration = {
+            'metric': {
+                'description': 'Can be minkowski or manhattan',
+                'default': 'minkowski',
+                'categorical': ['minkowski', 'manhattan']
+            },
+            'n_neighbors': {
+                'description': 'Number of neighbors',
+                'default': 5,
+                'range': [1, 200],
+                'passthrough': False
+            },
+            'weights': {
+                'description': 'Weight function used in prediction.',
+                'default': 'uniform',
+                'categorical': ['uniform', 'distance']
+            }
+        }
+        self.model: KNeighborsRegressor = None
+
+    def fit(self, dataset: Dataset):
+        self.model = KNeighborsRegressor(
+            n_neighbors = min(self.get_config('n_neighbors'), dataset.X.shape[0]),
+            **self.passthrough_parameters()
+        )
+
+        self.model.fit(dataset.X, dataset.y)
+
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target in ['continuous']
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5 # neutral