keras-rs-nightly 0.0.1.dev2025042103__py3-none-any.whl → 0.0.1.dev2025042503__py3-none-any.whl

keras_rs/src/metrics/ranking_metrics_utils.py

@@ -0,0 +1,238 @@
+from typing import Callable, Optional, Union
+
+import keras
+from keras import ops
+
+from keras_rs.src import types
+
+
+def get_shuffled_indices(
+    shape: types.TensorShape,
+    mask: Optional[types.Tensor] = None,
+    shuffle_ties: bool = True,
+    seed: Optional[Union[int, keras.random.SeedGenerator]] = None,
+) -> types.Tensor:
+    """Utility function for getting shuffled indices, with masked indices
+    pushed to the end.
+
+    Args:
+        shape: tuple. The shape of the tensor for which to generate
+            shuffled indices.
+        mask: An optional boolean tensor with the same shape as `shape`.
+            If provided, elements where `mask` is `False` will be placed
+            at the end of the sorted indices. Defaults to `None` (no masking).
+        shuffle_ties: Boolean indicating how to handle ties if multiple elements
+            have the same sorting value (randomly when `shuffle_ties` is True
+            otherwise, order is preserved).
+        seed: Optional integer seed for the random number generator used when
+            `shuffle_ties` is True. Ensures reproducibility. Defaults to None.
+
+    Returns:
+        A tensor of shape `shape` containing shuffled indices.
+    """
+    # If `shuffle_ties` is True, generate random values. Otherwise, generate
+    # zeros so that we get `[0, 1, 2, ...]` as indices on doing `argsort`.
+    if shuffle_ties:
+        shuffle_values = keras.random.uniform(shape, seed=seed, dtype="float32")
+    else:
+        shuffle_values = ops.zeros(shape, dtype="float32")
+
+    # When `mask = False`, increase value by 1 so that those indices are placed
+    # at the end. Note that `shuffle_values` lies in the range `[0, 1)`, so
+    # adding by 1 works out.
+    if mask is not None:
+        shuffle_values = ops.where(
+            mask,
+            shuffle_values,
+            ops.add(shuffle_values, ops.cast(1, dtype="float32")),
+        )
+
+    shuffled_indices = ops.argsort(shuffle_values)
+    return shuffled_indices
+
+
+def sort_by_scores(
+    tensors_to_sort: list[types.Tensor],
+    scores: types.Tensor,
+    mask: Optional[types.Tensor] = None,
+    k: Optional[int] = None,
+    shuffle_ties: bool = True,
+    seed: Optional[Union[int, keras.random.SeedGenerator]] = None,
+) -> types.Tensor:
+    """
+    Utility function for sorting tensors by scores.
+
+    Args:
+        tensors_to_sort. list of tensors. All tensors are of shape
+            `(batch_size, list_size)`. These tensors are sorted based on
+            `scores`.
+        scores: tensor. Of shape `(batch_size, list_size)`. The scores to sort
+            by.
+        k: int. The number of top-ranked items to consider (the 'k' in 'top-k').
+            If `None`, `list_size` is used.
+        shuffle_ties: bool. Whether to randomly shuffle scores before sorting.
+            This is done to break ties.
+        seed: int. Seed for shuffling.
+
+    Returns:
+        List of sorted tensors (`tensors_to_sort`), sorted using `scores`.
+    """
+    max_possible_k = ops.shape(scores)[1]
+    if k is None:
+        k = max_possible_k
+    elif isinstance(max_possible_k, int):
+        k = min(k, max_possible_k)
+    else:
+        k = ops.minimum(k, max_possible_k)
+
+    # Shuffle ties randomly, and push masked values to the beginning.
+    shuffled_indices = None
+    if shuffle_ties or mask is not None:
+        shuffled_indices = get_shuffled_indices(
+            ops.shape(scores),
+            mask=mask,
+            shuffle_ties=True,
+            seed=seed,
+        )
+        scores = ops.take_along_axis(scores, shuffled_indices, axis=1)
+
+    # Get top-k indices.
+    _, indices = ops.top_k(scores, k=k, sorted=True)
+
+    # If we shuffled our `scores` tensor, we need to get the correct indices
+    # by indexing into `shuffled_indices`.
+    if shuffled_indices is not None:
+        indices = ops.take_along_axis(shuffled_indices, indices, axis=1)
+
+    return [
+        ops.take_along_axis(tensor_to_sort, indices, axis=1)
+        for tensor_to_sort in tensors_to_sort
+    ]
+
+
+def get_list_weights(
+    weights: types.Tensor, relevance: types.Tensor
+) -> types.Tensor:
+    """Computes per-list weights from provided sample weights.
+
+    Per-list weights are calculated as follows:
+    ```
+    per_list_weights = sum(weights * relevance) / sum(relevance).
+    ```
+
+    For lists where the sum of relevance is 0, a default weight is assigned:
+    ```
+    sum(per_list_weights) / num(sum(relevance) != 0 AND sum(weights) != 0)
+    ```
+
+    If all lists have a sum of relevance equal to 0, the default weight is 1.0.
+
+    As a result of the above computation, this function takes care of the
+    following cases:
+    - **Uniform Weights:** When all input weights are 1.0, all per-list weights
+      will be 1.0, even for lists with no relevant examples. This aligns with
+      standard ranking metrics.
+    - **Non-zero Weights per List:** If every list has at least one non-zero
+      weight, the default weight mechanism is not utilized, which is suitable
+      for unbiased metrics.
+    - **Mixed Scenarios:** For cases with a mix of lists having zero and
+      non-zero relevance and weights, the weights for lists with non-zero
+      relevance and weights are proportional to:
+
+      ```
+      per_list_weights / sum(per_list_weights) *
+      num(sum(relevance) != 0) / num(lists)
+      ```
+
+      The rest have weights `1.0 / num(lists)`.
+
+    Args:
+        weights: tensor. Weights tensor of shape `(batch_size, list_size)`.
+        relevance: tensor. The relevance `Tensor` of shape
+            `(batch_size, list_size)`.
+
+    Returns:
+        A tensor of shape `(batch_size, 1)`, containing the per-list weights.
+    """
+    # Calculate if the sum of weights per list is greater than 0.0.
+    nonzero_weights = ops.greater(ops.sum(weights, axis=1, keepdims=True), 0.0)
+    # Calculate the sum of relevance per list
+    per_list_relevance = ops.sum(relevance, axis=1, keepdims=True)
+    # Calculate if the sum of relevance per list is greater than 0.0
+    nonzero_relevance_condition = ops.greater(per_list_relevance, 0.0)
+    # Identify lists where both weights and relevance sums are non-zero.
+    nonzero_relevance = ops.cast(
+        ops.logical_and(nonzero_weights, nonzero_relevance_condition),
+        dtype="float32",
+    )
+    # Count the number of lists with non-zero relevance and non-zero weights.
+    nonzero_relevance_count = ops.sum(nonzero_relevance, axis=0, keepdims=True)
+
+    # Calculate the per-list weights using the core formula.
+    # Numerator: `sum(weights * relevance)` per list
+    numerator = ops.sum(ops.multiply(weights, relevance), axis=1, keepdims=True)
+    # Denominator: per_list_relevance = sum(relevance) per list
+    per_list_weights = ops.divide_no_nan(numerator, per_list_relevance)
+
+    # Calculate the sum of the computed per-list weights.
+    sum_weights = ops.sum(per_list_weights, axis=0, keepdims=True)
+
+    # Calculate the average weight to use as default for lists with zero
+    # relevance but non-zero weights. If no lists have non-zero relevance,
+    # default to 1.0.
+    avg_weight = ops.where(
+        ops.greater(nonzero_relevance_count, 0.0),
+        ops.divide(sum_weights, nonzero_relevance_count),
+        ops.cast(1, dtype=sum_weights.dtype),
+    )
+
+    # Final assignment of weights based on conditions:
+    # 1. If sum(weights) == 0 for a list, the final weight is 0.
+    # 2. If sum(weights) > 0 AND sum(relevance) > 0, use the calculated
+    # `per_list_weights`.
+    # 3. If `sum(weights) > 0` AND `sum(relevance) == 0`, use the calculated
+    # `avg_weight`.
+    final_weights = ops.where(
+        nonzero_weights,
+        ops.where(
+            nonzero_relevance_condition,
+            per_list_weights,
+            avg_weight,
+        ),
+        ops.cast(0, dtype=per_list_weights.dtype),
+    )
+
+    return final_weights
+
+
+@keras.saving.register_keras_serializable()  # type: ignore[misc]
+def default_gain_fn(label: types.Tensor) -> types.Tensor:
+    return ops.subtract(ops.power(2.0, label), 1.0)
+
+
+@keras.saving.register_keras_serializable()  # type: ignore[misc]
+def default_rank_discount_fn(rank: types.Tensor) -> types.Tensor:
+    return ops.divide(
+        ops.cast(1, dtype=rank.dtype),
+        ops.log2(ops.add(ops.cast(1, dtype=rank.dtype), rank)),
+    )
+
+
+def compute_dcg(
+    y_true: types.Tensor,
+    sample_weight: types.Tensor,
+    gain_fn: Callable[[types.Tensor], types.Tensor] = default_gain_fn,
+    rank_discount_fn: Callable[
+        [types.Tensor], types.Tensor
+    ] = default_rank_discount_fn,
+) -> types.Tensor:
+    list_size = ops.shape(y_true)[1]
+    positions = ops.arange(1, list_size + 1, dtype="float32")
+    gain = gain_fn(y_true)
+    discount = rank_discount_fn(positions)
+
+    return ops.sum(
+        ops.multiply(sample_weight, ops.multiply(gain, discount)),
+        axis=1,
+        keepdims=True,
+    )

