replay-rec 0.18.0__py3-none-any.whl → 0.18.0rc0__py3-none-any.whl

replay/experimental/scenarios/obp_wrapper/replay_offline.py

@@ -0,0 +1,248 @@
+import logging
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+)
+
+import numpy as np
+import pandas as pd
+from obp.policy.base import BaseOfflinePolicyLearner
+from optuna import create_study
+from optuna.samplers import TPESampler
+from pyspark.sql import DataFrame
+
+from replay.data import Dataset, FeatureHint, FeatureInfo, FeatureSchema, FeatureType
+from replay.experimental.scenarios.obp_wrapper.obp_optuna_objective import OBPObjective
+from replay.experimental.scenarios.obp_wrapper.utils import split_bandit_feedback
+from replay.models.base_rec import BaseRecommender
+from replay.utils.spark_utils import convert2spark
+
+
+def obp2df(action: np.ndarray, reward: np.ndarray, timestamp: np.ndarray) -> Optional[pd.DataFrame]:
+    """
+    Converts OBP log to the pandas DataFrame
+    """
+
+    n_interactions = len(action)
+
+    df = pd.DataFrame(
+        {
+            "user_idx": np.arange(n_interactions),
+            "item_idx": action,
+            "rating": reward,
+            "timestamp": timestamp,
+        }
+    )
+
+    return df
+
+
+def context2df(context: np.ndarray, idx_col: np.ndarray, idx_col_name: str) -> Optional[pd.DataFrame]:
+    """
+    Converts OBP log to the pandas DataFrame
+    """
+
+    df1 = pd.DataFrame({idx_col_name + "_idx": idx_col})
+    cols = [str(i) + "_" + idx_col_name for i in range(context.shape[1])]
+    df2 = pd.DataFrame(context, columns=cols)
+
+    return df1.join(df2)
+
+
+@dataclass
+class OBPOfflinePolicyLearner(BaseOfflinePolicyLearner):
+    """
+    Off-policy learner which wraps OBP data representation into replay format.
+
+    :param n_actions: Number of actions.
+
+    :param len_list: Length of a list of actions in a recommendation/ranking inferface,
+                     slate size. When Open Bandit Dataset is used, 3 should be set.
+
+    :param replay_model: Any model from replay library with fit, predict functions.
+
+    :param dataset: Dataset of interactions (user_id, item_id, rating).
+                Constructing inside the fit method. Used for predict of replay_model.
+    """
+
+    replay_model: Optional[BaseRecommender] = None
+    log: Optional[DataFrame] = None
+    max_usr_id: int = 0
+    item_features: DataFrame = None
+    _study = None
+    _logger: Optional[logging.Logger] = None
+    _objective = OBPObjective
+
+    def __post_init__(self) -> None:
+        """Initialize Class."""
+        self.feature_schema = FeatureSchema(
+            [
+                FeatureInfo(
+                    column="user_idx",
+                    feature_type=FeatureType.CATEGORICAL,
+                    feature_hint=FeatureHint.QUERY_ID,
+                ),
+                FeatureInfo(
+                    column="item_idx",
+                    feature_type=FeatureType.CATEGORICAL,
+                    feature_hint=FeatureHint.ITEM_ID,
+                ),
+                FeatureInfo(
+                    column="rating",
+                    feature_type=FeatureType.NUMERICAL,
+                    feature_hint=FeatureHint.RATING,
+                ),
+                FeatureInfo(
+                    column="timestamp",
+                    feature_type=FeatureType.NUMERICAL,
+                    feature_hint=FeatureHint.TIMESTAMP,
+                ),
+            ]
+        )
+
+    @property
+    def logger(self) -> logging.Logger:
+        """
+        :return: get library logger
+        """
+        if self._logger is None:
+            self._logger = logging.getLogger("replay")
+        return self._logger
+
+    def fit(
+        self,
+        action: np.ndarray,
+        reward: np.ndarray,
+        timestamp: np.ndarray,
+        context: np.ndarray = None,
+        action_context: np.ndarray = None,
+    ) -> None:
+        """
+        Fits an offline bandit policy on the given logged bandit data.
+        This `fit` method wraps bandit data and calls `fit` method for the replay_model.
+
+        :param action: Actions sampled by the logging/behavior policy
+                       for each data in logged bandit data, i.e., :math:`a_i`.
+
+        :param reward: Rewards observed for each data in logged bandit data, i.e., :math:`r_i`.
+
+        :param timestamp: Moment of time when user interacted with corresponding item.
+
+        :param context: Context vectors observed for each data, i.e., :math:`x_i`.
+
+        :param action_context: Context vectors observed for each action.
+        """
+
+        log = convert2spark(obp2df(action, reward, timestamp))
+        self.log = log
+
+        user_features = None
+        self.max_usr_id = reward.shape[0]
+
+        if context is not None:
+            user_features = convert2spark(context2df(context, np.arange(context.shape[0]), "user"))
+
+        if action_context is not None:
+            self.item_features = convert2spark(context2df(action_context, np.arange(self.n_actions), "item"))
+
+        dataset = Dataset(
+            feature_schema=self.feature_schema,
+            interactions=log,
+            query_features=user_features,
+            item_features=self.item_features,
+        )
+        self.replay_model._fit_wrap(dataset)
+
+    def predict(self, n_rounds: int = 1, context: np.ndarray = None) -> np.ndarray:
+        """Predict best actions for new data.
+        Action set predicted by this `predict` method can contain duplicate items.
+        If a non-repetitive action set is needed, please use the `sample_action` method.
+
+        :context: Context vectors for new data.
+
+        :return: Action choices made by a classifier, which can contain duplicate items.
+            If a non-repetitive action set is needed, please use the `sample_action` method.
+        """
+
+        user_features = None
+        if context is not None:
+            user_features = convert2spark(
+                context2df(context, np.arange(self.max_usr_id, self.max_usr_id + n_rounds), "user")
+            )
+
+        users = convert2spark(pd.DataFrame({"user_idx": np.arange(self.max_usr_id, self.max_usr_id + n_rounds)}))
+        items = convert2spark(pd.DataFrame({"item_idx": np.arange(self.n_actions)}))
+
+        self.max_usr_id += n_rounds
+
+        dataset = Dataset(
+            feature_schema=self.feature_schema,
+            interactions=self.log,
+            query_features=user_features,
+            item_features=self.item_features,
+            check_consistency=False,
+        )
+
+        action_dist = self.replay_model._predict_proba(dataset, self.len_list, users, items, filter_seen_items=False)
+
+        return action_dist
+
+    def optimize(
+        self,
+        bandit_feedback: Dict[str, np.ndarray],
+        val_size: float = 0.3,
+        param_borders: Optional[Dict[str, List[Any]]] = None,
+        criterion: str = "ipw",
+        budget: int = 10,
+        new_study: bool = True,
+    ) -> Optional[Dict[str, Any]]:
+        """Optimize model parameters using optuna.
+        Optimization is carried out over the IPW/DR/DM scores(IPW by default).
+
+        :param bandit_feedback: Bandit log data with fields
+            ``[action, reward, context, action_context,
+            n_rounds, n_actions, position, pscore]`` as in OpenBanditPipeline.
+
+        :param val_size: Size of validation subset.
+
+        :param param_borders: Dictionary of parameter names with pair of borders
+                              for the parameters optimization algorithm.
+
+        :param criterion: Score for optimization. Available are `ipw`, `dr` and `dm`.
+
+        :param budget: Number of trials for the optimization algorithm.
+
+        :param new_study: Flag to create new study or not for optuna.
+
+        :return: Dictionary of parameter names with optimal value of corresponding parameter.
+        """
+
+        bandit_feedback_train, bandit_feedback_val = split_bandit_feedback(bandit_feedback, val_size)
+
+        if self.replay_model._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.replay_model._prepare_param_borders(param_borders)
+        if self.replay_model._init_params_in_search_space(search_space) and not self.replay_model._params_tried():
+            self._study.enqueue_trial(self.replay_model._init_args)
+
+        objective = self._objective(
+            search_space=search_space,
+            bandit_feedback_train=bandit_feedback_train,
+            bandit_feedback_val=bandit_feedback_val,
+            learner=self,
+            criterion=criterion,
+            k=self.len_list,
+        )
+
+        self._study.optimize(objective, budget)
+        best_params = self._study.best_params
+        self.replay_model.set_params(**best_params)
+        return best_params

replay/experimental/scenarios/obp_wrapper/utils.py

@@ -0,0 +1,87 @@
+from typing import Dict, List, Tuple
+
+import numpy as np
+from obp.ope import RegressionModel
+from sklearn.linear_model import LogisticRegression
+
+
+def get_est_rewards_by_reg(n_actions, len_list, bandit_feedback_train, bandit_feedback_test):
+    """
+    Fit Logistic Regression to rewards from `bandit_feedback`.
+    """
+    regression_model = RegressionModel(
+        n_actions=n_actions,
+        len_list=len_list,
+        action_context=bandit_feedback_train["action_context"],
+        base_model=LogisticRegression(max_iter=1000, random_state=12345),
+    )
+
+    regression_model.fit(
+        context=bandit_feedback_train["context"],
+        action=bandit_feedback_train["action"],
+        reward=bandit_feedback_train["reward"],
+        position=bandit_feedback_train["position"],
+        pscore=bandit_feedback_train["pscore"],
+    )
+
+    estimated_rewards_by_reg_model = regression_model.predict(
+        context=bandit_feedback_test["context"],
+    )
+
+    return estimated_rewards_by_reg_model
+
+
+def bandit_subset(borders: List[int], bandit_feedback: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]:
+    """
+    This function returns subset of a `bandit_feedback`
+    with borders specified in `borders`.
+
+    :param bandit_feedback: Bandit log data with fields
+                            ``[action, reward, context, action_context,
+                               n_rounds, n_actions, position, pscore]``
+                            as in OpenBanditPipeline.
+    :param borders: List with two values ``[left, right]``
+    :return: Returns subset of a `bandit_feedback` for each key with
+             indexes from `left`(including) to `right`(excluding).
+    """
+    assert len(borders) == 2
+
+    left, right = borders
+
+    assert left < right
+
+    position = None if bandit_feedback["position"] is None else bandit_feedback["position"][left:right]
+
+    return {
+        "n_rounds": right - left,
+        "n_actions": bandit_feedback["n_actions"],
+        "action": bandit_feedback["action"][left:right],
+        "position": position,
+        "reward": bandit_feedback["reward"][left:right],
+        "pscore": bandit_feedback["pscore"][left:right],
+        "context": bandit_feedback["context"][left:right],
+        "action_context": bandit_feedback["action_context"][left:right],
+    }
+
+
+def split_bandit_feedback(
+    bandit_feedback: Dict[str, np.ndarray], val_size: int = 0.3
+) -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:
+    """
+    Split `bandit_feedback` into two subsets.
+    :param bandit_feedback: Bandit log data with fields
+                            ``[action, reward, context, action_context,
+                               n_rounds, n_actions, position, pscore]``
+                            as in OpenBanditPipeline.
+    :param val_size: Number in range ``[0, 1]`` corresponding to the proportion of
+                     train/val split.
+    :return: `bandit_feedback_train` and `bandit_feedback_val` split.
+    """
+
+    n_rounds = bandit_feedback["n_rounds"]
+    n_rounds_train = int(n_rounds * (1.0 - val_size))
+
+    bandit_feedback_train = bandit_subset([0, n_rounds_train], bandit_feedback)
+    bandit_feedback_val = bandit_subset([n_rounds_train, n_rounds], bandit_feedback)
+
+    return bandit_feedback_train, bandit_feedback_val

