maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/learn/metrics/_regression.py

@@ -0,0 +1,256 @@
+# 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 warnings
+
+import numpy as np
+
+from ... import tensor as mt
+from ...session import execute as execute_tileables
+from ..utils.validation import (
+    _num_samples,
+    check_array,
+    check_consistent_length,
+    column_or_1d,
+)
+
+try:
+    from sklearn.exceptions import UndefinedMetricWarning
+except ImportError:
+    UndefinedMetricWarning = RuntimeWarning
+
+
+def _check_reg_targets(y_true, y_pred, multioutput, dtype="numeric"):
+    """Check that y_true and y_pred belong to the same regression task.
+
+    Parameters
+    ----------
+    y_true : array-like
+
+    y_pred : array-like
+
+    multioutput : array-like or string in ['raw_values', uniform_average',
+        'variance_weighted'] or None
+        None is accepted due to backward compatibility of r2_score().
+
+    Returns
+    -------
+    type_true : one of {'continuous', continuous-multioutput'}
+        The type of the true target data, as output by
+        'utils.multiclass.type_of_target'.
+
+    y_true : array-like of shape (n_samples, n_outputs)
+        Ground truth (correct) target values.
+
+    y_pred : array-like of shape (n_samples, n_outputs)
+        Estimated target values.
+
+    multioutput : array-like of shape (n_outputs) or string in ['raw_values',
+        uniform_average', 'variance_weighted'] or None
+        Custom output weights if ``multioutput`` is array-like or
+        just the corresponding argument if ``multioutput`` is a
+        correct keyword.
+
+    dtype : str or list, default="numeric"
+        the dtype argument passed to check_array.
+    """
+    y_true, y_pred = check_consistent_length(y_true, y_pred)
+    y_true = check_array(y_true, ensure_2d=False, dtype=dtype)
+    y_pred = check_array(y_pred, ensure_2d=False, dtype=dtype)
+
+    if y_true.ndim == 1:
+        y_true = y_true.reshape((-1, 1))
+
+    if y_pred.ndim == 1:
+        y_pred = y_pred.reshape((-1, 1))
+
+    if y_true.shape[1] != y_pred.shape[1]:
+        raise ValueError(
+            "y_true and y_pred have different number of output "
+            "({0}!={1})".format(y_true.shape[1], y_pred.shape[1])
+        )
+
+    n_outputs = y_true.shape[1]
+    allowed_multioutput_str = ("raw_values", "uniform_average", "variance_weighted")
+    if isinstance(multioutput, str):
+        if multioutput not in allowed_multioutput_str:
+            raise ValueError(
+                "Allowed 'multioutput' string values are {}. "
+                "You provided multioutput={!r}".format(
+                    allowed_multioutput_str, multioutput
+                )
+            )
+    elif multioutput is not None:
+        multioutput = check_array(multioutput, ensure_2d=False)
+        if n_outputs == 1:
+            raise ValueError("Custom weights are useful only in multi-output cases.")
+        elif n_outputs != len(multioutput):
+            raise ValueError(
+                ("There must be equally many custom weights (%d) as outputs (%d).")
+                % (len(multioutput), n_outputs)
+            )
+    y_type = "continuous" if n_outputs == 1 else "continuous-multioutput"
+
+    return y_type, y_true, y_pred, multioutput
+
+
+def r2_score(
+    y_true,
+    y_pred,
+    *,
+    sample_weight=None,
+    multioutput="uniform_average",
+    execute=False,
+    session=None,
+    run_kwargs=None
+):
+    """:math:`R^2` (coefficient of determination) regression score function.
+
+    Best possible score is 1.0 and it can be negative (because the
+    model can be arbitrarily worse). A constant model that always
+    predicts the expected value of y, disregarding the input features,
+    would get a :math:`R^2` score of 0.0.
+
+    Read more in the :ref:`User Guide <r2_score>`.
+
+    Parameters
+    ----------
+    y_true : array-like of shape (n_samples,) or (n_samples, n_outputs)
+        Ground truth (correct) target values.
+
+    y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs)
+        Estimated target values.
+
+    sample_weight : array-like of shape (n_samples,), default=None
+        Sample weights.
+
+    multioutput : {'raw_values', 'uniform_average', 'variance_weighted'}, \
+            array-like of shape (n_outputs,) or None, default='uniform_average'
+
+        Defines aggregating of multiple output scores.
+        Array-like value defines weights used to average scores.
+        Default is "uniform_average".
+
+        'raw_values' :
+            Returns a full set of scores in case of multioutput input.
+
+        'uniform_average' :
+            Scores of all outputs are averaged with uniform weight.
+
+        'variance_weighted' :
+            Scores of all outputs are averaged, weighted by the variances
+            of each individual output.
+
+    Returns
+    -------
+    z : float or tensor of floats
+        The :math:`R^2` score or ndarray of scores if 'multioutput' is
+        'raw_values'.
+
+    Notes
+    -----
+    This is not a symmetric function.
+
+    Unlike most other scores, :math:`R^2` score may be negative (it need not
+    actually be the square of a quantity R).
+
+    This metric is not well-defined for single samples and will return a NaN
+    value if n_samples is less than two.
+
+    References
+    ----------
+    .. [1] `Wikipedia entry on the Coefficient of determination
+            <https://en.wikipedia.org/wiki/Coefficient_of_determination>`_
+
+    Examples
+    --------
+    >>> from maxframe.learn.metrics import r2_score
+    >>> y_true = [3, -0.5, 2, 7]
+    >>> y_pred = [2.5, 0.0, 2, 8]
+    >>> r2_score(y_true, y_pred)
+    0.948...
+    >>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
+    >>> y_pred = [[0, 2], [-1, 2], [8, -5]]
+    >>> r2_score(y_true, y_pred,
+    ...          multioutput='variance_weighted')
+    0.938...
+    >>> y_true = [1, 2, 3]
+    >>> y_pred = [1, 2, 3]
+    >>> r2_score(y_true, y_pred)
+    1.0
+    >>> y_true = [1, 2, 3]
+    >>> y_pred = [2, 2, 2]
+    >>> r2_score(y_true, y_pred)
+    0.0
+    >>> y_true = [1, 2, 3]
+    >>> y_pred = [3, 2, 1]
+    >>> r2_score(y_true, y_pred)
+    -3.0
+    """
+    _, y_true, y_pred, multioutput = _check_reg_targets(y_true, y_pred, multioutput)
+    y_true, y_pred, sample_weight = check_consistent_length(
+        y_true, y_pred, sample_weight
+    )
+
+    if _num_samples(y_pred) < 2:
+        msg = "R^2 score is not well-defined with less than two samples."
+        warnings.warn(msg, UndefinedMetricWarning)
+        return float("nan")
+
+    if sample_weight is not None:
+        sample_weight = column_or_1d(sample_weight)
+        weight = sample_weight[:, np.newaxis]
+    else:
+        weight = 1.0
+
+    numerator = (weight * (y_true - y_pred) ** 2).sum(axis=0, dtype=np.float64)
+    denominator = (
+        weight * (y_true - mt.average(y_true, axis=0, weights=sample_weight)) ** 2
+    ).sum(axis=0, dtype=np.float64)
+    nonzero_denominator = denominator != 0
+    nonzero_numerator = numerator != 0
+    valid_score = nonzero_denominator & nonzero_numerator
+    output_scores = mt.ones((y_true.shape[1],))
+    output_scores[valid_score] = 1 - (numerator[valid_score] / denominator[valid_score])
+    # arbitrary set to zero to avoid -inf scores, having a constant
+    # y_true is not interesting for scoring a regression anyway
+    output_scores[nonzero_numerator & ~nonzero_denominator] = 0.0
+    if isinstance(multioutput, str):
+        if multioutput == "raw_values":
+            # return scores individually
+            return output_scores
+        elif multioutput == "uniform_average":
+            # passing None as weights results is uniform mean
+            avg_weights = None
+        elif multioutput == "variance_weighted":
+            avg_weights = denominator
+            # avoid fail on constant y or one-element arrays
+            cond1 = mt.any(nonzero_denominator)
+            execute_tileables(
+                cond1, nonzero_denominator, session=session, **(run_kwargs or dict())
+            )
+            if not cond1.fetch():
+                if not mt.any(nonzero_numerator).to_numpy(
+                    session=session, **(run_kwargs or dict())
+                ):
+                    return 1.0
+                else:
+                    return 0.0
+    else:
+        avg_weights = multioutput
+
+    res = mt.average(output_scores, weights=avg_weights)
+    if execute:
+        return res.execute(session=session, **(run_kwargs or dict()))
+    return res

