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

replay/metrics/offline_metrics.py

@@ -1,7 +1,7 @@
 import warnings
 from typing import Dict, List, Optional, Tuple, Union
 
-from replay.utils import PandasDataFrame, SparkDataFrame, PolarsDataFrame
+from replay.utils import PandasDataFrame, PolarsDataFrame, SparkDataFrame
 
 from .base_metric import Metric, MetricsDataFrameLike, MetricsReturnType
 from .coverage import Coverage
@@ -10,7 +10,6 @@ from .recall import Recall
 from .surprisal import Surprisal
 
 
-# pylint: disable=too-few-public-methods
 class OfflineMetrics:
     """
     Designed for efficient calculation of offline metrics provided by the RePlay.
@@ -146,7 +145,6 @@ class OfflineMetrics:
         "Recall": ["ground_truth"],
     }
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         metrics: List[Metric],
@@ -220,15 +218,11 @@ class OfflineMetrics:
             default_metric._check_duplicates_polars(recommendations)
         unchanged_recs = recommendations
 
-        # pylint: disable=too-many-function-args
-        result_dict["default"] = default_metric._get_enriched_recommendations(
-            recommendations, ground_truth
-        )
+        result_dict["default"] = default_metric._get_enriched_recommendations(recommendations, ground_truth)
 
         for metric in self.metrics:
             # find Coverage
             if metric.__class__.__name__ == "Coverage":
-                # pylint: disable=protected-access
                 result_dict["Coverage"] = Coverage(
                     topk=2,
                     query_column=query_column,
@@ -244,9 +238,7 @@ class OfflineMetrics:
                     item_column=item_column,
                     rating_column=rating_column,
                 )
-                cur_recs = novelty_metric._get_enriched_recommendations(
-                    unchanged_recs, train
-                )
+                cur_recs = novelty_metric._get_enriched_recommendations(unchanged_recs, train)
                 if is_spark:
                     cur_recs = cur_recs.withColumnRenamed("ground_truth", "train")
                 else:
@@ -265,12 +257,10 @@ class OfflineMetrics:
 
         return result_dict, train
 
-    # pylint: disable=no-self-use
     def _cache_dataframes(self, dataframes: Dict[str, SparkDataFrame]) -> None:
         for data in dataframes.values():
             data.cache()
 
-    # pylint: disable=no-self-use
     def _unpersist_dataframes(self, dataframes: Dict[str, SparkDataFrame]) -> None:
         for data in dataframes.values():
             data.unpersist()
@@ -294,22 +284,18 @@ class OfflineMetrics:
             else:
                 metric_args["recs"] = enriched_recs_dict["default"]
 
-            # pylint: disable=protected-access
             if is_spark:
                 result.update(metric._spark_compute(**metric_args))
             else:
                 result.update(metric._polars_compute(**metric_args))
         return result
 
-    # pylint: disable=no-self-use
     def _check_dataframes_types(
         self,
         recommendations: MetricsDataFrameLike,
         ground_truth: MetricsDataFrameLike,
         train: Optional[MetricsDataFrameLike],
-        base_recommendations: Optional[
-            Union[MetricsDataFrameLike, Dict[str, MetricsDataFrameLike]]
-        ],
+        base_recommendations: Optional[Union[MetricsDataFrameLike, Dict[str, MetricsDataFrameLike]]],
     ) -> None:
         types = set()
         types.add(type(recommendations))
@@ -317,7 +303,7 @@ class OfflineMetrics:
         if train is not None:
             types.add(type(train))
         if isinstance(base_recommendations, dict):
-            for _, df in base_recommendations.items():
+            for df in base_recommendations.values():
                 if not isinstance(df, list):
                     types.add(type(df))
                 else:
@@ -327,7 +313,8 @@ class OfflineMetrics:
             types.add(type(base_recommendations))
 
         if len(types) != 1:
-            raise ValueError("All given data frames must have the same type")
+            msg = "All given data frames must have the same type"
+            raise ValueError(msg)
 
     def _check_query_column_present(
         self,
@@ -350,7 +337,8 @@ class OfflineMetrics:
             dataset_names = dataset.columns
 
         if not isinstance(dataset, dict) and query_column not in dataset_names:
-            raise KeyError(f"Query column {query_column} is not present in {dataset_name} dataframe")
+            msg = f"Query column {query_column} is not present in {dataset_name} dataframe"
+            raise KeyError(msg)
 
     def _get_unique_queries(
         self,
@@ -386,14 +374,12 @@ class OfflineMetrics:
         if queries.issubset(other_queries) is False:
             warnings.warn(f"{dataset_name} contains queries that are not presented in recommendations")
 
-    def __call__(  # pylint: disable=too-many-branches, too-many-locals, too-many-statements
+    def __call__(  # noqa: C901
         self,
         recommendations: MetricsDataFrameLike,
         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,
     ) -> Dict[str, float]:
         """
         Compute metrics.