replay/experimental/scenarios/two_stages/reranker.py

@@ -0,0 +1,117 @@
+import logging
+from abc import abstractmethod
+from typing import Dict, Optional
+
+from lightautoml.automl.presets.tabular_presets import TabularAutoML
+from lightautoml.tasks import Task
+from pyspark.sql import DataFrame
+
+from replay.utils.spark_utils import convert2spark, get_top_k_recs
+
+
+class ReRanker:
+    """
+    Base class for models which re-rank recommendations produced by other models.
+    May be used as a part of two-stages recommendation pipeline.
+    """
+
+    _logger: Optional[logging.Logger] = None
+
+    @property
+    def logger(self) -> logging.Logger:
+        """
+        :returns: get library logger
+        """
+        if self._logger is None:
+            self._logger = logging.getLogger("replay")
+        return self._logger
+
+    @abstractmethod
+    def fit(self, data: DataFrame, fit_params: Optional[Dict] = None) -> None:
+        """
+        Fit the model which re-rank user-item pairs generated outside the models.
+
+        :param data: spark dataframe with obligatory ``[user_idx, item_idx, target]``
+            columns and features' columns
+        :param fit_params: dict of parameters to pass to model.fit()
+        """
+
+    @abstractmethod
+    def predict(self, data, k) -> DataFrame:
+        """
+        Re-rank data with the model and get top-k recommendations for each user.
+
+        :param data: spark dataframe with obligatory ``[user_idx, item_idx]``
+            columns and features' columns
+        :param k: number of recommendations for each user
+        """
+
+
+class LamaWrap(ReRanker):
+    """
+    LightAutoML TabularPipeline binary classification model wrapper for recommendations re-ranking.
+    Read more: https://github.com/sberbank-ai-lab/LightAutoML
+    """
+
+    def __init__(
+        self,
+        params: Optional[Dict] = None,
+        config_path: Optional[str] = None,
+    ):
+        """
+        Initialize LightAutoML TabularPipeline with passed params/configuration file.
+
+        :param params: dict of model parameters
+        :param config_path: path to configuration file
+        """
+        self.model = TabularAutoML(
+            task=Task("binary"),
+            config_path=config_path,
+            **(params if params is not None else {}),
+        )
+
+    def fit(self, data: DataFrame, fit_params: Optional[Dict] = None) -> None:
+        """
+        Fit the LightAutoML TabularPipeline model with binary classification task.
+        Data should include negative and positive user-item pairs.
+
+        :param data: spark dataframe with obligatory ``[user_idx, item_idx, target]``
+            columns and features' columns. `Target` column should consist of zeros and ones
+            as the model is a binary classification model.
+        :param fit_params: dict of parameters to pass to model.fit()
+            See LightAutoML TabularPipeline fit_predict parameters.
+        """
+
+        params = {"roles": {"target": "target"}, "verbose": 1}
+        params.update({} if fit_params is None else fit_params)
+        data = data.drop("user_idx", "item_idx")
+        data_pd = data.toPandas()
+        self.model.fit_predict(data_pd, **params)
+
+    def predict(self, data: DataFrame, k: int) -> DataFrame:
+        """
+        Re-rank data with the model and get top-k recommendations for each user.
+
+        :param data: spark dataframe with obligatory ``[user_idx, item_idx]``
+            columns and features' columns
+        :param k: number of recommendations for each user
+        :return: spark dataframe with top-k recommendations for each user
+            the dataframe columns are ``[user_idx, item_idx, relevance]``
+        """
+        data_pd = data.toPandas()
+        candidates_ids = data_pd[["user_idx", "item_idx"]]
+        data_pd.drop(columns=["user_idx", "item_idx"], inplace=True)
+        self.logger.info("Starting re-ranking")
+        candidates_pred = self.model.predict(data_pd)
+        candidates_ids.loc[:, "relevance"] = candidates_pred.data[:, 0]
+        self.logger.info(
+            "%s candidates rated for %s users",
+            candidates_ids.shape[0],
+            candidates_ids["user_idx"].nunique(),
+        )
+
+        self.logger.info("top-k")
+        return get_top_k_recs(
+            recs=convert2spark(candidates_ids),
+            k=k,
+        )