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

replay/models/random_rec.py

@@ -1,9 +1,10 @@
 from typing import Optional
 
 from replay.data import Dataset
-from .base_rec import NonPersonalizedRecommender
 from replay.utils import PYSPARK_AVAILABLE
 
+from .base_rec import NonPersonalizedRecommender
+
 if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
 
@@ -130,7 +131,6 @@ class RandomRec(NonPersonalizedRecommender):
     }
     sample: bool = True
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         distribution: str = "uniform",
@@ -159,17 +159,15 @@ class RandomRec(NonPersonalizedRecommender):
             `Cold_weight` value should be in interval (0, 1].
         """
         if distribution not in ("popular_based", "relevance", "uniform"):
-            raise ValueError(
-                "distribution can be one of [popular_based, relevance, uniform]"
-            )
+            msg = "distribution can be one of [popular_based, relevance, uniform]"
+            raise ValueError(msg)
         if alpha <= -1.0 and distribution == "popular_based":
-            raise ValueError("alpha must be bigger than -1")
+            msg = "alpha must be bigger than -1"
+            raise ValueError(msg)
         self.distribution = distribution
         self.alpha = alpha
         self.seed = seed
-        super().__init__(
-            add_cold_items=add_cold_items, cold_weight=cold_weight
-        )
+        super().__init__(add_cold_items=add_cold_items, cold_weight=cold_weight)
 
     @property
     def _init_args(self):
@@ -193,10 +191,7 @@ class RandomRec(NonPersonalizedRecommender):
                 .agg(sf.countDistinct(self.query_column).alias("user_count"))
                 .select(
                     sf.col(self.item_column),
-                    (
-                        sf.col("user_count").astype("float")
-                        + sf.lit(self.alpha)
-                    ).alias(self.rating_column),
+                    (sf.col("user_count").astype("float") + sf.lit(self.alpha)).alias(self.rating_column),
                 )
             )
         elif self.distribution == "relevance":
@@ -207,14 +202,11 @@ class RandomRec(NonPersonalizedRecommender):
             )
         else:
             self.item_popularity = (
-                dataset.interactions.select(self.item_column)
-                .distinct()
-                .withColumn(self.rating_column, sf.lit(1.0))
+                dataset.interactions.select(self.item_column).distinct().withColumn(self.rating_column, sf.lit(1.0))
             )
         self.item_popularity = self.item_popularity.withColumn(
             self.rating_column,
-            sf.col(self.rating_column)
-            / self.item_popularity.agg(sf.sum(self.rating_column)).first()[0],
+            sf.col(self.rating_column) / self.item_popularity.agg(sf.sum(self.rating_column)).first()[0],
         )
         self.item_popularity.cache().count()
         self.fill = self._calc_fill(self.item_popularity, self.cold_weight, self.rating_column)

replay/models/slim.py

@@ -6,17 +6,17 @@ from scipy.sparse import csc_matrix
 from sklearn.linear_model import ElasticNet
 
 from replay.data import Dataset
-from .base_neighbour_rec import NeighbourRec
-from .extensions.ann.index_builders.base_index_builder import IndexBuilder
 from replay.utils import PYSPARK_AVAILABLE
 from replay.utils.session_handler import State
 from replay.utils.spark_utils import spark_to_pandas
 
+from .base_neighbour_rec import NeighbourRec
+from .extensions.ann.index_builders.base_index_builder import IndexBuilder
+
 if PYSPARK_AVAILABLE:
     from pyspark.sql import types as st
 
 
-# pylint: disable=too-many-ancestors, too-many-instance-attributes
 class SLIM(NeighbourRec):
     """`SLIM: Sparse Linear Methods for Top-N Recommender Systems
     <http://glaros.dtc.umn.edu/gkhome/fetch/papers/SLIM2011icdm.pdf>`_"""
@@ -31,7 +31,6 @@ class SLIM(NeighbourRec):
         "lambda_": {"type": "loguniform", "args": [1e-6, 2]},
     }
 
-    # pylint: disable=R0913
     def __init__(
         self,
         beta: float = 0.01,
@@ -50,7 +49,8 @@ class SLIM(NeighbourRec):
             Default: ``False``.
         """
         if beta < 0 or lambda_ <= 0:
