maxframe 2.2.0__cp312-cp312-macosx_10_9_universal2.whl

maxframe/learn/linear_model/_base.py

@@ -0,0 +1,220 @@
+# 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 numbers
+from abc import ABCMeta, abstractmethod
+
+from ... import tensor as mt
+from ...tensor.datasource import tensor as astensor
+from ..core import BaseEstimator, ClassifierMixin
+from ..preprocessing import normalize as f_normalize
+from ..utils.validation import FLOAT_DTYPES, check_array
+
+try:
+    from sklearn.utils.validation import check_is_fitted
+except ImportError:
+    check_is_fitted = lambda *_: True
+
+
+def _preprocess_data(
+    X,
+    y,
+    fit_intercept,
+    normalize=False,
+    copy=True,
+    sample_weight=None,
+    return_mean=False,
+    check_input=True,
+):
+    """Center and scale data.
+
+    Centers data to have mean zero along axis 0. If fit_intercept=False or if
+    the X is a sparse matrix, no centering is done, but normalization can still
+    be applied. The function returns the statistics necessary to reconstruct
+    the input data, which are X_offset, y_offset, X_scale, such that the output
+
+        X = (X - X_offset) / X_scale
+
+    X_scale is the L2 norm of X - X_offset. If sample_weight is not None,
+    then the weighted mean of X and y is zero, and not the mean itself. If
+    return_mean=True, the mean, eventually weighted, is returned, independently
+    of whether X was centered (option used for optimization with sparse data in
+    coordinate_descend).
+
+    This is here because nearly all linear models will want their data to be
+    centered. This function also systematically makes y consistent with X.dtype
+    """
+    if isinstance(sample_weight, numbers.Number):
+        sample_weight = None
+    if sample_weight is not None:
+        sample_weight = astensor(sample_weight)
+
+    X = astensor(X)
+    y = astensor(y, dtype=X.dtype)
+
+    if check_input:
+        X = check_array(X, copy=copy, accept_sparse=["csr", "csc"], dtype=FLOAT_DTYPES)
+    elif copy:
+        if X.issparse():
+            X = X.copy()
+        else:
+            X = X.copy(order="K")
+
+    if fit_intercept:
+        if X.issparse():
+            raise NotImplementedError("Does not support sparse input!")
+        else:
+            X_offset = mt.average(X, axis=0, weights=sample_weight)
+            X = X - X_offset
+            if normalize:
+                X, X_scale = f_normalize(X, axis=0, copy=False, return_norm=True)
+            else:
+                X_scale = mt.ones(X.shape[1], dtype=X.dtype)
+        y_offset = mt.average(y, axis=0, weights=sample_weight)
+        y = y - y_offset
+    else:
+        if X.issparse():
+            raise NotImplementedError("Does not support sparse input!")
+        X_offset = mt.zeros(X.shape[1], dtype=X.dtype)
+        X_scale = mt.ones(X.shape[1], dtype=X.dtype)
+        if y.ndim == 1:
+            y_offset = X.dtype.type(0)
+        else:
+            y_offset = mt.zeros(y.shape[1], dtype=X.dtype)
+
+    return X, y, X_offset, y_offset, X_scale
+
+
+def _rescale_data(X, y, sample_weight):
+    """Rescale data sample-wise by square root of sample_weight.
+
+    For many linear models, this enables easy support for sample_weight.
+
+    Returns
+    -------
+    X_rescaled : {array-like, sparse matrix}
+
+    y_rescaled : {array-like, sparse matrix}
+    """
+    n_samples = X.shape[0]
+    sample_weight = mt.asarray(sample_weight)
+    if sample_weight.ndim == 0:
+        sample_weight = mt.full(n_samples, sample_weight, dtype=sample_weight.dtype)
+    sample_weight = mt.sqrt(sample_weight)
+    sw_matrix = mt.diag(sample_weight, sparse=True)
+    X = mt.dot(sw_matrix, X)
+    y = mt.dot(sw_matrix, y)
+    return X, y
+
+
+class LinearModel(BaseEstimator, metaclass=ABCMeta):
+    """Base class for Linear Models"""
+
+    @abstractmethod
+    def fit(self, X, y, sample_weight=None):
+        """Fit model."""
+
+    def _decision_function(self, X):
+        check_is_fitted(self)
+
+        X = self._validate_data(
+            X, y="no_validation", accept_sparse=["csr", "csc", "coo"], reset=False
+        )
+        return mt.dot(X, self.coef_.T) + self.intercept_
+
+    def predict(self, X):
+        """
+        Predict using the linear model.
+
+        Parameters
+        ----------
+        X : array-like or sparse matrix, shape (n_samples, n_features)
+            Samples.
+
+        Returns
+        -------
+        C : array, shape (n_samples,)
+            Returns predicted values.
+        """
+        return self._decision_function(X)
+
+    _preprocess_data = staticmethod(_preprocess_data)
+
+    def _set_intercept(self, X_offset, y_offset, X_scale):
+        """Set the intercept_"""
+        if self.fit_intercept:
+            self.coef_ = self.coef_ / X_scale
+            self.intercept_ = y_offset - mt.dot(X_offset, self.coef_.T)
+        else:
+            self.intercept_ = mt.tensor(0.0)
+
+    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

