maxframe 0.1.0b4__cp39-cp39-win_amd64.whl → 1.0.0__cp39-cp39-win_amd64.whl

maxframe/learn/contrib/xgboost/classifier.py

@@ -0,0 +1,110 @@
+# Copyright 1999-2024 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 numpy as np
+
+from ....tensor import argmax, transpose
+from ....tensor.merge.vstack import _vstack
+from ..utils import make_import_error_func
+from .core import XGBScikitLearnBase, xgboost
+
+if not xgboost:
+    XGBClassifier = make_import_error_func("xgboost")
+else:
+    from xgboost.sklearn import XGBClassifierBase
+
+    from .core import wrap_evaluation_matrices
+    from .predict import predict
+    from .train import train
+
+    class XGBClassifier(XGBScikitLearnBase, XGBClassifierBase):
+        """
+        Implementation of the scikit-learn API for XGBoost classification.
+        """
+
+        def fit(
+            self,
+            X,
+            y,
+            sample_weight=None,
+            base_margin=None,
+            eval_set=None,
+            sample_weight_eval_set=None,
+            base_margin_eval_set=None,
+            num_class=None,
+            **kw,
+        ):
+            session = kw.pop("session", None)
+            run_kwargs = kw.pop("run_kwargs", dict())
+            dtrain, evals = wrap_evaluation_matrices(
+                None,
+                X,
+                y,
+                sample_weight,
+                base_margin,
+                eval_set,
+                sample_weight_eval_set,
+                base_margin_eval_set,
+            )
+            params = self.get_xgb_params()
+            self.n_classes_ = num_class or 1
+            if self.n_classes_ > 2:
+                params["objective"] = "multi:softprob"
+                params["num_class"] = self.n_classes_
+            else:
+                params["objective"] = "binary:logistic"
+            self.evals_result_ = dict()
+            result = train(
+                params,
+                dtrain,
+                num_boost_round=self.get_num_boosting_rounds(),
+                evals=evals,
+                evals_result=self.evals_result_,
+                num_class=num_class,
+                session=session,
+                run_kwargs=run_kwargs,
+            )
+            self._Booster = result
+            return self
+
+        def predict(self, data, **kw):
+            prob = self.predict_proba(data, flag=True, **kw)
+            if prob.ndim > 1:
+                prediction = argmax(prob, axis=1)
+            else:
+                prediction = (prob > 0.5).astype(np.int64)
+            return prediction
+
+        def predict_proba(self, data, ntree_limit=None, flag=False, **kw):
+            if ntree_limit is not None:
+                raise NotImplementedError("ntree_limit is not currently supported")
+            prediction = predict(self.get_booster(), data, flag=flag, **kw)
+            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 transpose(_vstack((classzero_probs, classone_probs)))
+
+        @property
+        def classes_(self) -> np.ndarray:
+            return np.arange(self.n_classes_)

maxframe/learn/contrib/xgboost/core.py

