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

replay/data/nn/sequence_tokenizer.py

@@ -1,4 +1,7 @@
+import json
 import pickle
+import warnings
+from pathlib import Path
 from typing import Dict, List, Optional, Sequence, Set, Tuple, Union
 
 import numpy as np
@@ -6,14 +9,15 @@ import polars as pl
 from pandas import DataFrame as PandasDataFrame
 from polars import DataFrame as PolarsDataFrame
 
-from replay.data import Dataset, FeatureSchema, FeatureSource
+from replay.data import Dataset, FeatureHint, FeatureSchema, FeatureSource, FeatureType
 from replay.data.dataset_utils import DatasetLabelEncoder
-from .schema import TensorFeatureInfo, TensorFeatureSource, TensorSchema
-from .sequential_dataset import PandasSequentialDataset, SequentialDataset, PolarsSequentialDataset
-from .utils import ensure_pandas, groupby_sequences
-from replay.preprocessing import LabelEncoder
+from replay.preprocessing import LabelEncoder, LabelEncodingRule
 from replay.preprocessing.label_encoder import HandleUnknownStrategies
+from replay.utils.model_handler import deprecation_warning
 
+from .schema import TensorFeatureInfo, TensorFeatureSource, TensorSchema
+from .sequential_dataset import PandasSequentialDataset, PolarsSequentialDataset, SequentialDataset
+from .utils import ensure_pandas, groupby_sequences
 
 SequenceDataFrameLike = Union[PandasDataFrame, PolarsDataFrame]
 
@@ -33,7 +37,7 @@ class SequenceTokenizer:
         """
         :param tensor_schema: tensor schema of tensor features
         :param handle_unknown_rule: handle unknown labels rule for LabelEncoder,
-            values are in ('error', 'use_default_value').
+            values are in ('error', 'use_default_value', 'drop').
             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``,
@@ -60,6 +64,7 @@ class SequenceTokenizer:
         :returns: fitted SequenceTokenizer
         """
         self._check_if_tensor_schema_matches_data(dataset, self._tensor_schema)
+        self._assign_tensor_features_cardinality(dataset)
         self._encoder.fit(dataset)
         return self
 
