maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/learn/contrib/xgboost/core.py

@@ -20,18 +20,34 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import numpy as np
 
 from ....errors import TileableNotExecutedError
+from ....udf import builtin_function
 
 try:
     import xgboost
-except ImportError:
+except ImportError:  # pragma: no cover
     xgboost = None
 
-from ....core import OutputType
+from ....core import OutputType, enter_mode, is_kernel_mode
+from ...utils.odpsio import ODPSModelMixin, ReadODPSModel
 from ..models import ModelApplyChunk, ModelWithEval, ModelWithEvalData, to_remote_model
 from .dmatrix import DMatrix
 
+_xgb_type_to_np_type = {
+    "float": "float32",
+    "int": "int32",
+    "i": "bool",
+}
+
 
 class BoosterData(ModelWithEvalData):
+    def save_config(self) -> str:
+        try:
+            return self.fetch().save_config()
+        except:
+            if is_kernel_mode():
+                return "{}"
+            raise
+
     @staticmethod
     def _get_booster_score(bst, fmap=None, importance_type="weight"):
         if not fmap:
@@ -88,6 +104,58 @@ class BoosterData(ModelWithEvalData):
             strict_shape=strict_shape,
         )
 
+    @staticmethod
+    @builtin_function
+    def _get_training_info(bst, evals_result, local_info):
+        model_infos = {
+            "iteration": bst.num_boosted_rounds(),
+        }
+        if evals_result:
+            model_infos.update(
+                dict(
+                    duration_ms=evals_result.get("duration_ms"),
+                )
+            )
+        if bst.feature_names:
+            model_infos["feature_names"] = bst.feature_names
+            model_infos["feature_types"] = [
+                _xgb_type_to_np_type[x] for x in bst.feature_types
+            ]
+        model_infos.update(local_info or {})
+
+        try:
+            config = json.loads(bst.save_config())
+            stack = [config]
+            internal = {}
+            while stack:
+                obj = stack.pop()
+                for k, v in obj.items():
+                    if k.endswith("_param"):
+                        for p_k, p_v in v.items():
+                            internal[p_k] = p_v
+                    elif isinstance(v, dict):
+                        stack.append(v)
+
+            for k, v in internal.items():
+                for t in (int, float, str):
+                    try:
+                        model_infos[k] = t(v)
+                        break
+                    except ValueError:
+                        continue
+        except ValueError:
+            pass
+
+        return model_infos
+
+    def get_training_info(self, evals_result: dict = None, local_info: dict = None):
+        evals_result = getattr(self, "_evals_result", None) or evals_result
+        args = (evals_result, local_info)
+        op = ModelApplyChunk(
+            func=self._get_training_info, output_types=[OutputType.object]
+        )
+        return op(self, [{}], args=args)[0]
+
 
 class Booster(ModelWithEval):
     pass
@@ -97,7 +165,7 @@ if not xgboost:
     XGBScikitLearnBase = None
 else:
 
-    class XGBScikitLearnBase(xgboost.XGBModel):
+    class XGBScikitLearnBase(xgboost.XGBModel, ODPSModelMixin):
         """
         Base class for implementing scikit-learn interface
         """
@@ -158,7 +226,8 @@ else:
                 sample_weight_eval_set,
                 base_margin_eval_set,
             )
-            params = self.get_xgb_params()
+            with enter_mode(kernel=True):
+                params = self.get_xgb_params()
             if not params.get("objective"):
                 params["objective"] = "reg:squarederror"
             self.evals_result_ = dict()
@@ -181,6 +250,7 @@ else:
                 **train_kw,
             )
             self._Booster = result
+            self.evals_result_t_ = result.op.outputs[-1]
             return self
 
         def predict(self, data, **kw):
@@ -276,6 +346,45 @@ else:
                 n_features=self._n_features_in,
             )[0]
 
