replay-rec 0.16.0rc0__py3-none-any.whl → 0.17.0__py3-none-any.whl

replay/metrics/coverage.py

@@ -1,16 +1,20 @@
+import functools
+import operator
 from typing import Dict, List, Union
+
 import polars as pl
 
-from replay.utils import PYSPARK_AVAILABLE, PandasDataFrame, SparkDataFrame, PolarsDataFrame
+from replay.utils import PYSPARK_AVAILABLE, PandasDataFrame, PolarsDataFrame, SparkDataFrame
 
 from .base_metric import Metric, MetricsDataFrameLike, MetricsMeanReturnType, MetricsReturnType
 
 if PYSPARK_AVAILABLE:
-    from pyspark.sql import Window
-    from pyspark.sql import functions as sf
+    from pyspark.sql import (
+        Window,
+        functions as sf,
+    )
 
 
-# pylint: disable=too-few-public-methods
 class Coverage(Metric):
     """
     Metric calculation is as follows:
@@ -54,7 +58,6 @@ class Coverage(Metric):
     <BLANKLINE>
     """
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         topk: Union[List, int],
@@ -79,7 +82,6 @@ class Coverage(Metric):
         )
         self._allow_caching = allow_caching
 
-    # pylint: disable=arguments-differ
     def _get_enriched_recommendations(
         self,
         recommendations: Union[PolarsDataFrame, SparkDataFrame],
@@ -89,16 +91,9 @@ class Coverage(Metric):
         else:
             return self._get_enriched_recommendations_polars(recommendations)
 
-    # pylint: disable=arguments-differ
-    def _get_enriched_recommendations_spark(
-        self, recommendations: SparkDataFrame
-    ) -> SparkDataFrame:
-        window = Window.partitionBy(self.query_column).orderBy(
-            sf.col(self.rating_column).desc()
-        )
-        sorted_by_score_recommendations = recommendations.withColumn(
-            "rank", sf.row_number().over(window)
-        )
+    def _get_enriched_recommendations_spark(self, recommendations: SparkDataFrame) -> SparkDataFrame:
+        window = Window.partitionBy(self.query_column).orderBy(sf.col(self.rating_column).desc())
+        sorted_by_score_recommendations = recommendations.withColumn("rank", sf.row_number().over(window))
         grouped_recs = (
             sorted_by_score_recommendations.select(self.item_column, "rank")
             .groupBy(self.item_column)
@@ -106,10 +101,7 @@ class Coverage(Metric):
         )
         return grouped_recs
 
-    # pylint: disable=arguments-differ
-    def _get_enriched_recommendations_polars(
-        self, recommendations: PolarsDataFrame
-    ) -> PolarsDataFrame:
+    def _get_enriched_recommendations_polars(self, recommendations: PolarsDataFrame) -> PolarsDataFrame:
         sorted_by_score_recommendations = recommendations.select(
             pl.all().sort_by(self.rating_column, descending=True).over(self.query_column)
         )
@@ -119,17 +111,13 @@ class Coverage(Metric):
             )
         )
         grouped_recs = (
-            sorted_by_score_recommendations
-            .select(self.item_column, "rank")
+            sorted_by_score_recommendations.select(self.item_column, "rank")
             .group_by(self.item_column)
             .agg(pl.col("rank").min().alias("best_position"))
         )
         return grouped_recs
 
-    # pylint: disable=arguments-differ
-    def _spark_compute(
-        self, recs: SparkDataFrame, train: SparkDataFrame
-    ) -> MetricsMeanReturnType:
+    def _spark_compute(self, recs: SparkDataFrame, train: SparkDataFrame) -> MetricsMeanReturnType:
         """
         Calculating metrics for PySpark DataFrame.
         """
@@ -144,10 +132,9 @@ class Coverage(Metric):
                 recs.filter(sf.col("best_position") <= k)
                 .select(self.item_column)
                 .distinct()
-                .join(
-                    train.select(self.item_column).distinct(), on=self.item_column
-                )
-                .count() / item_count
+                .join(train.select(self.item_column).distinct(), on=self.item_column)
+                .count()
+                / item_count
             )
             metrics.append(res)
 