@@ -84,7 +89,6 @@ class SequenceTokenizer:
         :param dataset: input dataset to transform
         :returns: SequentialDataset
         """
-        # pylint: disable=protected-access
         return self.fit(dataset)._transform_unchecked(dataset)
 
     @property
@@ -161,10 +165,7 @@ class SequenceTokenizer:
 
         assert self._tensor_schema.item_id_feature_name
 
-        if is_polars:
-            dataset_type = PolarsSequentialDataset
-        else:
-            dataset_type = PandasSequentialDataset
+        dataset_type = PolarsSequentialDataset if is_polars else PandasSequentialDataset
 
         return dataset_type(
             tensor_schema=schema,
@@ -191,7 +192,7 @@ class SequenceTokenizer:
             return (
                 grouped_interactions.sort(dataset.feature_schema.query_id_column),
                 dataset.query_features,
-                dataset.item_features
+                dataset.item_features,
             )
 
         # We sort by QUERY_ID to make sure order is deterministic
@@ -211,7 +212,6 @@ class SequenceTokenizer:
 
         return grouped_interactions_pd, query_features_pd, item_features_pd
 
-    # pylint: disable=too-many-arguments
     def _make_sequence_features(
         self,
         schema: TensorSchema,
@@ -298,24 +298,27 @@ class SequenceTokenizer:
         for tensor_feature in tensor_schema.all_features:
             feature_sources = tensor_feature.feature_sources
             if not feature_sources:
-                raise ValueError("All tensor features must have sources defined")
+                msg = "All tensor features must have sources defined"
+                raise ValueError(msg)
 
             source_tables: List[FeatureSource] = [s.source for s in feature_sources]
 
             unexpected_tables = list(filter(lambda x: not isinstance(x, FeatureSource), source_tables))
             if len(unexpected_tables) > 0:
-                raise ValueError(f"Found unexpected source tables: {unexpected_tables}")
+                msg = f"Found unexpected source tables: {unexpected_tables}"
+                raise ValueError(msg)
 
             if not tensor_feature.is_seq:
                 if FeatureSource.INTERACTIONS in source_tables:
-                    raise ValueError("Interaction features must be treated as sequential")
+                    msg = "Interaction features must be treated as sequential"
+                    raise ValueError(msg)
 
                 if FeatureSource.ITEM_FEATURES in source_tables:
-                    raise ValueError("Item features must be treated as sequential")
+                    msg = "Item features must be treated as sequential"
+                    raise ValueError(msg)
 
-    # pylint: disable=too-many-branches
     @classmethod
-    def _check_if_tensor_schema_matches_data(
+    def _check_if_tensor_schema_matches_data(  # noqa: C901
         cls,
         dataset: Dataset,
         tensor_schema: TensorSchema,
@@ -324,77 +327,205 @@ class SequenceTokenizer:
         # Check if all source columns specified in tensor schema exist in provided data frames
         sources_for_tensors: List[TensorFeatureSource] = []
         for tensor_feature_name, tensor_feature in tensor_schema.items():
-            if (tensor_features_to_keep is not None) and (tensor_feature_name not in tensor_features_to_keep):
+            if tensor_features_to_keep is not None and tensor_feature_name not in tensor_features_to_keep:
                 continue
 
-            feature_sources = tensor_feature.feature_sources
-            if feature_sources:
-                sources_for_tensors += feature_sources
+            if tensor_feature.feature_sources:
+                sources_for_tensors += tensor_feature.feature_sources
 
         query_id_column = dataset.feature_schema.query_id_column
         item_id_column = dataset.feature_schema.item_id_column
 
-        interaction_feature_columns = set(
-            list(dataset.feature_schema.interaction_features.columns) + [query_id_column, item_id_column]
-        )
-        query_feature_columns = set(list(dataset.feature_schema.query_features.columns) + [query_id_column])
-        item_feature_columns = set(list(dataset.feature_schema.item_features.columns) + [item_id_column])
+        interaction_feature_columns = {
+            *dataset.feature_schema.interaction_features.columns,
+            query_id_column,
+            item_id_column,
+        }
+        query_feature_columns = {*dataset.feature_schema.query_features.columns, query_id_column}
+        item_feature_columns = {*dataset.feature_schema.item_features.columns, item_id_column}
 
         for feature_source in sources_for_tensors:
             assert feature_source is not None
             if feature_source.source == FeatureSource.INTERACTIONS:
                 if feature_source.column not in interaction_feature_columns:
-                    raise ValueError(f"Expected column '{feature_source.column}' in dataset")
+                    msg = f"Expected column '{feature_source.column}' in dataset"
+                    raise ValueError(msg)
             elif feature_source.source == FeatureSource.QUERY_FEATURES:
                 if dataset.query_features is None:
-                    raise ValueError(f"Expected column '{feature_source.column}', but query features are not specified")
+                    msg = f"Expected column '{feature_source.column}', but query features are not specified"
+                    raise ValueError(msg)
                 if feature_source.column not in query_feature_columns:
-                    raise ValueError(f"Expected column '{feature_source.column}' in query features data frame")
+                    msg = f"Expected column '{feature_source.column}' in query features data frame"
+                    raise ValueError(msg)
             elif feature_source.source == FeatureSource.ITEM_FEATURES:
                 if dataset.item_features is None:
-                    raise ValueError(f"Expected column '{feature_source.column}', but item features are not specified")
+                    msg = f"Expected column '{feature_source.column}', but item features are not specified"
+                    raise ValueError(msg)
                 if feature_source.column not in item_feature_columns:
-                    raise ValueError(f"Expected column '{feature_source.column}' in item features data frame")
+                    msg = f"Expected column '{feature_source.column}' in item features data frame"
+                    raise ValueError(msg)
             else:
-                raise ValueError(f"Found unexpected table '{feature_source.source}' in tensor schema")
+                msg = f"Found unexpected table '{feature_source.source}' in tensor schema"
+                raise ValueError(msg)
 
         # Check if user ID and item ID columns are consistent with tensor schema
         if tensor_schema.query_id_feature_name is not None:
             tensor_feature = tensor_schema.query_id_features.item()
             assert tensor_feature.feature_source
             if tensor_feature.feature_source.column != dataset.feature_schema.query_id_column:
-                raise ValueError("Tensor schema query ID source colum does not match query ID in data frame")
+                msg = "Tensor schema query ID source colum does not match query ID in data frame"
+                raise ValueError(msg)
 
         if tensor_schema.item_id_feature_name is None:
-            raise ValueError("Tensor schema must have item id feature defined")
+            msg = "Tensor schema must have item id feature defined"
+            raise ValueError(msg)
 
         tensor_feature = tensor_schema.item_id_features.item()
         assert tensor_feature.feature_source
         if tensor_feature.feature_source.column != dataset.feature_schema.item_id_column:
-            raise ValueError("Tensor schema item ID source colum does not match item ID in data frame")
+            msg = "Tensor schema item ID source colum does not match item ID in data frame"
+            raise ValueError(msg)
+
+    def _assign_tensor_features_cardinality(self, dataset: Dataset) -> None:
+        for tensor_feature in self._tensor_schema.categorical_features.all_features:
+            dataset_feature = dataset.feature_schema[tensor_feature.feature_source.column]
+            if tensor_feature.cardinality is not None:
+                warnings.warn(
+                    f"The specified cardinality of {tensor_feature.name} "
+                    f"will be replaced by {dataset_feature.column} from Dataset"
+                )
+            if dataset_feature.feature_type != FeatureType.CATEGORICAL:
+                error_msg = (
+                    f"TensorFeatureInfo {tensor_feature.name} "
+                    f"and FeatureInfo {dataset_feature.column} must be the same FeatureType"
+                )
+                raise RuntimeError(error_msg)
+            tensor_feature._set_cardinality(dataset_feature.cardinality)
 
     @classmethod
-    def load(cls, path: str) -> "SequenceTokenizer":
+    @deprecation_warning("with `use_pickle` equals to `True` will be deprecated in future versions")
+    def load(cls, path: str, use_pickle: bool = False) -> "SequenceTokenizer":
         """
         Load tokenizer object from the given path.
 
         :param path: Path to load the tokenizer.
