maxframe 0.1.0b4__cp310-cp310-win_amd64.whl → 1.0.0rc1__cp310-cp310-win_amd64.whl

maxframe/learn/contrib/xgboost/__init__.py

@@ -0,0 +1,26 @@
+# 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 config_mod_getattr as _config_mod_getattr
+from .dmatrix import DMatrix
+from .predict import predict
+from .train import train
+
+_config_mod_getattr(
+    {
+        "XGBClassifier": ".classifier.XGBClassifier",
+        "XGBRegressor": ".regressor.XGBRegressor",
+    },
+    globals(),
+)

maxframe/learn/contrib/xgboost/classifier.py

@@ -0,0 +1,86 @@
+# 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
+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,
+        ):
+            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,
+            )
+            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")
+            return predict(self.get_booster(), data, flag=flag, **kw)

maxframe/learn/contrib/xgboost/core.py

@@ -0,0 +1,156 @@
+# 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, List, Optional, Tuple
+
+try:
+    import xgboost
+except ImportError:
+    xgboost = None
+
+from .dmatrix import DMatrix
+
+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.
+            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 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,150 @@
+# 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 as OperandDef
+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_ = OperandDef.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]
+    y = astensor(y)
+    if y.ndim != 1:
+        raise ValueError(f"Expecting 1-d {name}, got: {y.ndim}-d")
+    return 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,138 @@
+# 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 pickle
+
+import numpy as np
+import pandas as pd
+
+from .... import opcodes as OperandDef
+from ....core.entity.output_types import OutputType
+from ....core.operator.base import Operator
+from ....core.operator.core import TileableOperatorMixin
+from ....dataframe.utils import parse_index
+from ....serialization.serializables import BoolField, BytesField, KeyField, TupleField
+from ....tensor.core import TENSOR_TYPE, TensorOrder
+from .dmatrix import check_data
+
+
+class XGBPredict(Operator, TileableOperatorMixin):
+    _op_type_ = OperandDef.XGBOOST_PREDICT
+    output_dtype = np.dtype(np.float32)
+
+    data = KeyField("data", default=None)
+    model = BytesField(
+        "model", on_serialize=pickle.dumps, on_deserialize=pickle.loads, 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]
+        if self.output_types[0] == OutputType.tensor:
+            # tensor
+            return self.new_tileable(
+                inputs,
+                shape=shape,
+                dtype=self.output_dtype,
+                order=TensorOrder.C_ORDER,
+            )
+        elif self.output_types[0] == OutputType.dataframe:
+            # dataframe
+            dtypes = pd.DataFrame(
+                np.random.rand(0, num_class), dtype=self.output_dtype
+            ).dtypes
+            return self.new_tileable(
+                inputs,
+                shape=shape,
+                dtypes=dtypes,
+                columns_value=parse_index(dtypes.index),
+                index_value=self.data.index_value,
+            )
+        else:
+            # series
+            return self.new_tileable(
+                inputs,
+                shape=shape,
+                index_value=self.data.index_value,
+                name="predictions",
+                dtype=self.output_dtype,
+            )
+
+
+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,
+):
+    data = check_data(data)
+    # TODO: check model datatype
+
+    num_class = getattr(model.op, "num_class", None)
+    if isinstance(data, TENSOR_TYPE):
+        output_types = [OutputType.tensor]
+    elif num_class is not None:
+        output_types = [OutputType.dataframe]
+    else:
+        output_types = [OutputType.series]
+
+    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,78 @@
+# 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())
+            if kw:
+                raise TypeError(
+                    f"fit got an unexpected keyword argument '{next(iter(kw))}'"
+                )
+
+            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.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):
+            session = kw.pop("session", None)
+            run_kwargs = kw.pop("run_kwargs", None)
+            return predict(
+                self.get_booster(), data, session=session, run_kwargs=run_kwargs, **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.

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

@@ -0,0 +1,43 @@
+# 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 pytest
+
+try:
+    import xgboost
+except ImportError:
+    xgboost = None
+
+
+from ..... import tensor as mt
+
+if xgboost:
+    from ..core import wrap_evaluation_matrices
+
+
+@pytest.mark.skipif(xgboost is None, reason="XGBoost not installed")
+def test_wrap_evaluation_matrices():
+    X = mt.random.rand(100, 3)
+    y = mt.random.randint(3, size=(100,))
+
+    eval_set = [(mt.random.rand(10, 3), mt.random.randint(3, size=10))]
+    with pytest.raises(ValueError):
+        # sample_weight_eval_set size wrong
+        wrap_evaluation_matrices(0.0, X, y, None, None, eval_set, [], None)
+
+    with pytest.raises(ValueError):
+        wrap_evaluation_matrices(0.0, X, y, None, None, None, eval_set, None)
+
+    evals = wrap_evaluation_matrices(0.0, X, y, None, None, eval_set, None, None)[1]
+    assert len(evals) > 0