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

replay/preprocessing/filters.py

@@ -5,6 +5,8 @@ from abc import ABC, abstractmethod
 from datetime import datetime, timedelta
 from typing import Callable, Optional, Tuple, Union
 
+import numpy as np
+import pandas as pd
 import polars as pl
 
 from replay.utils import PYSPARK_AVAILABLE, DataFrameLike, PandasDataFrame, PolarsDataFrame, SparkDataFrame
@@ -357,7 +359,7 @@ class NumInteractionsFilter(_BaseFilter):
     ...                                   "2020-02-01", "2020-01-01 00:04:15",
     ...                                   "2020-01-02 00:04:14", "2020-01-05 23:59:59"]},
     ...             )
-    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"])
+    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"], format="ISO8601")
     >>> log_sp = convert2spark(log_pd)
     >>> log_sp.show()
     +-------+-------+------+-------------------+
@@ -499,7 +501,7 @@ class EntityDaysFilter(_BaseFilter):
     ...                                   "2020-02-01", "2020-01-01 00:04:15",
     ...                                   "2020-01-02 00:04:14", "2020-01-05 23:59:59"]},
     ...             )
-    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"])
+    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"], format="ISO8601")
     >>> log_sp = convert2spark(log_pd)
     >>> log_sp.orderBy('user_id', 'item_id').show()
     +-------+-------+------+-------------------+
@@ -638,7 +640,7 @@ class GlobalDaysFilter(_BaseFilter):
     ...                                   "2020-02-01", "2020-01-01 00:04:15",
     ...                                   "2020-01-02 00:04:14", "2020-01-05 23:59:59"]},
     ...             )
-    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"])
+    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"], format="ISO8601")
     >>> log_sp = convert2spark(log_pd)
     >>> log_sp.show()
     +-------+-------+------+-------------------+
@@ -740,7 +742,7 @@ class TimePeriodFilter(_BaseFilter):
     ...                                   "2020-02-01", "2020-01-01 00:04:15",
     ...                                   "2020-01-02 00:04:14", "2020-01-05 23:59:59"]},
     ...             )
-    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"])
+    >>> log_pd["timestamp"] = pd.to_datetime(log_pd["timestamp"], format="ISO8601")
     >>> log_sp = convert2spark(log_pd)
     >>> log_sp.show()
     +-------+-------+------+-------------------+
@@ -823,3 +825,166 @@ class TimePeriodFilter(_BaseFilter):
         return interactions.filter(
             pl.col(self.timestamp_column).is_between(self.start_date, self.end_date, closed="left")
         )