+        :param use_pickle: If `False` - tokenizer will be loaded from `.replay` directory.
+            If `True` - tokenizer will be loaded with pickle.
+            Default: `False`.
 
         :returns: Loaded tokenizer object.
         """
-        with open(path, "rb") as file:
-            tokenizer = pickle.load(file)
+        if not use_pickle:
+            base_path = Path(path).with_suffix(".replay").resolve()
+            with open(base_path / "init_args.json", "r") as file:
+                tokenizer_dict = json.loads(file.read())
+
+            # load tensor_schema, tensor_features
+            tensor_schema_data = tokenizer_dict["init_args"]["tensor_schema"]
+            features_list = []
+            for feature_data in tensor_schema_data:
+                feature_data["feature_sources"] = [
+                    TensorFeatureSource(source=FeatureSource[x["source"]], column=x["column"], index=x["index"])
+                    for x in feature_data["feature_sources"]
+                ]
+                f_type = feature_data["feature_type"]
+                f_hint = feature_data["feature_hint"]
+                feature_data["feature_type"] = FeatureType[f_type] if f_type else None
+                feature_data["feature_hint"] = FeatureHint[f_hint] if f_hint else None
+                features_list.append(TensorFeatureInfo(**feature_data))
+            tokenizer_dict["init_args"]["tensor_schema"] = TensorSchema(features_list)
+
+            # Load encoder columns and rules
+            types = list(FeatureHint) + list(FeatureSource)
+            map_types = {x.name: x for x in types}
+            encoder_features_columns = {
+                map_types[key]: value for key, value in tokenizer_dict["encoder"]["features_columns"].items()
+            }
+
+            rules_dict = tokenizer_dict["encoder"]["encoding_rules"]
+            for rule in rules_dict:
+                rule_data = rules_dict[rule]
+                if rule_data["mapping"] and rule_data["is_int"]:
+                    rule_data["mapping"] = {int(key): value for key, value in rule_data["mapping"].items()}
+                    del rule_data["is_int"]
+
+                tokenizer_dict["encoder"]["encoding_rules"][rule] = LabelEncodingRule(**rule_data)
+
+            # Init tokenizer
+            tokenizer = cls(**tokenizer_dict["init_args"])
+            tokenizer._encoder._features_columns = encoder_features_columns
+            tokenizer._encoder._encoding_rules = tokenizer_dict["encoder"]["encoding_rules"]
+        else:
+            with open(path, "rb") as file:
+                tokenizer = pickle.load(file)
 
         return tokenizer
 
-    def save(self, path: str) -> None:
+    @deprecation_warning("with `use_pickle` equals to `True` will be deprecated in future versions")
+    def save(self, path: str, use_pickle: bool = False) -> None:
         """
         Save the tokenizer to the given path.
 
         :param path: Path to save the tokenizer.
