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

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)

maxframe/learn/metrics/pairwise/euclidean.py

@@ -0,0 +1,176 @@
+# 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 ....config import options
+from ....core import EntityData
+from ....serialization.serializables import BoolField, KeyField
+from ....tensor.core import TensorOrder
+from ...utils.validation import check_array
+from .core import PairwiseDistances
+
+
+class EuclideanDistances(PairwiseDistances):
+    _op_type_ = opcodes.PAIRWISE_EUCLIDEAN_DISTANCES
+
+    x = KeyField("X")
+    y = KeyField("Y", default=None)
+    x_norm_squared = KeyField("X_norm_squared", default=None)
+    y_norm_squared = KeyField("Y_norm_squared", default=None)
+    squared = BoolField("squared", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "EuclideanDistances", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        input_iter = iter(inputs)
+        op.x = next(input_iter)
+        if op.y is not None:
+            op.y = next(input_iter)
+        if op.x_norm_squared is not None:
+            op.x_norm_squared = next(input_iter)
+        if op.y_norm_squared is not None:
+            op.y_norm_squared = next(input_iter)
+
+    def __call__(self, X, Y=None, Y_norm_squared=None, X_norm_squared=None):
+        # If norms are passed as float32, they are unused. If arrays are passed as
+        # float32, norms needs to be recomputed on upcast chunks.
+        # TODO: use a float64 accumulator in row_norms to avoid the latter.
+        if X_norm_squared is not None:
+            XX = check_array(X_norm_squared)
+            if XX.shape == (1, X.shape[0]):
+                XX = XX.T
+            elif XX.shape != (X.shape[0], 1):
+                raise ValueError("Incompatible dimensions for X and X_norm_squared")
+            if XX.dtype == np.float32:
+                XX = self.x_norm_squared = None
+        else:
+            XX = None
+
+        if X is Y and XX is not None:
+            # shortcut in the common case euclidean_distances(X, X)
+            YY = XX.T
+        elif Y_norm_squared is not None:
+            YY = mt.atleast_2d(Y_norm_squared)
+
+            if YY.shape != (1, Y.shape[0]):
+                raise ValueError("Incompatible dimensions for Y and Y_norm_squared")
+            if YY.dtype == np.float32:
+                YY = self.y_norm_squared = None
+        else:
+            YY = None
+
+        inputs = [X, Y]
+        if XX is not None:
+            inputs.append(XX)
+        if YY is not None:
+            inputs.append(YY)
+        return self.new_tensor(
+            inputs, shape=(X.shape[0], Y.shape[0]), order=TensorOrder.C_ORDER
+        )
+
+
+def euclidean_distances(
+    X, Y=None, Y_norm_squared=None, squared=False, X_norm_squared=None
+):
+    """
+    Considering the rows of X (and Y=X) as vectors, compute the
+    distance matrix between each pair of vectors.
+
+    For efficiency reasons, the euclidean distance between a pair of row
+    vector x and y is computed as::
+
+        dist(x, y) = sqrt(dot(x, x) - 2 * dot(x, y) + dot(y, y))
+
+    This formulation has two advantages over other ways of computing distances.
+    First, it is computationally efficient when dealing with sparse data.
+    Second, if one argument varies but the other remains unchanged, then
+    `dot(x, x)` and/or `dot(y, y)` can be pre-computed.
+
+    However, this is not the most precise way of doing this computation, and
+    the distance matrix returned by this function may not be exactly
+    symmetric as required by, e.g., ``scipy.spatial.distance`` functions.
+
+    Read more in the :ref:`User Guide <metrics>`.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix}, shape (n_samples_1, n_features)
+
+    Y : {array-like, sparse matrix}, shape (n_samples_2, n_features)
+
+    Y_norm_squared : array-like, shape (n_samples_2, ), optional
+        Pre-computed dot-products of vectors in Y (e.g.,
+        ``(Y**2).sum(axis=1)``)
+        May be ignored in some cases, see the note below.
+
+    squared : boolean, optional
+        Return squared Euclidean distances.
+
+    X_norm_squared : array-like, shape = [n_samples_1], optional
+        Pre-computed dot-products of vectors in X (e.g.,
+        ``(X**2).sum(axis=1)``)
+        May be ignored in some cases, see the note below.
+
+    Notes
+    -----
+    To achieve better accuracy, `X_norm_squared` and `Y_norm_squared` may be
+    unused if they are passed as ``float32``.
+
+    Returns
+    -------
+    distances : tensor, shape (n_samples_1, n_samples_2)
+
+    Examples
+    --------
+    >>> from maxframe.learn.metrics.pairwise import euclidean_distances
+    >>> X = [[0, 1], [1, 1]]
+    >>> # distance between rows of X
+    >>> euclidean_distances(X, X).execute()
+    array([[0., 1.],
+           [1., 0.]])
+    >>> # get distance to origin
+    >>> euclidean_distances(X, [[0, 0]]).execute()
+    array([[1.        ],
+           [1.41421356]])
+
+    See also
+    --------
+    paired_distances : distances betweens pairs of elements of X and Y.
+    """
+    if X.dtype == np.float32:
+        if Y is None:
+            dtype = X.dtype
+        elif Y.dtype == np.float32:
+            dtype = np.float32
+        else:
+            dtype = np.float64
+    else:
+        dtype = np.float64
+
+    X, Y = EuclideanDistances.check_pairwise_arrays(X, Y)
+    op = EuclideanDistances(
+        x=X,
+        y=Y,
+        x_norm_squared=X_norm_squared,
+        y_norm_squared=Y_norm_squared,
+        squared=squared,
+        dtype=np.dtype(dtype),
+        chunk_store_limit=options.chunk_store_limit,
+    )
+    return op(X, Y=Y, Y_norm_squared=Y_norm_squared, X_norm_squared=X_norm_squared)

maxframe/learn/metrics/pairwise/haversine.py

@@ -0,0 +1,96 @@
+# 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 BoolField, KeyField
+from ....tensor.core import TensorOrder
+from .core import PairwiseDistances
+
+
+class HaversineDistances(PairwiseDistances):
+    _op_type_ = opcodes.PAIRWISE_HAVERSINE_DISTANCES
+
+    x = KeyField("x")
+    y = KeyField("y")
+    # for test purpose
+    use_sklearn = BoolField("use_sklearn", default=True)
+
+    @classmethod
+    def _set_inputs(cls, op: "HaversineDistances", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.x, op.y = op._inputs[:2]
+
+    def __call__(self, X, Y=None):
+        X, Y = self.check_pairwise_arrays(X, Y)
+        if self.y is None:
+            self.y = Y
+
+        if X.shape[1] != 2 or Y.shape[1] != 2:
+            raise ValueError("Haversine distance only valid in 2 dimensions")
+        if X.issparse() or Y.issparse():
+            raise TypeError("Haversine distance requires inputs dense")
+
+        return self.new_tensor(
+            [X, Y], shape=(X.shape[0], Y.shape[0]), order=TensorOrder.C_ORDER
+        )
+
+
+def haversine_distances(X, Y=None):
+    """Compute the Haversine distance between samples in X and Y
+
+    The Haversine (or great circle) distance is the angular distance between
+    two points on the surface of a sphere. The first distance of each point is
+    assumed to be the latitude, the second is the longitude, given in radians.
+    The dimension of the data must be 2.
+
+    .. math::
+       D(x, y) = 2\\arcsin[\\sqrt{\\sin^2((x1 - y1) / 2)
+                                + \\cos(x1)\\cos(y1)\\sin^2((x2 - y2) / 2)}]
+
+    Parameters
+    ----------
+    X : array_like, shape (n_samples_1, 2)
+
+    Y : array_like, shape (n_samples_2, 2), optional
+
+    Returns
+    -------
+    distance : {Tensor}, shape (n_samples_1, n_samples_2)
+
+    Notes
+    -----
+    As the Earth is nearly spherical, the haversine formula provides a good
+    approximation of the distance between two points of the Earth surface, with
+    a less than 1% error on average.
+
+    Examples
+    --------
+    We want to calculate the distance between the Ezeiza Airport
+    (Buenos Aires, Argentina) and the Charles de Gaulle Airport (Paris, France)
+
+    >>> from maxframe.learn.metrics.pairwise import haversine_distances
+    >>> bsas = [-34.83333, -58.5166646]
+    >>> paris = [49.0083899664, 2.53844117956]
+    >>> result = haversine_distances([bsas, paris])
+    >>> (result * 6371000/1000).execute()  # multiply by Earth radius to get kilometers
+    array([[    0.        , 11279.45379464],
+           [11279.45379464,     0.        ]])
+    """
+    op = HaversineDistances(x=X, y=Y, dtype=np.dtype(np.float64))
+    return op(X, Y=Y)

maxframe/learn/metrics/pairwise/manhattan.py

@@ -0,0 +1,80 @@
+# 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 .core import PairwiseDistances
+
+
+class ManhattanDistances(PairwiseDistances):
+    _op_type_ = opcodes.PAIRWISE_MANHATTAN_DISTANCES
+
+    x = KeyField("x")
+    y = KeyField("y")
+
+    @classmethod
+    def _set_inputs(cls, op: "ManhattanDistances", 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)
+        if self.y is None:
+            self.y = Y
+        shape = (X.shape[0], Y.shape[0])
+
+        return self.new_tensor([X, Y], shape=shape, order=TensorOrder.C_ORDER)
+
+
+def manhattan_distances(X, Y=None):
+    """ Compute the L1 distances between the vectors in X and Y.
+
+    Read more in the :ref:`User Guide <metrics>`.
+
+    Parameters
+    ----------
+    X : array_like
+        A tensor with shape (n_samples_X, n_features).
+
+    Y : array_like, optional
+        A tensor with shape (n_samples_Y, n_features).
+
+    Returns
+    -------
+    D : Tensor
+        Shape is (n_samples_X, n_samples_Y) and D contains
+        the pairwise L1 distances.
+
+    Examples
+    --------
+    >>> from maxframe.learn.metrics.pairwise import manhattan_distances
+    >>> manhattan_distances([[3]], [[3]]).execute() #doctest:+ELLIPSIS
+    array([[0.]])
+    >>> manhattan_distances([[3]], [[2]]).execute() #doctest:+ELLIPSIS
+    array([[1.]])
+    >>> manhattan_distances([[2]], [[3]]).execute() #doctest:+ELLIPSIS
+    array([[1.]])
+    >>> manhattan_distances([[1, 2], [3, 4]],\
+         [[1, 2], [0, 3]]).execute() #doctest:+ELLIPSIS
+    array([[0., 2.],
+           [4., 4.]])
+    """
+    op = ManhattanDistances(x=X, y=Y, dtype=np.dtype(np.float64))
+    return op(X, Y=Y)

maxframe/learn/metrics/pairwise/pairwise.py

@@ -0,0 +1,127 @@
+# 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
+from functools import partial
+
+try:
+    from sklearn.exceptions import DataConversionWarning
+except ImportError:  # pragma: no cover
+    DataConversionWarning = None
+
+from ....tensor.spatial import distance
+from ...utils.validation import check_non_negative
+from .core import PairwiseDistances
+from .cosine import cosine_distances
+from .euclidean import euclidean_distances
+from .haversine import haversine_distances
+from .manhattan import manhattan_distances
+
+_VALID_METRICS = [
+    "euclidean",
+    "l2",
+    "l1",
+    "manhattan",
+    "cityblock",
+    "braycurtis",
+    "canberra",
+    "chebyshev",
+    "correlation",
+    "cosine",
+    "dice",
+    "hamming",
+    "jaccard",
+    "kulsinski",
+    "mahalanobis",
+    "matching",
+    "minkowski",
+    "rogerstanimoto",
+    "russellrao",
+    "seuclidean",
+    "sokalmichener",
+    "sokalsneath",
+    "sqeuclidean",
+    "yule",
+    "wminkowski",
+    "haversine",
+]
+
+# Helper functions - distance
+PAIRWISE_DISTANCE_FUNCTIONS = {
+    # If updating this dictionary, update the doc in both distance_metrics()
+    # and also in pairwise_distances()!
+    "cityblock": manhattan_distances,
+    "cosine": cosine_distances,
+    "euclidean": euclidean_distances,
+    "haversine": haversine_distances,
+    "l2": euclidean_distances,
+    "l1": manhattan_distances,
+    "manhattan": manhattan_distances,
+    "precomputed": None,  # HACK: precomputed is always allowed, never called
+}
+
+# These distances require boolean tensors, when using maxframe.tensor.spatial.distance
+PAIRWISE_BOOLEAN_FUNCTIONS = [
+    "dice",
+    "jaccard",
+    "kulsinski",
+    "matching",
+    "rogerstanimoto",
+    "russellrao",
+    "sokalmichener",
+    "sokalsneath",
+    "yule",
+]
+
+
+def pairwise_distances(X, Y=None, metric="euclidean", **kwds):
+    if (
+        metric not in _VALID_METRICS
+        and not callable(metric)
+        and metric != "precomputed"
+    ):
+        raise ValueError(
+            f"Unknown metric {metric}. Valid metrics are {_VALID_METRICS}, "
+            "or 'precomputed', or a callable"
+        )
+
+    if metric == "precomputed":
+        X, _ = PairwiseDistances.check_pairwise_arrays(X, Y, precomputed=True)
+
+        whom = (
+            "`pairwise_distances`. Precomputed distance "
+            " need to have non-negative values."
+        )
+        X = check_non_negative(X, whom=whom)
+        return X
+    elif metric in PAIRWISE_DISTANCE_FUNCTIONS:
+        func = PAIRWISE_DISTANCE_FUNCTIONS[metric]
+    else:
+        # including when metric is callable
+        dtype = bool if metric in PAIRWISE_BOOLEAN_FUNCTIONS else None
+
+        if (
+            dtype == bool
+            and (X.dtype != bool or (Y is not None and Y.dtype != bool))
+            and DataConversionWarning is not None
+        ):
+            msg = f"Data was converted to boolean for metric {metric}"
+            warnings.warn(msg, DataConversionWarning)
+
+        X, Y = PairwiseDistances.check_pairwise_arrays(X, Y, dtype=dtype)
+        if X is Y:
+            return distance.squareform(distance.pdist(X, metric=metric, **kwds))
+        func = partial(distance.cdist, metric=metric, **kwds)
+
+    return func(X, Y, **kwds)