maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/learn/contrib/lightgbm/callback.py

@@ -0,0 +1,114 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+from typing import Callable, List, Union
+
+from ....serialization.serializables import (
+    AnyField,
+    BoolField,
+    DictField,
+    FieldTypes,
+    Int32Field,
+)
+from ....udf import BuiltinFunction
+from ..utils import TrainingCallback
+
+try:
+    from lightgbm.callback import _EarlyStoppingCallback, _ResetParameterCallback
+
+    _use_lgbm_callback_classes = True
+except ImportError:
+    try:
+        from lightgbm.callback import early_stopping as _EarlyStoppingCallback
+        from lightgbm.callback import reset_parameter as _ResetParameterCallback
+
+        _use_lgbm_callback_classes = False
+    except ImportError:
+        _EarlyStoppingCallback = _ResetParameterCallback = None
+
+
+class LGBMTrainingCallback(TrainingCallback):
+    _local_to_remote = {}
+
+    @classmethod
+    def _load_local_to_remote_mapping(cls, globals_dict):
+        if isinstance(_EarlyStoppingCallback, type):
+            return super()._load_local_to_remote_mapping(globals_dict)
+        # lightgbm<4.0: callbacks returning closures
+        for v in globals_dict.values():
+            if isinstance(v, type) and issubclass(v, cls) and v._local_cls is not None:
+                cls._local_to_remote[v._local_cls.__name__] = v
+
+    @classmethod
+    def from_local(cls, callback_obj):
+        cls._load_local_to_remote_mapping(globals())
+        if _use_lgbm_callback_classes:
+            return super().from_local(callback_obj)
+        cb_name = callback_obj.__qualname__.split(".", 1)[0]
+        if cb_name not in cls._local_to_remote:
+            return callback_obj
+
+        remote_cls = cls._local_to_remote[cb_name]
+        closure_vars = inspect.getclosurevars(callback_obj).nonlocals
+        kw = {k: v for k, v in closure_vars.items() if k in remote_cls._FIELDS}
+        return remote_cls(**kw)
+
+
+class EarlyStoppingCallback(LGBMTrainingCallback):
+    _local_cls = _EarlyStoppingCallback
+
+    stopping_rounds = Int32Field("stopping_rounds")
+    first_metric_only = BoolField("first_metric_only")
+    verbose = BoolField("verbose")
+    min_delta = AnyField("min_delta")
+
+    def _extract_kw(self) -> dict:
+        kw = super()._extract_kw()
+        if not _use_lgbm_callback_classes:
+            kw.pop("min_delta", None)
+        return kw
+
+
+def early_stopping(
+    stopping_rounds: int,
+    first_metric_only: bool = False,
+    verbose: bool = True,
+    min_delta: Union[float, List[float]] = 0.0,
+) -> EarlyStoppingCallback:
+    return EarlyStoppingCallback(
+        stopping_rounds=stopping_rounds,
+        first_metric_only=first_metric_only,
+        verbose=verbose,
+        min_delta=min_delta,
+    )
+
+
+class ResetParameterCallback(LGBMTrainingCallback):
+    _local_cls = _ResetParameterCallback
+
+    kwargs = DictField("kwargs", key_type=FieldTypes.string, default_factory=dict)
+
+    def has_custom_code(self) -> bool:
+        return any(
+            not isinstance(v, (list, BuiltinFunction)) for v in self.kwargs.values()
+        )
+
+    def _extract_kw(self) -> dict:
+        # _ResetParameterCallback in lightgbm accepts kwargs as **kwargs
+        return self.kwargs
+
+
+def reset_parameter(**kwargs: Union[list, Callable]) -> Callable:
+    return ResetParameterCallback(kwargs=kwargs)

maxframe/learn/contrib/lightgbm/classifier.py