-        """
-        with open(path, "wb") as file:
-            pickle.dump(self, file)
+        :param use_pickle: If `False` - tokenizer will be saved in `.replay` directory.
+            If `True` - tokenizer will be saved with pickle.
+            Default: `False`.
+        """
+        if not use_pickle:
+            tokenizer_dict = {}
+            tokenizer_dict["_class_name"] = self.__class__.__name__
+            tokenizer_dict["init_args"] = {
+                "allow_collect_to_master": self._allow_collect_to_master,
+                "handle_unknown_rule": self._encoder._handle_unknown_rule,
+                "default_value_rule": self._encoder._default_value_rule,
+                "tensor_schema": [],
+            }
+
+            # save tensor schema
+            for feature in list(self._tensor_schema.values()):
+                tokenizer_dict["init_args"]["tensor_schema"].append(
+                    {
+                        "name": feature.name,
+                        "feature_type": feature.feature_type.name,
+                        "is_seq": feature.is_seq,
+                        "feature_hint": feature.feature_hint.name if feature.feature_hint else None,
+                        "feature_sources": [
+                            {"source": x.source.name, "column": x.column, "index": x.index}
+                            for x in feature.feature_sources
+                        ]
+                        if feature.feature_sources
+                        else None,
+                        "cardinality": feature.cardinality if feature.feature_type == FeatureType.CATEGORICAL else None,
+                        "embedding_dim": feature.embedding_dim
+                        if feature.feature_type == FeatureType.CATEGORICAL
+                        else None,
+                        "tensor_dim": feature.tensor_dim if feature.feature_type == FeatureType.NUMERICAL else None,
+                    }
+                )
+
+            # save DatasetLabelEncoder
+            tokenizer_dict["encoder"] = {
+                "features_columns": {key.name: value for key, value in self._encoder._features_columns.items()},
+                "encoding_rules": {
+                    key: {
+                        "column": value.column,
+                        "mapping": value._mapping,
+                        "handle_unknown": value._handle_unknown,
+                        "default_value": value._default_value,
+                        "is_int": isinstance(next(iter(value._mapping.keys())), int),
+                    }
+                    for key, value in self._encoder._encoding_rules.items()
+                },
+            }
+
+            base_path = Path(path).with_suffix(".replay").resolve()
+            base_path.mkdir(parents=True, exist_ok=True)
+
+            with open(base_path / "init_args.json", "w+") as file:
+                json.dump(tokenizer_dict, file)
+        else:
+            with open(path, "wb") as file:
+                pickle.dump(self, file)
 
 
 class _SequenceProcessor:
@@ -409,7 +540,6 @@ class _SequenceProcessor:
         with passing all tensor features one by one.
     """
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         tensor_schema: TensorSchema,
@@ -462,13 +592,9 @@ class _SequenceProcessor:
         for tensor_feature_name in self._tensor_schema:
             tensor_feature = self._tensor_schema[tensor_feature_name]
             if tensor_feature.is_cat:
-                data = data.join(
-                    self._process_cat_feature(tensor_feature), on=self._query_id_column, how="left"
-                )
+                data = data.join(self._process_cat_feature(tensor_feature), on=self._query_id_column, how="left")
             elif tensor_feature.is_num:
-                data = data.join(
-                    self._process_num_feature(tensor_feature), on=self._query_id_column, how="left"
-                )
+                data = data.join(self._process_num_feature(tensor_feature), on=self._query_id_column, how="left")
             else:
                 assert False, "Unknown tensor feature type"
         return data
@@ -490,38 +616,40 @@ class _SequenceProcessor:
         def get_sequence(user, source, data):
             if source.source == FeatureSource.INTERACTIONS:
                 return np.array(
-                    self._grouped_interactions
-                    .filter(pl.col(self._query_id_column) == user)[source.column][0],
-                    dtype=np.float32
+                    self._grouped_interactions.filter(pl.col(self._query_id_column) == user)[source.column][0],
+                    dtype=np.float32,
                 ).tolist()
             elif source.source == FeatureSource.ITEM_FEATURES:
                 return (
                     pl.DataFrame({self._item_id_column: data})
                     .join(self._item_features, on=self._item_id_column, how="left")
-                    .select(source.column).to_numpy().reshape(-1).tolist()
+                    .select(source.column)
+                    .to_numpy()
+                    .reshape(-1)
+                    .tolist()
                 )
             else:
                 assert False, "Unknown tensor feature source table"
+
         result = (
-            self._grouped_interactions
-            .select(self._query_id_column, self._item_id_column)
-            .map_rows(
-                lambda x:
-                (
-                    x[0],
-                    [get_sequence(x[0], source, x[1])
-                     for source in tensor_feature.feature_sources]
-                )
+            self._grouped_interactions.select(self._query_id_column, self._item_id_column).map_rows(
+                lambda x: (x[0], [get_sequence(x[0], source, x[1]) for source in tensor_feature.feature_sources])
             )
         ).rename({"column_0": self._query_id_column, "column_1": tensor_feature.name})
 
-        return pl.DataFrame({
-            self._query_id_column: result[self._query_id_column].to_list(),
-            tensor_feature.name: list(map(
-                lambda x: np.array(x).reshape(-1, len(tensor_feature.feature_sources)).tolist(),
-                result[tensor_feature.name].to_list()
-            ))
-        })
+        if tensor_feature.feature_hint == FeatureHint.TIMESTAMP:
+            reshape_size = -1
+        else:
+            reshape_size = (-1, len(tensor_feature.feature_sources))
+
+        return pl.DataFrame(
+            {
+                self._query_id_column: result[self._query_id_column].to_list(),
+                tensor_feature.name: [
+                    np.array(x).reshape(reshape_size).tolist() for x in result[tensor_feature.name].to_list()
+                ],
+            }
+        )
 
     def _process_num_feature(self, tensor_feature: TensorFeatureInfo) -> List[np.ndarray]:
         """
@@ -554,7 +682,10 @@ class _SequenceProcessor:
                 else:
                     assert False, "Unknown tensor feature source table"
             all_seqs = np.array(all_features_for_user, dtype=np.float32)
-            all_seqs = all_seqs.reshape(-1, (len(tensor_feature.feature_sources)))
+            if tensor_feature.feature_hint == FeatureHint.TIMESTAMP:
+                all_seqs = all_seqs.reshape(-1)
+            else:
+                all_seqs = all_seqs.reshape(-1, (len(tensor_feature.feature_sources)))
             values.append(all_seqs)
         return values
 
@@ -572,9 +703,9 @@ class _SequenceProcessor:
         assert source is not None
 
         if self._is_polars:
-            return self._grouped_interactions.select(
-                self._query_id_column, source.column
-            ).rename({source.column: tensor_feature.name})
+            return self._grouped_interactions.select(self._query_id_column, source.column).rename(
+                {source.column: tensor_feature.name}
+            )
 
         return [np.array(sequence, dtype=np.int64) for sequence in self._grouped_interactions[source.column]]
 
@@ -603,9 +734,9 @@ class _SequenceProcessor:
                 result = self._query_features
                 repeat_value = 1
 
-            return result.select(
-                self._query_id_column, pl.col(source.column).repeat_by(repeat_value)
-            ).rename({source.column: tensor_feature.name})
+            return result.select(self._query_id_column, pl.col(source.column).repeat_by(repeat_value)).rename(
+                {source.column: tensor_feature.name}
+            )
 
         query_feature = self._query_features[source.column].values
         if tensor_feature.is_seq:
@@ -632,20 +763,19 @@ class _SequenceProcessor:
 
         if self._is_polars:
             return (
-                self._grouped_interactions
-                .select(self._query_id_column, self._item_id_column)
+                self._grouped_interactions.select(self._query_id_column, self._item_id_column)
                 .map_rows(
-                    lambda x:
-                    (
+                    lambda x: (
                         x[0],
                         pl.DataFrame({self._item_id_column: x[1]})
                         .join(self._item_features, on=self._item_id_column, how="left")
-                        .select(source.column).to_numpy().reshape(-1).tolist(),
+                        .select(source.column)
+                        .to_numpy()
+                        .reshape(-1)
+                        .tolist(),
                     )
-                ).rename({
-                    "column_0": self._query_id_column,
-                    "column_1": tensor_feature.name
-                })
+                )
+                .rename({"column_0": self._query_id_column, "column_1": tensor_feature.name})
             )
 
         item_feature = self._item_features[source.column]

replay/data/nn/sequential_dataset.py

@@ -6,11 +6,9 @@ import polars as pl
 from pandas import DataFrame as PandasDataFrame
 from polars import DataFrame as PolarsDataFrame
 
-from replay.data.schema import FeatureType
 from .schema import TensorSchema
 
 
-# pylint: disable=missing-function-docstring
 class SequentialDataset(abc.ABC):
     """
     Abstract base class for sequential dataset
@@ -132,19 +130,9 @@ class PandasSequentialDataset(SequentialDataset):
 
         self._sequences = sequences
 
-        for feature in tensor_schema.all_features:
-            if feature.feature_type == FeatureType.CATEGORICAL:
-                # pylint: disable=protected-access
-                feature._set_cardinality_callback(self.cardinality_callback)
-
     def __len__(self) -> int:
         return len(self._sequences)
 
-    def cardinality_callback(self, column: str) -> int:
-        if self._query_id_column == column:
-            return self._sequences.index.nunique()
-        return len({x for seq in self._sequences[column] for x in seq})
-
     def get_query_id(self, index: int) -> int:
         return self._sequences.index[index]
 
@@ -181,12 +169,12 @@ class PandasSequentialDataset(SequentialDataset):
 
     @classmethod
     def _check_if_schema_matches_data(cls, tensor_schema: TensorSchema, data: PandasDataFrame) -> None:
-        for tensor_feature_name in tensor_schema.keys():
+        for tensor_feature_name in tensor_schema:
             if tensor_feature_name not in data:
-                raise ValueError("Tensor schema does not match with provided data frame")
+                msg = "Tensor schema does not match with provided data frame"
+                raise ValueError(msg)
 
 
-# pylint:disable=super-init-not-called
 class PolarsSequentialDataset(PandasSequentialDataset):
     """
     Sequential dataset that stores sequences in PolarsDataFrame format.
@@ -215,11 +203,6 @@ class PolarsSequentialDataset(PandasSequentialDataset):
         if self._sequences.index.name != query_id_column:
             self._sequences = self._sequences.set_index(query_id_column)
 
-        for feature in tensor_schema.all_features:
-            if feature.feature_type == FeatureType.CATEGORICAL:
-                # pylint: disable=protected-access
-                feature._set_cardinality_callback(self.cardinality_callback)
-
     def filter_by_query_id(self, query_ids_to_keep: np.ndarray) -> "PolarsSequentialDataset":
         filtered_sequences = self._sequences.loc[query_ids_to_keep]
         if filtered_sequences.index.name == self._query_id_column:
@@ -233,6 +216,7 @@ class PolarsSequentialDataset(PandasSequentialDataset):
 
     @classmethod
     def _check_if_schema_matches_data(cls, tensor_schema: TensorSchema, data: PolarsDataFrame) -> None:
-        for tensor_feature_name in tensor_schema.keys():
+        for tensor_feature_name in tensor_schema:
             if tensor_feature_name not in data:
-                raise ValueError("Tensor schema does not match with provided data frame")
+                msg = "Tensor schema does not match with provided data frame"
+                raise ValueError(msg)