keras_rs/src/metrics/recall_at_k.py

@@ -0,0 +1,85 @@
+from keras import ops
+
+from keras_rs.src import types
+from keras_rs.src.api_export import keras_rs_export
+from keras_rs.src.metrics.ranking_metric import RankingMetric
+from keras_rs.src.metrics.ranking_metric import (
+    ranking_metric_subclass_doc_string,
+)
+from keras_rs.src.metrics.ranking_metric import (
+    ranking_metric_subclass_doc_string_args,
+)
+from keras_rs.src.metrics.ranking_metrics_utils import get_list_weights
+from keras_rs.src.metrics.ranking_metrics_utils import sort_by_scores
+from keras_rs.src.utils.doc_string_utils import format_docstring
+
+
+@keras_rs_export("keras_rs.metrics.RecallAtK")
+class RecallAtK(RankingMetric):
+    def compute_metric(
+        self,
+        y_true: types.Tensor,
+        y_pred: types.Tensor,
+        mask: types.Tensor,
+        sample_weight: types.Tensor,
+    ) -> types.Tensor:
+        # Assume: `y_true = [0, 0, 1]`, `y_pred = [0.1, 0.9, 0.2]`.
+        # `sorted_y_true = [0, 1, 0]` (sorted in descending order).
+        (sorted_y_true,) = sort_by_scores(
+            tensors_to_sort=[y_true],
+            scores=y_pred,
+            mask=mask,
+            k=self.k,
+            shuffle_ties=self.shuffle_ties,
+            seed=self.seed_generator,
+        )
+
+        relevance = ops.cast(
+            ops.greater_equal(
+                sorted_y_true, ops.cast(1, dtype=sorted_y_true.dtype)
+            ),
+            dtype="float32",
+        )
+        overall_relevance = ops.cast(
+            ops.greater_equal(y_true, ops.cast(1, dtype=y_true.dtype)),
+            dtype="float32",
+        )
+        per_list_recall = ops.divide_no_nan(
+            ops.sum(relevance, axis=1, keepdims=True),
+            ops.sum(overall_relevance, axis=1, keepdims=True),
+        )
+
+        # Get weights.
+        per_list_weights = get_list_weights(
+            weights=sample_weight, relevance=overall_relevance
+        )
+
+        return per_list_recall, per_list_weights
+
+
+concept_sentence = (
+    "It measures the proportion of relevant items found in the top-k "
+    "recommendations out of the total number of relevant items for a user"
+)
+relevance_type = "binary indicators (0 or 1) of relevance"
+score_range_interpretation = (
+    "Scores range from 0 to 1, with 1 indicating that all relevant items "
+    "for the user were found within the top-k recommendations"
+)
+formula = """```
+R@k(y, s) = sum_i I[rank(s_i) < k] y_i / sum_j y_j
+```
+
+where `y_i` is the relevance label (0/1) of the item ranked at position
+`i`, `I[condition]` is 1 if the condition is met, otherwise 0."""
+extra_args = ""
+RecallAtK.__doc__ = format_docstring(
+    ranking_metric_subclass_doc_string,
+    width=80,
+    metric_name="Recall@k",
+    metric_abbreviation="R@k",
+    concept_sentence=concept_sentence,
+    relevance_type=relevance_type,
+    score_range_interpretation=score_range_interpretation,
+    formula=formula,
+) + ranking_metric_subclass_doc_string_args.format(extra_args=extra_args)