@@ -0,0 +1,199 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .... import tensor as mt
+from ....tensor.merge.vstack import _vstack
+from ...preprocessing import LabelEncoder
+from ...utils import check_classification_targets
+from ...utils.checks import assert_all_finite
+from ..utils import make_import_error_func
+from .core import LGBMScikitLearnBase
+
+try:
+    import lightgbm
+except ImportError:
+    lightgbm = None
+
+
+if not lightgbm:
+    LGBMClassifier = make_import_error_func("lightgbm")
+else:
+
+    class LGBMClassifier(LGBMScikitLearnBase, lightgbm.LGBMClassifier):
+        _default_objective = "binary"
+
+        def __init__(self, *args, **kwargs):
+            if args:
+                if (
+                    isinstance(args[0], lightgbm.LGBMClassifier)
+                    and getattr(args[0], "_le", None) is not None
+                ):
+                    self._le = LabelEncoder()
+                    self._le.classes_ = mt.array(args[0]._le.classes_)
+                elif isinstance(args[0], lightgbm.Booster):
+                    self._le = LabelEncoder()
+                    self._le.classes_ = mt.arange(args[0].params.get("num_class", 2))
+            super().__init__(*args, **kwargs)
+
+        def fit(
+            self,
+            X,
+            y,
+            *,
+            sample_weight=None,
+            init_score=None,
+            group=None,
+            eval_set=None,
+            eval_names=None,
+            eval_sample_weight=None,
+            eval_init_score=None,
+            eval_group=None,
+            eval_metric=None,
+            early_stopping_rounds=None,
+            verbose=True,
+            feature_name="auto",
+            categorical_feature="auto",
+            callbacks=None,
+            init_model=None,
+            classes=None,
+            **kwargs
+        ):
+            """
+            unsupported features:
+            1. eval_metric
+            """
+            if classes:
+                self._le = LabelEncoder()
+                self._le.classes_ = mt.array(classes)
+            else:
+                y = assert_all_finite(y, check_only=False)
+                _, y = check_classification_targets(y, return_value=True)
+                self._le = LabelEncoder().fit(y)
+                _y = self._le.transform(y, execute=False)
+
+            num_class = self._le.classes_.shape[0]
+            if num_class > 2:
+                # Switch to using a multiclass objective in the underlying LGBM instance
+                ova_aliases = {"multiclassova", "multiclass_ova", "ova", "ovr"}
+                if self._objective not in ova_aliases and not callable(self._objective):
+                    self._objective = "multiclass"
+
+            if not callable(eval_metric):
+                if isinstance(eval_metric, (str, type(None))):
+                    eval_metric = [eval_metric]
+                if num_class > 2:
+                    for index, metric in enumerate(eval_metric):
+                        if metric in {"logloss", "binary_logloss"}:
+                            eval_metric[index] = "multi_logloss"
+                        elif metric in {"error", "binary_error"}:
+                            eval_metric[index] = "multi_error"
+                else:
+                    for index, metric in enumerate(eval_metric):
+                        if metric in {"logloss", "multi_logloss"}:
+                            eval_metric[index] = "binary_logloss"
+                        elif metric in {"error", "multi_error"}:
+                            eval_metric[index] = "binary_error"
+
+            # do not modify args, as it causes errors in model selection tools
+            valid_sets = None
+            if eval_set is not None:
+                if isinstance(eval_set, tuple):
+                    eval_set = [eval_set]
+                valid_sets = [None] * len(eval_set)
+                for i, (valid_x, valid_y) in enumerate(eval_set):
+                    if valid_x is X and valid_y is y:
+                        valid_sets[i] = (valid_x, _y)
+                    else:
+                        valid_sets[i] = (
+                            valid_x,
+                            self._le.transform(valid_y, execute=False),
+                        )
+
+            super().fit(
+                X,
+                y,
+                sample_weight=sample_weight,
+                init_score=init_score,
+                eval_set=valid_sets,
+                eval_names=eval_names,
+                eval_sample_weight=eval_sample_weight,
+                eval_init_score=eval_init_score,
+                eval_metric=eval_metric,
+                early_stopping_rounds=early_stopping_rounds,
+                verbose=verbose,
+                feature_name=feature_name,
+                categorical_feature=categorical_feature,
+                callbacks=callbacks,
+                init_model=init_model,
+            )
+            return self
+
+        def predict(
+            self,
+            X,
+            raw_score=False,
+            start_iteration=0,
+            num_iteration=None,
+            pred_leaf=False,
+            pred_contrib=False,
+            **kwargs
+        ):
+            result = self.predict_proba(
+                X,
+                raw_score,
+                start_iteration,
+                num_iteration,
+                pred_leaf,
+                pred_contrib,
+                **kwargs
+            )
+            if callable(self._objective) or raw_score or pred_leaf or pred_contrib:
+                return result
+            else:
+                class_index = mt.argmax(result, axis=1)
+                return self._le.inverse_transform(class_index)
+
+        def predict_proba(
+            self,
+            X,
+            raw_score=False,
+            start_iteration=0,
+            num_iteration=None,
+            pred_leaf=False,
+            pred_contrib=False,
+            **kwargs
+        ):
+            prediction = super().predict(
+                X,
+                raw_score,
+                start_iteration,
+                num_iteration,
+                pred_leaf,
+                pred_contrib,
+                **kwargs
+            )
+            if len(prediction.shape) == 2 and prediction.shape[1] == self.n_classes_:
+                # multi-class
+                return prediction
+            if (
+                len(prediction.shape) == 2
+                and self.n_classes_ == 2
+                and prediction.shape[1] >= self.n_classes_
+            ):
+                # multi-label
+                return prediction
+            # binary logistic function
+            classone_probs = prediction
+            classzero_probs = 1.0 - classone_probs
+            return mt.transpose(_vstack((classzero_probs, classone_probs)))

