Cold users/items support in non-personilized models (#120)

- Supported cold recommendations in non-personalized models (random, popular and popular-in-category)
- Added check for incorrect types of cold targets
- Changed the logic of choosing random sampler for `RandomModel` and increased the sampling speed
- Changed the logic of `RandomModel`: now the recommendations are different for repeated calls of recommend methods

Author: feldlime

CHANGELOG.md

@@ -10,9 +10,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added 
 - Warm users/items support in `Dataset` ([#77](https://github.com/MobileTeleSystems/RecTools/pull/77))
-- Warm and cold users/items support in `ModelBase` ([#77](https://github.com/MobileTeleSystems/RecTools/pull/77))
+- Warm and cold users/items support in `ModelBase` and non-personalized models ([#77](https://github.com/MobileTeleSystems/RecTools/pull/77), [#120](https://github.com/MobileTeleSystems/RecTools/pull/120))
 - Warm and cold users/items support in `cross_validate` ([#77](https://github.com/MobileTeleSystems/RecTools/pull/77))
 
+### Changed
+- Changed the logic of choosing random sampler for `RandomModel` and increased the sampling speed ([#120](https://github.com/MobileTeleSystems/RecTools/pull/120))
+- Changed the logic of `RandomModel`: now the recommendations are different for repeated calls of recommend methods ([#120](https://github.com/MobileTeleSystems/RecTools/pull/120))
+
 ### Removed
 - `return_external_ids` parameter in `recommend` and `recommend_to_items` model methods ([#77](https://github.com/MobileTeleSystems/RecTools/pull/77))
 

rectools/models/base.py

@@ -147,7 +147,11 @@ def recommend(
 
         # Here for hot and warm we get internal ids, for cold we keep given ids
         hot_user_ids, warm_user_ids, cold_user_ids = self._split_targets_by_hot_warm_cold(
-            users, dataset.user_id_map, dataset.n_hot_users, assume_external_ids
+            users,
+            dataset.user_id_map,
+            dataset.n_hot_users,
+            assume_external_ids,
+            "user",
         )
         self._check_targets_are_valid(hot_user_ids, warm_user_ids, cold_user_ids, "user")
 
@@ -257,7 +261,11 @@ def recommend_to_items(  # pylint: disable=too-many-branches
 
         # Here for hot and warm we get internal ids, for cold we keep given ids
         hot_target_ids, warm_target_ids, cold_target_ids = self._split_targets_by_hot_warm_cold(
-            target_items, dataset.item_id_map, dataset.n_hot_items, assume_external_ids
+            target_items,
+            dataset.item_id_map,
+            dataset.n_hot_items,
+            assume_external_ids,
+            "item",
         )
         self._check_targets_are_valid(hot_target_ids, warm_target_ids, cold_target_ids, "item")
 
@@ -344,9 +352,17 @@ def _split_targets_by_hot_warm_cold(
         id_map: IdMap,
         n_hot: int,
         assume_external_ids: bool,
+        entity: tpe.Literal["user", "item"],
     ) -> tp.Tuple[InternalIdsArray, InternalIdsArray, AnyIdsArray]:
         if assume_external_ids:
             known_ids, cold_ids = id_map.convert_to_internal(targets, strict=False, return_missing=True)
+            try:
+                cold_ids = cold_ids.astype(id_map.external_dtype)
+            except ValueError:
+                raise TypeError(
+                    f"Given {entity} ids must be convertible to the "
+                    f"{entity}_id` type in dataset ({id_map.external_dtype})"
+                )
         else:
             target_ids = cls._ensure_internal_ids_valid(targets)
             known_mask = target_ids < id_map.size

rectools/models/popular.py

@@ -27,7 +27,7 @@
 from rectools.types import InternalIdsArray
 from rectools.utils import fast_isin_for_sorted_test_elements
 
-from .base import ModelBase, Scores, ScoresArray
+from .base import FixedColdRecoModelMixin, ModelBase, Scores, ScoresArray
 from .utils import get_viewed_item_ids
 
 
@@ -40,7 +40,7 @@ class Popularity(Enum):
     SUM_WEIGHT = "sum_weight"
 
 
-class PopularModel(ModelBase):
+class PopularModel(FixedColdRecoModelMixin, ModelBase):
     """
     Model generating recommendations based on popularity of items.
 
@@ -73,6 +73,9 @@ class PopularModel(ModelBase):
         Degree of verbose output. If ``0``, no output will be provided.
     """
 
+    recommends_for_warm = False
+    recommends_for_cold = True
+
     def __init__(
         self,
         popularity: str = "n_users",
@@ -116,12 +119,12 @@ def _fit(self, dataset: Dataset) -> None:  # type: ignore
         items = items_scores.index.values
         scores = items_scores.values.astype(float)
 
-        if self.add_cold:  # pragma: no cover  # TODO: remove when added support for warm and cold
+        if self.add_cold:
             cold_items = np.setdiff1d(dataset.item_id_map.internal_ids, items)
             items = np.concatenate((items, cold_items))
             scores = np.concatenate((scores, np.zeros(cold_items.size)))
 
-        if self.inverse:  # pragma: no cover  # TODO: remove when added support for warm and cold
+        if self.inverse:
             items = items[::-1]
             scores = scores[::-1]
 
@@ -147,11 +150,7 @@ def _recommend_u2i(
         filter_viewed: bool,
         sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray],
     ) -> tp.Tuple[InternalIds, InternalIds, Scores]:
-        if sorted_item_ids_to_recommend is not None:
-            valid_items_mask = fast_isin_for_sorted_test_elements(self.popularity_list[0], sorted_item_ids_to_recommend)
-            popularity_list = (self.popularity_list[0][valid_items_mask], self.popularity_list[1][valid_items_mask])
-        else:
-            popularity_list = self.popularity_list
+        popularity_list = self._get_filtered_popularity_list(sorted_item_ids_to_recommend)
 
         if filter_viewed:
             user_items = dataset.get_user_item_matrix(include_weights=False)
@@ -215,3 +214,20 @@ def _recommend_i2i(
         all_reco_ids = np.tile(single_reco, n_targets)
         all_scores = np.tile(single_scores, n_targets)
         return all_target_ids, all_reco_ids, all_scores
+
+    def _get_filtered_popularity_list(
+        self, sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray]
+    ) -> tp.Tuple[InternalIdsArray, ScoresArray]:
+        popularity_list = self.popularity_list
+        if sorted_item_ids_to_recommend is not None:
+            valid_items_mask = fast_isin_for_sorted_test_elements(popularity_list[0], sorted_item_ids_to_recommend)
+            popularity_list = (popularity_list[0][valid_items_mask], popularity_list[1][valid_items_mask])
+        return popularity_list
+
+    def _get_cold_reco(
+        self, k: int, sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray]
+    ) -> tp.Tuple[InternalIds, Scores]:
+        popularity_list = self._get_filtered_popularity_list(sorted_item_ids_to_recommend)
+        reco_ids = popularity_list[0][:k]
+        scores = popularity_list[1][:k]
+        return reco_ids, scores

rectools/models/popular_in_category.py

@@ -95,6 +95,9 @@ class PopularInCategoryModel(PopularModel):
         Degree of verbose output. If ``0``, no output will be provided.
     """
 
+    recommends_for_warm = False
+    recommends_for_cold = True
+
     def __init__(
         self,
         category_feature: str,
@@ -319,18 +322,62 @@ def _recommend_i2i(
         k: int,
         sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray],
     ) -> tp.Tuple[InternalIds, InternalIds, Scores]:
-        _, single_reco, single_scores = self._recommend_u2i(
-            user_ids=dataset.user_id_map.internal_ids[:1],
-            dataset=dataset,
-            k=k,
-            filter_viewed=False,
-            sorted_item_ids_to_recommend=sorted_item_ids_to_recommend,
-        )
-
+        single_reco, single_scores = self._get_cold_reco(k, sorted_item_ids_to_recommend)
         n_targets = len(target_ids)
         n_reco_per_target = len(single_reco)
 
         all_target_ids = np.repeat(target_ids, n_reco_per_target)
         all_reco_ids = np.tile(single_reco, n_targets)
         all_scores = np.tile(single_scores, n_targets)
         return all_target_ids, all_reco_ids, all_scores
+
+    def _get_cold_reco(
+        self, k: int, sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray]
+    ) -> tp.Tuple[InternalIds, Scores]:
+        num_recs = self._get_num_recs_for_each_category(k)
+        main_recs = []
+        fallback_recs = []
+        for priority, num_col in enumerate(num_recs.index):
+            model = self.models[num_col]
+            reco_ids, reco_scores = model._get_cold_reco(  # pylint: disable=protected-access
+                k, sorted_item_ids_to_recommend
+            )
+            reco_df = pd.DataFrame(
+                {
+                    Columns.Item: reco_ids,
+                    Columns.Score: reco_scores,
+                    "category_priority": priority,
+                }
+            )
+            reco_df["category_rank"] = range(len(reco_df))
+            main_mask = reco_df["category_rank"] < num_recs.loc[num_col]
+            main_recs.append(reco_df[main_mask])
+            fallback_recs.append(reco_df[~main_mask])
+        cat_recs = pd.concat(main_recs, sort=False)
+        cat_recs.drop_duplicates(subset=[Columns.Item], inplace=True)
+        if len(cat_recs) < k:
+            cat_recs["is_main_rec"] = True
+            extra_recs = pd.concat(fallback_recs, sort=False)
+            extra_recs["is_main_rec"] = False
+            full_recs = pd.concat([cat_recs, extra_recs], sort=False)
+            full_recs.drop_duplicates(subset=[Columns.Item], inplace=True)
+
+            # Extra recommendations are given in a specific logic to guarantee that fallback recommendations
+            # never replace main recommendations in final result. And popular category doesn't dominate
+            # over other categories in fallback recs. Thus `rotate` mixing strategy is applied before getting
+            # k recs for each user.
+            full_recs.sort_values(
+                by=["is_main_rec", "category_rank", "category_priority"],
+                ascending=[False, True, True],
+                inplace=True,
+            )
+            full_recs = full_recs.head(k)
+        else:
+            full_recs = cat_recs
+
+        if self.mixing_strategy == MixingStrategy.GROUP:
+            full_recs.sort_values(by=["category_priority", "category_rank"], inplace=True)
+        elif self.mixing_strategy == MixingStrategy.ROTATE:
+            full_recs["category_rank"] = full_recs.groupby(["category_priority"], sort=False).cumcount()
+            full_recs.sort_values(by=["category_rank", "category_priority"], inplace=True)
+        return full_recs[Columns.Item].values, full_recs[Columns.Score].values

rectools/models/random.py

@@ -22,17 +22,32 @@
 
 from rectools import InternalIds
 from rectools.dataset import Dataset
-from rectools.types import InternalIdsArray
+from rectools.types import AnyIdsArray, InternalId, InternalIdsArray
 from rectools.utils import fast_isin_for_sorted_test_elements
 
-from .base import ModelBase, Scores
+from .base import ModelBase, Scores, SemiInternalRecoTriplet
 from .utils import get_viewed_item_ids
 
-# Experiments have shown that for random sampling without replacement if k / n > 0.025
-# where n - size of population, k - required number of samples
-# it's faster to use `np.random.choice(population, k, replace=False)
-# otherwise it's better to use `random.sample(population, k)
-K_TO_N_MIN_NUMPY_RATIO = 0.025
+
+class _RandomGen:
+    def __init__(self, random_state: tp.Optional[int] = None) -> None:
+        self.python_gen = random.Random(random_state)
+        self.np_gen = np.random.default_rng(random_state)
+
+
+class _RandomSampler:
+    def __init__(self, values: np.ndarray, random_gen: _RandomGen) -> None:
+        self.python_gen = random_gen.python_gen
+        self.np_gen = random_gen.np_gen
+        self.values = values
+        self.values_list = list(values)  # for random.sample
+
+    def sample(self, n: int) -> np.ndarray:
+        if n < 25:  # Empiric value, for optimization
+            sampled = np.asarray(self.python_gen.sample(self.values_list, n))
+        else:
+            sampled = self.np_gen.choice(self.values, n, replace=False)
+        return sampled
 
 
 class RandomModel(ModelBase):
@@ -52,9 +67,14 @@ class RandomModel(ModelBase):
         Degree of verbose output. If ``0``, no output will be provided.
     """
 
+    recommends_for_warm = False
+    recommends_for_cold = True
+
     def __init__(self, random_state: tp.Optional[int] = None, verbose: int = 0):
         super().__init__(verbose=verbose)
         self.random_state = random_state
+        self.random_gen = _RandomGen(random_state)
+
         self.all_item_ids: np.ndarray
 
     def _fit(self, dataset: Dataset) -> None:  # type: ignore
@@ -71,18 +91,11 @@ def _recommend_u2i(
         if filter_viewed:
             user_items = dataset.get_user_item_matrix(include_weights=False)
 
-        if sorted_item_ids_to_recommend is not None:
-            item_ids = np.unique(sorted_item_ids_to_recommend)
-        else:
-            item_ids = self.all_item_ids
-
-        item_indices = list(range(item_ids.size))  # for random.sample
-
-        np.random.seed(self.random_state)
-        random.seed(self.random_state, version=2)
+        item_ids = sorted_item_ids_to_recommend if sorted_item_ids_to_recommend is not None else self.all_item_ids
+        sampler = _RandomSampler(item_ids, self.random_gen)
 
         all_user_ids = []
-        all_reco_ids = []
+        all_reco_ids: tp.List[InternalId] = []
         all_scores: tp.List[float] = []
         for user_id in tqdm(user_ids, disable=self.verbose == 0):
             if filter_viewed:
@@ -92,21 +105,16 @@ def _recommend_u2i(
                 n_reco = k
 
             n_reco = min(n_reco, item_ids.size)
-
-            if n_reco / item_ids.size < K_TO_N_MIN_NUMPY_RATIO:
-                reco_indices = random.sample(item_indices, n_reco)
-                reco_ids = item_ids[reco_indices]
-            else:
-                reco_ids = np.random.choice(item_ids, n_reco, replace=False)
+            reco_ids = sampler.sample(n_reco)
 
             if filter_viewed:
                 reco_ids = reco_ids[fast_isin_for_sorted_test_elements(reco_ids, viewed_ids, invert=True)][:k]
 
             reco_scores = np.arange(reco_ids.size, 0, -1)
 
             all_user_ids.extend([user_id] * len(reco_ids))
-            all_reco_ids.extend(reco_ids)
-            all_scores.extend(reco_scores)
+            all_reco_ids.extend(reco_ids.tolist())
+            all_scores.extend(reco_scores.tolist())
 
         return all_user_ids, all_reco_ids, all_scores
 
@@ -118,3 +126,20 @@ def _recommend_i2i(
         sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray],
     ) -> tp.Tuple[InternalIds, InternalIds, Scores]:
         return self._recommend_u2i(target_ids, dataset, k, False, sorted_item_ids_to_recommend)
+
+    def _recommend_cold(
+        self, target_ids: AnyIdsArray, k: int, sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray]
+    ) -> SemiInternalRecoTriplet:
+        item_ids = sorted_item_ids_to_recommend if sorted_item_ids_to_recommend is not None else self.all_item_ids
+        sampler = _RandomSampler(item_ids, self.random_gen)
+        n_reco = min(k, item_ids.size)
+
+        reco_ids_lst = []
+        for _ in tqdm(target_ids, disable=self.verbose == 0):
+            reco_ids = sampler.sample(n_reco)
+            reco_ids_lst.append(reco_ids)
+
+        reco_item_ids = np.concatenate(reco_ids_lst)
+        reco_target_ids = np.repeat(target_ids, n_reco)
+        reco_scores = np.tile(np.arange(n_reco, 0, -1), len(target_ids))
+        return reco_target_ids, reco_item_ids, reco_scores

tests/model_selection/test_cross_validate.py

@@ -160,7 +160,7 @@ def setup(self) -> None:
                 None,
                 [
                     {"model": "popular", "i_split": 0, "precision@2": 0.5, "recall@1": 0.5},
-                    {"model": "random", "i_split": 0, "precision@2": 0.5, "recall@1": 1.0},
+                    {"model": "random", "i_split": 0, "precision@2": 0.5, "recall@1": 0.0},
                     {"model": "popular", "i_split": 1, "precision@2": 0.375, "recall@1": 0.25},
                     {"model": "random", "i_split": 1, "precision@2": 0.375, "recall@1": 0.5},
                 ],

tests/models/test_base.py

@@ -468,6 +468,13 @@ def test_warm_only_model_raises_on_warm_without_features(self, kind: str) -> Non
         with pytest.raises(ValueError, match="doesn't support recommendations for cold"):
             self._get_reco(targets, "hot_warm", "no_features", kind)
 
+    @pytest.mark.parametrize("dataset_key", ("no_features", "with_features"))
+    @pytest.mark.parametrize("kind", ("u2i", "i2i"))
+    @pytest.mark.parametrize("model_key", ("hot_cold", "hot_warm_cold"))
+    def test_raises_on_incorrect_cold_targets_type(self, dataset_key: str, kind: str, model_key: str) -> None:
+        with pytest.raises(TypeError):
+            self._get_reco(["some_id"], model_key, dataset_key, kind)
+
 
 class TestFixedColdRecoModelMixin:
     def test_cold_reco_works(self) -> None: