maxframe 1.3.1__cp310-cp310-win32.whl → 2.0.0b2__cp310-cp310-win32.whl

maxframe/learn/contrib/lightgbm/_train.py

@@ -0,0 +1,163 @@
+# 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 itertools
+import logging
+from typing import List
+
+from .... import opcodes
+from ....core import OutputType
+from ....core.operator import ObjectOperator, ObjectOperatorMixin
+from ....serialization.serializables import (
+    AnyField,
+    BoolField,
+    DictField,
+    FieldTypes,
+    FunctionField,
+    Int32Field,
+    KeyField,
+    ListField,
+    StringField,
+)
+from ....typing_ import EntityType
+from ..models import to_remote_model
+from ..utils import TrainingCallback
+from .core import Booster, BoosterData, LGBMScikitLearnBase
+
+logger = logging.getLogger(__name__)
+
+
+class LGBMTrain(ObjectOperator, ObjectOperatorMixin):
+    _op_type_ = opcodes.LGBM_TRAIN
+    _op_module_ = "learn.contrib.lightgbm"
+
+    params = DictField("params", key_type=FieldTypes.string, default_factory=dict)
+    train_set = KeyField("train_set", default=None)
+    num_boost_round = Int32Field("num_boost_round", default=None)
+    valid_sets = ListField("valid_sets", FieldTypes.key, default_factory=list)
+    valid_names = ListField("valid_names", FieldTypes.string, default_factory=list)
+    feval = FunctionField("feval", default=None)
+    init_model = KeyField("init_model", default=None)
+    feature_name = AnyField("feature_name", default=None)
+    categorical_feature = AnyField("categorical_feature", default=None)
+    keep_training_booster = BoolField("keep_training_booster", default=False)
+    callbacks = ListField(
+        "callbacks",
+        field_type=FunctionField.field_type,
+        default=None,
+        on_serialize=TrainingCallback.from_local,
+    )
+    tree_learner = StringField("tree_learner", default=None)
+    timeout = Int32Field("timeout", default=None)
+    # indicating shape of the predicted data of the model
+    num_class = Int32Field("num_class", default=None)
+
+    def __init__(self, gpu=None, **kw):
+        super().__init__(gpu=gpu, **kw)
+        if self.output_types is None:
+            self.output_types = [OutputType.object]
+        if self.has_evals_result:
+            self.output_types.append(OutputType.object)
+
+    @classmethod
+    def _set_inputs(cls, op: "LGBMTrain", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        input_it = iter(op.inputs)
+        op.train_set = next(input_it)
+        op.valid_sets = list(itertools.islice(input_it, len(op.valid_sets or [])))
+        if op.init_model is not None:
+            op.init_model = next(input_it)
+
+    def __call__(self, evals_result):
+        inputs = [self.train_set]
+        if self.has_evals_result:
+            inputs.extend(self.valid_sets)
+        if self.init_model is not None:
+            inputs.append(self.init_model)
+        kws = [{"object_class": Booster}, {}]
+        return self.new_tileables(inputs, kws=kws, evals_result=evals_result)[0]
+
+    @property
+    def output_limit(self):
+        return 2 if self.has_evals_result else 1
+
+    def has_custom_code(self) -> bool:
+        if not self.callbacks:
+            return False
+        return any(
+            not isinstance(cb, TrainingCallback) or cb.has_custom_code()
+            for cb in self.callbacks
+        )
+
+    @property
+    def has_evals_result(self) -> bool:
+        return bool(self.valid_sets)
+
+
+def _get_lgbm_booster(init_model):
+    import lightgbm
+
+    if isinstance(init_model, (LGBMScikitLearnBase, lightgbm.LGBMModel)):
+        init_model = init_model.booster_
+
+    if isinstance(init_model, (Booster, BoosterData)):
+        return init_model
+    elif isinstance(init_model, lightgbm.Booster):
+        return to_remote_model(init_model, model_cls=Booster)
+    raise ValueError(f"Cannot use {type(init_model)} as init_model")
+
+
+def train(
+    params,
+    train_set,
+    num_boost_round=100,
+    valid_sets=None,
+    valid_names=None,
+    feval=None,
+    init_model=None,
+    keep_training_booster=False,
+    callbacks=None,
+    num_class=2,
+    evals_result=None,
+    **kwargs,
+):
+    evals_result = evals_result if evals_result is not None else dict()
+    timeout = kwargs.pop("timeout", 120)
+    session = kwargs.pop("session", None)
+    run_kwargs = kwargs.pop("run_kwargs", dict())
+    if valid_sets and valid_names:
+        if not isinstance(valid_names, list):
+            raise TypeError("valid_names must be a list of strings")
+        if len(valid_names) != len(valid_sets):
+            raise ValueError("size of valid_names must match size of valid_sets")
+    if init_model is not None:
+        init_model = _get_lgbm_booster(init_model)
+    data = LGBMTrain(
+        params=params,
+        train_set=train_set,
+        num_boost_round=num_boost_round,
+        valid_sets=valid_sets,
+        valid_names=valid_names,
+        feval=feval,
+        init_model=init_model,
+        keep_training_booster=keep_training_booster,
+        callbacks=callbacks,
+        num_class=num_class,
+        evals_result=evals_result,
+        timeout=timeout,
+        **kwargs,
+    )(evals_result)
+    if valid_sets:
+        data.execute(session=session, **run_kwargs)
+    return data

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)))