maxframe/learn/metrics/_scorer.py

@@ -0,0 +1,60 @@
+# 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 Callable, Union
+
+from . import accuracy_score, log_loss, r2_score
+
+try:
+    from sklearn.metrics import make_scorer
+except ImportError:
+    make_scorer = lambda *_, **__: None
+
+accuracy_score = make_scorer(accuracy_score)
+r2_score = make_scorer(r2_score)
+neg_log_loss_scorer = make_scorer(log_loss, greater_is_better=False, needs_proba=True)
+
+
+SCORERS = dict(
+    r2=r2_score,
+    accuracy=accuracy_score,
+    neg_log_loss=neg_log_loss_scorer,
+)
+
+
+def get_scorer(score_func: Union[str, Callable], **kwargs) -> Callable:
+    """
+    Get a scorer from string
+
+    Parameters
+    ----------
+    score_func : str | callable
+        scoring method as string. If callable it is returned as is.
+
+    Returns
+    -------
+    scorer : callable
+        The scorer.
+    """
+    if isinstance(score_func, str):
+        try:
+            scorer = SCORERS[score_func]
+        except KeyError:
+            raise ValueError(
+                "{} is not a valid scoring value. "
+                "Valid options are {}".format(score_func, sorted(SCORERS))
+            )
+        return scorer
+    else:
+        return make_scorer(score_func, **kwargs)