+
+
+class QuantileItemsFilter(_BaseFilter):
+    """
+    Filter is aimed on undersampling the interactions dataset.
+
+    Filter algorithm performs undersampling by removing `items_proportion` of interactions
+    for each items counts that exceeds the `alpha_quantile` value in distribution. Filter firstly
+    removes popular items (items that have most interactions). Filter also keeps the original
+    relation of items popularity among each other by removing interactions only in range of
+    current item count and quantile count (specified by `alpha_quantile`).
+
+    >>> import pandas as pd
+    >>> from replay.utils.spark_utils import convert2spark
+    >>> log_pd = pd.DataFrame({
+    ...        "user_id": [0, 0, 1, 2, 2, 2, 2],
+    ...        "item_id": [0, 2, 1, 1, 2, 2, 2]
+    ... })
+    >>> log_spark = convert2spark(log_pd)
+    >>> log_spark.show()
+    +-------+-------+
+    |user_id|item_id|
+    +-------+-------+
+    |      0|      0|
+    |      0|      2|
+    |      1|      1|
+    |      2|      1|
+    |      2|      2|
+    |      2|      2|
+    |      2|      2|
+    +-------+-------+
+    <BLANKLINE>
+
+    >>> QuantileItemsFilter(query_column="user_id").transform(log_spark).show()
+    +-------+-------+
+    |user_id|item_id|
+    +-------+-------+
+    |      0|      0|
+    |      1|      1|
+    |      2|      1|
+    |      2|      2|
+    |      2|      2|
+    |      0|      2|
+    +-------+-------+
+    <BLANKLINE>
+    """
+
+    def __init__(
+        self,
+        alpha_quantile: float = 0.99,
+        items_proportion: float = 0.5,
+        query_column: str = "query_id",
+        item_column: str = "item_id",
+    ) -> None:
+        """
+        :param alpha_quantile: Quantile value of items counts distribution to keep unchanged.
+            Every items count that exceeds this value will be undersampled.
+            Default: ``0.99``.
+        :param items_proportion: proportion of items counts to remove for items that
+            exceeds `alpha_quantile` value in range of current item count and quantile count
+            to make sure we keep original relation between items unchanged.
+            Default: ``0.5``.
+        :param query_column: query column name.
+            Default: ``query_id``.
+        :param item_column: item column name.
+            Default: ``item_id``.
+        """
+        if not 0 < alpha_quantile < 1:
+            msg = "`alpha_quantile` value must be in (0, 1)"
+            raise ValueError(msg)
+        if not 0 < items_proportion < 1:
+            msg = "`items_proportion` value must be in (0, 1)"
+            raise ValueError(msg)
+
+        self.alpha_quantile = alpha_quantile
+        self.items_proportion = items_proportion
+        self.query_column = query_column
+        self.item_column = item_column
+
+    def _filter_pandas(self, df: pd.DataFrame):
+        items_distribution = df.groupby(self.item_column).size().reset_index().rename(columns={0: "counts"})
+        users_distribution = df.groupby(self.query_column).size().reset_index().rename(columns={0: "counts"})
+        count_threshold = items_distribution.loc[:, "counts"].quantile(self.alpha_quantile, interpolation="midpoint")
+        df_with_counts = df.merge(items_distribution, how="left", on=self.item_column).merge(
+            users_distribution, how="left", on=self.query_column, suffixes=["_items", "_users"]
+        )
+        long_tail = df_with_counts.loc[df_with_counts["counts_items"] <= count_threshold]
+        short_tail = df_with_counts.loc[df_with_counts["counts_items"] > count_threshold]
+        short_tail["num_items_to_delete"] = self.items_proportion * (
+            short_tail["counts_items"] - long_tail["counts_items"].max()
+        )
+        short_tail["num_items_to_delete"] = short_tail["num_items_to_delete"].astype("int")
+        short_tail = short_tail.sort_values("counts_users", ascending=False)
+
+        def get_mask(x):
+            mask = np.ones_like(x)
+            threshold = x.iloc[0]
+            mask[:threshold] = 0
+            return mask
+
+        mask = short_tail.groupby(self.item_column)["num_items_to_delete"].transform(get_mask).astype(bool)
+        return pd.concat([long_tail[df.columns], short_tail.loc[mask][df.columns]])
+
+    def _filter_polars(self, df: pl.DataFrame):
+        items_distribution = df.group_by(self.item_column).len()
+        users_distribution = df.group_by(self.query_column).len()
+        count_threshold = items_distribution.select("len").quantile(self.alpha_quantile, "midpoint")["len"][0]
+        df_with_counts = (
+            df.join(items_distribution, how="left", on=self.item_column).join(
+                users_distribution, how="left", on=self.query_column
+            )
+        ).rename({"len": "counts_items", "len_right": "counts_users"})
+        long_tail = df_with_counts.filter(pl.col("counts_items") <= count_threshold)
+        short_tail = df_with_counts.filter(pl.col("counts_items") > count_threshold)
+        max_long_tail_count = long_tail["counts_items"].max()
+        items_to_delete = (
+            short_tail.select(
+                self.query_column,
+                self.item_column,
+                self.items_proportion * (pl.col("counts_items") - max_long_tail_count),
+            )
+            .with_columns(pl.col("literal").cast(pl.Int64).alias("num_items_to_delete"))
+            .select(self.item_column, "num_items_to_delete")
+            .unique(maintain_order=True)
+        )
+        short_tail = short_tail.join(items_to_delete, how="left", on=self.item_column).sort(
+            "counts_users", descending=True
+        )
+        short_tail = short_tail.with_columns(index=pl.int_range(short_tail.shape[0]))
+        grouped = short_tail.group_by(self.item_column, maintain_order=True).agg(
+            pl.col("index"), pl.col("num_items_to_delete")
+        )
+        grouped = grouped.with_columns(
+            pl.col("num_items_to_delete").list.get(0),
+            (pl.col("index").list.len() - pl.col("num_items_to_delete").list.get(0)).alias("tail"),
+        )
+        grouped = grouped.with_columns(pl.col("index").list.tail(pl.col("tail")))
+        grouped = grouped.explode("index").select("index")
+        short_tail = grouped.join(short_tail, how="left", on="index")
+        return pl.concat([long_tail.select(df.columns), short_tail.select(df.columns)])
+
+    def _filter_spark(self, df: SparkDataFrame):
+        items_distribution = df.groupBy(self.item_column).agg(sf.count(self.query_column).alias("counts_items"))
+        users_distribution = df.groupBy(self.query_column).agg(sf.count(self.item_column).alias("counts_users"))
+        count_threshold = items_distribution.toPandas().loc[:, "counts_items"].quantile(self.alpha_quantile, "midpoint")
+        df_with_counts = df.join(items_distribution, on=self.item_column).join(users_distribution, on=self.query_column)
+        long_tail = df_with_counts.filter(sf.col("counts_items") <= count_threshold)
+        short_tail = df_with_counts.filter(sf.col("counts_items") > count_threshold)
+        max_long_tail_count = long_tail.agg({"counts_items": "max"}).collect()[0][0]
+        items_to_delete = (
+            short_tail.withColumn(
+                "num_items_to_delete",
+                (self.items_proportion * (sf.col("counts_items") - max_long_tail_count)).cast("int"),
+            )
+            .select(self.item_column, "num_items_to_delete")
+            .distinct()
+        )
+        short_tail = short_tail.join(items_to_delete, on=self.item_column, how="left")
+        short_tail = short_tail.withColumn(
+            "index", sf.row_number().over(Window.partitionBy(self.item_column).orderBy(sf.col("counts_users").desc()))
+        )
+        short_tail = short_tail.filter(sf.col("index") > sf.col("num_items_to_delete"))
+        return long_tail.select(df.columns).union(short_tail.select(df.columns))

replay/splitters/base_splitter.py

@@ -85,7 +85,7 @@ class Splitter(ABC):
             json.dump(splitter_dict, file)
 
     @classmethod
-    def load(cls, path: str) -> "Splitter":
+    def load(cls, path: str, **kwargs) -> "Splitter":
         """
         Method for loading splitter from `.replay` directory.
         """