@@ -424,9 +410,7 @@ class OfflineMetrics:
 
         :return: metric values
         """
-        self._check_dataframes_types(
-            recommendations, ground_truth, train, base_recommendations
-        )
+        self._check_dataframes_types(recommendations, ground_truth, train, base_recommendations)
 
         if len(self.main_metrics) > 0:
             query_column = self.main_metrics[0].query_column
@@ -443,31 +427,22 @@ class OfflineMetrics:
 
         if train is not None:
             self._check_query_column_present(train, query_column, "train")
-            self._check_contains(
-                recs_queries,
-                self._get_unique_queries(train, query_column),
-                "train"
-            )
+            self._check_contains(recs_queries, self._get_unique_queries(train, query_column), "train")
         if base_recommendations is not None:
-            if (not isinstance(base_recommendations, dict)
-                    or isinstance(next(iter(base_recommendations.values())), list)):
+            if not isinstance(base_recommendations, dict) or isinstance(
+                next(iter(base_recommendations.values())), list
+            ):
                 base_recommendations = {"base_recommendations": base_recommendations}
             for name, dataset in base_recommendations.items():
                 self._check_query_column_present(dataset, query_column, name)
-                self._check_contains(
-                    recs_queries,
-                    self._get_unique_queries(dataset, query_column),
-                    name
-                )
+                self._check_contains(recs_queries, self._get_unique_queries(dataset, query_column), name)
 
         result = {}
         if isinstance(recommendations, (SparkDataFrame, PolarsDataFrame)):
             is_spark = isinstance(recommendations, SparkDataFrame)
             assert isinstance(ground_truth, type(recommendations))
             assert train is None or isinstance(train, type(recommendations))
-            enriched_recs_dict, train = self._get_enriched_recommendations(
-                recommendations, ground_truth, train
-            )
+            enriched_recs_dict, train = self._get_enriched_recommendations(recommendations, ground_truth, train)
 
             if is_spark and self._allow_caching:
                 self._cache_dataframes(enriched_recs_dict)
@@ -480,12 +455,8 @@ class OfflineMetrics:
                 "train": train,
             }
             for metric in self.metrics:
-                args_to_call: Dict[str, Union[PandasDataFrame, Dict]] = {
-                    "recommendations": recommendations
-                }
-                for data_name in self._metrics_call_requirement_map[
-                    str(metric.__class__.__name__)
-                ]:
+                args_to_call: Dict[str, Union[PandasDataFrame, Dict]] = {"recommendations": recommendations}
+                for data_name in self._metrics_call_requirement_map[str(metric.__class__.__name__)]:
                     args_to_call[data_name] = current_map[data_name]
                 result.update(metric(**args_to_call))
         unexpectedness_result = {}
@@ -493,23 +464,17 @@ class OfflineMetrics:
 
         if len(self.unexpectedness_metric) != 0:
             if base_recommendations is None:
-                raise ValueError(
-                    "Can not calculate Unexpectedness because base_recommendations is None"
-                )
-            if isinstance(base_recommendations, dict) and not isinstance(
-                list(base_recommendations.values())[0], list
-            ):
+                msg = "Can not calculate Unexpectedness because base_recommendations is None"
+                raise ValueError(msg)
+            first_element = next(iter(base_recommendations.values()))
+            if isinstance(base_recommendations, dict) and not isinstance(first_element, list):
                 for unexp in self.unexpectedness_metric:
                     for model_name in base_recommendations:
-                        cur_result = unexp(
-                            recommendations, base_recommendations[model_name]
-                        )
+                        cur_result = unexp(recommendations, base_recommendations[model_name])
                         for metric_name in cur_result:
                             splitted = metric_name.split("@")
                             splitted[0] += "_" + model_name
-                            unexpectedness_result["@".join(splitted)] = cur_result[
-                                metric_name
-                            ]
+                            unexpectedness_result["@".join(splitted)] = cur_result[metric_name]
 
         if len(self.diversity_metric) != 0:
             for diversity in self.diversity_metric:

replay/metrics/precision.py

@@ -3,16 +3,15 @@ from typing import List
 from .base_metric import Metric
 
 
-# pylint: disable=too-few-public-methods
 class Precision(Metric):
     """
     Mean percentage of relevant items among top ``K`` recommendations.
 
     .. math::