@@ -156,10 +143,7 @@ class Coverage(Metric):
 
         return self._aggregate_results(metrics)
 
-    # pylint: disable=arguments-differ
-    def _polars_compute(
-        self, recs: PolarsDataFrame, train: PolarsDataFrame
-    ) -> MetricsMeanReturnType:
+    def _polars_compute(self, recs: PolarsDataFrame, train: PolarsDataFrame) -> MetricsMeanReturnType:
         """
         Calculating metrics for Polars DataFrame.
         """
@@ -172,44 +156,38 @@ class Coverage(Metric):
                 .select(self.item_column)
                 .unique()
                 .join(train.select(self.item_column).unique(), on=self.item_column)
-                .count() / item_count
+                .count()
+                / item_count
             ).rows()[0][0]
             metrics.append(res)
 
         return self._aggregate_results(metrics)
 
-    # pylint: disable=arguments-renamed
-    def _spark_call(
-        self, recommendations: SparkDataFrame, train: SparkDataFrame
-    ) -> MetricsReturnType:
+    def _spark_call(self, recommendations: SparkDataFrame, train: SparkDataFrame) -> MetricsReturnType:
         """
         Implementation for Pyspark DataFrame.
         """
         recs = self._get_enriched_recommendations(recommendations)
         return self._spark_compute(recs, train)
 
-    # pylint: disable=arguments-renamed
-    def _polars_call(
-        self, recommendations: PolarsDataFrame, train: PolarsDataFrame
-    ) -> MetricsReturnType:
+    def _polars_call(self, recommendations: PolarsDataFrame, train: PolarsDataFrame) -> MetricsReturnType:
         """
         Implementation for Polars DataFrame.
         """
         recs = self._get_enriched_recommendations(recommendations)
         return self._polars_compute(recs, train)
 
-    # pylint: disable=arguments-differ
     def _dict_call(self, recommendations: Dict, train: Dict) -> MetricsReturnType:
         """
         Calculating metrics in dict format.
         """
-        train_items = set(sum(train.values(), []))
+        train_items = set(functools.reduce(operator.iconcat, train.values(), []))
 
         len_train_items = len(train_items)
         metrics = []
         for k in self.topk:
             pred_items = set()
-            for _, items in recommendations.items():
+            for items in recommendations.values():
                 for item in items[:k]:
                     pred_items.add(item)
             metrics.append(len(pred_items & train_items) / len_train_items)
@@ -250,9 +228,7 @@ class Coverage(Metric):
             else self._convert_dict_to_dict_with_score(recommendations)
         )
         self._check_duplicates_dict(recommendations)
-        train = (
-            self._convert_pandas_to_dict_without_score(train) if is_pandas else train
-        )
+        train = self._convert_pandas_to_dict_without_score(train) if is_pandas else train
         assert isinstance(train, dict)
         return self._dict_call(recommendations, train)
 

replay/metrics/descriptors.py

@@ -4,7 +4,7 @@ from typing import Union
 import numpy as np
 from scipy.stats import norm, sem
 
-from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame, PolarsDataFrame
+from replay.utils import PYSPARK_AVAILABLE, PolarsDataFrame, SparkDataFrame
 
 if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
@@ -66,9 +66,7 @@ class Median(CalculationDescriptor):
 
     def spark(self, distribution: SparkDataFrame):
         column_name = distribution.columns[0]
-        return distribution.select(
-            sf.expr(f"percentile_approx({column_name}, 0.5)")
-        ).first()[0]
+        return distribution.select(sf.expr(f"percentile_approx({column_name}, 0.5)")).first()[0]
 
     def cpu(self, distribution: Union[np.array, PolarsDataFrame]):
         if isinstance(distribution, PolarsDataFrame):
@@ -119,12 +117,5 @@ class ConfidenceInterval(CalculationDescriptor):
         column_name = distribution.columns[0]
         quantile = norm.ppf((1 + self.alpha) / 2)
         count = distribution.select(column_name).count().rows()[0][0]