replay/utils/common.py

@@ -1,7 +1,12 @@
+import functools
+import inspect
 import json
 from pathlib import Path
-from typing import Union
+from typing import Any, Callable, Union
 
+from polars import from_pandas as pl_from_pandas
+
+from replay.data.dataset import Dataset
 from replay.splitters import (
     ColdUserRandomSplitter,
     KFolds,
@@ -12,7 +17,16 @@ from replay.splitters import (
     TimeSplitter,
     TwoStageSplitter,
 )
-from replay.utils import TORCH_AVAILABLE
+from replay.utils import (
+    TORCH_AVAILABLE,
+    PandasDataFrame,
+    PolarsDataFrame,
+    SparkDataFrame,
+)
+from replay.utils.spark_utils import (
+    convert2spark as pandas_to_spark,
+    spark_to_pandas,
+)
 
 SavableObject = Union[
     ColdUserRandomSplitter,
@@ -23,10 +37,11 @@ SavableObject = Union[
     RatioSplitter,
     TimeSplitter,
     TwoStageSplitter,
+    Dataset,
 ]
 
 if TORCH_AVAILABLE:
-    from replay.data.nn import SequenceTokenizer
+    from replay.data.nn import PandasSequentialDataset, PolarsSequentialDataset, SequenceTokenizer
 
     SavableObject = Union[
         ColdUserRandomSplitter,
@@ -38,6 +53,8 @@ if TORCH_AVAILABLE:
         TimeSplitter,
         TwoStageSplitter,
         SequenceTokenizer,
+        PandasSequentialDataset,
+        PolarsSequentialDataset,
     ]
 
 
@@ -50,7 +67,7 @@ def save_to_replay(obj: SavableObject, path: Union[str, Path]) -> None:
     obj.save(path)
 
 
-def load_from_replay(path: Union[str, Path]) -> SavableObject:
+def load_from_replay(path: Union[str, Path], **kwargs) -> SavableObject:
     """
     General function to load RePlay models, splitters and tokenizer.
 
@@ -60,6 +77,91 @@ def load_from_replay(path: Union[str, Path]) -> SavableObject:
     with open(path / "init_args.json", "r") as file:
         class_name = json.loads(file.read())["_class_name"]
     obj_type = globals()[class_name]
-    obj = obj_type.load(path)
+    obj = obj_type.load(path, **kwargs)
 
     return obj
+
+
+def _check_if_dataframe(var: Any):
+    if not isinstance(var, (SparkDataFrame, PolarsDataFrame, PandasDataFrame)):
+        msg = f"Object of type {type(var)} is not a dataframe of known type (can be pandas|spark|polars)"
+        raise ValueError(msg)
+
+
+def check_if_dataframe(*args_to_check: str) -> Callable[..., Any]:
+    def decorator_func(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        def wrap_func(*args: Any, **kwargs: Any) -> Any:
+            extended_kwargs = {}
+            extended_kwargs.update(kwargs)
+            extended_kwargs.update(dict(zip(inspect.signature(func).parameters.keys(), args)))
+            # add default param values to dict with arguments
+            extended_kwargs.update(
+                {
+                    x.name: x.default
+                    for x in inspect.signature(func).parameters.values()
+                    if x.name not in extended_kwargs and x.default is not x.empty
+                }
+            )
+            vals_to_check = [extended_kwargs[_arg] for _arg in args_to_check]
+            for val in vals_to_check:
+                _check_if_dataframe(val)
+            return func(*args, **kwargs)
+
+        return wrap_func
+
+    return decorator_func
+
+
+@check_if_dataframe("data")
+def convert2pandas(
+    data: Union[SparkDataFrame, PolarsDataFrame, PandasDataFrame], allow_collect_to_master: bool = False
+) -> PandasDataFrame:
+    """
+    Convert the spark|polars DataFrame to a pandas.DataFrame.
+    Returns unchanged dataframe if the input is already of type pandas.DataFrame.
+
+    :param data: The dataframe to convert. Can be polars|spark|pandas DataFrame.
+    :param allow_collect_to_master: If set to False (default) raises a warning
+        about collecting parallelized data to the master node.
+    """
+    if isinstance(data, PandasDataFrame):
+        return data
+    if isinstance(data, PolarsDataFrame):
+        return data.to_pandas()
+    if isinstance(data, SparkDataFrame):
+        return spark_to_pandas(data, allow_collect_to_master, from_constructor=False)
+
+
+@check_if_dataframe("data")
+def convert2polars(
+    data: Union[SparkDataFrame, PolarsDataFrame, PandasDataFrame], allow_collect_to_master: bool = False
+) -> PolarsDataFrame:
+    """
+    Convert the spark|pandas DataFrame to a polars.DataFrame.
+    Returns unchanged dataframe if the input is already of type polars.DataFrame.
+
+    :param data: The dataframe to convert. Can be spark|pandas|polars DataFrame.
+    :param allow_collect_to_master: If set to False (default) raises a warning
+        about collecting parallelized data to the master node.
+    """
+    if isinstance(data, PandasDataFrame):
+        return pl_from_pandas(data)
+    if isinstance(data, PolarsDataFrame):
+        return data
+    if isinstance(data, SparkDataFrame):
+        return pl_from_pandas(spark_to_pandas(data, allow_collect_to_master, from_constructor=False))
+
+
+@check_if_dataframe("data")
+def convert2spark(data: Union[SparkDataFrame, PolarsDataFrame, PandasDataFrame]) -> SparkDataFrame:
+    """
+    Convert the pandas|polars DataFrame to a pysaprk.sql.DataFrame.
+    Returns unchanged dataframe if the input is already of type pysaprk.sql.DataFrame.
+
+    :param data: The dataframe to convert. Can be pandas|polars|spark Datarame.
+    """
+    if isinstance(data, (PandasDataFrame, SparkDataFrame)):
+        return pandas_to_spark(data)
+    if isinstance(data, PolarsDataFrame):
+        return pandas_to_spark(data.to_pandas())

replay/utils/spark_utils.py

@@ -33,7 +33,9 @@ class SparkCollectToMasterWarning(Warning):  # pragma: no cover
     """
 
 
-def spark_to_pandas(data: SparkDataFrame, allow_collect_to_master: bool = False) -> pd.DataFrame:  # pragma: no cover
+def spark_to_pandas(
+    data: SparkDataFrame, allow_collect_to_master: bool = False, from_constructor: bool = True
+) -> pd.DataFrame:  # pragma: no cover
     """
     Convert Spark DataFrame to Pandas DataFrame.
 
@@ -42,10 +44,15 @@ def spark_to_pandas(data: SparkDataFrame, allow_collect_to_master: bool = False)
 
     :returns: Converted Pandas DataFrame.
     """
+    warn_msg = "Spark Data Frame is collected to master node, this may lead to OOM exception for larger dataset. "
+    if from_constructor:
+        _msg = "To remove this warning set allow_collect_to_master=True in the recommender constructor."
+    else:
+        _msg = "To remove this warning set allow_collect_to_master=True."
+    warn_msg += _msg
     if not allow_collect_to_master:
         warnings.warn(
-            "Spark Data Frame is collected to master node, this may lead to OOM exception for larger dataset. "
-            "To remove this warning set allow_collect_to_master=True in the recommender constructor.",
+            warn_msg,
             SparkCollectToMasterWarning,
         )
     return data.toPandas()
@@ -169,7 +176,7 @@ if PYSPARK_AVAILABLE:
         <BLANKLINE>
         >>> output_data = input_data.select(vector_dot("one", "two").alias("dot"))
         >>> output_data.schema
-        StructType(List(StructField(dot,DoubleType,true)))
+        StructType([StructField('dot', DoubleType(), True)])
         >>> output_data.show()
         +----+
         | dot|
@@ -207,7 +214,7 @@ if PYSPARK_AVAILABLE:
         <BLANKLINE>
         >>> output_data = input_data.select(vector_mult("one", "two").alias("mult"))
         >>> output_data.schema
-        StructType(List(StructField(mult,VectorUDT,true)))
+        StructType([StructField('mult', VectorUDT(), True)])
         >>> output_data.show()
         +---------+
         |     mult|
@@ -244,7 +251,7 @@ if PYSPARK_AVAILABLE:
         <BLANKLINE>
         >>> output_data = input_data.select(array_mult("one", "two").alias("mult"))
         >>> output_data.schema
-        StructType(List(StructField(mult,ArrayType(DoubleType,true),true)))
+        StructType([StructField('mult', ArrayType(DoubleType(), True), True)])
         >>> output_data.show()
         +----------+
         |      mult|

{replay_rec-0.17.0rc0.dist-info → replay_rec-0.17.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: replay-rec
-Version: 0.17.0rc0
+Version: 0.17.1
 Summary: RecSys Library
 Home-page: https://sb-ai-lab.github.io/RePlay/
 License: Apache-2.0
@@ -20,25 +20,17 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Provides-Extra: all
 Provides-Extra: spark
 Provides-Extra: torch
-Requires-Dist: d3rlpy (>=2.0.4,<3.0.0)
-Requires-Dist: gym (>=0.26.0,<0.27.0)
 Requires-Dist: hnswlib (==0.7.0)
-Requires-Dist: implicit (>=0.7.0,<0.8.0)
-Requires-Dist: lightautoml (>=0.3.1,<0.4.0)
-Requires-Dist: lightfm (==1.17)
 Requires-Dist: lightning (>=2.0.2,<3.0.0) ; extra == "torch" or extra == "all"
-Requires-Dist: llvmlite (>=0.32.1)
 Requires-Dist: nmslib (==2.1.1)
-Requires-Dist: numba (>=0.50)
 Requires-Dist: numpy (>=1.20.0)
 Requires-Dist: optuna (>=3.2.0,<3.3.0)
-Requires-Dist: pandas (>=1.3.5,<2.0.0)
+Requires-Dist: pandas (>=1.3.5,<=2.2.2)
 Requires-Dist: polars (>=0.20.7,<0.21.0)
 Requires-Dist: psutil (>=5.9.5,<5.10.0)
 Requires-Dist: pyarrow (>=12.0.1)
-Requires-Dist: pyspark (>=3.0,<3.3) ; extra == "spark" or extra == "all"
+Requires-Dist: pyspark (>=3.0,<3.5) ; extra == "spark" or extra == "all"
 Requires-Dist: pytorch-ranger (>=0.1.1,<0.2.0) ; extra == "torch" or extra == "all"
-Requires-Dist: sb-obp (>=0.5.7,<0.6.0)
 Requires-Dist: scikit-learn (>=1.0.2,<2.0.0)
 Requires-Dist: scipy (>=1.8.1,<1.9.0)
 Requires-Dist: torch (>=1.8,<2.0) ; extra == "torch" or extra == "all"

{replay_rec-0.17.0rc0.dist-info → replay_rec-0.17.1.dist-info}/RECORD

@@ -1,68 +1,16 @@
-replay/__init__.py,sha256=y6Ms_dBdP_0tx6CPUF9QV0jrhb-ogRReafA6edgal_E,54
+replay/__init__.py,sha256=wUk_ODIXbOTEQKc4cIBpsptZ--yblkgTGRfXStYmQKI,46
 replay/data/__init__.py,sha256=g5bKRyF76QL_BqlED-31RnS8pBdcyj9loMsx5vAG_0E,301
-replay/data/dataset.py,sha256=ysMTNfx8I2hI9fSugtt3IPhenmutgzQMw-8VcM3oUJk,21299
+replay/data/dataset.py,sha256=cSStvCqIc6WAJNtbmsxncSpcQZ1KfULMsrmf_V0UdPw,29490
 replay/data/dataset_utils/__init__.py,sha256=9wUvG8ZwGUvuzLU4zQI5FDcH0WVVo5YLN2ey3DterP0,55
 replay/data/dataset_utils/dataset_label_encoder.py,sha256=TEx2zLw5rJdIz1SRBEznyVv5x_Cs7o6QQbzMk-M1LU0,9598
 replay/data/nn/__init__.py,sha256=WxLsi4rgOuuvGYHN49xBPxP2Srhqf3NYgfBDVH-ZvBo,1122
-replay/data/nn/schema.py,sha256=BYU65vLqPDl69OE-rReh59fiQK0ERfs1xbBLWCiIJnw,14258
-replay/data/nn/sequence_tokenizer.py,sha256=dXD8l7IfK1dod8p--I6BhvE9af3iUOfpaoW2QBU9hTs,34133
-replay/data/nn/sequential_dataset.py,sha256=fqlyBAzDmpH332S-LoMP9PoRYMtgZpxG6Qdahmk5GtE,7840
+replay/data/nn/schema.py,sha256=pO4N7RgmgrqfD1-2d95OTeihKHTZ-5y2BG7CX_wBFi4,16198
+replay/data/nn/sequence_tokenizer.py,sha256=Ambrp3CMOp3JP68PiwmVh0m-_zNXiWzxxVreHkEwOyY,32592
+replay/data/nn/sequential_dataset.py,sha256=jCWxC0Pm1eQ5p8Y6_Bmg4fSEvPaecLrqz1iaWzaICdI,11014
 replay/data/nn/torch_sequential_dataset.py,sha256=BqrK_PtkhpsaY1zRIWGk4EgwPL31a7IWCc0hLDuwDQc,10984
 replay/data/nn/utils.py,sha256=YKE9gkIHZDDiwv4THqOWL4PzsdOujnPuM97v79Mwq0E,2769
 replay/data/schema.py,sha256=F_cv6sYb6l23yuX5xWnbqoJ9oSeUT2NpIM19u8Lf2jA,15606
 replay/data/spark_schema.py,sha256=4o0Kn_fjwz2-9dBY3q46F9PL0F3E7jdVpIlX7SG3OZI,1111
-replay/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-replay/experimental/metrics/__init__.py,sha256=W6S9YTGCezLORyTKCqL4Y_PniC1k3Bu5XWIM3WVHg2Q,2860
-replay/experimental/metrics/base_metric.py,sha256=aYmKZ_336dRrlslBzYsgsOzmed54BNjNXsRcpzB5gyM,22648
-replay/experimental/metrics/coverage.py,sha256=3kVBAUhIEOuD8aJ6DShH2xh_1F61dcLZb001VCkmeJk,3154
-replay/experimental/metrics/experiment.py,sha256=Bd_XB9zbngcAwf5JLZKVPsFWQoz9pEGlPEUbkiR_MDc,7343
-replay/experimental/metrics/hitrate.py,sha256=TfWJrUyZXabdMr4tn8zqUPGDcYy2yphVCzXmLSHCxY0,675
-replay/experimental/metrics/map.py,sha256=S4dKiMpYR0_pu0bqioGMT0kIC1s2aojFP4rddBqMPtM,921
-replay/experimental/metrics/mrr.py,sha256=q6I1Cndlwr716mMuYtTMu0lN8Rrp9khxhb49OM2IpV8,530
-replay/experimental/metrics/ncis_precision.py,sha256=yrErOhBZvZdNpQPx_AXyktDJatqdWRIHNMyei0QDJtQ,1088
-replay/experimental/metrics/ndcg.py,sha256=q3KTsyZCrfvcpEjEnR_kWVB9ZaTFRxnoNRAr2WD0TrU,1538
-replay/experimental/metrics/precision.py,sha256=U9pD9yRGeT8uH32BTyQ-W5qsAnbFWu-pqy4XfkcXfCM,664
-replay/experimental/metrics/recall.py,sha256=5xRPGxfbVoDFEI5E6dVlZpT4RvnDlWzaktyoqh3a8mc,774
-replay/experimental/metrics/rocauc.py,sha256=yq4vW2_bXO8HCjREBZVrHMKeZ054LYvjJmLJTXWPfQA,1675
-replay/experimental/metrics/surprisal.py,sha256=CK4_zed2bSMDwC7ZBCS8d8RwGEqt8bh3w3fTpjKiK6Y,3052
-replay/experimental/metrics/unexpectedness.py,sha256=JQQXEYHtQM8nqp7X2He4E9ZYwbpdENaK8oQG7sUQT3s,2621
-replay/experimental/models/__init__.py,sha256=R284PXgSxt-JWWwlSTLggchash0hrLfy4b2w-ySaQf4,588
-replay/experimental/models/admm_slim.py,sha256=Oz-x0aQAnGFN9z7PB7MiKfduBasc4KQrBT0JwtYdwLY,6581
-replay/experimental/models/base_neighbour_rec.py,sha256=pRcffr0cdRNZRVpzWb2Qv-UIsLkhbs7K1GRAmrSqPSM,7506
-replay/experimental/models/base_rec.py,sha256=rj2r7r_mmJdzKAkg5CHG1eqJhOpUHAETPe0NwfibFjU,49606
-replay/experimental/models/base_torch_rec.py,sha256=oDkCxVFQjIHSWKlCns6mU3ECWbQW3mQZWvBHBxJQdwc,8111
-replay/experimental/models/cql.py,sha256=9ONDMblfxUgol5Pb2UInfSHVRbB2Ma15zAZC6valhtk,19628
-replay/experimental/models/ddpg.py,sha256=sZrGgwj_kKeUnwwT9qooc4Cxz2oVGkNfUwUe1N7mreI,31982
-replay/experimental/models/dt4rec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-replay/experimental/models/dt4rec/dt4rec.py,sha256=ZIHYonDubStN7Gb703csy86R7Q3_1fZc4zJf98HYFe4,5895
-replay/experimental/models/dt4rec/gpt1.py,sha256=T3buFtYyF6Fh6sW6f9dUZFcFEnQdljItbRa22CiKb0w,14044
-replay/experimental/models/dt4rec/trainer.py,sha256=YeaJ8mnoYZqnPwm1P9qOYb8GzgFC5At-JeSDcvG2V2o,3859
-replay/experimental/models/dt4rec/utils.py,sha256=jbCx2Xc85VtjQx-caYhJFfVuj1Wf866OAiSoZlR4q48,8201
-replay/experimental/models/extensions/spark_custom_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-replay/experimental/models/extensions/spark_custom_models/als_extension.py,sha256=dKSVCMXWRB7IUnpEK_QNhSEuUSVcG793E8MT_AGXneY,25890
-replay/experimental/models/implicit_wrap.py,sha256=8F-f-CaStmlNHwphu-yu8o4Aft08NKDD_SqqH0zp1Uo,4655
-replay/experimental/models/lightfm_wrap.py,sha256=a2ctIEoZf7I0C_awiQI1lE4RGJ7ISs60znysgHRXZCw,11337
-replay/experimental/models/mult_vae.py,sha256=FdJ-GL6Jj2l5-38edKp_jsNfwFNGPxMHXKn8cG2tGJs,11607
-replay/experimental/models/neuromf.py,sha256=QRu--zIyOSQIp8R5Ksgiw7o0s5yOhQpuAX9YshKJs4w,14391
-replay/experimental/models/scala_als.py,sha256=PVf0YA3ii4iRwGqpYg6nStgaauyrm9QTzLtK_4f1En0,10985
-replay/experimental/nn/data/__init__.py,sha256=5EAF-FNd7xhkUpTq_5MyVcPXBD81mJCwYrcbhdGOWjE,48
-replay/experimental/nn/data/schema_builder.py,sha256=5PphL9kK-tVm30nWdTjHUzqVOnTwKiU_MlxGdL5HJ8Y,1736
-replay/experimental/preprocessing/__init__.py,sha256=uMyeyQ_GKqjLhVGwhrEk3NLhhzS0DKi5xGo3VF4WkiA,130
-replay/experimental/preprocessing/data_preparator.py,sha256=fQ8Blo_uzA-2eC-_ViVeU26Tqj5lxLTCBoDJfEmiqUo,35968
-replay/experimental/preprocessing/padder.py,sha256=o7S_Zk-ne_jria3QhWCKkYa6bEqhCdtvCA-R0MjOvU4,9569
-replay/experimental/preprocessing/sequence_generator.py,sha256=E1_0uZJLv8V_n6YzRlgUWtcrHIdjNwPeBN-BMbz0e-A,9053
-replay/experimental/scenarios/__init__.py,sha256=gWFLCkLyOmOppvbRMK7C3UMlMpcbIgiGVolSH6LPgWA,91
-replay/experimental/scenarios/obp_wrapper/__init__.py,sha256=rsRyfsTnVNp20LkTEugwoBrV9XWbIhR8tOqec_Au6dY,450
-replay/experimental/scenarios/obp_wrapper/obp_optuna_objective.py,sha256=vmLANYB5i1UR3uY7e-T0IBEYwPxOYHtKqhkmUvMUYhU,2548
-replay/experimental/scenarios/obp_wrapper/replay_offline.py,sha256=A6TPBFHj_UUL0N6DHSF0-hACsH5cw2o1GMYvpPS6964,8756
-replay/experimental/scenarios/obp_wrapper/utils.py,sha256=-ioWTb73NmHWxVxw4BdSolctqeeGIyjKtydwc45nrrk,3271
-replay/experimental/scenarios/two_stages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-replay/experimental/scenarios/two_stages/reranker.py,sha256=tJtWhbHRNV4sJZ9RZzqIfylTplKh9QVwTIBhEGGnXq8,4244
-replay/experimental/scenarios/two_stages/two_stages_scenario.py,sha256=ZgflnQ6xuxDFphdKX6Q0jtXidHS7c2YvDaccoaL78Qo,29846
-replay/experimental/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-replay/experimental/utils/logger.py,sha256=UwLowaeOG17sDEe32LiZel8MnjSTzeW7J3uLG1iwLuA,639
-replay/experimental/utils/model_handler.py,sha256=0ksSm5bJ1bL32VV5HI-KPe0a1EAzzOhMtmSYaM_zRrE,6271
-replay/experimental/utils/session_handler.py,sha256=076TLpTOcnh13BznNTtJW6Zhrqvm9Ee1mlpP5YMD4No,1313
 replay/metrics/__init__.py,sha256=KDkxVnKa4ks9K9GmlrdTx1pkIl-MAmm78ZASsp2ZndE,2812
 replay/metrics/base_metric.py,sha256=uleW5vLrdA3iRx72tFyW0cxe6ne_ugQ1XaY_ZTcnAOo,15960
 replay/metrics/categorical_diversity.py,sha256=OYsF-Ng-WrF9CC-sKgQKngrA779NO8MtgRvvAyC8MXM,10781
@@ -148,14 +96,14 @@ replay/optimization/__init__.py,sha256=az6U10rF7X6rPRUUPwLyiM1WFNJ_6kl0imA5xLVWF
 replay/optimization/optuna_objective.py,sha256=Z-8X0_FT3BicVWj0UhxoLrvZAck3Dhn7jHDGo0i0hxA,7653
 replay/preprocessing/__init__.py,sha256=TtBysFqYeDy4kZAEnWEaNSwPvbffYdfMkEs71YG51fM,411
 replay/preprocessing/converter.py,sha256=DczqsVLrwFi6EFhK2HR8rGiIxGCwXeY7QNgWorjA41g,4390
-replay/preprocessing/filters.py,sha256=6MaO4IIyKNFP2AR94YA5iQUhQvuCRhAFfj0opI6o4-Q,33744
+replay/preprocessing/filters.py,sha256=wsXWQoZ-2aAecunLkaTxeLWi5ow4e3FAGcElx0iNx0w,41669
 replay/preprocessing/history_based_fp.py,sha256=tfgKJPKm53LSNqM6VmMXYsVrRDc-rP1Tbzn8s3mbziQ,18751
 replay/preprocessing/label_encoder.py,sha256=MLBavPD-dB644as0E9ZJSE9-8QxGCB_IHek1w3xtqDI,27040
 replay/preprocessing/sessionizer.py,sha256=G6i0K3FwqtweRxvcSYraJ-tBWAT2HnV-bWHHlIZJF-s,12217
 replay/scenarios/__init__.py,sha256=kw2wRkPPinw0IBA20D83XQ3xeSudk3KuYAAA1Wdr8xY,93
 replay/scenarios/fallback.py,sha256=EeBmIR-5igzKR2m55bQRFyhxTkpJez6ZkCW449n8hWs,7130
 replay/splitters/__init__.py,sha256=DnqVMelrzLwR8fGQgcWN_8FipGs8T4XGSPOMW-L_x2g,454
-replay/splitters/base_splitter.py,sha256=qWW8Sueu0BrYt0WIxMbzooAC4-jhEmyd6pMND_H_qB0,7751
+replay/splitters/base_splitter.py,sha256=hj9_GYDWllzv3XnxN6WHu1JKRRVjXo77vZEOLbF9v-s,7761
 replay/splitters/cold_user_random_splitter.py,sha256=gVwBVdn_0IOaLGT_UzJoS9AMaPhelZy-FpC5JQS1PhA,4136
 replay/splitters/k_folds.py,sha256=WH02_DP18A2ae893ysonmfLPB56_i1ETllTAwaCYekg,6218
 replay/splitters/last_n_splitter.py,sha256=r9kdq2JPi508C9ywjwc68an-iq27KsigMfHWLz0YohE,15346
@@ -165,16 +113,15 @@ replay/splitters/ratio_splitter.py,sha256=8zvuCn16Icc4ntQPKXJ5ArAWuJzCZ9NHZtgWct
 replay/splitters/time_splitter.py,sha256=iXhuafjBx7dWyJSy-TEVy1IUQBwMpA1gAiF4-GtRe2g,9031
 replay/splitters/two_stage_splitter.py,sha256=PWozxjjgjrVzdz6Sm9dcDTeH0bOA24reFzkk_N_TgbQ,17734
 replay/utils/__init__.py,sha256=vDJgOWq81fbBs-QO4ZDpdqR4KDyO1kMOOxBRi-5Gp7E,253
-replay/utils/common.py,sha256=6JxR5bFuTFTFWad36J5Zu8dFgpFXoof6VsVpF2sD7h8,1471
+replay/utils/common.py,sha256=s4Pro3QCkPeVBsj-s0vrbhd_pkJD-_-2M_sIguxGzQQ,5411
 replay/utils/dataframe_bucketizer.py,sha256=LipmBBQkdkLGroZpbP9i7qvTombLdMxo2dUUys1m5OY,3748
 replay/utils/distributions.py,sha256=kGGq2KzQZ-yhTuw_vtOsKFXVpXUOQ2l4aIFBcaDufZ8,1202
 replay/utils/model_handler.py,sha256=V-mHDh8_UexjVSsMBBRA9yrjS_5MPHwYOwv_UrI-Zfs,6466
 replay/utils/session_handler.py,sha256=ijTvDSNAe1D9R1e-dhtd-r80tFNiIBsFdWZLgw-gLEo,5153
-replay/utils/spark_utils.py,sha256=PhNi9fW28ek0ZB90AUg3tsT5BULbQjDhLalxxww9eLE,26700
+replay/utils/spark_utils.py,sha256=k5lUFM2C9QZKQON3dqhgfswyUF4tsgJOn0U2wCKimqM,26901
 replay/utils/time.py,sha256=J8asoQBytPcNw-BLGADYIsKeWhIoN1H5hKiX9t2AMqo,9376
 replay/utils/types.py,sha256=5sw0A7NG4ZgQKdWORnBy0wBZ5F98sP_Ju8SKQ6zbDS4,651
-replay_rec-0.17.0rc0.dist-info/LICENSE,sha256=rPmcA7UrHxBChEAAlJyE24qUWKKl9yLQXxFsKeg_LX4,11344
-replay_rec-0.17.0rc0.dist-info/METADATA,sha256=8Ki81O8-t1bWieQu4WJFFNWMu4CrvhwBSaU0mcfhh4o,10889
-replay_rec-0.17.0rc0.dist-info/NOTICE,sha256=k0bo4KHiHLRax5K3XKTTrf2Fi8V91mJ-R3FMdh6Reg0,2002
-replay_rec-0.17.0rc0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-replay_rec-0.17.0rc0.dist-info/RECORD,,
+replay_rec-0.17.1.dist-info/LICENSE,sha256=rPmcA7UrHxBChEAAlJyE24qUWKKl9yLQXxFsKeg_LX4,11344
+replay_rec-0.17.1.dist-info/METADATA,sha256=IDkSzO_PcQgyU4Xqnpi0WTHkqyVS0t3vNvisONZaBLg,10589
+replay_rec-0.17.1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+replay_rec-0.17.1.dist-info/RECORD,,

{replay_rec-0.17.0rc0.dist-info → replay_rec-0.17.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.6.1
 Root-Is-Purelib: true
 Tag: py3-none-any

replay/experimental/metrics/__init__.py

@@ -1,61 +0,0 @@
-"""
-Most metrics require dataframe with recommendations
-and dataframe with ground truth values —
-which objects each user interacted with.
-
-- recommendations (Union[pandas.DataFrame, spark.DataFrame]):
-    predictions of a recommender system,
-    DataFrame with columns ``[user_id, item_id, relevance]``
-- ground_truth (Union[pandas.DataFrame, spark.DataFrame]):
-    test data, DataFrame with columns
-    ``[user_id, item_id, timestamp, relevance]``
-
-Metric is calculated for all users, presented in ``ground_truth``
-for accurate metric calculation in case when the recommender system generated
-recommendation not for all users.  It is assumed, that all users,
-we want to calculate metric for, have positive interactions.
-
-But if we have users, who observed the recommendations, but have not responded,
-those users will be ignored and metric will be overestimated.
-For such case we propose additional optional parameter ``ground_truth_users``,
-the dataframe with all users, which should be considered during the metric calculation.
-
-- ground_truth_users (Optional[Union[pandas.DataFrame, spark.DataFrame]]):
-    full list of users to calculate metric for, DataFrame with ``user_id`` column
-
-Every metric is calculated using top ``K`` items for each user.
-It is also possible to calculate metrics
-using multiple values for ``K`` simultaneously.
-In this case the result will be a dictionary and not a number.
-
-Make sure your recommendations do not contain user-item duplicates
-as duplicates could lead to the wrong calculation results.
-
-- k (Union[Iterable[int], int]):
-    a single number or a list, specifying the
-    truncation length for recommendation list for each user
-
-By default, metrics are averaged by users,
-but you can alternatively use method ``metric.median``.
-Also, you can get the lower bound
-of ``conf_interval`` for a given ``alpha``.
-
-Diversity metrics require extra parameters on initialization stage,
-but do not use ``ground_truth`` parameter.
-
-For each metric, a formula for its calculation is given, because this is
-important for the correct comparison of algorithms, as mentioned in our
-`article <https://arxiv.org/abs/2206.12858>`_.
-"""
-from replay.experimental.metrics.base_metric import Metric, NCISMetric
-from replay.experimental.metrics.coverage import Coverage
-from replay.experimental.metrics.hitrate import HitRate
-from replay.experimental.metrics.map import MAP
-from replay.experimental.metrics.mrr import MRR
-from replay.experimental.metrics.ncis_precision import NCISPrecision
-from replay.experimental.metrics.ndcg import NDCG
-from replay.experimental.metrics.precision import Precision
-from replay.experimental.metrics.recall import Recall
-from replay.experimental.metrics.rocauc import RocAuc
-from replay.experimental.metrics.surprisal import Surprisal
-from replay.experimental.metrics.unexpectedness import Unexpectedness