-        Precision@K(i) = \\frac {\sum_{j=1}^{K}\mathbb{1}_{r_{ij}}}{K}
+        Precision@K(i) = \\frac {\\sum_{j=1}^{K}\\mathbb{1}_{r_{ij}}}{K}
 
     .. math::
-        Precision@K = \\frac {\sum_{i=1}^{N}Precision@K(i)}{N}
+        Precision@K = \\frac {\\sum_{i=1}^{N}Precision@K(i)}{N}
 
     :math:`\\mathbb{1}_{r_{ij}}` -- indicator function showing that user :math:`i` interacted with item :math:`j`
 
@@ -62,9 +61,7 @@ class Precision(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/recall.py

@@ -3,7 +3,6 @@ from typing import List
 from .base_metric import Metric
 
 
-# pylint: disable=too-few-public-methods
 class Recall(Metric):
     """
     Recall measures the coverage of the recommended items, and is defined as:
@@ -11,10 +10,10 @@ class Recall(Metric):
     Mean percentage of relevant items, that was shown among top ``K`` recommendations.
 
     .. math::
-        Recall@K(i) = \\frac {\sum_{j=1}^{K}\mathbb{1}_{r_{ij}}}{|Rel_i|}
+        Recall@K(i) = \\frac {\\sum_{j=1}^{K}\\mathbb{1}_{r_{ij}}}{|Rel_i|}
 
     .. math::
-        Recall@K = \\frac {\sum_{i=1}^{N}Recall@K(i)}{N}
+        Recall@K = \\frac {\\sum_{i=1}^{N}Recall@K(i)}{N}
 
     :math:`\\mathbb{1}_{r_{ij}}` -- indicator function showing that user :math:`i` interacted with item :math:`j`
 
@@ -66,9 +65,7 @@ class Recall(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/rocauc.py

@@ -3,7 +3,6 @@ from typing import List
 from .base_metric import Metric
 
 
-# pylint: disable=too-few-public-methods
 class RocAuc(Metric):
     """
     Receiver Operating Characteristic/Area Under the Curve is the aggregated performance measure,
@@ -13,21 +12,21 @@ class RocAuc(Metric):
     The bigger the value of AUC, the better the classification model.
 
     .. math::
-        ROCAUC@K(i) = \\frac {\sum_{s=1}^{K}\sum_{t=1}^{K}
-        \mathbb{1}_{r_{si}<r_{ti}}
-        \mathbb{1}_{gt_{si}<gt_{ti}}}
-        {\sum_{s=1}^{K}\sum_{t=1}^{K} \mathbb{1}_{gt_{si}<gt_{tj}}}
+        ROCAUC@K(i) = \\frac {\\sum_{s=1}^{K}\\sum_{t=1}^{K}
+        \\mathbb{1}_{r_{si}<r_{ti}}
+        \\mathbb{1}_{gt_{si}<gt_{ti}}}
+        {\\sum_{s=1}^{K}\\sum_{t=1}^{K} \\mathbb{1}_{gt_{si}<gt_{tj}}}
 
     :math:`\\mathbb{1}_{r_{si}<r_{ti}}` -- indicator function showing that recommendation score for
     user :math:`i` for item :math:`s` is bigger than for item :math:`t`
 
-    :math:`\mathbb{1}_{gt_{si}<gt_{ti}}` --  indicator function showing that
+    :math:`\\mathbb{1}_{gt_{si}<gt_{ti}}` --  indicator function showing that
     user :math:`i` values item :math:`s` more than item :math:`t`.
 
     Metric is averaged by all users.
 
     .. math::
-        ROCAUC@K = \\frac {\sum_{i=1}^{N}ROCAUC@K(i)}{N}
+        ROCAUC@K = \\frac {\\sum_{i=1}^{N}ROCAUC@K(i)}{N}
 
     >>> recommendations
        query_id  item_id  rating
@@ -75,9 +74,7 @@ class RocAuc(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/surprisal.py

@@ -4,7 +4,7 @@ from typing import Dict, List, Union
 import numpy as np
 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, MetricsReturnType
 
@@ -12,13 +12,12 @@ if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
 
 
-# pylint: disable=too-few-public-methods
 class Surprisal(Metric):
     """
     Measures how many surprising rare items are present in recommendations.
 
     .. math::
-        \\textit{Self-Information}(j)= -\log_2 \\frac {u_j}{N}
+        \\textit{Self-Information}(j)= -\\log_2 \\frac {u_j}{N}
 
     :math:`u_j` -- number of users that interacted with item :math:`j`.
     Cold items are treated as if they were rated by 1 user.
@@ -32,12 +31,12 @@ class Surprisal(Metric):
     Recommendation list surprisal is the average surprisal of items in it.
 
     .. math::
-        Surprisal@K(i) = \\frac {\sum_{j=1}^{K}Surprisal(j)} {K}
+        Surprisal@K(i) = \\frac {\\sum_{j=1}^{K}Surprisal(j)} {K}
 
     Final metric is averaged by users.
 
     .. math::
-        Surprisal@K = \\frac {\sum_{i=1}^{N}Surprisal@K(i)}{N}
+        Surprisal@K = \\frac {\\sum_{i=1}^{N}Surprisal@K(i)}{N}
 
     :math:`N` -- the number of users.
 
@@ -83,7 +82,6 @@ class Surprisal(Metric):
     <BLANKLINE>
     """
 
-    # pylint: disable=no-self-use
     def _get_weights(self, train: Dict) -> Dict:
         n_users = len(train.keys())
         items_counter = defaultdict(set)
@@ -102,7 +100,6 @@ class Surprisal(Metric):
             recs_with_weights[user] = [weights.get(i, 1) for i in items]
         return recs_with_weights
 
-    # pylint: disable=arguments-renamed
     def _get_enriched_recommendations(
         self,
         recommendations: Union[PolarsDataFrame, SparkDataFrame],
@@ -113,38 +110,28 @@ class Surprisal(Metric):
         else:
             return self._get_enriched_recommendations_polars(recommendations, train)
 
-    def _get_enriched_recommendations_spark(  # pylint: disable=arguments-renamed
+    def _get_enriched_recommendations_spark(
         self, recommendations: SparkDataFrame, train: SparkDataFrame
     ) -> SparkDataFrame:
         n_users = train.select(self.query_column).distinct().count()
         item_weights = train.groupby(self.item_column).agg(
-            (
-                sf.log2(n_users / sf.countDistinct(self.query_column)) / np.log2(n_users)
-            ).alias("weight")
+            (sf.log2(n_users / sf.countDistinct(self.query_column)) / np.log2(n_users)).alias("weight")
         )
-        recommendations = recommendations.join(
-            item_weights, on=self.item_column, how="left"
-        ).fillna(1.0)
+        recommendations = recommendations.join(item_weights, on=self.item_column, how="left").fillna(1.0)
 
-        sorted_by_score_recommendations = self._get_items_list_per_user(
-            recommendations, "weight"
-        )
+        sorted_by_score_recommendations = self._get_items_list_per_user(recommendations, "weight")
         return self._rearrange_columns(sorted_by_score_recommendations)
 
-    def _get_enriched_recommendations_polars(  # pylint: disable=arguments-renamed
+    def _get_enriched_recommendations_polars(
         self, recommendations: PolarsDataFrame, train: PolarsDataFrame
     ) -> PolarsDataFrame:
         n_users = train.select(self.query_column).n_unique()
         item_weights = train.group_by(self.item_column).agg(
             (np.log2(n_users / pl.col(self.query_column).n_unique()) / np.log2(n_users)).alias("weight")
         )
-        recommendations = recommendations.join(
-            item_weights, on=self.item_column, how="left"
-        ).fill_nan(1.0)
+        recommendations = recommendations.join(item_weights, on=self.item_column, how="left").fill_nan(1.0)
 
-        sorted_by_score_recommendations = self._get_items_list_per_user(
-            recommendations, "weight"
-        )
+        sorted_by_score_recommendations = self._get_items_list_per_user(recommendations, "weight")
         return self._rearrange_columns(sorted_by_score_recommendations)
 
     def __call__(
@@ -183,9 +170,7 @@ class Surprisal(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)
 
         weights = self._get_recommendation_weights(recommendations, train)
@@ -196,9 +181,7 @@ class Surprisal(Metric):
         )
 
     @staticmethod
-    def _get_metric_value_by_user(  # pylint: disable=arguments-differ
-        ks: List[int], pred_item_ids: List, pred_weights: List
-    ) -> List[float]:
+    def _get_metric_value_by_user(ks: List[int], pred_item_ids: List, pred_weights: List) -> List[float]:
         if not pred_item_ids:
             return [0.0 for _ in ks]
         res = []

replay/metrics/torch_metrics_builder.py

@@ -28,7 +28,6 @@ DEFAULT_METRICS: List[MetricName] = [
 DEFAULT_KS: List[int] = [1, 5, 10, 20]
 
 
-# pylint: disable=too-many-instance-attributes
 @dataclass
 class _MetricRequirements:
     """
@@ -113,7 +112,6 @@ class _CoverageHelper:
         self._train_hist = torch.zeros(self.item_count)
         self._pred_hist: Dict[int, torch.Tensor] = {k: torch.zeros(self.item_count) for k in self._top_k}
 
-    # pylint: disable=attribute-defined-outside-init
     def _ensure_hists_on_device(self, device: torch.device) -> None:
         self._train_hist = self._train_hist.to(device)
         for k in self._top_k:
@@ -192,13 +190,11 @@ class _MetricBuilder(abc.ABC):
         """
 
 
-# pylint: disable=too-many-instance-attributes
 class TorchMetricsBuilder(_MetricBuilder):
     """
     Computes specified metrics over multiple batches
     """
 
-    # pylint: disable=dangerous-default-value
     def __init__(
         self,
         metrics: List[MetricName] = DEFAULT_METRICS,

replay/metrics/unexpectedness.py

@@ -1,11 +1,10 @@
 from typing import List, Optional, Union
 
-from replay.utils import PandasDataFrame, SparkDataFrame, PolarsDataFrame
+from replay.utils import PandasDataFrame, PolarsDataFrame, SparkDataFrame
 
 from .base_metric import Metric, MetricsDataFrameLike, MetricsReturnType
 
 
-# pylint: disable=too-few-public-methods
 class Unexpectedness(Metric):
     """
     Fraction of recommended items that are not present in some baseline\
@@ -13,11 +12,12 @@ class Unexpectedness(Metric):
 
     .. math::
         Unexpectedness@K(i) = 1 -
-            \\frac {\parallel R^{i}_{1..\min(K, \parallel R^{i} \parallel)} \cap BR^{i}_{1..\min(K, \parallel BR^{i} \parallel)} \parallel}
+            \\frac {\\parallel R^{i}_{1..\\min(K, \\parallel R^{i} \\parallel)}
+            \\cap BR^{i}_{1..\\min(K, \\parallel BR^{i} \\parallel)} \\parallel}
             {K}
 
     .. math::
-        Unexpectedness@K = \\frac {1}{N}\sum_{i=1}^{N}Unexpectedness@K(i)
+        Unexpectedness@K = \\frac {1}{N}\\sum_{i=1}^{N}Unexpectedness@K(i)
 
     :math:`R_{1..j}^{i}` -- the first :math:`j` recommendations for the :math:`i`-th user.
 
@@ -61,7 +61,7 @@ class Unexpectedness(Metric):
      'Unexpectedness-ConfidenceInterval@4': 0.0}
     <BLANKLINE>
     """
-    # pylint: disable=arguments-renamed
+
     def _get_enriched_recommendations(
         self,
         recommendations: Union[PolarsDataFrame, SparkDataFrame],
@@ -72,14 +72,14 @@ class Unexpectedness(Metric):
         else:
             return self._get_enriched_recommendations_polars(recommendations, base_recommendations)
 
-    def _get_enriched_recommendations_spark(  # pylint: disable=arguments-renamed
+    def _get_enriched_recommendations_spark(
         self, recommendations: SparkDataFrame, base_recommendations: SparkDataFrame
     ) -> SparkDataFrame:
         sorted_by_score_recommendations = self._get_items_list_per_user(recommendations)
 
-        sorted_by_score_base_recommendations = self._get_items_list_per_user(
-            base_recommendations
-        ).withColumnRenamed("pred_item_id", "base_pred_item_id")
+        sorted_by_score_base_recommendations = self._get_items_list_per_user(base_recommendations).withColumnRenamed(
+            "pred_item_id", "base_pred_item_id"
+        )
 
         enriched_recommendations = sorted_by_score_recommendations.join(
             sorted_by_score_base_recommendations, how="left", on=self.query_column
@@ -87,14 +87,14 @@ class Unexpectedness(Metric):
 
         return self._rearrange_columns(enriched_recommendations)
 
-    def _get_enriched_recommendations_polars(  # pylint: disable=arguments-renamed
+    def _get_enriched_recommendations_polars(
         self, recommendations: PolarsDataFrame, base_recommendations: PolarsDataFrame
     ) -> PolarsDataFrame:
         sorted_by_score_recommendations = self._get_items_list_per_user(recommendations)
 
-        sorted_by_score_base_recommendations = self._get_items_list_per_user(
-            base_recommendations
-        ).rename({"pred_item_id": "base_pred_item_id"})
+        sorted_by_score_base_recommendations = self._get_items_list_per_user(base_recommendations).rename(
+            {"pred_item_id": "base_pred_item_id"}
+        )
 
         enriched_recommendations = sorted_by_score_recommendations.join(
             sorted_by_score_base_recommendations, how="left", on=self.query_column
@@ -152,12 +152,7 @@ class Unexpectedness(Metric):
         )
 
     @staticmethod
-    def _get_metric_value_by_user(  # pylint: disable=arguments-differ
-        ks: List[int], base_recs: Optional[List], recs: Optional[List]
-    ) -> List[float]:
+    def _get_metric_value_by_user(ks: List[int], base_recs: Optional[List], recs: Optional[List]) -> List[float]:
         if not base_recs or not recs:
             return [0.0 for _ in ks]
-        res = []
-        for k in ks:
-            res.append(1.0 - len(set(recs[:k]) & set(base_recs[:k])) / k)
-        return res
+        return [1.0 - len(set(recs[:k]) & set(base_recs[:k])) / k for k in ks]

replay/models/__init__.py

@@ -12,6 +12,7 @@ from .association_rules import AssociationRulesItemRec
 from .base_rec import Recommender
 from .cat_pop_rec import CatPopRec
 from .cluster import ClusterRec
+from .kl_ucb import KLUCB
 from .knn import ItemKNN
 from .pop_rec import PopRec
 from .query_pop_rec import QueryPopRec
@@ -19,7 +20,5 @@ from .random_rec import RandomRec
 from .slim import SLIM
 from .thompson_sampling import ThompsonSampling
 from .ucb import UCB
-# pylint: disable=cyclic-import
-from .kl_ucb import KLUCB
 from .wilson import Wilson
 from .word2vec import Word2VecRec

replay/models/als.py

@@ -2,9 +2,10 @@ from os.path import join
 from typing import Optional, Tuple
 
 from replay.data import Dataset
-from .base_rec import ItemVectorModel, Recommender
 from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame
 
+from .base_rec import ItemVectorModel, Recommender
+
 if PYSPARK_AVAILABLE:
     import pyspark.sql.functions as sf
     from pyspark.ml.recommendation import ALS, ALSModel
@@ -13,7 +14,6 @@ if PYSPARK_AVAILABLE:
     from replay.utils.spark_utils import list_to_vector_udf
 
 
-# pylint: disable=too-many-instance-attributes
 class ALSWrap(Recommender, ItemVectorModel):
     """Wrapper for `Spark ALS
     <https://spark.apache.org/docs/latest/api/python/pyspark.mllib.html#pyspark.mllib.recommendation.ALS>`_.
@@ -24,7 +24,6 @@ class ALSWrap(Recommender, ItemVectorModel):
         "rank": {"type": "loguniform_int", "args": [8, 256]},
     }
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         rank: int = 10,
@@ -98,7 +97,6 @@ class ALSWrap(Recommender, ItemVectorModel):
             self.model.itemFactors.unpersist()
             self.model.userFactors.unpersist()
 
-    # pylint: disable=too-many-arguments
     def _predict(
         self,
         dataset: Optional[Dataset],
@@ -107,10 +105,8 @@ class ALSWrap(Recommender, ItemVectorModel):
         items: SparkDataFrame,
         filter_seen_items: bool = True,
     ) -> SparkDataFrame:
-
         if (items.count() == self.fit_items.count()) and (
-            items.join(self.fit_items, on=self.item_column, how="inner").count()
-            == self.fit_items.count()
+            items.join(self.fit_items, on=self.item_column, how="inner").count() == self.fit_items.count()
         ):
             max_seen = 0
             if filter_seen_items and dataset is not None:
@@ -125,9 +121,7 @@ class ALSWrap(Recommender, ItemVectorModel):
 
             recs_als = self.model.recommendForUserSubset(queries, k + max_seen)
             return (
-                recs_als.withColumn(
-                    "recommendations", sf.explode("recommendations")
-                )
+                recs_als.withColumn("recommendations", sf.explode("recommendations"))
                 .withColumn(self.item_column, sf.col(f"recommendations.{self.item_column}"))
                 .withColumn(
                     self.rating_column,
@@ -144,7 +138,7 @@ class ALSWrap(Recommender, ItemVectorModel):
     def _predict_pairs(
         self,
         pairs: SparkDataFrame,
-        dataset: Optional[Dataset] = None,
+        dataset: Optional[Dataset] = None,  # noqa: ARG002
     ) -> SparkDataFrame:
         return (
             self.model.transform(pairs)
@@ -153,15 +147,13 @@ class ALSWrap(Recommender, ItemVectorModel):
         )
 
     def _get_features(
-        self, ids: SparkDataFrame, features: Optional[SparkDataFrame]
+        self, ids: SparkDataFrame, features: Optional[SparkDataFrame]  # noqa: ARG002
     ) -> Tuple[Optional[SparkDataFrame], Optional[int]]:
         entity = "user" if self.query_column in ids.columns else "item"
         entity_col = self.query_column if self.query_column in ids.columns else self.item_column
 
         als_factors = getattr(self.model, f"{entity}Factors")
-        als_factors = als_factors.withColumnRenamed(
-            "id", entity_col
-        ).withColumnRenamed("features", f"{entity}_factors")
+        als_factors = als_factors.withColumnRenamed("id", entity_col).withColumnRenamed("features", f"{entity}_factors")
         return (
             als_factors.join(ids, how="right", on=entity_col),
             self.model.rank,