replay-rec 0.19.0rc0__py3-none-any.whl → 0.20.0__py3-none-any.whl

replay/models/extensions/ann/utils.py

@@ -1,6 +1,3 @@
-import hnswlib
-import nmslib
-
 from .entities.hnswlib_param import HnswlibParam
 from .entities.nmslib_hnsw_param import NmslibHnswParam
 
@@ -15,6 +12,8 @@ def create_hnswlib_index_instance(params: HnswlibParam, init: bool = False):
         If `False` then the index will be used to load index data from a file.
     :return: `hnswlib` index instance
     """
+    import hnswlib
+
     index = hnswlib.Index(space=params.space, dim=params.dim)
 
     if init:
@@ -35,6 +34,8 @@ def create_nmslib_index_instance(params: NmslibHnswParam):
     :param params: `NmslibHnswParam`
     :return: `nmslib` index
     """
+    import nmslib
+
     index = nmslib.init(
         method=params.method,
         space=params.space,

replay/models/knn.py

@@ -1,12 +1,14 @@
-from typing import Any, Dict, Optional
+from typing import Optional
 
 from replay.data import Dataset
-from replay.optimization.optuna_objective import ItemKNNObjective
-from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame
+from replay.utils import OPTUNA_AVAILABLE, PYSPARK_AVAILABLE, SparkDataFrame
 
 from .base_neighbour_rec import NeighbourRec
 from .extensions.ann.index_builders.base_index_builder import IndexBuilder
 
+if OPTUNA_AVAILABLE:
+    from replay.models.optimization import ItemKNNObjective
+
 if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
     from pyspark.sql.window import Window
@@ -15,7 +17,7 @@ if PYSPARK_AVAILABLE:
 class ItemKNN(NeighbourRec):
     """Item-based ItemKNN with modified cosine similarity measure."""
 
-    def _get_ann_infer_params(self) -> Dict[str, Any]:
+    def _get_ann_infer_params(self) -> dict:
         return {
             "features_col": None,
         }
@@ -25,12 +27,15 @@ class ItemKNN(NeighbourRec):
     item_norms: Optional[SparkDataFrame]
     bm25_k1 = 1.2
     bm25_b = 0.75
-    _objective = ItemKNNObjective
-    _search_space = {
-        "num_neighbours": {"type": "int", "args": [1, 100]},
-        "shrink": {"type": "int", "args": [0, 100]},
-        "weighting": {"type": "categorical", "args": [None, "tf_idf", "bm25"]},
-    }
+
+    _valid_weightings = [None, "tf_idf", "bm25"]
+    if OPTUNA_AVAILABLE:
+        _objective = ItemKNNObjective
+        _search_space = {
+            "num_neighbours": {"type": "int", "args": [1, 100]},
+            "shrink": {"type": "int", "args": [0, 100]},
+            "weighting": {"type": "categorical", "args": _valid_weightings},
+        }
 
     def __init__(
         self,
@@ -48,19 +53,15 @@ class ItemKNN(NeighbourRec):
         :param index_builder: `IndexBuilder` instance that adds ANN functionality.
             If not set, then ann will not be used.
         """
+        self.init_index_builder(index_builder)
         self.shrink = shrink
         self.use_rating = use_rating
         self.num_neighbours = num_neighbours
 
-        valid_weightings = self._search_space["weighting"]["args"]
-        if weighting not in valid_weightings:
-            msg = f"weighting must be one of {valid_weightings}"
+        if weighting not in self._valid_weightings:
+            msg = f"weighting must be one of {self._valid_weightings}"
             raise ValueError(msg)
         self.weighting = weighting
-        if isinstance(index_builder, (IndexBuilder, type(None))):
-            self.index_builder = index_builder
-        elif isinstance(index_builder, dict):
-            self.init_builder_from_dict(index_builder)
 
     @property
     def _init_args(self):

replay/models/nn/sequential/bert4rec/dataset.py

@@ -12,7 +12,7 @@ from replay.data.nn import (
     TorchSequentialDataset,
     TorchSequentialValidationDataset,
 )
-from replay.utils.model_handler import deprecation_warning
+from replay.utils import deprecation_warning
 
 
 class Bert4RecTrainingBatch(NamedTuple):

replay/models/nn/sequential/callbacks/prediction_callbacks.py

@@ -6,14 +6,14 @@ import torch
 
 from replay.models.nn.sequential import Bert4Rec
 from replay.models.nn.sequential.postprocessors import BasePostProcessor
-from replay.utils import PYSPARK_AVAILABLE, MissingImportType, PandasDataFrame, PolarsDataFrame, SparkDataFrame
+from replay.utils import PYSPARK_AVAILABLE, MissingImport, PandasDataFrame, PolarsDataFrame, SparkDataFrame
 
 if PYSPARK_AVAILABLE:  # pragma: no cover
     import pyspark.sql.functions as sf
     from pyspark.sql import SparkSession
     from pyspark.sql.types import ArrayType, DoubleType, IntegerType, StructType
 else:
-    SparkSession = MissingImportType
+    SparkSession = MissingImport
 
 
 class PredictionBatch(Protocol):

replay/models/nn/sequential/compiled/__init__.py

@@ -3,3 +3,13 @@ from replay.utils import OPENVINO_AVAILABLE
 if OPENVINO_AVAILABLE:
     from .bert4rec_compiled import Bert4RecCompiled
     from .sasrec_compiled import SasRecCompiled
+
+    __all__ = ["Bert4RecCompiled", "SasRecCompiled"]
+else:
+    import sys
+
+    err = ImportError('Cannot import from module "compiled" - OpenVINO prerequisites not found.')
+    if sys.version_info >= (3, 11):  # pragma: py-lt-311
+        err.add_note('To enable this functionality, ensure you have both "openvino" and "onnx" packages isntalled.')
+
+    raise err

replay/models/nn/sequential/compiled/base_compiled_model.py

@@ -131,7 +131,9 @@ class BaseCompiledModel:
         self._output_name = compiled_model.output().names.pop()
 
     @staticmethod
-    def _validate_num_candidates_to_score(num_candidates: Union[int, None]) -> Union[int, None]:
+    def _validate_num_candidates_to_score(
+        num_candidates: Union[int, None],
+    ) -> Union[int, None]:
         """Check if num_candidates param is proper"""
 
         if num_candidates is None:

replay/models/nn/sequential/compiled/bert4rec_compiled.py

@@ -130,9 +130,18 @@ class Bert4RecCompiled(BaseCompiledModel):
             candidates_to_score = torch.zeros((1,)).long()
             model_input_names += ["candidates_to_score"]
             model_dynamic_axes_in_input["candidates_to_score"] = {0: "num_candidates_to_score"}
-            model_input_sample = ({item_seq_name: item_sequence}, padding_mask, tokens_mask, candidates_to_score)
+            model_input_sample = (
+                {item_seq_name: item_sequence},
+                padding_mask,
+                tokens_mask,
+                candidates_to_score,
+            )
         else:
-            model_input_sample = ({item_seq_name: item_sequence}, padding_mask, tokens_mask)
+            model_input_sample = (
+                {item_seq_name: item_sequence},
+                padding_mask,
+                tokens_mask,
+            )
 
         # Need to disable "Better Transformer" optimizations that interfere with the compilation process
         if hasattr(torch.backends, "mha"):

replay/models/nn/sequential/compiled/sasrec_compiled.py

@@ -127,7 +127,11 @@ class SasRecCompiled(BaseCompiledModel):
             candidates_to_score = torch.zeros((1,)).long()
             model_input_names += ["candidates_to_score"]
             model_dynamic_axes_in_input["candidates_to_score"] = {0: "num_candidates_to_score"}
-            model_input_sample = ({item_seq_name: item_sequence}, padding_mask, candidates_to_score)
+            model_input_sample = (
+                {item_seq_name: item_sequence},
+                padding_mask,
+                candidates_to_score,
+            )
         else:
             model_input_sample = ({item_seq_name: item_sequence}, padding_mask)
 

replay/models/nn/sequential/sasrec/dataset.py

@@ -10,7 +10,7 @@ from replay.data.nn import (
     TorchSequentialDataset,
     TorchSequentialValidationDataset,
 )
-from replay.utils.model_handler import deprecation_warning
+from replay.utils import deprecation_warning
 
 
 class SasRecTrainingBatch(NamedTuple):

replay/models/nn/sequential/sasrec/model.py

@@ -442,7 +442,7 @@ class SasRecLayers(torch.nn.Module):
 
 class SasRecNormalizer(torch.nn.Module):
     """
-    SasRec notmilization layers
+    SasRec normalization layers
 
     Link: https://arxiv.org/pdf/1808.09781.pdf
     """

replay/models/optimization/__init__.py

@@ -0,0 +1,14 @@
+"""
+Hyperparameter optimization of models
+"""
+
+from replay.utils.types import OPTUNA_AVAILABLE
+
+from .optuna_mixin import IsOptimizible
+
+if OPTUNA_AVAILABLE:
+    from .optuna_objective import ItemKNNObjective, ObjectiveWrapper
+
+    __all__ = ["IsOptimizible", "ItemKNNObjective", "ObjectiveWrapper"]
+else:
+    __all__ = ["IsOptimizible"]

replay/models/optimization/optuna_mixin.py

@@ -0,0 +1,279 @@
+import warnings
+from collections.abc import Sequence
+from copy import deepcopy
+from functools import partial
+from typing import NoReturn, Optional, Union
+
+from typing_extensions import TypeAlias
+
+from replay.data import Dataset
+from replay.metrics import NDCG, Metric
+from replay.models.common import RecommenderCommons
+from replay.models.optimization.optuna_objective import ObjectiveWrapper, SplitData, scenario_objective_calculator
+from replay.utils import OPTUNA_AVAILABLE, FeatureUnavailableError, FeatureUnavailableWarning
+
+MainObjective = partial(ObjectiveWrapper, objective_calculator=scenario_objective_calculator)
+
+if OPTUNA_AVAILABLE:
+
+    class OptunaMixin(RecommenderCommons):
+        """
+        A mixin class enabling hyperparameter optimization in a recommender using Optuna objectives.
+        """
+
+        _objective = MainObjective
+        _search_space: Optional[dict[str, Union[str, Sequence[Union[str, int, float]]]]] = None
+        study = None
+        criterion: Optional[Metric] = None
+
+        @staticmethod
+        def _filter_dataset_features(
+            dataset: Dataset,
+        ) -> Dataset:
+            """
+            Filter features of dataset to match with items and queries of interactions
+
+            :param dataset: dataset with interactions and features
+            :return: filtered dataset
+            """
+            if dataset.query_features is None and dataset.item_features is None:
+                return dataset
+
+            query_features = None
+            item_features = None
+            if dataset.query_features is not None:
+                query_features = dataset.query_features.join(
+                    dataset.interactions.select(dataset.feature_schema.query_id_column).distinct(),
+                    on=dataset.feature_schema.query_id_column,
+                )
+            if dataset.item_features is not None:
+                item_features = dataset.item_features.join(
+                    dataset.interactions.select(dataset.feature_schema.item_id_column).distinct(),
+                    on=dataset.feature_schema.item_id_column,
+                )
+
+            return Dataset(
+                feature_schema=dataset.feature_schema,
+                interactions=dataset.interactions,
+                query_features=query_features,
+                item_features=item_features,
+                check_consistency=False,
+                categorical_encoded=False,
+            )
+
+        def _prepare_split_data(
+            self,
+            train_dataset: Dataset,
+            test_dataset: Dataset,
+        ) -> SplitData:
+            """
+            This method converts data to spark and packs it into a named tuple to pass into optuna.
+
+            :param train_dataset: train data
+            :param test_dataset: test data
+            :return: packed PySpark DataFrames
+            """
+            train = self._filter_dataset_features(train_dataset)
+            test = self._filter_dataset_features(test_dataset)
+            queries = test_dataset.interactions.select(self.query_column).distinct()
+            items = test_dataset.interactions.select(self.item_column).distinct()
+
+            split_data = SplitData(
+                train,
+                test,
+                queries,
+                items,
+            )
+            return split_data
+
+        def _check_borders(self, param, borders):
+            """Raise value error if param borders are not valid"""
+            if param not in self._search_space:
+                msg = f"Hyper parameter {param} is not defined for {self!s}"
+                raise ValueError(msg)
+            if not isinstance(borders, list):
+                msg = f"Parameter {param} borders are not a list"
+                raise ValueError()
+            if self._search_space[param]["type"] != "categorical" and len(borders) != 2:
+                msg = f"Hyper parameter {param} is numerical but bounds are not in ([lower, upper]) format"
+                raise ValueError(msg)
+
+        def _prepare_param_borders(self, param_borders: Optional[dict[str, list]] = None) -> dict[str, dict[str, list]]:
+            """
+            Checks if param borders are valid and convert them to a search_space format
+
+            :param param_borders: a dictionary with search grid, where
+                key is the parameter name and value is the range of possible values
+                ``{param: [low, high]}``.
+            :return:
+            """
+            search_space = deepcopy(self._search_space)
+            if param_borders is None:
+                return search_space
+
+            for param, borders in param_borders.items():
+                self._check_borders(param, borders)
+                search_space[param]["args"] = borders
+
+            # Optuna trials should contain all searchable parameters
+            # to be able to correctly return best params
+            # If used didn't specify some params to be tested optuna still needs to suggest them
+            # This part makes sure this suggestion will be constant
+            args = self._init_args
+            missing_borders = {param: args[param] for param in search_space if param not in param_borders}
+            for param, value in missing_borders.items():
+                if search_space[param]["type"] == "categorical":
+                    search_space[param]["args"] = [value]
+                else:
+                    search_space[param]["args"] = [value, value]
+
+            return search_space
+
+        def _init_params_in_search_space(self, search_space):
+            """Check if model params are inside search space"""
+            params = self._init_args
+            outside_search_space = {}
+            for param, value in params.items():
+                if param not in search_space:
+                    continue
+                borders = search_space[param]["args"]
+                param_type = search_space[param]["type"]
+
+                extra_category = param_type == "categorical" and value not in borders
+                param_out_of_bounds = param_type != "categorical" and (value < borders[0] or value > borders[1])
+                if extra_category or param_out_of_bounds:
+                    outside_search_space[param] = {
+                        "borders": borders,
+                        "value": value,
+                    }
+
+            if outside_search_space:
+                self.logger.debug(
+                    "Model is initialized with parameters outside the search space: %s."
+                    "Initial parameters will not be evaluated during optimization."
+                    "Change search spare with 'param_borders' argument if necessary",
+                    outside_search_space,
+                )
+                return False
+            else:
+                return True
+
+        def _params_tried(self):
+            """check if current parameters were already evaluated"""
+            if self.study is None:
+                return False
+
+            params = {name: value for name, value in self._init_args.items() if name in self._search_space}
+            return any(params == trial.params for trial in self.study.trials)
+
+        def optimize(
+            self,
+            train_dataset: Dataset,
+            test_dataset: Dataset,
+            param_borders: Optional[dict[str, list]] = None,
+            criterion: Metric = NDCG,
+            k: int = 10,
+            budget: int = 10,
+            new_study: bool = True,
+        ) -> Optional[dict]:
+            """
+            Searches the best parameters with optuna.
+
+            :param train_dataset: train data
+            :param test_dataset: test data
+            :param param_borders: a dictionary with search borders, where
+                key is the parameter name and value is the range of possible values
+                ``{param: [low, high]}``. In case of categorical parameters it is
+                all possible values: ``{cat_param: [cat_1, cat_2, cat_3]}``.
+            :param criterion: metric to use for optimization
+            :param k: recommendation list length
+            :param budget: number of points to try
+            :param new_study: keep searching with previous study or start a new study
+            :return: dictionary with best parameters
+            """
+            from optuna import create_study
+            from optuna.samplers import TPESampler
+
+            self.query_column = train_dataset.feature_schema.query_id_column
+            self.item_column = train_dataset.feature_schema.item_id_column
+            self.rating_column = train_dataset.feature_schema.interactions_rating_column
+            self.timestamp_column = train_dataset.feature_schema.interactions_timestamp_column
+
+            self.criterion = criterion(
+                topk=k,
+                query_column=self.query_column,
+                item_column=self.item_column,
+                rating_column=self.rating_column,
+            )
+
+            if self._search_space is None:
+                self.logger.warning("%s has no hyper parameters to optimize", str(self))
+                return None
+
+            if self.study is None or new_study:
+                self.study = create_study(direction="maximize", sampler=TPESampler())
+
+            search_space = self._prepare_param_borders(param_borders)
+            if self._init_params_in_search_space(search_space) and not self._params_tried():
+                self.study.enqueue_trial(self._init_args)
+
+            split_data = self._prepare_split_data(train_dataset, test_dataset)
+            objective = self._objective(
+                search_space=search_space,
+                split_data=split_data,
+                recommender=self,
+                criterion=self.criterion,
+                k=k,
+            )
+
+            self.study.optimize(objective, budget)
+            best_params = self.study.best_params
+            self.set_params(**best_params)
+            return best_params
+
+else:
+    feature_warning = FeatureUnavailableWarning(
+        "Optimization feature not enabled - `optuna` package not found. "
+        "Ensure you have the package installed if you want to "
+        "use the `optimize()` method in your recommenders."
+    )
+    warnings.warn(feature_warning)
+
+    class OptunaStub(RecommenderCommons):
+        """A stub class to use in case of missing dependencies."""
+
+        def optimize(
+            self,
+            train_dataset: Dataset,  # noqa: ARG002
+            test_dataset: Dataset,  # noqa: ARG002
+            param_borders: Optional[dict[str, list]] = None,  # noqa: ARG002
+            criterion: Metric = NDCG,  # noqa: ARG002
+            k: int = 10,  # noqa: ARG002
+            budget: int = 10,  # noqa: ARG002
+            new_study: bool = True,  # noqa: ARG002
+        ) -> NoReturn:
+            """
+            Searches the best parameters with optuna.
+
+            :param train_dataset: train data
+            :param test_dataset: test data
+            :param param_borders: a dictionary with search borders, where
+                key is the parameter name and value is the range of possible values
+                ``{param: [low, high]}``. In case of categorical parameters it is
+                all possible values: ``{cat_param: [cat_1, cat_2, cat_3]}``.
+            :param criterion: metric to use for optimization
+            :param k: recommendation list length
+            :param budget: number of points to try
+            :param new_study: keep searching with previous study or start a new study
+            :return: dictionary with best parameters
+            """
+            import sys
+
+            err = FeatureUnavailableError('Cannot use method "optimize()" - Optuna not found.')
+            if sys.version_info >= (3, 11):  # pragma: py-lt-311
+                err.add_note('To enable this functionality, ensure you have the "optuna" package isntalled.')
+
+            raise err
+
+
+IsOptimizible: TypeAlias = OptunaMixin if OPTUNA_AVAILABLE else OptunaStub

replay/{optimization → models/optimization}/optuna_objective.py

@@ -5,9 +5,7 @@ This class calculates loss function for optimization process
 import collections
 import logging
 from functools import partial
-from typing import Any, Callable, Dict, List, Optional, Union
-
-from optuna import Trial
+from typing import TYPE_CHECKING, Any, Callable, Union
 
 from replay.metrics import Metric
 from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame
@@ -15,6 +13,9 @@ from replay.utils import PYSPARK_AVAILABLE, SparkDataFrame
 if PYSPARK_AVAILABLE:
     from pyspark.sql import functions as sf
 
+if TYPE_CHECKING:
+    from optuna import Trial
+
 
 SplitData = collections.namedtuple(  # noqa: PYI024
     "SplitData",
@@ -36,7 +37,7 @@ class ObjectiveWrapper:
         self.objective_calculator = objective_calculator
         self.kwargs = kwargs
 
-    def __call__(self, trial: Trial) -> float:
+    def __call__(self, trial: "Trial") -> float:
         """
         Calculate criterion for ``optuna``.
 
@@ -47,9 +48,9 @@ class ObjectiveWrapper:
 
 
 def suggest_params(
-    trial: Trial,
-    search_space: Dict[str, Dict[str, Union[str, List[Any]]]],
-) -> Dict[str, Any]:
+    trial: "Trial",
+    search_space: dict[str, dict[str, Union[str, list]]],
+) -> dict:
     """
     This function suggests params to try.
 
@@ -124,8 +125,8 @@ def eval_quality(
 
 
 def scenario_objective_calculator(
-    trial: Trial,
-    search_space: Dict[str, List[Optional[Any]]],
+    trial: "Trial",
+    search_space: dict[str, list],
     split_data: SplitData,
     recommender,
     criterion: Metric,
@@ -146,9 +147,6 @@ def scenario_objective_calculator(
     return eval_quality(split_data, recommender, criterion, k)
 
 
-MainObjective = partial(ObjectiveWrapper, objective_calculator=scenario_objective_calculator)
-
-
 class ItemKNNObjective:
     """
     This class is implemented according to
@@ -180,8 +178,8 @@ class ItemKNNObjective:
 
     def objective_calculator(
         self,
-        trial: Trial,
-        search_space: Dict[str, List[Optional[Any]]],
+        trial: "Trial",
+        search_space: dict[str, list],
         split_data: SplitData,
         recommender,
         criterion: Metric,
@@ -215,7 +213,7 @@ class ItemKNNObjective:
         logger.debug("%s=%.6f", criterion, criterion_value)
         return criterion_value
 
-    def __call__(self, trial: Trial) -> float:
+    def __call__(self, trial: "Trial") -> float:
         """
         Calculate criterion for ``optuna``.
 

replay/models/slim.py

@@ -48,6 +48,8 @@ class SLIM(NeighbourRec):
         :param allow_collect_to_master: Flag allowing spark to make a collection to the master node,
             Default: ``False``.
         """
+        self.init_index_builder(index_builder)
+
         if beta < 0 or lambda_ <= 0:
             msg = "Invalid regularization parameters"
             raise ValueError(msg)
@@ -55,10 +57,6 @@ class SLIM(NeighbourRec):
         self.lambda_ = lambda_
         self.seed = seed
         self.allow_collect_to_master = allow_collect_to_master
-        if isinstance(index_builder, (IndexBuilder, type(None))):
-            self.index_builder = index_builder
-        elif isinstance(index_builder, dict):
-            self.init_builder_from_dict(index_builder)
 
     @property
     def _init_args(self):

replay/models/word2vec.py

@@ -19,7 +19,7 @@ if PYSPARK_AVAILABLE:
     from replay.utils.spark_utils import join_with_col_renaming, multiply_scala_udf, vector_dot
 
 
-class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
+class Word2VecRec(ANNMixin, Recommender, ItemVectorModel):
     """
     Trains word2vec model where items are treated as words and queries as sentences.
     """
@@ -36,16 +36,14 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         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]:
+    def _configure_index_builder(self, interactions: SparkDataFrame) -> Dict[str, Any]:
+        item_vectors = self._get_item_vectors()
+        item_vectors = item_vectors.select(self.item_column, vector_to_array("item_vector").alias("item_vector"))
+
         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}
