API: modeling.regression

skyulf.modeling.regression

Regression models.

AdaBoostRegressorApplier

Bases: SklearnApplier

AdaBoost Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class AdaBoostRegressorApplier(SklearnApplier):
    """AdaBoost Regressor Applier."""

AdaBoostRegressorCalculator

Bases: SklearnCalculator

AdaBoost Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("adaboost_regressor", AdaBoostRegressorApplier)
@node_meta(
    id="adaboost_regressor",
    name="AdaBoost Regressor",
    category="Modeling",
    description="An AdaBoost regressor.",
    params={"n_estimators": 50, "learning_rate": 1.0},
    tags=["regression"],
    learns_from_data=True,
)
class AdaBoostRegressorCalculator(SklearnCalculator):
    """AdaBoost Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=AdaBoostRegressor,
            default_params={
                "n_estimators": 50,
                "learning_rate": 1.0,
            },
            problem_type="regression",
        )

DecisionTreeRegressorApplier

Bases: SklearnApplier

Decision Tree Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class DecisionTreeRegressorApplier(SklearnApplier):
    """Decision Tree Regressor Applier."""

DecisionTreeRegressorCalculator

Bases: SklearnCalculator

Decision Tree Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("decision_tree_regressor", DecisionTreeRegressorApplier)
@node_meta(
    id="decision_tree_regressor",
    name="Decision Tree Regressor",
    category="Modeling",
    description="A decision tree regressor.",
    params={"max_depth": None, "min_samples_split": 2, "criterion": "squared_error"},
    tags=["regression"],
    learns_from_data=True,
)
class DecisionTreeRegressorCalculator(SklearnCalculator):
    """Decision Tree Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=DecisionTreeRegressor,
            default_params={
                "max_depth": None,
                "min_samples_split": 2,
                "criterion": "squared_error",
            },
            problem_type="regression",
        )

ElasticNetRegressionApplier

Bases: SklearnApplier

ElasticNet Regression Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class ElasticNetRegressionApplier(SklearnApplier):
    """ElasticNet Regression Applier."""

ElasticNetRegressionCalculator

Bases: SklearnCalculator

ElasticNet Regression Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("elasticnet_regression", ElasticNetRegressionApplier)
@node_meta(
    id="elasticnet_regression",
    name="ElasticNet Regression",
    category="Modeling",
    description="Linear regression with combined L1 and L2 priors.",
    params={"alpha": 1.0, "l1_ratio": 0.5, "selection": "cyclic"},
    tags=["requires_scaling", "regression"],
    learns_from_data=True,
)
class ElasticNetRegressionCalculator(SklearnCalculator):
    """ElasticNet Regression Calculator."""

    def __init__(self):
        super().__init__(
            model_class=ElasticNet,
            default_params={
                "alpha": 1.0,
                "l1_ratio": 0.5,
                "selection": "cyclic",
            },
            problem_type="regression",
        )

ExtraTreesRegressorApplier

Bases: SklearnApplier

Extra Trees Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class ExtraTreesRegressorApplier(SklearnApplier):
    """Extra Trees Regressor Applier."""

ExtraTreesRegressorCalculator

Bases: SklearnCalculator

Extra Trees Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("extra_trees_regressor", ExtraTreesRegressorApplier)
@node_meta(
    id="extra_trees_regressor",
    name="Extra Trees Regressor",
    category="Modeling",
    description="Extremely randomised trees — faster than Random Forest, often comparably accurate.",
    params={"n_estimators": 100, "max_depth": None, "min_samples_split": 2},
    tags=["regression"],
    learns_from_data=True,
)
class ExtraTreesRegressorCalculator(SklearnCalculator):
    """Extra Trees Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=ExtraTreesRegressor,
            default_params={
                "n_estimators": 100,
                "max_depth": None,
                "min_samples_split": 2,
                "min_samples_leaf": 1,
                "criterion": "squared_error",
                "bootstrap": False,
                "n_jobs": -1,
            },
            problem_type="regression",
        )

GradientBoostingRegressorApplier

Bases: SklearnApplier

Gradient Boosting Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class GradientBoostingRegressorApplier(SklearnApplier):
    """Gradient Boosting Regressor Applier."""

GradientBoostingRegressorCalculator

Bases: SklearnCalculator

Gradient Boosting Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("gradient_boosting_regressor", GradientBoostingRegressorApplier)
@node_meta(
    id="gradient_boosting_regressor",
    name="Gradient Boosting Regressor",
    category="Modeling",
    description="Gradient Boosting for regression.",
    params={"n_estimators": 100, "learning_rate": 0.1, "max_depth": 3},
    tags=["regression"],
    learns_from_data=True,
)
class GradientBoostingRegressorCalculator(SklearnCalculator):
    """Gradient Boosting Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=GradientBoostingRegressor,
            default_params={
                "n_estimators": 100,
                "learning_rate": 0.1,
                "max_depth": 3,
            },
            problem_type="regression",
        )