-        std = (
-            distribution
-            .select(column_name)
-            .std()
-            .fill_null(0.0)
-            .fill_nan(0.0)
-            .rows()[0][0]
-        )
-        return quantile * std / (count ** 0.5)
+        std = distribution.select(column_name).std().fill_null(0.0).fill_nan(0.0).rows()[0][0]
+        return quantile * std / (count**0.5)

replay/metrics/experiment.py

@@ -6,8 +6,6 @@ from .base_metric import Metric, MetricsDataFrameLike
 from .offline_metrics import OfflineMetrics
 
 
-# pylint: disable=too-many-instance-attributes
-# pylint: disable=too-few-public-methods
 class Experiment:
     """
     The class is designed for calculating, storing and comparing metrics
@@ -102,15 +100,12 @@ class Experiment:
     <BLANKLINE>
     """
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         metrics: List[Metric],
         ground_truth: MetricsDataFrameLike,
         train: Optional[MetricsDataFrameLike] = None,
-        base_recommendations: Optional[
-            Union[MetricsDataFrameLike, Dict[str, MetricsDataFrameLike]]
-        ] = None,
+        base_recommendations: Optional[Union[MetricsDataFrameLike, Dict[str, MetricsDataFrameLike]]] = None,
         query_column: str = "query_id",
         item_column: str = "item_id",
         rating_column: str = "rating",
@@ -182,7 +177,6 @@ class Experiment:
         for metric, value in cur_metrics.items():
             self.results.at[name, metric] = value
 
-    # pylint: disable=not-an-iterable
     def compare(self, name: str) -> pd.DataFrame:
         """
         Show results as a percentage difference to record ``name``.
@@ -191,7 +185,8 @@ class Experiment:
         :return: results table in a percentage format
         """
         if name not in self.results.index:
-            raise ValueError(f"No results for model {name}")
+            msg = f"No results for model {name}"
+            raise ValueError(msg)
         columns = [column for column in self.results.columns if column[-1].isdigit()]
         data_frame = self.results[columns].copy()
         baseline = data_frame.loc[name]

replay/metrics/hitrate.py

@@ -3,17 +3,16 @@ from typing import List
 from .base_metric import Metric
 
 
-# pylint: disable=too-few-public-methods
 class HitRate(Metric):
     """
     Percentage of users that have at least one correctly recommended item\
         among top-k.
 
     .. math::
-        HitRate@K(i) = \max_{j \in [1..K]}\mathbb{1}_{r_{ij}}
+        HitRate@K(i) = \\max_{j \\in [1..K]}\\mathbb{1}_{r_{ij}}
 
     .. math::
-        HitRate@K = \\frac {\sum_{i=1}^{N}HitRate@K(i)}{N}
+        HitRate@K = \\frac {\\sum_{i=1}^{N}HitRate@K(i)}{N}
 
     :math:`\\mathbb{1}_{r_{ij}}` -- indicator function stating that user :math:`i` interacted with item :math:`j`
 
@@ -63,9 +62,7 @@ class HitRate(Metric):
     """
 
     @staticmethod
-    def _get_metric_value_by_user(  # pylint: disable=arguments-differ
-        ks: List[int], ground_truth: List, pred: List
-    ) -> List[float]:
+    def _get_metric_value_by_user(ks: List[int], ground_truth: List, pred: List) -> List[float]:
         if not ground_truth or not pred:
             return [0.0 for _ in ks]
         set_gt = set(ground_truth)

replay/metrics/map.py

@@ -3,16 +3,15 @@ from typing import List
 from .base_metric import Metric
 
 
