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

replay/experimental/scenarios/obp_wrapper/replay_offline.py

@@ -1,271 +0,0 @@
-import numpy as np
-import pandas as pd
-import logging
-
-from dataclasses import dataclass
-
-from obp.policy.base import BaseOfflinePolicyLearner
-from pyspark.sql import DataFrame
-
-from replay.utils.spark_utils import convert2spark
-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.data import Dataset, FeatureHint, FeatureInfo, FeatureSchema, FeatureType
-
-from optuna import create_study
-from optuna.samplers import TPESampler
-
-from typing import (
-    Any,
-    Dict,
-    List,
-    Optional,
-)
-
-
-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
-
-    # pylint: disable=too-many-arguments, arguments-differ
-    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)
-
-    # pylint: disable=arguments-renamed
-    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
-
-    # pylint: disable=too-many-arguments, too-many-locals, no-member
-    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

@@ -1,88 +0,0 @@
-from sklearn.linear_model import LogisticRegression
-from obp.ope import RegressionModel
-import numpy as np
-from typing import Dict, List, Tuple
-
-
-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

@@ -1,116 +0,0 @@
-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,
-        )