HistGradientBoostingRegressorApplier

Bases: SklearnApplier

HistGradientBoosting Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class HistGradientBoostingRegressorApplier(SklearnApplier):
    """HistGradientBoosting Regressor Applier."""

HistGradientBoostingRegressorCalculator

Bases: SklearnCalculator

HistGradientBoosting Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("hist_gradient_boosting_regressor", HistGradientBoostingRegressorApplier)
@node_meta(
    id="hist_gradient_boosting_regressor",
    name="Hist Gradient Boosting Regressor",
    category="Modeling",
    description="Histogram-based gradient boosting — sklearn's fast LightGBM-style implementation.",
    params={"max_iter": 100, "learning_rate": 0.1, "max_leaf_nodes": 31},
    tags=["regression"],
    learns_from_data=True,
)
class HistGradientBoostingRegressorCalculator(SklearnCalculator):
    """HistGradientBoosting Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=HistGradientBoostingRegressor,
            default_params={
                "max_iter": 100,
                "learning_rate": 0.1,
                "max_leaf_nodes": 31,
                "max_depth": None,
                "min_samples_leaf": 20,
                "l2_regularization": 0.0,
                "max_bins": 255,
            },
            problem_type="regression",
        )

KNeighborsRegressorApplier

Bases: SklearnApplier

K-Neighbors Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class KNeighborsRegressorApplier(SklearnApplier):
    """K-Neighbors Regressor Applier."""

KNeighborsRegressorCalculator

Bases: SklearnCalculator

K-Neighbors Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("k_neighbors_regressor", KNeighborsRegressorApplier)
@node_meta(
    id="k_neighbors_regressor",
    name="K-Neighbors Regressor",
    category="Modeling",
    description="Regression based on k-nearest neighbors.",
    params={"n_neighbors": 5, "weights": "uniform", "algorithm": "auto"},
    tags=["requires_scaling", "regression"],
    learns_from_data=True,
)
class KNeighborsRegressorCalculator(SklearnCalculator):
    """K-Neighbors Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=KNeighborsRegressor,
            default_params={
                "n_neighbors": 5,
                "weights": "uniform",
                "algorithm": "auto",
                "n_jobs": -1,
            },
            problem_type="regression",
        )

LGBMRegressorApplier

Bases: SklearnApplier

LightGBM Regressor Applier.

LightGBM 4.x sets feature_names_in_ to auto-generated names (Column_0, Column_1...) even when fit with numpy arrays, and the property's deleter is intentionally a no-op (see upstream source). That triggers sklearn's UserWarning: X does not have valid feature names on every predict call. We suppress it locally here so the warning never leaks out of the applier boundary.

Source code in skyulf-core/skyulf/modeling/regression.py

class LGBMRegressorApplier(SklearnApplier):
    """LightGBM Regressor Applier.

    LightGBM 4.x sets ``feature_names_in_`` to auto-generated names
    (``Column_0``, ``Column_1``...) even when fit with numpy arrays, and the
    property's deleter is intentionally a no-op (see upstream source). That
    triggers sklearn's ``UserWarning: X does not have valid feature names``
    on every predict call. We suppress it locally here so the warning never
    leaks out of the applier boundary.
    """

    def predict(self, df, model_artifact):
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore", message=".*valid feature names.*")
            return super().predict(df, model_artifact)