@@ -0,0 +1,241 @@
+# Copyright 1999-2024 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 typing import Any, Callable, Dict, List, Optional, Tuple
+
+try:
+    import xgboost
+except ImportError:
+    xgboost = None
+
+from ...core import Model, ModelData
+from .dmatrix import DMatrix
+
+
+class BoosterData(ModelData):
+    __slots__ = ("_evals_result",)
+
+    _evals_result: Dict
+
+    def __init__(self, *args, evals_result=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._evals_result = evals_result if evals_result is not None else dict()
+
+    def execute(self, session=None, **kw):
+        # The evals_result should be fetched when BoosterData.execute() is called.
+        result = super().execute(session=session, **kw)
+        if self.op.has_evals_result and self.key == self.op.outputs[0].key:
+            self._evals_result.update(self.op.outputs[1].fetch(session=session))
+        return result
+
+    def predict(
+        self,
+        data,
+        output_margin=False,
+        pred_leaf=False,
+        pred_contribs=False,
+        approx_contribs=False,
+        pred_interactions=False,
+        validate_features=True,
+        training=False,
+        iteration_range=None,
+        strict_shape=False,
+    ):
+        from .predict import predict
+
+        return predict(
+            self,
+            data,
+            output_margin=output_margin,
+            pred_leaf=pred_leaf,
+            pred_contribs=pred_contribs,
+            approx_contribs=approx_contribs,
+            pred_interactions=pred_interactions,
+            validate_features=validate_features,
+            training=training,
+            iteration_range=iteration_range,
+            strict_shape=strict_shape,
+        )
+
+
+class Booster(Model):
+    pass
+
+
+if not xgboost:
+    XGBScikitLearnBase = None
+else:
+
+    class XGBScikitLearnBase(xgboost.XGBModel):
+        """
+        Base class for implementing scikit-learn interface
+        """
+
+        def fit(
+            self,
+            X,
+            y,
+            sample_weights=None,
+            eval_set=None,
+            sample_weight_eval_set=None,
+            **kw,
+        ):
+            """
+            Fit the regressor. Note that fit() is an eager-execution
+            API. The call will be blocked until training finished.
+
+            Parameters
+            ----------
+            X : array_like
+                Feature matrix
+            y : array_like
+                Labels
+            sample_weight : array_like
+                instance weights
+            eval_set : list, optional
+                A list of (X, y) tuple pairs to use as validation sets, for which
+                metrics will be computed.
+                Validation metrics will help us track the performance of the model.
+            sample_weight_eval_set : list, optional
+                A list of the form [L_1, L_2, ..., L_n], where each L_i is a list
+                of group weights on the i-th validation set.
+            """
+            raise NotImplementedError
+
+        def predict(self, data, **kw):
+            """
+            Predict with `data`.
+
+            Parameters
+            ----------
+              data: data that can be used to perform prediction
+            Returns
+            -------
+            prediction : maxframe.tensor.Tensor
+            """
+            raise NotImplementedError
+
+        def evals_result(self, **kw) -> Dict:
+            """Return the evaluation results.
+
+            If **eval_set** is passed to the :py:meth:`fit` function, you can call
+            ``evals_result()`` to get evaluation results for all passed **eval_sets**.  When
+            **eval_metric** is also passed to the :py:meth:`fit` function, the
+            **evals_result** will contain the **eval_metrics** passed to the :py:meth:`fit`
+            function.
+
+            The returned evaluation result is a dictionary:
+
+            .. code-block:: python
+
+                {'validation_0': {'logloss': ['0.604835', '0.531479']},
+                 'validation_1': {'logloss': ['0.41965', '0.17686']}}
+
+            Note that evals_result() will be blocked until the train is finished.
+
+            Returns
+            -------
+            evals_result
+
+            """
+            result = super().evals_result()
+            if not self._Booster.op.has_evals_result or len(result) != 0:
+                return result
+            session = kw.pop("session", None)
+            run_kwargs = kw.pop("run_kwargs", dict())
+            self._Booster.execute(session=session, **run_kwargs)
+            return super().evals_result()
+
+    def wrap_evaluation_matrices(
+        missing: float,
+        X: Any,
+        y: Any,
+        sample_weight: Optional[Any],
+        base_margin: Optional[Any],
+        eval_set: Optional[List[Tuple[Any, Any]]],
+        sample_weight_eval_set: Optional[List[Any]],
+        base_margin_eval_set: Optional[List[Any]],
+        label_transform: Callable = lambda x: x,
+    ) -> Tuple[Any, Optional[List[Tuple[Any, str]]]]:
+        """
+        Convert array_like evaluation matrices into DMatrix.
+        Perform validation on the way.
+        """
+        train_dmatrix = DMatrix(
+            data=X,
+            label=label_transform(y),
+            weight=sample_weight,
+            base_margin=base_margin,
+            missing=missing,
+        )
+
+        n_validation = 0 if eval_set is None else len(eval_set)
+
+        def validate_or_none(meta: Optional[List], name: str) -> List:
+            if meta is None:
+                return [None] * n_validation
+            if len(meta) != n_validation:
+                raise ValueError(
+                    f"{name}'s length does not equal `eval_set`'s length, "
+                    + f"expecting {n_validation}, got {len(meta)}"
+                )
+            return meta
+
+        if eval_set is not None:
+            sample_weight_eval_set = validate_or_none(
+                sample_weight_eval_set, "sample_weight_eval_set"
+            )
+            base_margin_eval_set = validate_or_none(
+                base_margin_eval_set, "base_margin_eval_set"
+            )
+
+            evals = []
+            for i, (valid_X, valid_y) in enumerate(eval_set):
+                # Skip the duplicated entry.
+                if all(
+                    (
+                        valid_X is X,
+                        valid_y is y,
+                        sample_weight_eval_set[i] is sample_weight,
+                        base_margin_eval_set[i] is base_margin,
+                    )
+                ):
+                    evals.append(train_dmatrix)
+                else:
+                    m = DMatrix(
+                        data=valid_X,
+                        label=label_transform(valid_y),
+                        weight=sample_weight_eval_set[i],
+                        base_margin=base_margin_eval_set[i],
+                        missing=missing,
+                    )
+                    evals.append(m)
+            nevals = len(evals)
+            eval_names = [f"validation_{i}" for i in range(nevals)]
+            evals = list(zip(evals, eval_names))
+        else:
+            if any(
+                meta is not None
+                for meta in [
+                    sample_weight_eval_set,
+                    base_margin_eval_set,
+                ]
+            ):
+                raise ValueError(
+                    "`eval_set` is not set but one of the other evaluation meta info is "
+                    "not None."
+                )
+            evals = []
+
+        return train_dmatrix, evals

maxframe/learn/contrib/xgboost/dmatrix.py

@@ -0,0 +1,147 @@
+# Copyright 1999-2024 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 opcodes
+from ....core.entity.output_types import get_output_types
+from ....core.operator.base import Operator
+from ....core.operator.core import TileableOperatorMixin
+from ....dataframe.core import DATAFRAME_TYPE
+from ....serialization.serializables import Float64Field, KeyField, ListField
+from ....serialization.serializables.field import AnyField, Int64Field
+from ....tensor import tensor as astensor
+from ....tensor.core import TENSOR_TYPE
+from ....typing_ import TileableType
+from ...utils import convert_to_tensor_or_dataframe
+
+
+class ToDMatrix(Operator, TileableOperatorMixin):
+    _op_type_ = opcodes.TO_DMATRIX
+
+    data = KeyField("data", default=None)
+    label = KeyField("label", default=None)
+    missing = Float64Field("missing", default=None)
+    weight = KeyField("weight", default=None)
+    base_margin = KeyField("base_margin", default=None)
+    feature_names = ListField("feature_names", default=None)
+    feature_types = ListField("feature_types", default=None)
+    feature_weights = AnyField("feature_weights", default=None)
+    nthread = Int64Field("nthread", default=None)
+    group = AnyField("group", default=None)
+    qid = AnyField("qid", default=None)
+    label_lower_bound = AnyField("label_lower_bound", default=None)
+    label_upper_bound = AnyField("label_upper_bound", default=None)
+
+    @property
+    def output_limit(self):
+        return 1
+
+    def _set_inputs(self, inputs):
+        super()._set_inputs(inputs)
+        if self.data is not None:
+            self.data = self._inputs[0]
+        has_label = self.label is not None
+        if has_label:
+            self.label = self._inputs[1]
+        if self.weight is not None:
+            i = 1 if not has_label else 2
+            self.weight = self._inputs[i]
+        if self.base_margin is not None:
+            self.base_margin = self._inputs[-1]
+
+    @staticmethod
+    def _get_kw(obj):
+        if isinstance(obj, TENSOR_TYPE):
+            return {"shape": obj.shape, "dtype": obj.dtype, "order": obj.order}
+        else:
+            return {
+                "shape": obj.shape,
+                "dtypes": obj.dtypes,
+                "index_value": obj.index_value,
+                "columns_value": obj.columns_value,
+            }
+
+    def __call__(self):
+        inputs = [self.data]
+        kw = self._get_kw(self.data)
+        if self.label is not None:
+            inputs.append(self.label)
+        if self.weight is not None:
+            inputs.append(self.weight)
+        if self.base_margin is not None:
+            inputs.append(self.base_margin)
+
+        return self.new_tileable(inputs, **kw)
+
+
+def check_data(data):
+    data = convert_to_tensor_or_dataframe(data)
+    if data.ndim != 2:
+        raise ValueError(f"Expecting 2-d data, got: {data.ndim}-d")
+
+    return data
+
+
+def check_array_like(y: TileableType, name: str) -> TileableType:
+    if y is None:
+        return
+    y = convert_to_tensor_or_dataframe(y)
+    if isinstance(y, DATAFRAME_TYPE):
+        y = y.iloc[:, 0]
+    return astensor(y)
+
+
+def to_dmatrix(
+    data,
+    label=None,
+    missing=None,
+    weight=None,
+    base_margin=None,
+    feature_names=None,
+    feature_types=None,
+    feature_weights=None,
+    nthread=None,
+    group=None,
+    qid=None,
+    label_lower_bound=None,
+    label_upper_bound=None,
+):
+    data = check_data(data)
+    label = check_array_like(label, "label")
+    weight = check_array_like(weight, "weight")
+    base_margin = check_array_like(base_margin, "base_margin")
+
+    # If not multiple outputs, try to collect the chunks on same worker into one
+    # to feed the data into XGBoost for training.
+    op = ToDMatrix(
+        data=data,
+        label=label,
+        missing=missing,
+        weight=weight,
+        base_margin=base_margin,
+        feature_names=feature_names,
+        feature_types=feature_types,
+        feature_weights=feature_weights,
+        nthread=nthread,
+        group=group,
+        qid=qid,
+        label_lower_bound=label_lower_bound,
+        label_upper_bound=label_upper_bound,
+        gpu=data.op.gpu,
+        _output_types=get_output_types(data),
+    )
+    return op()
+
+
+DMatrix = to_dmatrix

maxframe/learn/contrib/xgboost/predict.py

@@ -0,0 +1,121 @@
+# Copyright 1999-2024 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 numpy as np
+
+from .... import opcodes
+from ....core.entity.output_types import OutputType
+from ....core.operator.base import Operator
+from ....core.operator.core import TileableOperatorMixin
+from ....serialization.serializables import (
+    BoolField,
+    KeyField,
+    ReferenceField,
+    TupleField,
+)
+from ....tensor.core import TensorOrder
+from .core import BoosterData
+from .dmatrix import check_data
+
+
+class XGBPredict(Operator, TileableOperatorMixin):
+    _op_type_ = opcodes.XGBOOST_PREDICT
+    output_dtype = np.dtype(np.float32)
+
+    data = KeyField("data", default=None)
+    model = ReferenceField("model", reference_type=BoosterData, default=None)
+    pred_leaf = BoolField("pred_leaf", default=False)
+    pred_contribs = BoolField("pred_contribs", default=False)
+    approx_contribs = BoolField("approx_contribs", default=False)
+    pred_interactions = BoolField("pred_interactions", default=False)
+    validate_features = BoolField("validate_features", default=True)
+    training = BoolField("training", default=False)
+    iteration_range = TupleField("iteration_range", default_factory=lambda x: (0, 0))
+    strict_shape = BoolField("strict_shape", default=False)
+    flag = BoolField("flag", default=False)
+
+    def __init__(self, output_types=None, gpu=None, **kw):
+        super().__init__(_output_types=output_types, gpu=gpu, **kw)
+
+    def _set_inputs(self, inputs):
+        super()._set_inputs(inputs)
+        self.data = self._inputs[0]
+        self.model = self._inputs[1]
+
+    def __call__(self):
+        num_class = getattr(self.model.op, "num_class", None)
+        if num_class is not None:
+            num_class = int(num_class)
+        if num_class is not None:
+            shape = (self.data.shape[0], num_class)
+        else:
+            shape = (self.data.shape[0],)
+        inputs = [self.data, self.model]
+        return self.new_tileable(
+            inputs,
+            shape=shape,
+            dtype=self.output_dtype,
+            order=TensorOrder.C_ORDER,
+        )
+
+
+def predict(
+    model,
+    data,
+    output_margin=False,
+    pred_leaf=False,
+    pred_contribs=False,
+    approx_contribs=False,
+    pred_interactions=False,
+    validate_features=True,
+    training=False,
+    iteration_range=None,
+    strict_shape=False,
+    flag=False,
+):
+    """
+    Using MaxFrame XGBoost model to predict data.
+
+    Parameters
+    ----------
+    Parameters are the same as `xgboost.train`. The predict() is lazy-execution mode.
+
+    Returns
+    -------
+    results: Booster
+    """
+    data = check_data(data)
+    # TODO: check model datatype
+
+    output_types = [OutputType.tensor]
+
+    iteration_range = iteration_range or (0, 0)
+
+    return XGBPredict(
+        data=data,
+        model=model,
+        output_margin=output_margin,
+        pred_leaf=pred_leaf,
+        pred_contribs=pred_contribs,
+        approx_contribs=approx_contribs,
+        pred_interactions=pred_interactions,
+        validate_features=validate_features,
+        training=training,
+        iteration_range=iteration_range,
+        strict_shape=strict_shape,
+        gpu=data.op.gpu,
+        output_types=output_types,
+        flag=flag,
+    )()

maxframe/learn/contrib/xgboost/regressor.py

@@ -0,0 +1,71 @@
+# Copyright 1999-2024 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 ..utils import make_import_error_func
+from .core import XGBScikitLearnBase, xgboost
+
+if not xgboost:
+    XGBRegressor = make_import_error_func("xgboost")
+else:
+    from .core import wrap_evaluation_matrices
+    from .predict import predict
+    from .train import train
+
+    class XGBRegressor(XGBScikitLearnBase):
+        """
+        Implementation of the scikit-learn API for XGBoost regressor.
+        """
+
+        def fit(
+            self,
+            X,
+            y,
+            sample_weight=None,
+            base_margin=None,
+            eval_set=None,
+            sample_weight_eval_set=None,
+            base_margin_eval_set=None,
+            **kw,
+        ):
+            session = kw.pop("session", None)
+            run_kwargs = kw.pop("run_kwargs", dict())
+            dtrain, evals = wrap_evaluation_matrices(
+                None,
+                X,
+                y,
+                sample_weight,
+                base_margin,
+                eval_set,
+                sample_weight_eval_set,
+                base_margin_eval_set,
+            )
+            params = self.get_xgb_params()
+            if not params.get("objective"):
+                params["objective"] = "reg:squarederror"
+            self.evals_result_ = dict()
+            result = train(
+                params,
+                dtrain,
+                num_boost_round=self.get_num_boosting_rounds(),
+                evals=evals,
+                evals_result=self.evals_result_,
+                session=session,
+                run_kwargs=run_kwargs,
+            )
+            self._Booster = result
+            return self
+
+        def predict(self, data, **kw):
+            return predict(self.get_booster(), data, **kw)

maxframe/learn/contrib/xgboost/tests/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 1999-2024 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.