-            raise ValueError("Invalid regularization parameters")
+            msg = "Invalid regularization parameters"
+            raise ValueError(msg)
         self.beta = beta
         self.lambda_ = lambda_
         self.seed = seed
@@ -74,10 +74,7 @@ class SLIM(NeighbourRec):
         self,
         dataset: Dataset,
     ) -> None:
-        interactions = (
-            dataset.interactions
-            .select(self.query_column, self.item_column, self.rating_column)
-        )
+        interactions = dataset.interactions.select(self.query_column, self.item_column, self.rating_column)
         pandas_interactions = spark_to_pandas(interactions, self.allow_collect_to_master)
         interactions_matrix = csc_matrix(
             (
@@ -108,7 +105,7 @@ class SLIM(NeighbourRec):
             positive=True,
         )
 
-        def slim_column(pandas_df: pd.DataFrame) -> pd.DataFrame:   # pragma: no cover
+        def slim_column(pandas_df: pd.DataFrame) -> pd.DataFrame:  # pragma: no cover
             """
             fit similarity matrix with ElasticNet
             :param pandas_df: pd.Dataframe
@@ -117,9 +114,7 @@ class SLIM(NeighbourRec):
             idx = int(pandas_df["item_idx_one"][0])
             column = interactions_matrix[:, idx]
             column_arr = column.toarray().ravel()
-            interactions_matrix[
-                interactions_matrix[:, idx].nonzero()[0], idx
-            ] = 0
+            interactions_matrix[interactions_matrix[:, idx].nonzero()[0], idx] = 0
 
             regression.fit(interactions_matrix, column_arr)
             interactions_matrix[:, idx] = column

replay/models/thompson_sampling.py

@@ -3,9 +3,10 @@ from typing import Optional
 import numpy as np
 
 from replay.data.dataset import Dataset
-from .base_rec import NonPersonalizedRecommender
 from replay.utils import PYSPARK_AVAILABLE
 
+from .base_rec import NonPersonalizedRecommender
+
 if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
 
@@ -19,6 +20,7 @@ class ThompsonSampling(NonPersonalizedRecommender):
     The reward probability of each of the K arms is modeled by a Beta distribution
     which is updated after an arm is selected. The initial prior distribution is Beta(1,1).
     """
+
     def __init__(
         self,
         sample: bool = False,
@@ -38,24 +40,21 @@ class ThompsonSampling(NonPersonalizedRecommender):
     ) -> None:
         self._check_rating(dataset)
 
-        num_positive = dataset.interactions.filter(
-            sf.col(self.rating_column) == sf.lit(1)
-        ).groupby(self.item_column).agg(
-            sf.count(self.rating_column).alias("positive")
+        num_positive = (
+            dataset.interactions.filter(sf.col(self.rating_column) == sf.lit(1))
+            .groupby(self.item_column)
+            .agg(sf.count(self.rating_column).alias("positive"))
         )
-        num_negative = dataset.interactions.filter(
-            sf.col(self.rating_column) == sf.lit(0)
-        ).groupby(self.item_column).agg(
-            sf.count(self.rating_column).alias("negative")
+        num_negative = (
+            dataset.interactions.filter(sf.col(self.rating_column) == sf.lit(0))
+            .groupby(self.item_column)
+            .agg(sf.count(self.rating_column).alias("negative"))
         )
 
-        self.item_popularity = num_positive.join(
-            num_negative, how="inner", on=self.item_column
-        )
+        self.item_popularity = num_positive.join(num_negative, how="inner", on=self.item_column)
 
         self.item_popularity = self.item_popularity.withColumn(
-            self.rating_column,
-            sf.udf(np.random.beta, "double")("positive", "negative")
+            self.rating_column, sf.udf(np.random.beta, "double")("positive", "negative")
         ).drop("positive", "negative")
         self.item_popularity.cache().count()
         self.fill = np.random.beta(1, 1)

replay/models/ucb.py

@@ -3,9 +3,10 @@ from typing import Any, Dict, List, Optional
 
 from replay.data.dataset import Dataset
 from replay.metrics import NDCG, Metric
-from .base_rec import NonPersonalizedRecommender
 from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame
 
+from .base_rec import NonPersonalizedRecommender
+
 if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
 
@@ -85,7 +86,6 @@ class UCB(NonPersonalizedRecommender):
             Could be changed after model training by setting the `sample` attribute.
         :param seed: random seed. Provides reproducibility if fixed
         """
-        # pylint: disable=super-init-not-called
         self.coef = exploration_coef
         self.sample = sample
         self.seed = seed
@@ -99,16 +99,15 @@ class UCB(NonPersonalizedRecommender):
             "seed": self.seed,
         }
 
-    # pylint: disable=too-many-arguments
     def optimize(
         self,
-        train_dataset: Dataset,
-        test_dataset: Dataset,
-        param_borders: Optional[Dict[str, List[Any]]] = None,
-        criterion: Metric = NDCG,
-        k: int = 10,
-        budget: int = 10,
-        new_study: bool = True,
+        train_dataset: Dataset,  # noqa: ARG002
+        test_dataset: Dataset,  # noqa: ARG002
+        param_borders: Optional[Dict[str, List[Any]]] = None,  # noqa: ARG002
+        criterion: Metric = NDCG,  # noqa: ARG002
+        k: int = 10,  # noqa: ARG002
+        budget: int = 10,  # noqa: ARG002
+        new_study: bool = True,  # noqa: ARG002
     ) -> None:
         """
         Searches best parameters with optuna.
@@ -126,15 +125,13 @@ class UCB(NonPersonalizedRecommender):
         :return: dictionary with best parameters
         """
         self.logger.warning(
-            "The UCB model has only exploration coefficient parameter, "
-            "which cannot not be directly optimized"
+            "The UCB model has only exploration coefficient parameter, which cannot not be directly optimized"
         )
 
     def _fit(
         self,
         dataset: Dataset,
     ) -> None:
-
         self._check_rating(dataset)
 
         # we save this dataframe for the refit() method
@@ -180,17 +177,9 @@ class UCB(NonPersonalizedRecommender):
         self._calc_item_popularity()
 
     def _calc_item_popularity(self):
-
         items_counts = self.items_counts_aggr.withColumn(
             self.rating_column,
-            (
-                sf.col("pos") / sf.col("total")
-                + sf.sqrt(
-                    self.coef
-                    * sf.log(sf.lit(self.full_count))
-                    / sf.col("total")
-                )
-            ),
+            (sf.col("pos") / sf.col("total") + sf.sqrt(self.coef * sf.log(sf.lit(self.full_count)) / sf.col("total"))),
         )
 
         self.item_popularity = items_counts.drop("pos", "total")

replay/models/wilson.py

@@ -3,9 +3,10 @@ from typing import Optional
 from scipy.stats import norm
 
 from replay.data import Dataset
-from .pop_rec import PopRec
 from replay.utils import PYSPARK_AVAILABLE
 
+from .pop_rec import PopRec
+
 if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
 
@@ -50,7 +51,6 @@ class Wilson(PopRec):
 
     """
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         alpha=0.05,
@@ -82,9 +82,7 @@ class Wilson(PopRec):
         self.alpha = alpha
         self.sample = sample
         self.seed = seed
-        super().__init__(
-            add_cold_items=add_cold_items, cold_weight=cold_weight
-        )
+        super().__init__(add_cold_items=add_cold_items, cold_weight=cold_weight)
 
     @property
     def _init_args(self):
@@ -100,7 +98,6 @@ class Wilson(PopRec):
         self,
         dataset: Dataset,
     ) -> None:
-
         self._check_rating(dataset)
 
         items_counts = dataset.interactions.groupby(self.item_column).agg(
@@ -111,16 +108,10 @@ class Wilson(PopRec):
         crit = norm.isf(self.alpha / 2.0)
         items_counts = items_counts.withColumn(
             self.rating_column,
-            (sf.col("pos") + sf.lit(0.5 * crit**2))
-            / (sf.col("total") + sf.lit(crit**2))
+            (sf.col("pos") + sf.lit(0.5 * crit**2)) / (sf.col("total") + sf.lit(crit**2))
             - sf.lit(crit)
             / (sf.col("total") + sf.lit(crit**2))
-            * sf.sqrt(
-                (sf.col("total") - sf.col("pos"))
-                * sf.col("pos")
-                / sf.col("total")
-                + crit**2 / 4
-            ),
+            * sf.sqrt((sf.col("total") - sf.col("pos")) * sf.col("pos") / sf.col("total") + crit**2 / 4),
         )
 
         self.item_popularity = items_counts.drop("pos", "total")

replay/models/word2vec.py

@@ -1,22 +1,24 @@
 from typing import Any, Dict, Optional
 
 from replay.data import Dataset
+from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame
+
 from .base_rec import ItemVectorModel, Recommender
 from .extensions.ann.ann_mixin import ANNMixin
 from .extensions.ann.index_builders.base_index_builder import IndexBuilder
-from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame
 
 if PYSPARK_AVAILABLE:
     from pyspark.ml.feature import Word2Vec
     from pyspark.ml.functions import vector_to_array
     from pyspark.ml.stat import Summarizer
-    from pyspark.sql import functions as sf
-    from pyspark.sql import types as st
+    from pyspark.sql import (
+        functions as sf,
+        types as st,
+    )
 
     from replay.utils.spark_utils import join_with_col_renaming, multiply_scala_udf, vector_dot
 
 
-# pylint: disable=too-many-instance-attributes, too-many-ancestors
 class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
     """
     Trains word2vec model where items are treated as words and queries as sentences.
@@ -31,29 +33,18 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
     def _get_vectors_to_infer_ann_inner(self, interactions: SparkDataFrame, queries: SparkDataFrame) -> SparkDataFrame:
         query_vectors = self._get_query_vectors(queries, interactions)
         # converts to pandas_udf compatible format
-        query_vectors = query_vectors.select(
-            self.query_column, vector_to_array("query_vector").alias("query_vector")
-        )
+        query_vectors = query_vectors.select(self.query_column, vector_to_array("query_vector").alias("query_vector"))
         return query_vectors
 
     def _get_ann_build_params(self, interactions: SparkDataFrame) -> Dict[str, Any]:
         self.index_builder.index_params.dim = self.rank
         self.index_builder.index_params.max_elements = interactions.select(self.item_column).distinct().count()
         self.logger.debug("index 'num_elements' = %s", self.num_elements)
-        return {
-            "features_col": "item_vector",
-            "ids_col": self.item_column
-        }
+        return {"features_col": "item_vector", "ids_col": self.item_column}
 
-    def _get_vectors_to_build_ann(self, interactions: SparkDataFrame) -> SparkDataFrame:
+    def _get_vectors_to_build_ann(self, interactions: SparkDataFrame) -> SparkDataFrame:  # noqa: ARG002
         item_vectors = self._get_item_vectors()
-        item_vectors = (
-            item_vectors
-            .select(
-                self.item_column,
-                vector_to_array("item_vector").alias("item_vector")
-            )
-        )
+        item_vectors = item_vectors.select(self.item_column, vector_to_array("item_vector").alias("item_vector"))
         return item_vectors
 
     idf: SparkDataFrame
@@ -66,7 +57,6 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         "use_idf": {"type": "categorical", "args": [True, False]},
     }
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         rank: int = 100,
@@ -120,14 +110,6 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         }
 
     def _save_model(self, path: str, additional_params: Optional[dict] = None):
-        # # create directory on shared disk or in HDFS
-        # path_info = get_filesystem(path)
-        # destination_filesystem, target_dir_path = fs.FileSystem.from_uri(
-        #     path_info.hdfs_uri + path_info.path
-        #     if path_info.filesystem == FileSystem.HDFS
-        #     else path_info.path
-        # )
-        # destination_filesystem.create_dir(target_dir_path)
         super()._save_model(path, additional_params)
         if self.index_builder:
             self._save_index(path)
@@ -146,9 +128,7 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
             .agg(sf.countDistinct(self.query_column).alias("count"))
             .withColumn(
                 "idf",
-                sf.log(sf.lit(self.queries_count) / sf.col("count"))
-                if self.use_idf
-                else sf.lit(1.0),
+                sf.log(sf.lit(self.queries_count) / sf.col("count")) if self.use_idf else sf.lit(1.0),
             )
             .select(self.item_column, "idf")
         )
@@ -156,17 +136,11 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
 
         interactions_by_queries = (
             dataset.interactions.groupBy(self.query_column)
-            .agg(
-                sf.collect_list(sf.struct(self.timestamp_column, self.item_column)).alias(
-                    "ts_item_idx"
-                )
-            )
+            .agg(sf.collect_list(sf.struct(self.timestamp_column, self.item_column)).alias("ts_item_idx"))
             .withColumn("ts_item_idx", sf.array_sort("ts_item_idx"))
             .withColumn(
                 "items",
-                sf.col(f"ts_item_idx.{self.item_column}").cast(
-                    st.ArrayType(st.StringType())
-                ),
+                sf.col(f"ts_item_idx.{self.item_column}").cast(st.ArrayType(st.StringType())),
             )
             .drop("ts_item_idx")
         )
@@ -215,12 +189,8 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         :return: query embeddings dataframe
             ``[query_id, query_vector]``
         """
-        res = join_with_col_renaming(
-            interactions, queries, on_col_name=self.query_column, how="inner"
-        )
-        res = join_with_col_renaming(
-            res, self.idf, on_col_name=self.item_column, how="inner"
-        )
+        res = join_with_col_renaming(interactions, queries, on_col_name=self.query_column, how="inner")
+        res = join_with_col_renaming(res, self.idf, on_col_name=self.item_column, how="inner")
         res = res.join(
             self.vectors.hint("broadcast"),
             how="inner",
@@ -228,11 +198,7 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         ).drop("item")
         return (
             res.groupby(self.query_column)
-            .agg(
-                Summarizer.mean(
-                    multiply_scala_udf(sf.col("idf"), sf.col("vector"))
-                ).alias("query_vector")
-            )
+            .agg(Summarizer.mean(multiply_scala_udf(sf.col("idf"), sf.col("vector"))).alias("query_vector"))
             .select(self.query_column, "query_vector")
         )
 
@@ -242,36 +208,27 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         dataset: Dataset,
     ) -> SparkDataFrame:
         if dataset is None:
-            raise ValueError(
-                f"interactions is not provided, {self} predict requires interactions."
-            )
+            msg = f"interactions is not provided, {self} predict requires interactions."
+            raise ValueError(msg)
 
-        query_vectors = self._get_query_vectors(
-            pairs.select(self.query_column).distinct(), dataset.interactions
-        )
-        pairs_with_vectors = join_with_col_renaming(
-            pairs, query_vectors, on_col_name=self.query_column, how="inner"
-        )
+        query_vectors = self._get_query_vectors(pairs.select(self.query_column).distinct(), dataset.interactions)
+        pairs_with_vectors = join_with_col_renaming(pairs, query_vectors, on_col_name=self.query_column, how="inner")
         pairs_with_vectors = pairs_with_vectors.join(
             self.vectors, on=sf.col(self.item_column) == sf.col("item"), how="inner"
         ).drop("item")
         return pairs_with_vectors.select(
             self.query_column,
             sf.col(self.item_column),
-            (
-                vector_dot(sf.col("vector"), sf.col("query_vector"))
-                + sf.lit(self.rank)
-            ).alias(self.rating_column),
+            (vector_dot(sf.col("vector"), sf.col("query_vector")) + sf.lit(self.rank)).alias(self.rating_column),
         )
 
-    # pylint: disable=too-many-arguments
     def _predict(
         self,
         dataset: Dataset,
-        k: int,
+        k: int,  # noqa: ARG002
         queries: SparkDataFrame,
         items: SparkDataFrame,
-        filter_seen_items: bool = True,
+        filter_seen_items: bool = True,  # noqa: ARG002
     ) -> SparkDataFrame:
         return self._predict_pairs_inner(queries.crossJoin(items), dataset)
 
@@ -283,6 +240,4 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         return self._predict_pairs_inner(pairs, dataset)
 
     def _get_item_vectors(self):
-        return self.vectors.withColumnRenamed(
-            "vector", "item_vector"
-        ).withColumnRenamed("item", self.item_column)
+        return self.vectors.withColumnRenamed("vector", "item_vector").withColumnRenamed("item", self.item_column)

replay/optimization/optuna_objective.py

@@ -15,13 +15,12 @@ if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
 
 
-SplitData = collections.namedtuple(
+SplitData = collections.namedtuple(  # noqa: PYI024
     "SplitData",
     "train_dataset test_dataset queries items",
 )
 
 
-# pylint: disable=too-few-public-methods
 class ObjectiveWrapper:
     """
     This class is implemented according to
@@ -32,11 +31,7 @@ class ObjectiveWrapper:
     other arguments are passed into ``__init__``.
     """
 
-    # pylint: disable=too-many-arguments,too-many-instance-attributes
-
-    def __init__(
-        self, objective_calculator: Callable[..., float], **kwargs: Any
-    ):
+    def __init__(self, objective_calculator: Callable[..., float], **kwargs: Any):
         self.objective_calculator = objective_calculator
         self.kwargs = kwargs
 
@@ -51,7 +46,8 @@ class ObjectiveWrapper:
 
 
 def suggest_params(
-    trial: Trial, search_space: Dict[str, Dict[str, Union[str, List[Any]]]],
+    trial: Trial,
+    search_space: Dict[str, Dict[str, Union[str, List[Any]]]],
 ) -> Dict[str, Any]:
     """
     This function suggests params to try.
@@ -81,9 +77,7 @@ def suggest_params(
 
 
 def calculate_criterion_value(
-    criterion: Metric,
-    recommendations: SparkDataFrame,
-    ground_truth: SparkDataFrame
+    criterion: Metric, recommendations: SparkDataFrame, ground_truth: SparkDataFrame
 ) -> float:
     """
     Calculate criterion value for given parameters
@@ -93,11 +87,14 @@ def calculate_criterion_value(
     :return: criterion value
     """
     result_dict = criterion(recommendations, ground_truth)
-    return list(result_dict.values())[0]
+    return next(iter(result_dict.values()))
 
 
 def eval_quality(
-    split_data: SplitData, recommender, criterion: Metric, k: int,
+    split_data: SplitData,
+    recommender,
+    criterion: Metric,
+    k: int,
 ) -> float:
     """
     Calculate criterion value using model, data and criterion parameters
@@ -109,7 +106,6 @@ def eval_quality(
     """
     logger = logging.getLogger("replay")
     logger.debug("Fitting model inside optimization")
-    # pylint: disable=protected-access
     recommender._fit_wrap(
         split_data.train_dataset,
     )
@@ -126,7 +122,6 @@ def eval_quality(
     return criterion_value
 
 
-# pylint: disable=too-many-arguments
 def scenario_objective_calculator(
     trial: Trial,
     search_space: Dict[str, List[Optional[Any]]],
@@ -150,12 +145,9 @@ def scenario_objective_calculator(
     return eval_quality(split_data, recommender, criterion, k)
 
 
-MainObjective = partial(
-    ObjectiveWrapper, objective_calculator=scenario_objective_calculator
-)
+MainObjective = partial(ObjectiveWrapper, objective_calculator=scenario_objective_calculator)
 
 
-# pylint: disable=too-few-public-methods
 class ItemKNNObjective:
     """
     This class is implemented according to
@@ -166,13 +158,9 @@ class ItemKNNObjective:
     other arguments are passed into ``__init__``.
     """
 
-    # pylint: disable=too-many-arguments,too-many-instance-attributes
-
     def __init__(self, **kwargs: Any):
         self.kwargs = kwargs
-        max_neighbours = self.kwargs["search_space"]["num_neighbours"]["args"][
-            1
-        ]
+        max_neighbours = self.kwargs["search_space"]["num_neighbours"]["args"][1]
         model = self.kwargs["recommender"]
         split_data = self.kwargs["split_data"]
         train_dataset = split_data.train_dataset
@@ -213,9 +201,7 @@ class ItemKNNObjective:
         recommender.fit_queries = split_data.train_dataset.interactions.select(self.query_column).distinct()
         recommender.fit_items = split_data.train_dataset.interactions.select(self.item_column).distinct()
         similarity = recommender._shrink(self.dot_products, recommender.shrink)
-        recommender.similarity = recommender._get_k_most_similar(
-            similarity
-        ).cache()
+        recommender.similarity = recommender._get_k_most_similar(similarity).cache()
         recs = recommender._predict_wrap(
             dataset=split_data.train_dataset,
             k=k,

replay/preprocessing/__init__.py

@@ -5,13 +5,12 @@ This module contains tools for preprocessing data including:
 - processors for feature transforms
 """
 
+from .converter import CSRConverter
 from .history_based_fp import (
     ConditionalPopularityProcessor,
     EmptyFeatureProcessor,
     HistoryBasedFeaturesProcessor,
     LogStatFeaturesProcessor,
 )
-
-from .converter import CSRConverter
 from .label_encoder import LabelEncoder, LabelEncodingRule
 from .sessionizer import Sessionizer