LGBMRegressorCalculator

Bases: SklearnCalculator

LightGBM Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("lgbm_regressor", LGBMRegressorApplier)
@node_meta(
    id="lgbm_regressor",
    name="LightGBM Regressor",
    category="Modeling",
    description="LightGBM: leaf-wise gradient boosting, fast and memory-efficient with categorical support.",
    params={"n_estimators": 100, "num_leaves": 31, "learning_rate": 0.1},
    tags=["regression"],
    learns_from_data=True,
)
class LGBMRegressorCalculator(SklearnCalculator):
    """LightGBM Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=LGBMRegressor,
            default_params={
                "n_estimators": 100,
                "num_leaves": 31,
                "learning_rate": 0.1,
                "max_depth": -1,
                "min_child_samples": 20,
                "subsample": 1.0,
                "colsample_bytree": 1.0,
                "reg_alpha": 0.0,
                "reg_lambda": 0.0,
                "boosting_type": "gbdt",
                "n_jobs": -1,
                "verbose": -1,
                "verbosity": -1,
            },
            problem_type="regression",
        )

    def fit(
        self,
        X,
        y,
        config,
        progress_callback=None,
        log_callback=None,
        validation_data=None,
        iteration_callback=None,
    ):
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore", message=".*valid feature names.*")
            return super().fit(
                X,
                y,
                config,
                progress_callback=progress_callback,
                log_callback=log_callback,
                validation_data=validation_data,
                iteration_callback=iteration_callback,
            )

    def _boosting_fit_kwargs(self, model, X_np, y_np, iteration_callback):
        if iteration_callback is None:
            return {}
        return {
            "eval_set": [(X_np, y_np)],
            "callbacks": [LightGBMIterationAdapter(iteration_callback)],
        }

LassoRegressionApplier

Bases: SklearnApplier

Lasso Regression Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class LassoRegressionApplier(SklearnApplier):
    """Lasso Regression Applier."""

LassoRegressionCalculator

Bases: SklearnCalculator

Lasso Regression Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("lasso_regression", LassoRegressionApplier)
@node_meta(
    id="lasso_regression",
    name="Lasso Regression",
    category="Modeling",
    description="Linear Model trained with L1 prior as regularizer.",
    params={"alpha": 1.0, "selection": "cyclic"},
    tags=["requires_scaling", "regression"],
    learns_from_data=True,
)
class LassoRegressionCalculator(SklearnCalculator):
    """Lasso Regression Calculator."""

    def __init__(self):
        super().__init__(
            model_class=Lasso,
            default_params={"alpha": 1.0, "selection": "cyclic"},
            problem_type="regression",
        )

LinearRegressionApplier

Bases: SklearnApplier

Linear Regression Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class LinearRegressionApplier(SklearnApplier):
    """Linear Regression Applier."""

LinearRegressionCalculator

Bases: SklearnCalculator

Linear Regression Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("linear_regression", LinearRegressionApplier)
@node_meta(
    id="linear_regression",
    name="Linear Regression",
    category="Modeling",
    description="Ordinary least squares Linear Regression.",
    params={"fit_intercept": True, "copy_X": True, "n_jobs": -1},
    tags=["requires_scaling", "regression"],
    learns_from_data=True,
)
class LinearRegressionCalculator(SklearnCalculator):
    """Linear Regression Calculator."""

    def __init__(self):
        super().__init__(
            model_class=LinearRegression,
            default_params={
                "fit_intercept": True,
                "copy_X": True,
                "n_jobs": -1,
            },
            problem_type="regression",
        )

RandomForestRegressorApplier

Bases: SklearnApplier

Random Forest Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class RandomForestRegressorApplier(SklearnApplier):
    """Random Forest Regressor Applier."""

RandomForestRegressorCalculator

Bases: SklearnCalculator

Random Forest Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("random_forest_regressor", RandomForestRegressorApplier)
@node_meta(
    id="random_forest_regressor",
    name="Random Forest Regressor",
    category="Modeling",
    description="Ensemble of decision trees for regression.",
    params={"n_estimators": 50, "max_depth": 10, "min_samples_split": 5},
    tags=["regression"],
    learns_from_data=True,
)
class RandomForestRegressorCalculator(SklearnCalculator):
    """Random Forest Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=RandomForestRegressor,
            default_params={
                "n_estimators": 50,
                "max_depth": 10,
                "min_samples_split": 5,
                "min_samples_leaf": 2,
                "n_jobs": -1,
            },
            problem_type="regression",
        )