@@ -0,0 +1,175 @@
+# 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 numpy.linalg import LinAlgError
+
+from ... import tensor as mt
+from ..core import RegressorMixin
+from ..utils.validation import _check_sample_weight
+from ._base import LinearModel, _rescale_data
+
+try:
+    from sklearn.base import MultiOutputMixin
+except ImportError:
+    MultiOutputMixin = type("MultiOutputMixin", (object,), {})
+
+
+class LinearRegression(MultiOutputMixin, RegressorMixin, LinearModel):
+    """
+    Ordinary least squares Linear Regression.
+
+    LinearRegression fits a linear model with coefficients w = (w1, ..., wp)
+    to minimize the residual sum of squares between the observed targets in
+    the dataset, and the targets predicted by the linear approximation.
+
+    Parameters
+    ----------
+    fit_intercept : bool, default=True
+        Whether to calculate the intercept for this model. If set
+        to False, no intercept will be used in calculations
+        (i.e. data is expected to be centered).
+
+    normalize : bool, default=False
+        This parameter is ignored when ``fit_intercept`` is set to False.
+        If True, the regressors X will be normalized before regression by
+        subtracting the mean and dividing by the l2-norm.
+        If you wish to standardize, please use
+        :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``
+        on an estimator with ``normalize=False``.
+
+    copy_X : bool, default=True
+        If True, X will be copied; else, it may be overwritten.
+
+    positive : bool, default=False
+        When set to ``True``, forces the coefficients to be positive. This
+        option is only supported for dense arrays.
+
+    Attributes
+    ----------
+    coef_ : array of shape (n_features, ) or (n_targets, n_features)
+        Estimated coefficients for the linear regression problem.
+        If multiple targets are passed during the fit (y 2D), this
+        is a 2D array of shape (n_targets, n_features), while if only
+        one target is passed, this is a 1D array of length n_features.
+
+    rank_ : int
+        Rank of matrix `X`. Only available when `X` is dense.
+
+    singular_ : array of shape (min(X, y),)
+        Singular values of `X`. Only available when `X` is dense.
+
+    intercept_ : float or array of shape (n_targets,)
+        Independent term in the linear model. Set to 0.0 if
+        `fit_intercept = False`.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+    See Also
+    --------
+    Ridge : Ridge regression addresses some of the
+        problems of Ordinary Least Squares by imposing a penalty on the
+        size of the coefficients with l2 regularization.
+    Lasso : The Lasso is a linear model that estimates
+        sparse coefficients with l1 regularization.
+    ElasticNet : Elastic-Net is a linear regression
+        model trained with both l1 and l2 -norm regularization of the
+        coefficients.
+    """
+
+    _data_attributes = ["coef_", "intercept_"]
+
+    def __init__(
+        self,
+        *,
+        fit_intercept=True,
+        normalize=False,
+        copy_X=True,
+        positive=False,
+    ):
+        self.fit_intercept = fit_intercept
+        self.normalize = normalize
+        self.copy_X = copy_X
+        self.positive = positive
+
+    def fit(
+        self, X, y, sample_weight=None, session=None, run_kwargs=None, execute=False
+    ):
+        """
+        Fit linear model.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training data.
+
+        y : array-like of shape (n_samples,) or (n_samples, n_targets)
+            Target values. Will be cast to X's dtype if necessary.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Individual weights for each sample.
+
+        Returns
+        -------
+        self : object
+            Fitted Estimator.
+        """
+        accept_sparse = False if self.positive else ["csr", "csc", "coo"]
+
+        X, y = self._validate_data(
+            X, y, accept_sparse=accept_sparse, y_numeric=True, multi_output=True
+        )
+
+        if sample_weight is not None:
+            sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype)
+
+        X, y, X_offset, y_offset, X_scale = self._preprocess_data(
+            X,
+            y,
+            fit_intercept=self.fit_intercept,
+            normalize=self.normalize,
+            copy=self.copy_X,
+            sample_weight=sample_weight,
+            return_mean=True,
+        )
+
+        if sample_weight is not None:
+            # Sample weight can be implemented via a simple rescaling.
+            X, y = _rescale_data(X, y, sample_weight)
+
+        if self.positive:
+            # TODO: implement optimize.nnls first
+            raise NotImplementedError("Does not support positive coefficients!")
+        elif X.issparse():
+            # TODO: implement sparse.linalg.lsqr first
+            raise NotImplementedError("Does not support sparse input!")
+        else:
+            # TODO: implement linalg.lstsq first
+            # In numpy:
+            #   Mat mul does NOT always satisfy associative law
+            # Tyipical mistake:
+            #   (mt.linalg.inv(X.T @ X) @ (X.T @ y)).T
+            self.coef_ = (mt.linalg.inv(X.T @ X) @ X.T @ y).T
+
+        if y.ndim == 1:
+            self.coef_ = mt.ravel(self.coef_)
+        self._set_intercept(X_offset, y_offset, X_scale)
+        if execute:
+            run_kwargs = run_kwargs or {}
+            try:
+                self.execute(session=session, **run_kwargs)
+            except LinAlgError:
+                # TODO: implement linalg.lstsq first
+                raise NotImplementedError("Does not support singular matrix!")
+        return self