replay/data/nn/torch_sequential_dataset.py

@@ -14,6 +14,7 @@ class TorchSequentialBatch(NamedTuple):
     """
     Batch of TorchSequentialDataset
     """
+
     query_id: torch.LongTensor
     padding_mask: torch.BoolTensor
     features: TensorMap
@@ -88,7 +89,7 @@ class TorchSequentialDataset(TorchDataset):
     ) -> torch.Tensor:
         sequence = self._sequential.get_sequence(sequence_index, feature.name)
         if feature.is_seq:
-            sequence = sequence[sequence_offset : sequence_offset + self._max_sequence_length]  # noqa: E203
+            sequence = sequence[sequence_offset : sequence_offset + self._max_sequence_length]
 
         tensor_dtype = self._get_tensor_dtype(feature)
         tensor_sequence = torch.tensor(sequence, dtype=tensor_dtype)
@@ -109,14 +110,15 @@ class TorchSequentialDataset(TorchDataset):
         elif len(sequence.shape) == 2:
             padded_sequence_shape = (self._max_sequence_length, sequence.shape[1])
         else:
-            raise ValueError(f"Unsupported shape for sequence: {len(sequence.shape)}")
+            msg = f"Unsupported shape for sequence: {len(sequence.shape)}"
+            raise ValueError(msg)
 
         padded_sequence = torch.full(
             padded_sequence_shape,
             self._padding_value,
             dtype=sequence.dtype,
         )
-        padded_sequence[-len(sequence) :].copy_(sequence)  # noqa: E203
+        padded_sequence[-len(sequence) :].copy_(sequence)
         return padded_sequence
 
     def _get_tensor_dtype(self, feature: TensorFeatureInfo) -> torch.dtype:
@@ -151,6 +153,7 @@ class TorchSequentialValidationBatch(NamedTuple):
     """
     Batch of TorchSequentialValidationDataset
     """
+
     query_id: torch.LongTensor
     padding_mask: torch.BoolTensor
     features: TensorMap
@@ -167,7 +170,6 @@ class TorchSequentialValidationDataset(TorchDataset):
     Torch dataset for sequential recommender models that additionally stores ground truth
     """
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         sequential: SequentialDataset,
@@ -195,19 +197,24 @@ class TorchSequentialValidationDataset(TorchDataset):
 
         if label_feature_name:
             if label_feature_name not in ground_truth.schema:
-                raise ValueError("Label feature name not found in ground truth schema")
+                msg = "Label feature name not found in ground truth schema"
+                raise ValueError(msg)
 
             if label_feature_name not in train.schema:
-                raise ValueError("Label feature name not found in train schema")
+                msg = "Label feature name not found in train schema"
+                raise ValueError(msg)
 
             if not ground_truth.schema[label_feature_name].is_cat:
-                raise ValueError("Label feature must be categorical")
+                msg = "Label feature must be categorical"
+                raise ValueError(msg)
 
             if not ground_truth.schema[label_feature_name].is_seq:
-                raise ValueError("Label feature must be sequential")
+                msg = "Label feature must be sequential"
+                raise ValueError(msg)
 
         if len(np.intersect1d(sequential.get_all_query_ids(), ground_truth.get_all_query_ids())) == 0:
-            raise ValueError("Sequential data and ground truth must contain the same query IDs")
+            msg = "Sequential data and ground truth must contain the same query IDs"
+            raise ValueError(msg)
 
         self._ground_truth = ground_truth
         self._train = train
@@ -271,7 +278,9 @@ class TorchSequentialValidationDataset(TorchDataset):
         ground_truth_item_feature = ground_truth_schema.item_id_features.item()
 
         if sequential_item_feature.name != ground_truth_item_feature.name:
-            raise ValueError("Schema mismatch: item feature name does not match ground truth")
+            msg = "Schema mismatch: item feature name does not match ground truth"
+            raise ValueError(msg)
 
         if sequential_item_feature.cardinality != ground_truth_item_feature.cardinality:
-            raise ValueError("Schema mismatch: item feature cardinality does not match ground truth")
+            msg = "Schema mismatch: item feature cardinality does not match ground truth"
+            raise ValueError(msg)