maxframe/learn/contrib/lightgbm/core.py

@@ -0,0 +1,372 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import enum
+
+import numpy as np
+import pandas as pd
+
+from ....core import OutputType
+from ....dataframe import DataFrame as MFDataFrame
+from ....dataframe import Series as MFSeries
+from ....errors import TileableNotExecutedError
+from ....lib.version import parse as parse_version
+from ....tensor import tensor as mf_tensor
+from ..models import ModelApplyChunk, ModelWithEval, ModelWithEvalData, to_remote_model
+
+
+class LGBMModelType(enum.Enum):
+    CLASSIFIER = 0
+    REGRESSOR = 1
+    RANKER = 2
+
+
+_model_type_to_model = dict()
+
+
+def get_model_cls_from_type(model_type: LGBMModelType):
+    import lightgbm
+
+    if not _model_type_to_model:
+        _model_type_to_model.update(
+            {
+                LGBMModelType.CLASSIFIER: lightgbm.LGBMClassifier,
+                LGBMModelType.REGRESSOR: lightgbm.LGBMRegressor,
+                LGBMModelType.RANKER: lightgbm.LGBMRanker,
+            }
+        )
+    return _model_type_to_model[model_type]
+
+
+class BoosterData(ModelWithEvalData):
+    @staticmethod
+    def _calc_feature_importance(bst, importance_type="split", iteration=None):
+        return bst.feature_importance(
+            importance_type=importance_type, iteration=iteration
+        )
+
+    def feature_importance(self, importance_type="split", iteration=None):
+        op = ModelApplyChunk(
+            func=self._calc_feature_importance, output_types=[OutputType.tensor]
+        )
+        params = {
+            "shape": (np.nan,),
+            "dtype": np.dtype(np.float32 if importance_type == "gain" else np.int32),
+        }
+        return op(self, [params], importance_type=importance_type, iteration=iteration)[
+            0
+        ]
+
+    def predict(
+        self,
+        data,
+        start_iteration=0,
+        num_iteration=None,
+        raw_score=False,
+        pred_leaf=False,
+        pred_contrib=False,
+        data_has_header=False,
+        validate_features=False,
+        **kwargs,
+    ):
+        from ._predict import predict
+
+        return predict(
+            self,
+            data,
+            start_iteration=start_iteration,
+            num_iteration=num_iteration,
+            raw_score=raw_score,
+            pred_leaf=pred_leaf,
+            pred_contrib=pred_contrib,
+            data_has_header=data_has_header,
+            validate_features=validate_features,
+            **kwargs,
+        )
+
+
+class Booster(ModelWithEval):
+    pass
+
+
+class LGBMScikitLearnBase:
+    _default_objective = None
+
+    def __init__(self, *args, **kwargs):
+        import lightgbm
+
+        if args and isinstance(args[0], (lightgbm.LGBMModel, lightgbm.Booster)):
+            if isinstance(args[0], lightgbm.LGBMModel):
+                booster = args[0].booster_
+                self._objective = args[0].objective
+            else:
+                booster = args[0]
+                self._objective = (
+                    args[0].params.get("objective") or self._default_objective
+                )
+            self._Booster = to_remote_model(booster, model_cls=Booster)
+        else:
+            super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        try:
+            local_model = self.fetch()
+            return repr(local_model)
+        except TileableNotExecutedError:
+            return f"<{type(self).__name__} unexecuted>"
+
+    @classmethod
+    def _fix_verbose_args(cls, kwds, params):
+        if "verbose" not in kwds:
+            return
+
+        import lightgbm
+
+        if parse_version(lightgbm.__version__).major >= 4:
+            params["verbose"] = kwds.pop("verbose")
+
+    @classmethod
+    def _get_lgbm_class(cls):
+        try:
+            return getattr(cls, "_lgbm_class")
+        except AttributeError:
+            lgbm_class = next(
+                base for base in cls.__bases__ if base.__module__.startswith("lightgbm")
+            )
+            cls._lgbm_class = lgbm_class
+            return lgbm_class
+
+    @classmethod
+    def _get_param_names(cls):
+        return cls._get_lgbm_class()._get_param_names()
+
+    @staticmethod
+    def _copy_extra_params(source, dest):
+        params = source.get_params()
+        attributes = source.__dict__
+        extra_param_names = set(attributes.keys()).difference(params.keys())
+        for name in extra_param_names:
+            setattr(dest, name, attributes[name])
+
+    @staticmethod
+    def _convert_tileable(obj):
+        if isinstance(obj, np.ndarray):
+            return mf_tensor(obj)
+        elif isinstance(obj, pd.DataFrame):
+            return MFDataFrame(obj)
+        elif isinstance(obj, pd.Series):
+            return MFSeries(obj)
+        return obj
+
+    @classmethod
+    def _construct_dataset(
+        cls, X, y, sample_weight, init_score, group, params, categorical_feature="auto"
+    ):
+        from .dataset import Dataset
+
+        return Dataset(
+            cls._convert_tileable(X),
+            label=cls._convert_tileable(y),
+            weight=cls._convert_tileable(sample_weight),
+            group=group,
+            init_score=cls._convert_tileable(init_score),
+            params=params,
+            categorical_feature=categorical_feature,
+        )
+
+    def fit(
+        self,
+        X,
+        y,
+        *,
+        sample_weight=None,
+        init_score=None,
+        group=None,
+        eval_set=None,
+        eval_names=None,
+        eval_sample_weight=None,
+        eval_init_score=None,
+        eval_group=None,
+        eval_metric=None,
+        early_stopping_rounds=None,
+        verbose=True,
+        feature_name="auto",
+        categorical_feature="auto",
+        callbacks=None,
+        init_model=None,
+        num_class=None,
+        **kwargs,
+    ):
+        """
+        unsupported features:
+        1. class weights
+        2. validation of dataframe inputs
+        3. eval_metric
+        4. fobj
+        5. feval
+        """
+        from ._train import train
+
+        session = kwargs.pop("session", None)
+        run_kwargs = kwargs.pop("run_kwargs", dict())
+
+        self._n_features = X.shape[1]
+        if self._objective is None:
+            self._objective = self._default_objective
+
+        self._evals_result = {}
+        params = self.get_params()
+        self._fix_verbose_args(kwargs, params)
+
+        params.pop("silent", None)
+        params.pop("importance_type", None)
+        params.pop("n_estimators", None)
+        params.pop("class_weight", None)
+        params.pop("objective", None)
+
+        if isinstance(params["random_state"], np.random.RandomState):
+            params["random_state"] = params["random_state"].randint(
+                np.iinfo(np.int32).max
+            )
+        self._n_classes = num_class or 2
+        if self._n_classes is not None and self._n_classes > 2:
+            params.pop("num_class", None)
+            params["num_class"] = self._n_classes
+        params["objective"] = self._objective
+
+        train_set = self._construct_dataset(
+            X,
+            y,
+            sample_weight,
+            init_score,
+            group,
+            params,
+            categorical_feature=categorical_feature,
+        )
+
+        valid_sets = []
+        if eval_set is not None:
+
+            def _get_meta_data(collection, name, i):
+                if collection is None:
+                    return None
+                elif isinstance(collection, list):
+                    return collection[i] if len(collection) > i else None
+                elif isinstance(collection, dict):
+                    return collection.get(i, None)
+                else:
+                    raise TypeError("{} should be dict or list".format(name))
+
+            if isinstance(eval_set, tuple):
+                eval_set = [eval_set]
+            for i, valid_data in enumerate(eval_set):
+                # reduce cost for prediction training data
+                if valid_data[0] is X and valid_data[1] is y:
+                    valid_set = train_set
+                else:
+                    valid_weight = _get_meta_data(
+                        eval_sample_weight, "eval_sample_weight", i
+                    )
+                    valid_init_score = _get_meta_data(
+                        eval_init_score, "eval_init_score", i
+                    )
+                    valid_group = _get_meta_data(eval_group, "eval_group", i)
+                    valid_set = self._construct_dataset(
+                        valid_data[0],
+                        valid_data[1],
+                        valid_weight,
+                        valid_init_score,
+                        valid_group,
+                        params,
+                    )
+                valid_sets.append(valid_set)
+
+        self._Booster = train(
+            params,
+            train_set,
+            num_boost_round=self.n_estimators,
+            valid_sets=valid_sets,
+            valid_names=eval_names,
+            early_stopping_rounds=early_stopping_rounds,
+            evals_result=self._evals_result,
+            verbose_eval=verbose,
+            feature_name=feature_name,
+            categorical_feature=categorical_feature,
+            callbacks=callbacks,
+            init_model=init_model,
+            session=session,
+            run_kwargs=run_kwargs,
+            **kwargs,
+        )
+        self.fitted_ = True
+        return self
+
+    def predict(
+        self,
+        X,
+        raw_score=False,
+        start_iteration=0,
+        num_iteration=None,
+        pred_leaf=False,
+        pred_contrib=False,
+        **kwargs,
+    ):
+        return self._Booster.predict(
+            X,
+            raw_score=raw_score,
+            start_iteration=start_iteration,
+            num_iteration=num_iteration,
+            pred_leaf=pred_leaf,
+            pred_contrib=pred_contrib,
+            **kwargs,
+        )
+
+    @property
+    def feature_importances_(self):
+        importances = self._Booster.feature_importance(
+            importance_type=self.importance_type
+        )
+        importances.params = {"shape": (self._n_features,)}
+        return importances
+
+    def execute(self, session=None, run_kwargs=None):
+        self._Booster.execute(session=session, run_kwargs=run_kwargs)
+        return self
+
+    def fetch(self, session=None, run_kwargs=None):
+        import lightgbm
+
+        engine_kw = {"session": session, "run_kwargs": run_kwargs or dict()}
+        booster = self._Booster.fetch(**engine_kw)
+        if not hasattr(self, "_le"):
+            le = None
+        else:
+            try:
+                le = self._le.fetch(**engine_kw)
+            except TileableNotExecutedError:
+                le = self._le.execute(**engine_kw).fetch(**engine_kw)
+        remote_bst, self._Booster = self._Booster, booster
+        try:
+            local_cls = getattr(lightgbm, type(self).__name__)
+            local_model = local_cls(**self.get_params(deep=True))
+            local_model._Booster = booster
+            local_model._n_features = booster.num_feature()
+            if le is not None:
+                # need classes and label encoder for classifiers
+                local_model._n_classes = booster.params.get("num_class", 2)
+                local_model._le = le
+            local_model.fitted_ = True
+            return local_model
+        finally:
+            self._Booster = remote_bst