maxframe/learn/metrics/__init__.py

@@ -0,0 +1,31 @@
+# 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 _check_targets
+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/_check_targets.py

@@ -0,0 +1,95 @@
+# 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 typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ... import tensor as mt
+from ...core import ENTITY_TYPE, ExecutableTuple, OutputType
+from ...core.operator import Operator
+from ...serialization.serializables import AnyField
+from ...tensor.core import TensorOrder
+from ...typing_ import EntityType
+from ..core import LearnOperatorMixin
+
+
+class CheckTargets(Operator, LearnOperatorMixin):
+    _op_type_ = opcodes.CHECK_TARGETS
+
+    y_true = AnyField("y_true")
+    y_pred = AnyField("y_pred")
+
+    @property
+    def output_limit(self):
+        return 3
+
+    @classmethod
+    def _set_inputs(cls, op: "CheckTargets", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op.inputs)
+        if isinstance(op.y_true, ENTITY_TYPE):
+            op.y_true = next(inputs_iter)
+        if isinstance(op.y_pred, ENTITY_TYPE):
+            op.y_pred = next(inputs_iter)
+
+    def __call__(self, y_true, y_pred):
+        # scalar(y_type), y_true, y_pred
+        self.output_types = [OutputType.tensor] * 3
+
+        inputs = []
+        if isinstance(y_true, ENTITY_TYPE):
+            inputs.append(y_true)
+        if isinstance(y_pred, ENTITY_TYPE):
+            inputs.append(y_pred)
+
+        kws = list()
+        kws.append(
+            {"shape": (), "dtype": np.dtype(object), "order": TensorOrder.C_ORDER}
+        )
+        kws.extend([y.params for y in (mt.tensor(y_true), mt.tensor(y_pred))])
+        kws[1]["shape"] = kws[2]["shape"] = (np.nan,)
+        return ExecutableTuple(self.new_tileables(inputs, kws=kws))
+
+
+def _check_targets(y_true, y_pred):
+    """Check that y_true and y_pred belong to the same classification task
+
+    This converts multiclass or binary types to a common shape, and raises a
+    ValueError for a mix of multilabel and multiclass targets, a mix of
+    multilabel formats, for the presence of continuous-valued or multioutput
+    targets, or for targets of different lengths.
+
+    Column vectors are squeezed to 1d, while multilabel formats are returned
+    as CSR sparse label indicators.
+
+    Parameters
+    ----------
+    y_true : array-like
+
+    y_pred : array-like
+
+    Returns
+    -------
+    type_true : one of {'multilabel-indicator', 'multiclass', 'binary'}
+        The type of the true target data, as output by
+        ``utils.multiclass.type_of_target``
+
+    y_true : Tensor
+
+    y_pred : Tensor
+    """
+    op = CheckTargets(y_true=y_true, y_pred=y_pred)
+    return op(y_true, y_pred)