maxframe/learn/metrics/pairwise/__init__.py

@@ -0,0 +1,21 @@
+# 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 .cosine import cosine_distances, cosine_similarity
+from .euclidean import euclidean_distances
+from .haversine import haversine_distances
+from .manhattan import manhattan_distances
+from .pairwise import PAIRWISE_DISTANCE_FUNCTIONS, pairwise_distances
+from .pairwise_distances_topk import pairwise_distances_topk
+from .rbf_kernel import rbf_kernel

maxframe/learn/metrics/pairwise/core.py

@@ -0,0 +1,77 @@
+# 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 numpy as np
+
+from ....serialization.serializables import Int64Field
+from ....tensor import tensor as astensor
+from ....tensor.operators import TensorOperator, TensorOperatorMixin
+from ...utils.validation import check_array
+
+
+class PairwiseDistances(TensorOperator, TensorOperatorMixin):
+    _op_module_ = "learn"
+
+    chunk_store_limit = Int64Field("chunk_store_limit")
+
+    @staticmethod
+    def _return_float_dtype(X, Y):
+        """
+        1. If dtype of X and Y is float32, then dtype float32 is returned.
+        2. Else dtype float is returned.
+        """
+
+        X = astensor(X)
+
+        if Y is None:
+            Y_dtype = X.dtype
+        else:
+            Y = astensor(Y)
+            Y_dtype = Y.dtype
+
+        if X.dtype == Y_dtype == np.float32:
+            dtype = np.float32
+        else:
+            dtype = float
+
+        return X, Y, dtype
+
+    @staticmethod
+    def check_pairwise_arrays(X, Y, precomputed=False, dtype=None):
+        X, Y, dtype_float = PairwiseDistances._return_float_dtype(X, Y)
+
+        estimator = "check_pairwise_arrays"
+        if dtype is None:
+            dtype = dtype_float
+
+        if Y is X or Y is None:
+            X = Y = check_array(X, accept_sparse=True, dtype=dtype, estimator=estimator)
+        else:
+            X = check_array(X, accept_sparse=True, dtype=dtype, estimator=estimator)
+            Y = check_array(Y, accept_sparse=True, dtype=dtype, estimator=estimator)
+
+        if precomputed:
+            if X.shape[1] != Y.shape[0]:
+                raise ValueError(
+                    "Precomputed metric requires shape "
+                    f"(n_queries, n_indexed). Got ({X.shape[0]}, {X.shape[1]}) "
+                    f"for {Y.shape[0]} indexed."
+                )
+        elif X.shape[1] != Y.shape[1]:
+            raise ValueError(
+                "Incompatible dimension for X and Y matrices: "
+                f"X.shape[1] == {X.shape[1]} while Y.shape[1] == {Y.shape[1]}"
+            )
+
+        return X, Y