-
-    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"))
-        return item_vectors
+        return item_vectors, {"features_col": "item_vector", "ids_col": self.item_column}
 
     idf: SparkDataFrame
     vectors: SparkDataFrame
@@ -81,6 +79,7 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         :param index_builder: `IndexBuilder` instance that adds ANN functionality.
             If not set, then ann will not be used.
         """
+        self.init_index_builder(index_builder)
 
         self.rank = rank
         self.window_size = window_size
@@ -90,10 +89,6 @@ class Word2VecRec(Recommender, ItemVectorModel, ANNMixin):
         self.max_iter = max_iter
         self._seed = seed
         self._num_partitions = num_partitions
-        if isinstance(index_builder, (IndexBuilder, type(None))):
-            self.index_builder = index_builder
-        elif isinstance(index_builder, dict):
-            self.init_builder_from_dict(index_builder)
         self.num_elements = None
 
     @property

replay/preprocessing/discretizer.py

@@ -172,8 +172,7 @@ class GreedyDiscretizingRule(BaseDiscretizingRule):
                 if (
                     is_big_count_value[i]
                     or cur_cnt_inbin >= mean_bin_size
-                    or is_big_count_value[i + 1]
-                    and cur_cnt_inbin >= max(1.0, mean_bin_size * 0.5)
+                    or (is_big_count_value[i + 1] and cur_cnt_inbin >= max(1.0, mean_bin_size * 0.5))
                 ):
                     upper_bounds[bin_cnt] = distinct_values[i]
                     bin_cnt += 1

replay/preprocessing/history_based_fp.py

@@ -264,7 +264,7 @@ class LogStatFeaturesProcessor(EmptyFeatureProcessor):
             )
             # TO DO std и date diff заменяем на inf, date features - будут ли работать корректно?
             # если не заменять, будет ли работать корректно?
-            .fillna({col_name: 0 for col_name in self.user_log_features.columns + self.item_log_features.columns})
+            .fillna(dict.fromkeys(self.user_log_features.columns + self.item_log_features.columns, 0))
         )
 
         joined = joined.withColumn(