keras_rs/src/metrics/utils.py

@@ -0,0 +1,72 @@
+from typing import Optional
+
+from keras import ops
+
+from keras_rs.src import types
+from keras_rs.src.utils.keras_utils import check_rank
+from keras_rs.src.utils.keras_utils import check_shapes_compatible
+
+
+def standardize_call_inputs_ranks(
+    y_true: types.Tensor,
+    y_pred: types.Tensor,
+    mask: Optional[types.Tensor] = None,
+    check_y_true_rank: bool = True,
+) -> tuple[types.Tensor, types.Tensor, Optional[types.Tensor], bool]:
+    """
+    Utility function for processing inputs for losses and metrics.
+
+    This utility function does three things:
+
+    - Checks that `y_true`, `y_pred` are of rank 1 or 2;
+    - Checks that `y_true`, `y_pred`, `mask` have the same shape;
+    - Adds batch dimension if rank = 1.
+
+    Args:
+        y_true: tensor. Ground truth values.
+        y_pred: tensor. The predicted values.
+        mask: tensor. Boolean mask for `y_true`.
+        check_y_true_rank: bool. Whether to check the rank of `y_true`.
+
+    Returns:
+        Tuple of processed `y_true`, `y_pred`, `mask`, and `batched`. `batched`
+        is a bool indicating if the inputs are batched.
+    """
+
+    y_true_shape = ops.shape(y_true)
+    y_true_rank = len(y_true_shape)
+    y_pred_shape = ops.shape(y_pred)
+    y_pred_rank = len(y_pred_shape)
+    if mask is not None:
+        mask_shape = ops.shape(mask)
+        mask_rank = len(mask_shape)
+
+    if check_y_true_rank:
+        check_rank(y_true_rank, allowed_ranks=(1, 2), tensor_name="y_true")
+    check_rank(y_pred_rank, allowed_ranks=(1, 2), tensor_name="y_pred")
+    if mask is not None:
+        check_rank(mask_rank, allowed_ranks=(1, 2), tensor_name="mask")
+    if not check_shapes_compatible(y_true_shape, y_pred_shape):
+        raise ValueError(
+            "`y_true` and `y_pred` should have the same shape. Received: "
+            f"`y_true.shape` = {y_true_shape}, `y_pred.shape` = {y_pred_shape}."
+        )
+    if mask is not None and not check_shapes_compatible(
+        y_true_shape, mask_shape
+    ):
+        raise ValueError(
+            "`y_true['labels']` and `y_true['mask']` should have the same "
+            f"shape. Received: `y_true['labels'].shape` = {y_true_shape}, "
+            f"`y_true['mask'].shape` = {mask_shape}."
+        )
+
+    batched = True
+    if y_true_rank == 1:
+        batched = False
+
+        y_true = ops.expand_dims(y_true, axis=0)
+        y_pred = ops.expand_dims(y_pred, axis=0)
+        if mask is not None:
+            mask = ops.expand_dims(mask, axis=0)
+
+    return y_true, y_pred, mask, batched