-# pylint: disable=too-few-public-methods
 class MAP(Metric):
     """
     Mean Average Precision -- average the ``Precision`` at relevant positions \
         for each user, and then calculate the mean across all users.
 
     .. math::
-        &AP@K(i) = \\frac {1}{\min(K, |Rel_i|)} \sum_{j=1}^{K}\mathbb{1}_{r_{ij}}Precision@j(i)
+        &AP@K(i) = \\frac {1}{\\min(K, |Rel_i|)} \\sum_{j=1}^{K}\\mathbb{1}_{r_{ij}}Precision@j(i)
 
-        &MAP@K = \\frac {\sum_{i=1}^{N}AP@K(i)}{N}
+        &MAP@K = \\frac {\\sum_{i=1}^{N}AP@K(i)}{N}
 
     :math:`\\mathbb{1}_{r_{ij}}` -- indicator function showing if user :math:`i` interacted with item :math:`j`
 
@@ -64,9 +63,7 @@ class MAP(Metric):
     """
 
     @staticmethod
-    def _get_metric_value_by_user(  # pylint: disable=arguments-differ
-        ks: List[int], ground_truth: List, pred: List
-    ) -> List[float]:
+    def _get_metric_value_by_user(ks: List[int], ground_truth: List, pred: List) -> List[float]:
         if not ground_truth or not pred:
             return [0.0 for _ in ks]
         res = []

replay/metrics/mrr.py

@@ -3,7 +3,6 @@ from typing import List
 from .base_metric import Metric
 
 
-# pylint: disable=too-few-public-methods
 class MRR(Metric):
     """
     Mean Reciprocal Rank -- Reciprocal Rank is the inverse position of the
@@ -56,9 +55,7 @@ class MRR(Metric):
     """
 
     @staticmethod
-    def _get_metric_value_by_user(  # pylint: disable=arguments-differ
-        ks: List[int], ground_truth: List, pred: List
-    ) -> List[float]:
+    def _get_metric_value_by_user(ks: List[int], ground_truth: List, pred: List) -> List[float]:
         if not ground_truth or not pred:
             return [0.0 for _ in ks]
         set_gt = set(ground_truth)

replay/metrics/ndcg.py

@@ -4,7 +4,6 @@ from typing import List
 from .base_metric import Metric
 
 
-# pylint: disable=too-few-public-methods
 class NDCG(Metric):
     """
     Normalized Discounted Cumulative Gain is a metric
@@ -14,7 +13,7 @@ class NDCG(Metric):
     whether the item was consumed or not, relevance value is ignored.
 
     .. math::
-        DCG@K(i) = \sum_{j=1}^{K}\\frac{\mathbb{1}_{r_{ij}}}{\log_2 (j+1)}
+        DCG@K(i) = \\sum_{j=1}^{K}\\frac{\\mathbb{1}_{r_{ij}}}{\\log_2 (j+1)}
 
 
     :math:`\\mathbb{1}_{r_{ij}}` -- indicator function showing that user :math:`i` interacted with item :math:`j`
@@ -23,7 +22,7 @@ class NDCG(Metric):
     for user :math:`i` and recommendation length :math:`K`.
 
     .. math::
-        IDCG@K(i) = max(DCG@K(i)) = \sum_{j=1}^{K}\\frac{\mathbb{1}_{j\le|Rel_i|}}{\log_2 (j+1)}
+        IDCG@K(i) = max(DCG@K(i)) = \\sum_{j=1}^{K}\\frac{\\mathbb{1}_{j\\le|Rel_i|}}{\\log_2 (j+1)}
 
     .. math::
         nDCG@K(i) = \\frac {DCG@K(i)}{IDCG@K(i)}
@@ -33,7 +32,7 @@ class NDCG(Metric):
     Metric is averaged by users.
 
     .. math::
-        nDCG@K = \\frac {\sum_{i=1}^{N}nDCG@K(i)}{N}
+        nDCG@K = \\frac {\\sum_{i=1}^{N}nDCG@K(i)}{N}
 
     >>> recommendations
        query_id  item_id  rating
@@ -81,9 +80,7 @@ class NDCG(Metric):
     """
 
     @staticmethod
-    def _get_metric_value_by_user(  # pylint: disable=arguments-differ
-        ks: List[int], ground_truth: List, pred: List
-    ) -> List[float]:
+    def _get_metric_value_by_user(ks: List[int], ground_truth: List, pred: List) -> List[float]:
         if not pred or not ground_truth:
             return [0.0 for _ in ks]
         set_gt = set(ground_truth)