RidgeRegressionApplier

Bases: SklearnApplier

Ridge Regression Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class RidgeRegressionApplier(SklearnApplier):
    """Ridge Regression Applier."""

RidgeRegressionCalculator

Bases: SklearnCalculator

Ridge Regression Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("ridge_regression", RidgeRegressionApplier)
@node_meta(
    id="ridge_regression",
    name="Ridge Regression",
    category="Modeling",
    description="Linear least squares with l2 regularization.",
    params={"alpha": 1.0, "solver": "auto"},
    tags=["requires_scaling", "regression"],
    learns_from_data=True,
)
class RidgeRegressionCalculator(SklearnCalculator):
    """Ridge Regression Calculator."""

    def __init__(self):
        super().__init__(
            model_class=Ridge,
            default_params={
                "alpha": 1.0,
                "solver": "auto",
            },
            problem_type="regression",
        )

SVRApplier

Bases: SklearnApplier

SVR Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class SVRApplier(SklearnApplier):
    """SVR Applier."""

SVRCalculator

Bases: SklearnCalculator

SVR Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("svr", SVRApplier)
@node_meta(
    id="svr",
    name="Support Vector Regressor",
    category="Modeling",
    description="Epsilon-Support Vector Regression.",
    params={"C": 1.0, "kernel": "rbf", "gamma": "scale"},
    tags=["requires_scaling", "regression"],
    learns_from_data=True,
)
class SVRCalculator(SklearnCalculator):
    """SVR Calculator."""

    def __init__(self):
        super().__init__(
            model_class=SVR,
            default_params={"C": 1.0, "kernel": "rbf", "gamma": "scale"},
            problem_type="regression",
        )

XGBRegressorApplier

Bases: SklearnApplier

XGBoost Regressor Applier.

Source code in skyulf-core/skyulf/modeling/regression.py

class XGBRegressorApplier(SklearnApplier):
    """XGBoost Regressor Applier."""

XGBRegressorCalculator

Bases: SklearnCalculator

XGBoost Regressor Calculator.

Source code in skyulf-core/skyulf/modeling/regression.py

@NodeRegistry.register("xgboost_regressor", XGBRegressorApplier)
@node_meta(
    id="xgboost_regressor",
    name="XGBoost Regressor",
    category="Modeling",
    description="Extreme Gradient Boosting regressor.",
    params={"n_estimators": 100, "max_depth": 6, "learning_rate": 0.3},
    tags=["regression"],
    learns_from_data=True,
)
class XGBRegressorCalculator(SklearnCalculator):
    """XGBoost Regressor Calculator."""

    def __init__(self):
        super().__init__(
            model_class=XGBRegressor,
            default_params={
                "n_estimators": 100,
                "max_depth": 6,
                "learning_rate": 0.3,
                "subsample": 0.8,
                "colsample_bytree": 0.8,
                "n_jobs": -1,
            },
            problem_type="regression",
        )

    def _boosting_fit_kwargs(self, model, X_np, y_np, iteration_callback):
        if iteration_callback is None or XgboostIterationAdapter is None:
            return {}
        # XGBoost 3.x reads callbacks from the estimator itself (they were
        # removed from fit()). eval_set is display-only (no early
        # stopping), so the trained model is identical to a plain fit — it
        # just streams per-round training loss for the live chart.
        model.callbacks = [
            XgboostIterationAdapter(iteration_callback, total=int(model.n_estimators))
        ]
        return {
            "eval_set": [(X_np, y_np)],
            "verbose": False,
            "_detach_callbacks": True,
        }