keras_rs/src/utils/doc_string_utils.py

@@ -0,0 +1,48 @@
+import re
+import textwrap
+from typing import Any
+
+
+def format_docstring(template: str, width: int = 80, **kwargs: Any) -> str:
+    """Formats and wraps a docstring using dedent and fill."""
+    base_indent_str = " " * 4
+
+    # Initial format
+    formatted = template.format(**kwargs)
+
+    # Dedent the whole block
+    dedented_all = textwrap.dedent(formatted).strip()
+
+    # Split into logical paragraphs/blocks.
+    blocks = re.split(r"(\n\s*\n)", dedented_all)
+
+    processed_output = []
+
+    for block in blocks:
+        stripped_block = block.strip()
+        if not stripped_block:
+            processed_output.append(block)
+            continue
+
+        if "```" in stripped_block:
+            formula_dedented = textwrap.dedent(stripped_block)
+            processed_output.append(
+                textwrap.indent(formula_dedented, base_indent_str)
+            )
+        elif "where:" in stripped_block:
+            processed_output.append(
+                textwrap.indent(stripped_block, base_indent_str)
+            )
+        else:
+            processed_output.append(
+                textwrap.fill(
+                    stripped_block,
+                    width=width - len(base_indent_str),
+                    initial_indent=base_indent_str,
+                    subsequent_indent=base_indent_str,
+                )
+            )
+
+    final_string = "".join(processed_output).strip()
+    final_string = base_indent_str + final_string
+    return final_string