+        @property
+        def training_info_(self):
+            local_info = {}
+            attrs = [
+                "n_classes_",
+                "learning_rate",
+            ]
+            for attr in attrs:
+                if getattr(self, attr, None):
+                    local_info[attr] = getattr(self, attr)
+            return self._Booster.get_training_info(
+                evals_result=self.evals_result_t_, local_info=local_info
+            )
+
+        def _get_odps_model_info(self) -> ODPSModelMixin.ODPSModelInfo:
+            model_format = (
+                "BOOSTED_TREE_CLASSIFIER"
+                if hasattr(self, "predict_proba")
+                else "BOOSTED_TREE_REGRESSOR"
+            )
+            return ODPSModelMixin.ODPSModelInfo(
+                model_format=model_format, model_params=self._Booster
+            )
+
+        @classmethod
+        def _build_odps_source_model(cls, op: ReadODPSModel) -> Any:
+            if not (
+                op.format == "BOOSTED_TREE_CLASSIFIER" and hasattr(cls, "predict_proba")
+            ) and not (
+                op.format == "BOOSTED_TREE_REGRESSOR"
+                and not hasattr(cls, "predict_proba")
+            ):
+                return None
+            op._output_types = [OutputType.object]
+            booster = op.new_tileable(None, object_class=Booster)
+            estimator = cls()
+            estimator._Booster = booster
+            return estimator
+
     def wrap_evaluation_matrices(
         missing: float,
         X: Any,

maxframe/learn/contrib/xgboost/predict.py

@@ -15,6 +15,7 @@
 from typing import List
 
 import numpy as np
+import pandas as pd
 
 from .... import opcodes
 from ....core import EntityData
@@ -62,9 +63,10 @@ class XGBPredict(Operator, TileableOperatorMixin):
 
     def __call__(self):
         num_class = getattr(self.model.op, "num_class", None)
-        if num_class is not None:
+        output_ndim = getattr(self.model.op, "output_ndim", None)
+        if num_class is not None and not pd.isna(num_class):
             num_class = int(num_class)
-        if num_class is not None and num_class > 2:
+        if num_class is not None and (num_class > 2 or output_ndim == 2):
             shape = (self.data.shape[0], num_class)
         else:
             shape = (self.data.shape[0],)

maxframe/learn/contrib/xgboost/regressor.py

@@ -14,6 +14,7 @@
 
 from typing import Union
 
+from ...utils.odpsio import register_odps_model
 from ..utils import make_import_error_func
 from .core import XGBScikitLearnBase, xgboost
 
@@ -24,6 +25,7 @@ else:
 
     from .predict import predict
 
+    @register_odps_model
     class XGBRegressor(XGBScikitLearnBase, XGBRegressorBase):
         """
         Implementation of the scikit-learn API for XGBoost regressor.
@@ -69,6 +71,9 @@ else:
                 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.
             """
+            if y.ndim == 2:
+                kw["num_class"] = y.shape[1]
+                kw["output_ndim"] = 2
             super().fit(
                 X,
                 y,

maxframe/learn/contrib/xgboost/train.py

@@ -25,6 +25,7 @@ from ....serialization.serializables import (
     DictField,
     FieldTypes,
     FunctionField,
+    Int16Field,
     Int64Field,
     KeyField,
     ListField,
@@ -50,7 +51,7 @@ class XGBTrain(ObjectOperator, ObjectOperatorMixin):
     dtrain = KeyField("dtrain", default=None)
     evals = ListField("evals", on_serialize=_on_serialize_evals, default=None)
     obj = FunctionField("obj", default=None)
-    feval = FunctionField("obj", default=None)
+    feval = FunctionField("feval", default=None)
     maximize = BoolField("maximize", default=None)
     early_stopping_rounds = Int64Field("early_stopping_rounds", default=None)
     verbose_eval = AnyField("verbose_eval", default=None)
@@ -64,8 +65,12 @@ class XGBTrain(ObjectOperator, ObjectOperatorMixin):
     custom_metric = FunctionField("custom_metric", default=None)
     num_boost_round = Int64Field("num_boost_round", default=10)
     num_class = Int64Field("num_class", default=None)
+    _has_evals_result = BoolField("has_evals_result", default=False)
+    output_ndim = Int16Field("output_ndim", default=None)
 
     def __init__(self, gpu=None, **kw):
+        if kw.get("evals_result") is not None:
+            kw["_has_evals_result"] = True
         super().__init__(gpu=gpu, **kw)
         if self.output_types is None:
             self.output_types = [OutputType.object]
@@ -110,7 +115,7 @@ class XGBTrain(ObjectOperator, ObjectOperatorMixin):
 
     @property
     def has_evals_result(self) -> bool:
-        return self.evals
+        return self._has_evals_result or self.evals
 
 
 def _get_xgb_booster(xgb_model):

maxframe/learn/core.py

@@ -222,6 +222,41 @@ class TransformerMixin:
             return self.fit(X, y, **fit_params).transform(X)
 
 
+class ClassifierMixin:
+    """Mixin class for all classifiers in scikit-learn."""
+
+    _estimator_type = "classifier"
+
+    def score(self, X, y, sample_weight=None):
+        """
+        Return the mean accuracy on the given test data and labels.
+
+        In multi-label classification, this is the subset accuracy
+        which is a harsh metric since you require for each sample that
+        each label set be correctly predicted.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Test samples.
+
+        y : array-like of shape (n_samples,) or (n_samples, n_outputs)
+            True labels for X.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights.
+
+        Returns
+        -------
+        score : Tensor
+            Mean accuracy of self.predict(X) wrt. y.
+        """
+        from .metrics import accuracy_score
+
+        result = accuracy_score(y, self.predict(X), sample_weight=sample_weight)
+        return result
+
+
 class RegressorMixin:
     """Mixin class for all regression estimators in scikit-learn."""
 
@@ -276,3 +311,34 @@ class RegressorMixin:
 
     def _more_tags(self):  # noqa: R0201  # pylint: disable=no-self-use
         return {"requires_y": True}
+
+
+class ClusterMixin:
+    """Mixin class for all cluster estimators in scikit-learn."""
+
+    _estimator_type = "clusterer"
+
+    def fit_predict(self, X, y=None):
+        """
+        Perform clustering on `X` and returns cluster labels.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Input data.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        labels : ndarray of shape (n_samples,), dtype=np.int64
+            Cluster labels.
+        """
+        # non-optimized default implementation; override when a better
+        # method is possible for a given clustering algorithm
+        self.fit(X)
+        return self.labels_
+
+    def _more_tags(self):
+        return {"preserves_dtype": []}

maxframe/learn/linear_model/_base.py

@@ -17,7 +17,7 @@ from abc import ABCMeta, abstractmethod
 
 from ... import tensor as mt
 from ...tensor.datasource import tensor as astensor
-from ..core import BaseEstimator
+from ..core import BaseEstimator, ClassifierMixin
 from ..preprocessing import normalize as f_normalize
 from ..utils.validation import FLOAT_DTYPES, check_array
 
@@ -161,3 +161,60 @@ class LinearModel(BaseEstimator, metaclass=ABCMeta):
 
     def _more_tags(self):  # noqa: R0201  # pylint: disable=no-self-use
         return {"requires_y": True}
+
+
+class LinearClassifierMixin(ClassifierMixin):
+    """Mixin for linear classifiers.
+
+    Handles prediction for sparse and dense X.
+    """
+
+    def decision_function(self, X):
+        """
+        Predict confidence scores for samples.
+
+        The confidence score for a sample is proportional to the signed
+        distance of that sample to the hyperplane.
+
+        Parameters
+        ----------
+        X : array-like or sparse matrix, shape (n_samples, n_features)
+            Samples.
+
+        Returns
+        -------
+        array, shape=(n_samples,) if n_classes == 2 else (n_samples, n_classes)
+            Confidence scores per (sample, class) combination. In the binary
+            case, confidence score for self.classes_[1] where >0 means this
+            class would be predicted.
+        """
+        check_is_fitted(self)
+
+        X = check_array(X, accept_sparse="csr")
+
+        n_features = self.coef_.shape[1]
+        if X.shape[1] != n_features:
+            raise ValueError(
+                "X has %d features per sample; expecting %d" % (X.shape[1], n_features)
+            )
+
+        scores = mt.dot(X, self.coef_.T) + self.intercept_
+        return scores
+
+    def predict(self, X):
+        """
+        Predict class labels for samples in X.
+
+        Parameters
+        ----------
+        X : array-like or sparse matrix, shape (n_samples, n_features)
+            Samples.
+
+        Returns
+        -------
+        C : array, shape [n_samples]
+            Predicted class label per sample.
+        """
+        scores = self.decision_function(X)
+        indices = scores.argmax(axis=1)
+        return self.classes_[indices].execute()

maxframe/learn/linear_model/_lin_reg.py

@@ -22,7 +22,7 @@ from ._base import LinearModel, _rescale_data
 try:
     from sklearn.base import MultiOutputMixin
 except ImportError:
-    MultiOutputMixin = object
+    MultiOutputMixin = type("MultiOutputMixin", (object,), {})
 
 
 class LinearRegression(MultiOutputMixin, RegressorMixin, LinearModel):

maxframe/learn/metrics/__init__.py

@@ -17,9 +17,15 @@ from ._classification import (
     accuracy_score,
     f1_score,
     fbeta_score,
+    log_loss,
     multilabel_confusion_matrix,
     precision_recall_fscore_support,
     precision_score,
     recall_score,
 )
+from ._ranking import auc, roc_auc_score, roc_curve
 from ._regression import r2_score
+from .pairwise import pairwise_distances
+
+# isort: off
+from ._scorer import get_scorer

maxframe/learn/metrics/_classification.py

@@ -33,6 +33,7 @@ from ...serialization.serializables import (
 from ...tensor.core import TensorOrder
 from ...typing_ import EntityType
 from ..core import LearnOperatorMixin
+from ..utils import check_array, check_consistent_length
 from ._check_targets import _check_targets
 
 
@@ -163,6 +164,150 @@ def accuracy_score(
     return score.execute(session=session, **(run_kwargs or dict()))
 
 
+class LogLoss(Operator, LearnOperatorMixin):
+    _op_type_ = opcodes.LOG_LOSS
+
+    y_true = AnyField("y_true")
+    y_pred = AnyField("y_pred")
+    eps = Float64Field("eps", default=1e-15)
+    normalize = BoolField("normalize", default=True)
+    sample_weight = AnyField("sample_weight", default=None)
+    labels = AnyField("labels", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "LogLoss", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op.inputs)
+        op.y_true = next(inputs_iter)
+        op.y_pred = next(inputs_iter)
+        if isinstance(op.sample_weight, ENTITY_TYPE):
+            op.sample_weight = next(inputs_iter)
+        if isinstance(op.labels, ENTITY_TYPE):
+            op.labels = next(inputs_iter)
+
+    def __call__(self, y_true, y_pred, sample_weight=None, labels=None):
+        self._output_types = [OutputType.tensor]
+        self.sample_weight = sample_weight
+        self.labels = labels
+        inputs = [y_true, y_pred]
+        if isinstance(self.sample_weight, ENTITY_TYPE):
+            inputs.append(self.sample_weight)
+        if isinstance(self.labels, ENTITY_TYPE):
+            inputs.append(self.labels)
+
+        dtype = (
+            np.dtype(float)
+            if self.normalize
+            else np.result_type(y_true.dtype, y_pred.dtype)
+        )
+        return self.new_tileable(
+            inputs, dtype=dtype, shape=(), order=TensorOrder.C_ORDER
+        )
+
+
+def log_loss(
+    y_true,
+    y_pred,
+    *,
+    eps=1e-15,
+    normalize=True,
+    sample_weight=None,
+    labels=None,
+    execute=False,
+    session=None,
+    run_kwargs=None,
+):
+    r"""Log loss, aka logistic loss or cross-entropy loss.
+
+    This is the loss function used in (multinomial) logistic regression
+    and extensions of it such as neural networks, defined as the negative
+    log-likelihood of a logistic model that returns ``y_pred`` probabilities
+    for its training data ``y_true``.
+    The log loss is only defined for two or more labels.
+    For a single sample with true label :math:`y \in \{0,1\}` and
+    and a probability estimate :math:`p = \operatorname{Pr}(y = 1)`, the log
+    loss is:
+
+    .. math::
+        L_{\log}(y, p) = -(y \log (p) + (1 - y) \log (1 - p))
+
+    Read more in the :ref:`User Guide <log_loss>`.
+
+    Parameters
+    ----------
+    y_true : array-like or label indicator matrix
+        Ground truth (correct) labels for n_samples samples.
+
+    y_pred : array-like of float, shape = (n_samples, n_classes) or (n_samples,)
+        Predicted probabilities, as returned by a classifier's
+        predict_proba method. If ``y_pred.shape = (n_samples,)``
+        the probabilities provided are assumed to be that of the
+        positive class. The labels in ``y_pred`` are assumed to be
+        ordered alphabetically, as done by
+        :class:`preprocessing.LabelBinarizer`.
+
+    eps : float, default=1e-15
+        Log loss is undefined for p=0 or p=1, so probabilities are
+        clipped to max(eps, min(1 - eps, p)).
+
+    normalize : bool, default=True
+        If true, return the mean loss per sample.
+        Otherwise, return the sum of the per-sample losses.
+
+    sample_weight : array-like of shape (n_samples,), default=None
+        Sample weights.
+
+    labels : array-like, default=None
+        If not provided, labels will be inferred from y_true. If ``labels``
+        is ``None`` and ``y_pred`` has shape (n_samples,) the labels are
+        assumed to be binary and are inferred from ``y_true``.
+
+    Returns
+    -------
+    loss : float
+
+    Notes
+    -----
+    The logarithm used is the natural logarithm (base-e).
+
+    Examples
+    --------
+    >>> from maxframe.learn.metrics import log_loss
+    >>> log_loss(["spam", "ham", "ham", "spam"],
+    ...          [[.1, .9], [.9, .1], [.8, .2], [.35, .65]])
+    0.21616...
+
+    References
+    ----------
+    C.M. Bishop (2006). Pattern Recognition and Machine Learning. Springer,
+    p. 209.
+    """
+    if not isinstance(y_true, (ENTITY_TYPE, np.ndarray)):
+        y_true = mt.array(y_true)
+    if not isinstance(y_pred, (ENTITY_TYPE, np.ndarray)):
+        y_pred = mt.array(y_pred)
+    if sample_weight is not None and not isinstance(y_pred, (ENTITY_TYPE, np.ndarray)):
+        sample_weight = mt.array(sample_weight)
+    if labels is not None and not isinstance(labels, (ENTITY_TYPE, np.ndarray)):
+        labels = mt.array(labels)
+
+    y_pred = check_array(y_pred, ensure_2d=False)
+    y_pred, y_true, sample_weight = check_consistent_length(
+        y_pred, y_true, sample_weight
+    )
+
+    op = LogLoss(eps=eps, normalize=normalize)
+    res = op(
+        y_true=y_true,
+        y_pred=y_pred,
+        sample_weight=sample_weight,
+        labels=labels,
+    )
+    if execute:
+        return res.execute(session=session, **(run_kwargs or {}))
+    return res
+
+
 class MultiLabelConfusionMatrix(Operator, LearnOperatorMixin):
     _op_type_ = opcodes.MULTILABEL_CONFUSION_MATRIX