maxframe/learn/metrics/pairwise/cosine.py

@@ -0,0 +1,115 @@
+# 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 ....core import EntityData
+from ....serialization.serializables import KeyField
+from ....tensor.core import TensorOrder
+from ...preprocessing import normalize
+from .core import PairwiseDistances
+
+
+class CosineDistances(PairwiseDistances):
+    _op_type_ = opcodes.PAIRWISE_COSINE_DISTANCES
+
+    x = KeyField("x")
+    y = KeyField("y")
+
+    @classmethod
+    def _set_inputs(cls, op: "CosineDistances", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.x, op.y = inputs[:2]
+
+    def __call__(self, x, y=None):
+        x, y = self.check_pairwise_arrays(x, y)
+        return self.new_tensor(
+            [x, y], shape=(x.shape[0], y.shape[0]), order=TensorOrder.C_ORDER
+        )
+
+
+def cosine_similarity(X, Y=None, dense_output=True):
+    """Compute cosine similarity between samples in X and Y.
+
+    Cosine similarity, or the cosine kernel, computes similarity as the
+    normalized dot product of X and Y:
+
+        K(X, Y) = <X, Y> / (||X||*||Y||)
+
+    On L2-normalized data, this function is equivalent to linear_kernel.
+
+    Read more in the :ref:`User Guide <cosine_similarity>`.
+
+    Parameters
+    ----------
+    X : Tensor or sparse tensor, shape: (n_samples_X, n_features)
+        Input data.
+
+    Y : Tensor or sparse tensor, shape: (n_samples_Y, n_features)
+        Input data. If ``None``, the output will be the pairwise
+        similarities between all samples in ``X``.
+
+    dense_output : boolean (optional), default True
+        Whether to return dense output even when the input is sparse. If
+        ``False``, the output is sparse if both input tensors are sparse.
+
+    Returns
+    -------
+    kernel matrix : Tensor
+        A tensor with shape (n_samples_X, n_samples_Y).
+    """
+    X, Y = PairwiseDistances.check_pairwise_arrays(X, Y)
+
+    X_normalized = normalize(X, copy=True)
+    if X is Y:
+        Y_normalized = X_normalized
+    else:
+        Y_normalized = normalize(Y, copy=True)
+
+    K = X_normalized.dot(Y_normalized.T)
+    if dense_output:
+        K = K.todense()
+    return K
+
+
+def cosine_distances(X, Y=None):
+    """Compute cosine distance between samples in X and Y.
+
+    Cosine distance is defined as 1.0 minus the cosine similarity.
+
+    Read more in the :ref:`User Guide <metrics>`.
+
+    Parameters
+    ----------
+    X : array_like, sparse matrix
+        with shape (n_samples_X, n_features).
+
+    Y : array_like, sparse matrix (optional)
+        with shape (n_samples_Y, n_features).
+
+    Returns
+    -------
+    distance matrix : Tensor
+        A tensor with shape (n_samples_X, n_samples_Y).
+
+    See also
+    --------
+    maxframe.learn.metrics.pairwise.cosine_similarity
+    maxframe.tensor.spatial.distance.cosine : dense matrices only
+    """
+    op = CosineDistances(x=X, y=Y, dtype=np.dtype(np.float64))
+    return op(X, y=Y)