keras_rs/src/utils/keras_utils.py

@@ -42,3 +42,15 @@ def check_shapes_compatible(
                 return False
 
     return True
+
+
+def check_rank(
+    x_rank: int,
+    allowed_ranks: tuple[int, ...],
+    tensor_name: str,
+) -> None:
+    if x_rank not in allowed_ranks:
+        raise ValueError(
+            f"`{tensor_name}` should have a rank from `{allowed_ranks}`."
+            f"Received: `{x_rank}`."
+        )

keras_rs/src/version.py

@@ -1,7 +1,7 @@
 from keras_rs.src.api_export import keras_rs_export
 
 # Unique source of truth for the version number.
-__version__ = "0.0.1.dev2025042103"
+__version__ = "0.0.1.dev2025042503"
 
 
 @keras_rs_export("keras_rs.version")

{keras_rs_nightly-0.0.1.dev2025042103.dist-info → keras_rs_nightly-0.0.1.dev2025042503.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: keras-rs-nightly
-Version: 0.0.1.dev2025042103
+Version: 0.0.1.dev2025042503
 Summary: Multi-backend recommender systems with Keras 3.
-Author-email: Keras RS team <keras-rs@google.com>
+Author-email: Keras team <keras-users@googlegroups.com>
 License: Apache License 2.0
-Project-URL: Home, https://keras.io/
+Project-URL: Home, https://keras.io/keras_rs
 Project-URL: Repository, https://github.com/keras-team/keras-rs
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Operating System :: Unix
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering

keras_rs_nightly-0.0.1.dev2025042503.dist-info/RECORD

@@ -0,0 +1,42 @@
+keras_rs/__init__.py,sha256=8sjHiPN2GhUqAq4V7Vh4FLLqYw20-jgdI26ZKX5sg6M,350
+keras_rs/layers/__init__.py,sha256=cvrFgFWg0RjI0ExUZOKZRdcN-FwTIkqhT33Vx8wGtjQ,905
+keras_rs/losses/__init__.py,sha256=m04QOgxIUfJ2MvCUKLgEof-UbSNKgUYLPnY-D9NAclI,573
+keras_rs/metrics/__init__.py,sha256=Qxpf6OFooIL9TIn2l3WgOea3HFRG0hq02glPAxtMZ9c,580
+keras_rs/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_rs/src/api_export.py,sha256=RsmG-DvO-cdFeAF9W6LRzms0kvtm-Yp9BAA_d-952zI,510
+keras_rs/src/types.py,sha256=UyOdgjqrqg_b58opnY8n6gTiDHKVR8z_bmEruehERBk,514
+keras_rs/src/version.py,sha256=xK7d2N2GcNnMxYdTlwcMzFhxwnexq30m_nMs_uRDSWA,222
+keras_rs/src/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_rs/src/layers/feature_interaction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_rs/src/layers/feature_interaction/dot_interaction.py,sha256=jGHcg0EiWxth6LTxG2yWgHcyx_GXrxvA61uQqpPfnDQ,6900
+keras_rs/src/layers/feature_interaction/feature_cross.py,sha256=5OCSI0vFYzJNmgkKcuHIbVv8U2q3UvS80-qZjPimDjM,8155
+keras_rs/src/layers/retrieval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_rs/src/layers/retrieval/brute_force_retrieval.py,sha256=izdppBXxJH0KqYEg7Zsr-SL-SHgAmnFopXMPalEO3uw,5676
+keras_rs/src/layers/retrieval/hard_negative_mining.py,sha256=IWFrbw1h9z3AUw4oUBKf5_Aud4MTHO_AKdHfoyFa5As,3031
+keras_rs/src/layers/retrieval/remove_accidental_hits.py,sha256=Z84z2YgKspKeNdc5id8lf9TAyFsbCCz3acJxiKXYipc,3324
+keras_rs/src/layers/retrieval/retrieval.py,sha256=hVOBF10SF2q_TgJdVUqztbnw5qQF-cxVRGdJbOKoL9M,4191
+keras_rs/src/layers/retrieval/sampling_probability_correction.py,sha256=80vgOPfBiF-PC0dSyqS57IcIxOxi_Q_R7eSXHn1G0yI,1437
+keras_rs/src/losses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_rs/src/losses/pairwise_hinge_loss.py,sha256=nrIU0d1IcCAGo7RVxNitkldJhY2ZrXxjTV7Po27FXds,950
+keras_rs/src/losses/pairwise_logistic_loss.py,sha256=2dTtRmrNfvF_lOvHK0UQ518L2d4fkvQZDj30HWB5A2s,1305
+keras_rs/src/losses/pairwise_loss.py,sha256=rmDr_Qc3yA0CR8rUCCGjOgdbjYfC505BLNuITyb1n8k,6132
+keras_rs/src/losses/pairwise_loss_utils.py,sha256=xvdGvdKNkvGvIaWYEQziWTFNa5EJz7rdkVGgrsnDHUk,1246
+keras_rs/src/losses/pairwise_mean_squared_error.py,sha256=KhSRvjg4RpwhASP1Sl7PZoq2488P_uGDr9tZWzZhDVU,2764
+keras_rs/src/losses/pairwise_soft_zero_one_loss.py,sha256=QdWn-lyWQM-U9ID9xGQ7oK10q9XT6qd1gxVAKy8hZH4,1239
+keras_rs/src/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_rs/src/metrics/dcg.py,sha256=DzSBc9ZbgNavuHRt3wtVzdx4ouAaaqeYhd9NxQLPq0g,5120
+keras_rs/src/metrics/mean_average_precision.py,sha256=SF5NlhlyVL9L_YVkj_s_135f3-8hILVHRziSGafGyZI,3915
+keras_rs/src/metrics/mean_reciprocal_rank.py,sha256=4stq0MzyWNokMlol6BESDAMuoUFieDrFFc57ue94h4Y,3240
+keras_rs/src/metrics/ndcg.py,sha256=G7WNFoUaOhnf4vMF1jgcI4yGxieUfJv5E0upv4Qs1AQ,6545
+keras_rs/src/metrics/precision_at_k.py,sha256=u-mj49qamt448gxkOI9YIZMMrhgO8QmetRFXGGlWOqY,3247
+keras_rs/src/metrics/ranking_metric.py,sha256=cdFb4Lg2Z8P-02ImMGUAX4XeOUyzEE8TA6nB4fDgq0U,10411
+keras_rs/src/metrics/ranking_metrics_utils.py,sha256=989J8pr6FRsA1HwBeF7SA8uQqjZT2XeCxKfRuMysWnQ,8828
+keras_rs/src/metrics/recall_at_k.py,sha256=hlPnR5AtFjdd5AG0zLkLGVyLO5mWtp2bAu_cSOq9Fws,2919
+keras_rs/src/metrics/utils.py,sha256=6xanTNdwARn4ugzmb7ko2kwAhNhsnR4NhrpS_qW0IKc,2506
+keras_rs/src/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_rs/src/utils/doc_string_utils.py,sha256=yVyQ8pYdl4gd4tKRhD8dXmQX1EwZeLiV3cCq3A1tUEk,1466
+keras_rs/src/utils/keras_utils.py,sha256=d28OdQP4GrJk4NIQS4n0KPtCbgOCxVU_vDnnI7ODpOw,1562
+keras_rs_nightly-0.0.1.dev2025042503.dist-info/METADATA,sha256=mJ89IDGmATYXeG9OiNQWwvnm1Z6TaXJ3Aedj7nMiixc,3614
+keras_rs_nightly-0.0.1.dev2025042503.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+keras_rs_nightly-0.0.1.dev2025042503.dist-info/top_level.txt,sha256=pWs8X78Z0cn6lfcIb9VYOW5UeJ-TpoaO9dByzo7_FFo,9
+keras_rs_nightly-0.0.1.dev2025042503.dist-info/RECORD,,

{keras_rs_nightly-0.0.1.dev2025042103.dist-info → keras_rs_nightly-0.0.1.dev2025042503.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

keras_rs/api/__init__.py

@@ -1,10 +0,0 @@
-"""DO NOT EDIT.
-
-This file was autogenerated. Do not edit it by hand,
-since your modifications would be overwritten.
-"""
-
-from keras_rs.api import layers
-from keras_rs.api import losses
-from keras_rs.src.version import __version__
-from keras_rs.src.version import version

keras_rs/api/losses/__init__.py

@@ -1,14 +0,0 @@
-"""DO NOT EDIT.
-
-This file was autogenerated. Do not edit it by hand,
-since your modifications would be overwritten.
-"""
-
-from keras_rs.src.losses.pairwise_hinge_loss import PairwiseHingeLoss
-from keras_rs.src.losses.pairwise_logistic_loss import PairwiseLogisticLoss
-from keras_rs.src.losses.pairwise_mean_squared_error import (
-    PairwiseMeanSquaredError,
-)
-from keras_rs.src.losses.pairwise_soft_zero_one_loss import (
-    PairwiseSoftZeroOneLoss,
-)

keras_rs/src/utils/pairwise_loss_utils.py

@@ -1,102 +0,0 @@
-from typing import Callable, Optional
-
-from keras import ops
-
-from keras_rs.src import types
-from keras_rs.src.utils.keras_utils import check_shapes_compatible
-
-
-def apply_pairwise_op(
-    x: types.Tensor, op: Callable[[types.Tensor, types.Tensor], types.Tensor]
-) -> types.Tensor:
-    return op(
-        ops.expand_dims(x, axis=-1),
-        ops.expand_dims(x, axis=-2),
-    )
-
-
-def pairwise_comparison(
-    labels: types.Tensor,
-    logits: types.Tensor,
-    mask: types.Tensor,
-    logits_op: Callable[[types.Tensor, types.Tensor], types.Tensor],
-) -> tuple[types.Tensor, types.Tensor]:
-    # Compute the difference for all pairs in a list. The output is a tensor
-    # with shape `(batch_size, list_size, list_size)`, where `[:, i, j]` stores
-    # information for pair `(i, j)`.
-    pairwise_labels_diff = apply_pairwise_op(labels, ops.subtract)
-    pairwise_logits = apply_pairwise_op(logits, logits_op)
-
-    # Keep only those cases where `l_i < l_j`.
-    pairwise_labels = ops.cast(
-        ops.greater(pairwise_labels_diff, 0), dtype=labels.dtype
-    )
-    if mask is not None:
-        valid_pairs = apply_pairwise_op(mask, ops.logical_and)
-        pairwise_labels = ops.multiply(
-            pairwise_labels, ops.cast(valid_pairs, dtype=pairwise_labels.dtype)
-        )
-
-    return pairwise_labels, pairwise_logits
-
-
-def process_loss_call_inputs(
-    y_true: types.Tensor,
-    y_pred: types.Tensor,
-    mask: Optional[types.Tensor] = None,
-) -> tuple[types.Tensor, types.Tensor, Optional[types.Tensor]]:
-    """
-    Utility function for processing inputs for pairwise losses.
-
-    This utility function does three things:
-
-    - Checks that `y_true`, `y_pred` are of rank 1 or 2;
-    - Checks that `y_true`, `y_pred`, `mask` have the same shape;
-    - Adds batch dimension if rank = 1.
-    """
-
-    y_true_shape = ops.shape(y_true)
-    y_true_rank = len(y_true_shape)
-    y_pred_shape = ops.shape(y_pred)
-    y_pred_rank = len(y_pred_shape)
-    if mask is not None:
-        mask_shape = ops.shape(mask)
-        mask_rank = len(mask_shape)
-
-    # Check ranks and shapes.
-    def check_rank(
-        x_rank: int,
-        allowed_ranks: tuple[int, ...] = (1, 2),
-        tensor_name: Optional[str] = None,
-    ) -> None:
-        if x_rank not in allowed_ranks:
-            raise ValueError(
-                f"`{tensor_name}` should have a rank from `{allowed_ranks}`."
-                f"Received: `{x_rank}`."
-            )
-
-    check_rank(y_true_rank, tensor_name="y_true")
-    check_rank(y_pred_rank, tensor_name="y_pred")
-    if mask is not None:
-        check_rank(mask_rank, tensor_name="mask")
-    if not check_shapes_compatible(y_true_shape, y_pred_shape):
-        raise ValueError(
-            "`y_true` and `y_pred` should have the same shape. Received: "
-            f"`y_true.shape` = {y_true_shape}, `y_pred.shape` = {y_pred_shape}."
-        )
-    if mask is not None and not check_shapes_compatible(
-        y_true_shape, mask_shape
-    ):
-        raise ValueError(
-            "`y_true['labels']` and `y_true['mask']` should have the same "
-            f"shape. Received: `y_true['labels'].shape` = {y_true_shape}, "
-            f"`y_true['mask'].shape` = {mask_shape}."
-        )
-
-    if y_true_rank == 1:
-        y_true = ops.expand_dims(y_true, axis=0)
-        y_pred = ops.expand_dims(y_pred, axis=0)
-        if mask is not None:
-            mask = ops.expand_dims(mask, axis=0)
-
-    return y_true, y_pred, mask