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

replay/__init__.py

@@ -1,2 +1,2 @@
 """ RecSys library """
-__version__ = "0.16.0.preview"
+__version__ = "0.17.0"

replay/data/__init__.py

@@ -1,6 +1,6 @@
-from .spark_schema import get_schema
 from .dataset import Dataset
 from .schema import FeatureHint, FeatureInfo, FeatureSchema, FeatureSource, FeatureType
+from .spark_schema import get_schema
 
 __all__ = [
     "Dataset",

replay/data/dataset.py

@@ -7,21 +7,20 @@ from typing import Callable, Dict, Iterable, List, Optional, Sequence
 
 import numpy as np
 
-from .schema import FeatureHint, FeatureInfo, FeatureSchema, FeatureSource, FeatureType
 from replay.utils import PYSPARK_AVAILABLE, DataFrameLike, PandasDataFrame, PolarsDataFrame, SparkDataFrame
 
+from .schema import FeatureHint, FeatureInfo, FeatureSchema, FeatureSource, FeatureType
+
 if PYSPARK_AVAILABLE:
-    import pyspark.sql.functions as F
+    import pyspark.sql.functions as sf
     from pyspark.storagelevel import StorageLevel
 
 
-# pylint: disable=too-many-instance-attributes
 class Dataset:
     """
     Universal dataset for feeding data to models.
     """
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         feature_schema: FeatureSchema,
@@ -57,23 +56,23 @@ class Dataset:
         try:
             feature_schema.item_id_column
         except Exception as exception:
-            raise ValueError("Item id column is not set.") from exception
+            msg = "Item id column is not set."
+            raise ValueError(msg) from exception
 
         try:
             feature_schema.query_id_column
         except Exception as exception:
-            raise ValueError("Query id column is not set.") from exception
-
-        if (
-            self.item_features is not None
-            and not check_dataframes_types_equal(self._interactions, self.item_features)
-        ):
-            raise TypeError("Interactions and item features should have the same type.")
-        if (
-            self.query_features is not None
-            and not check_dataframes_types_equal(self._interactions, self.query_features)
+            msg = "Query id column is not set."
+            raise ValueError(msg) from exception
+
+        if self.item_features is not None and not check_dataframes_types_equal(self._interactions, self.item_features):
+            msg = "Interactions and item features should have the same type."
+            raise TypeError(msg)
+        if self.query_features is not None and not check_dataframes_types_equal(
+            self._interactions, self.query_features
         ):
-            raise TypeError("Interactions and query features should have the same type.")
+            msg = "Interactions and query features should have the same type."
+            raise TypeError(msg)
 
         self._feature_source_map: Dict[FeatureSource, DataFrameLike] = {
             FeatureSource.INTERACTIONS: self.interactions,
@@ -191,6 +190,7 @@ class Dataset:
         return self._feature_schema
 
     if PYSPARK_AVAILABLE:
+
         def persist(self, storage_level: StorageLevel = StorageLevel(True, True, False, True, 1)) -> None:
             """
             Sets the storage level to persist SparkDataFrame for interactions, item_features
@@ -295,7 +295,6 @@ class Dataset:
     def _set_cardinality(self, features_list: Sequence[FeatureInfo]) -> None:
         for feature in features_list:
             if feature.feature_type == FeatureType.CATEGORICAL:
-                # pylint: disable=protected-access
                 feature._set_cardinality_callback(self._get_cardinality(feature))
 
     def _fill_feature_schema(self, feature_schema: FeatureSchema) -> FeatureSchema:
@@ -333,15 +332,14 @@ class Dataset:
 
         for feature in features_list:
             if feature.feature_hint in [FeatureHint.QUERY_ID, FeatureHint.ITEM_ID]:
-                # pylint: disable=protected-access
                 feature._set_feature_source(source=FeatureSource.INTERACTIONS)
                 continue
-            source = source_mapping.get(feature.column)  # type: ignore
+            source = source_mapping.get(feature.column)
             if source:
-                # pylint: disable=protected-access
                 feature._set_feature_source(source=source_mapping[feature.column])
             else:
-                raise ValueError(f"{feature.column} doesn't exist in provided dataframes")
+                msg = f"{feature.column} doesn't exist in provided dataframes"
+                raise ValueError(msg)
 
         self._set_cardinality(features_list=features_list)
         return features_list
@@ -362,10 +360,8 @@ class Dataset:
         self._set_cardinality(features_list=unlabeled_columns)
         return unlabeled_columns
 
-    # pylint: disable=no-self-use
     def _set_features_source(self, feature_list: List[FeatureInfo], source: FeatureSource) -> None:
         for feature in feature_list:
-            # pylint: disable=protected-access
             feature._set_feature_source(source)
 
     def _check_ids_consistency(self, hint: FeatureHint) -> None:
@@ -377,8 +373,8 @@ class Dataset:
             self.feature_schema.item_id_column if hint == FeatureHint.ITEM_ID else self.feature_schema.query_id_column
         )
         if self.is_pandas:
-            interactions_unique_ids = set(self.interactions[ids_column].unique())  # type: ignore
-            features_df_unique_ids = set(features_df[ids_column].unique())  # type: ignore  # pylint: disable=E1136
+            interactions_unique_ids = set(self.interactions[ids_column].unique())
+            features_df_unique_ids = set(features_df[ids_column].unique())
             in_interactions_not_in_features_ids = interactions_unique_ids - features_df_unique_ids
             is_consistent = len(in_interactions_not_in_features_ids) == 0
         elif self.is_spark:
@@ -389,14 +385,18 @@ class Dataset:
                 .count()
             ) == 0
         else:
-            is_consistent = len(
-                self.interactions.select(ids_column)
-                .unique()
-                .join(features_df.select(ids_column).unique(), on=ids_column, how="anti")
-            ) == 0
+            is_consistent = (
+                len(
+                    self.interactions.select(ids_column)
+                    .unique()
+                    .join(features_df.select(ids_column).unique(), on=ids_column, how="anti")
+                )
+                == 0
+            )
 
         if not is_consistent:
-            raise ValueError(f"There are IDs in the interactions that are missing in the {hint.name} dataframe.")
+            msg = f"There are IDs in the interactions that are missing in the {hint.name} dataframe."
+            raise ValueError(msg)
 
     def _check_column_encoded(
         self, data: DataFrameLike, column: str, source: FeatureSource, cardinality: Optional[int]
@@ -419,26 +419,29 @@ class Dataset:
             is_int = data[column].dtype.is_integer()
 
         if not is_int:
-            raise ValueError(f"IDs in {source.name}.{column} are not encoded. They are not int.")
+            msg = f"IDs in {source.name}.{column} are not encoded. They are not int."
+            raise ValueError(msg)
 
         if self.is_pandas:
-            min_id = data[column].min()  # type: ignore
+            min_id = data[column].min()
         elif self.is_spark:
-            min_id = data.agg(F.min(column).alias("min_index")).collect()[0][0]
+            min_id = data.agg(sf.min(column).alias("min_index")).collect()[0][0]
         else:
-            min_id = data[column].min()  # type: ignore
+            min_id = data[column].min()
         if min_id < 0:
-            raise ValueError(f"IDs in {source.name}.{column} are not encoded. Min ID is less than 0.")
+            msg = f"IDs in {source.name}.{column} are not encoded. Min ID is less than 0."
+            raise ValueError(msg)
 
         if self.is_pandas:
-            max_id = data[column].max()  # type: ignore
+            max_id = data[column].max()
         elif self.is_spark:
-            max_id = data.agg(F.max(column).alias("max_index")).collect()[0][0]
+            max_id = data.agg(sf.max(column).alias("max_index")).collect()[0][0]
         else:
-            max_id = data[column].max()  # type: ignore
+            max_id = data[column].max()
 
         if max_id >= cardinality:
-            raise ValueError(f"IDs in {source.name}.{column} are not encoded. Max ID is more than quantity of IDs.")
+            msg = f"IDs in {source.name}.{column} are not encoded. Max ID is more than quantity of IDs."
+            raise ValueError(msg)
 
     def _check_encoded(self) -> None:
         for feature in self.feature_schema.categorical_features.all_features:
@@ -471,11 +474,11 @@ class Dataset:
                         feature.cardinality,
                     )
             else:
-                data = self._feature_source_map[feature.feature_source]  # type: ignore
+                data = self._feature_source_map[feature.feature_source]
                 self._check_column_encoded(
                     data,
                     feature.column,
-                    feature.feature_source,  # type: ignore
+                    feature.feature_source,
                     feature.cardinality,
                 )
 

replay/data/dataset_utils/dataset_label_encoder.py

@@ -31,6 +31,7 @@ class DatasetLabelEncoder:
             When set to ``error`` an error will be raised in case an unknown label is present during transform.
             When set to ``use_default_value``, the encoded value of unknown label will be set
             to the value given for the parameter default_value.
+            When set to ``drop``, the unknown labels will be dropped.
             Default: ``error``.
         :param default_value: Default value that will fill the unknown labels after transform.
             When the parameter handle_unknown is set to ``use_default_value``,
@@ -105,7 +106,7 @@ class DatasetLabelEncoder:
         for column, feature_info in dataset.feature_schema.categorical_features.items():
             if column not in self._encoding_rules:
                 warnings.warn(
-                    f"Cannot transform feature '{column}' " "as it was not present at the fit stage",
+                    f"Cannot transform feature '{column}' as it was not present at the fit stage",
                     LabelEncoderTransformWarning,
                 )
                 continue
@@ -157,10 +158,7 @@ class DatasetLabelEncoder:
         self._check_if_initialized()
 
         columns_set: Set[str]
-        if isinstance(columns, str):
-            columns_set = set([columns])
-        else:
-            columns_set = set(columns)
+        columns_set = {columns} if isinstance(columns, str) else {*columns}
 
         def get_encoding_rules() -> Iterator[LabelEncodingRule]:
             for column, rule in self._encoding_rules.items():
@@ -200,7 +198,7 @@ class DatasetLabelEncoder:
         """
         query_id_column = self._features_columns[FeatureHint.QUERY_ID]
         item_id_column = self._features_columns[FeatureHint.ITEM_ID]
-        encoder = self.get_encoder(query_id_column + item_id_column)  # type: ignore
+        encoder = self.get_encoder(query_id_column + item_id_column)
         assert encoder is not None
         return encoder
 
@@ -231,7 +229,8 @@ class DatasetLabelEncoder:
 
     def _check_if_initialized(self) -> None:
         if not self._encoding_rules:
-            raise ValueError("Encoder is not initialized")
+            msg = "Encoder is not initialized"
+            raise ValueError(msg)
 
     def _fill_features_columns(self, feature_info: FeatureSchema) -> None:
         self._features_columns = {

replay/data/nn/__init__.py

@@ -3,7 +3,7 @@ from replay.utils import TORCH_AVAILABLE
 if TORCH_AVAILABLE:
     from .schema import MutableTensorMap, TensorFeatureInfo, TensorFeatureSource, TensorMap, TensorSchema
     from .sequence_tokenizer import SequenceTokenizer
-    from .sequential_dataset import PandasSequentialDataset, SequentialDataset, PolarsSequentialDataset
+    from .sequential_dataset import PandasSequentialDataset, PolarsSequentialDataset, SequentialDataset
     from .torch_sequential_dataset import (
         DEFAULT_GROUND_TRUTH_PADDING_VALUE,
         DEFAULT_TRAIN_PADDING_VALUE,

replay/data/nn/schema.py

@@ -11,7 +11,6 @@ from typing import (
     Set,
     Union,
     ValuesView,
-    Callable
 )
 
 import torch
@@ -23,7 +22,6 @@ TensorMap = Mapping[str, torch.Tensor]
 MutableTensorMap = Dict[str, torch.Tensor]
 
 
-# pylint: disable=too-many-instance-attributes
 class TensorFeatureSource:
     """
     Describes source of a feature
@@ -72,7 +70,6 @@ class TensorFeatureInfo:
     Information about a tensor feature.
     """
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         name: str,
@@ -108,15 +105,18 @@ class TensorFeatureInfo:
         self._is_seq = is_seq
 
         if not isinstance(feature_type, FeatureType):
-            raise ValueError("Unknown feature type")
+            msg = "Unknown feature type"
+            raise ValueError(msg)
         self._feature_type = feature_type
 
         if feature_type == FeatureType.NUMERICAL and (cardinality or embedding_dim):
-            raise ValueError("Cardinality and embedding dimensions are needed only with categorical feature type.")
+            msg = "Cardinality and embedding dimensions are needed only with categorical feature type."
+            raise ValueError(msg)
         self._cardinality = cardinality
 
         if feature_type == FeatureType.CATEGORICAL and tensor_dim:
-            raise ValueError("Tensor dimensions is needed only with numerical feature type.")
+            msg = "Tensor dimensions is needed only with numerical feature type."
+            raise ValueError(msg)
 
         if feature_type == FeatureType.CATEGORICAL:
             default_embedding_dim = 64
@@ -168,7 +168,8 @@ class TensorFeatureInfo:
             return None
 
         if len(source) > 1:
-            raise ValueError("Only one element feature sources can be converted to single feature source.")
+            msg = "Only one element feature sources can be converted to single feature source."
+            raise ValueError(msg)
         assert isinstance(self.feature_sources, list)
         return self.feature_sources[0]
 
@@ -199,35 +200,21 @@ class TensorFeatureInfo:
         :returns: Cardinality of the feature.
         """
         if self.feature_type != FeatureType.CATEGORICAL:
-            raise RuntimeError(
-                f"Can not get cardinality because feature type of {self.name} column is not categorical."
-            )
-        if hasattr(self, "_cardinality_callback") and self._cardinality is None:
-            self._set_cardinality(self._cardinality_callback(self._name))
+            msg = f"Can not get cardinality because feature type of {self.name} column is not categorical."
+            raise RuntimeError(msg)
         return self._cardinality
 
-    # pylint: disable=attribute-defined-outside-init
-    def _set_cardinality_callback(self, callback: Callable) -> None:
-        self._cardinality_callback = callback
-
     def _set_cardinality(self, cardinality: int) -> None:
         self._cardinality = cardinality
 
-    def reset_cardinality(self) -> None:
-        """
-        Reset cardinality of the feature to None.
-        """
-        self._cardinality = None
-
     @property
     def tensor_dim(self) -> Optional[int]:
         """
         :returns: Dimensions of the numerical feature.
         """
         if self.feature_type != FeatureType.NUMERICAL:
-            raise RuntimeError(
-                f"Can not get tensor dimensions because feature type of {self.name} feature is not numerical."
-            )
+            msg = f"Can not get tensor dimensions because feature type of {self.name} feature is not numerical."
+            raise RuntimeError(msg)
         return self._tensor_dim
 
     def _set_tensor_dim(self, tensor_dim: int) -> None:
@@ -239,9 +226,8 @@ class TensorFeatureInfo:
         :returns: Embedding dimensions of the feature.
         """
         if self.feature_type != FeatureType.CATEGORICAL:
-            raise RuntimeError(
-                f"Can not get embedding dimensions because feature type of {self.name} feature is not categorical."
-            )
+            msg = f"Can not get embedding dimensions because feature type of {self.name} feature is not categorical."
+            raise RuntimeError(msg)
         return self._embedding_dim
 
     def _set_embedding_dim(self, embedding_dim: int) -> None:
@@ -278,8 +264,9 @@ class TensorSchema(Mapping[str, TensorFeatureInfo]):
         :returns: Extract single feature from a schema.
         """
         if len(self._tensor_schema) != 1:
-            raise ValueError("Only one element tensor schema can be converted to single feature")
-        return list(self._tensor_schema.values())[0]
+            msg = "Only one element tensor schema can be converted to single feature"
+            raise ValueError(msg)
+        return next(iter(self._tensor_schema.values()))
 
     def items(self) -> ItemsView[str, TensorFeatureInfo]:
         return self._tensor_schema.items()
@@ -290,7 +277,7 @@ class TensorSchema(Mapping[str, TensorFeatureInfo]):
     def values(self) -> ValuesView[TensorFeatureInfo]:
         return self._tensor_schema.values()
 
-    def get(  # type: ignore
+    def get(
         self,
         key: str,
         default: Optional[TensorFeatureInfo] = None,
@@ -377,7 +364,7 @@ class TensorSchema(Mapping[str, TensorFeatureInfo]):
     @property
     def names(self) -> Sequence[str]:
         """
-       :returns: List of all feature's names.
+        :returns: List of all feature's names.
         """
         return list(self._tensor_schema)
 
@@ -447,7 +434,7 @@ class TensorSchema(Mapping[str, TensorFeatureInfo]):
         for filtration_func, filtration_param in zip(filter_functions, filter_parameters):
             filtered_features = list(
                 filter(
-                    lambda x: filtration_func(x, filtration_param),  # type: ignore  # pylint: disable=W0640
+                    lambda x: filtration_func(x, filtration_param),
                     filtered_features,
                 )
             )