replay/metrics/novelty.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Type
 
-from replay.utils import PandasDataFrame, SparkDataFrame, PolarsDataFrame
+from replay.utils import PandasDataFrame, PolarsDataFrame, SparkDataFrame
 
 from .base_metric import Metric, MetricsDataFrameLike, MetricsReturnType
 
@@ -8,7 +8,6 @@ if TYPE_CHECKING:  # pragma: no cover
     __class__: Type
 
 
-# pylint: disable=too-few-public-methods
 class Novelty(Metric):
     """
     Measure the fraction of shown items in recommendation list, that users\
@@ -16,11 +15,11 @@ class Novelty(Metric):
 
     .. math::
         Novelty@K(i) = \\frac
-        {\parallel {R^{i}_{1..\min(K, \parallel R^{i} \parallel)} \setminus train^{i}} \parallel}
+        {\\parallel {R^{i}_{1..\\min(K, \\parallel R^{i} \\parallel)} \\setminus train^{i}} \\parallel}
         {K}
 
     .. math::
-        Novelty@K = \\frac {1}{N}\sum_{i=1}^{N}Novelty@K(i)
+        Novelty@K = \\frac {1}{N}\\sum_{i=1}^{N}Novelty@K(i)
 
     :math:`R^{i}` -- the recommendations for the :math:`i`-th user.
 
@@ -114,9 +113,7 @@ class Novelty(Metric):
             else self._convert_dict_to_dict_with_score(recommendations)
         )
         self._check_duplicates_dict(recommendations)
-        train = (
-            self._convert_pandas_to_dict_without_score(train) if is_pandas else train
-        )
+        train = self._convert_pandas_to_dict_without_score(train) if is_pandas else train
         assert isinstance(train, dict)
 
         return self._dict_call(
@@ -125,41 +122,25 @@ class Novelty(Metric):
             train=train,
         )
 
-    # pylint: disable=arguments-renamed
-    def _spark_call(
-        self, recommendations: SparkDataFrame, train: SparkDataFrame
-    ) -> MetricsReturnType:
+    def _spark_call(self, recommendations: SparkDataFrame, train: SparkDataFrame) -> MetricsReturnType:
         """
         Implementation for Pyspark DataFrame.
         """
-        recs = self._get_enriched_recommendations(
-            recommendations, train
-        ).withColumnRenamed("ground_truth", "train")
+        recs = self._get_enriched_recommendations(recommendations, train).withColumnRenamed("ground_truth", "train")
         recs = self._rearrange_columns(recs)
         return self._spark_compute(recs)
 
-    # pylint: disable=arguments-renamed
-    def _polars_call(
-        self, recommendations: PolarsDataFrame, train: PolarsDataFrame
-    ) -> MetricsReturnType:
+    def _polars_call(self, recommendations: PolarsDataFrame, train: PolarsDataFrame) -> MetricsReturnType:
         """
         Implementation for Polars DataFrame.
         """
-        recs = self._get_enriched_recommendations(
-            recommendations, train
-        ).rename({"ground_truth": "train"})
+        recs = self._get_enriched_recommendations(recommendations, train).rename({"ground_truth": "train"})
         recs = self._rearrange_columns(recs)
         return self._polars_compute(recs)
 
-    # pylint: disable=arguments-differ
     @staticmethod
-    def _get_metric_value_by_user(
-        ks: List[int], pred: List, train: List
-    ) -> List[float]:
+    def _get_metric_value_by_user(ks: List[int], pred: List, train: List) -> List[float]:
         if not train or not pred:
             return [1.0 for _ in ks]
         set_train = set(train)
-        res = []
-        for k in ks:
-            res.append(1.0 - len(set(pred[:k]) & set_train) / len(pred[:k]))
-        return res
+        return [1.0 - len(set(pred[:k]) & set_train) / len(pred[:k]) for k in ks]