improve code

Author: krystianfranus

src/mypackage/baselines/baselines.py

@@ -46,7 +46,7 @@ def _common(stats_per_item: DataFrame, val: DataFrame):
     val = val.merge(stats_per_item, "inner", "item")
 
     # Compute aucroc and ndcg for different scenarios
-    indexes = torch.tensor(val["user"])
+    indexes = torch.tensor(val["list_id"])
     targets = torch.tensor(val["target"])
     worst_preds = torch.tensor((val["target"] + 1) % 2, dtype=torch.float32)
     random_preds = torch.rand(val.shape[0])

src/mypackage/data_processing/data_processing.py

@@ -47,32 +47,17 @@ def process_simple(
     train = interactions[interactions["timestamp"] < split_date]
     val = interactions[interactions["timestamp"] >= split_date]
 
-    # Keep train users with condition 0 < mean_target < 1
-    train_active_users = (
-        train.groupby("user")
+    # Keep lists with condition 0 < mean_target < 1
+    train_valid_lists = (
+        train.groupby("list_id")
         .agg({"target": "mean"})
         .rename(columns={"target": "mean"})
         .reset_index()
     )
-    train_active_users = train_active_users[
-        (train_active_users["mean"] > 0) & (train_active_users["mean"] < 1)
+    train_valid_lists = train_valid_lists[
+        (train_valid_lists["mean"] > 0) & (train_valid_lists["mean"] < 1)
     ]
-    train = train.merge(train_active_users, "inner", "user")
-
-    # Limit val users to these who occured in train data and also keep val users with 0 < mean_target < 1
-    # This way val users is a subset of train users (no cold users in val!)
-    # and we have train users with number of clicks at least 1 and val users with number of clicks at least 2
-    # val = val.merge(train_active_users, "inner", "user")
-    val_active_users = (
-        val.groupby("user")
-        .agg({"target": "mean"})
-        .rename(columns={"target": "mean"})
-        .reset_index()
-    )
-    val_active_users = val_active_users[
-        (val_active_users["mean"] > 0) & (val_active_users["mean"] < 1)
-    ]
-    val = val.merge(val_active_users, "inner", "user")
+    train = train.merge(train_valid_lists, "inner", "list_id")
 
     # Prepare user/item to idx mappers based on train data
     unique_train_users = train["user"].unique()
@@ -84,20 +69,32 @@ def process_simple(
         {"item": unique_train_items, "item_idx": np.arange(unique_train_items.size)}
     )
 
-    # Map user/item to idx
+    # Map user/item to idx - it removes cold users and items from validation
     train = train.merge(user_mapper, on="user", how="inner")
     train = train.merge(item_mapper, on="item", how="inner")
     val = val.merge(user_mapper, on="user", how="inner")
     val = val.merge(item_mapper, on="item", how="inner")
 
+    # Keep lists with condition 0 < mean_target < 1
+    val_valid_lists = (
+        val.groupby("list_id")
+        .agg({"target": "mean"})
+        .rename(columns={"target": "mean"})
+        .reset_index()
+    )
+    val_valid_lists = val_valid_lists[
+        (val_valid_lists["mean"] > 0) & (val_valid_lists["mean"] < 1)
+    ]
+    val = val.merge(val_valid_lists, "inner", "list_id")
+
     train = train.sort_values("timestamp").reset_index(drop=True)
     val = val.sort_values("timestamp").reset_index(drop=True)
 
     # Select valid columns
-    train = train[["timestamp", "user_idx", "item_idx", "target"]]
-    train.columns = ["timestamp", "user", "item", "target"]
-    val = val[["timestamp", "user_idx", "item_idx", "target"]]
-    val.columns = ["timestamp", "user", "item", "target"]
+    train = train[["timestamp", "list_id", "user_idx", "item_idx", "target"]]
+    train.columns = ["timestamp", "list_id", "user", "item", "target"]
+    val = val[["timestamp", "list_id", "user_idx", "item_idx", "target"]]
+    val.columns = ["timestamp", "list_id", "user", "item", "target"]
 
     # Mock test_data
     test = val.copy()  # test set == validation set (should be changed in the future!)
@@ -108,11 +105,13 @@ def process_simple(
     stats = {}
     stats["train_n_users"] = unique_train_users.size
     stats["train_n_items"] = unique_train_items.size
+    stats["train_n_lists"] = train["list_id"].nunique()
     stats["train_n_clicks"] = int(train["target"].sum())
     stats["train_n_impressions"] = len(train) - stats["train_n_clicks"]
     stats["train_ctr"] = stats["train_n_clicks"] / stats["train_n_impressions"]
     stats["val_n_users"] = unique_val_users.size
     stats["val_n_items"] = unique_val_items.size
+    stats["val_n_lists"] = val["list_id"].nunique()
     stats["val_n_clicks"] = int(val["target"].sum())
     stats["val_n_impressions"] = len(val) - stats["val_n_clicks"]
     stats["val_ctr"] = stats["val_n_clicks"] / stats["val_n_impressions"]
@@ -134,17 +133,6 @@ def process_bpr(
     train = tmp0.merge(tmp1, "inner", "user", suffixes=("_neg", "_pos"))
     val = interactions[interactions["timestamp"] >= split_date]
 
-    val_active_users = (
-        val.groupby("user")
-        .agg({"target": "mean"})
-        .rename(columns={"target": "mean"})
-        .reset_index()
-    )
-    val_active_users = val_active_users[
-        (val_active_users["mean"] > 0) & (val_active_users["mean"] < 1)
-    ]
-    val = val.merge(val_active_users, "inner", "user")
-
     # Prepare user/item to idx mappers based on train data
     unique_train_users = train["user"].unique()
     # unique_users = train["user"].unique()
@@ -175,9 +163,21 @@ def process_bpr(
 
     val = val.merge(user_mapper, on="user", how="inner")
     val = val.merge(item_mapper, on="item", how="inner")
-    val = val[["user_idx", "item_idx", "target"]].rename(
-        columns={"user_idx": "user", "item_idx": "item"}
+
+    # Keep lists with condition 0 < mean_target < 1
+    val_valid_lists = (
+        val.groupby("list_id")
+        .agg({"target": "mean"})
+        .rename(columns={"target": "mean"})
+        .reset_index()
     )
+    val_valid_lists = val_valid_lists[
+        (val_valid_lists["mean"] > 0) & (val_valid_lists["mean"] < 1)
+    ]
+    val = val.merge(val_valid_lists, "inner", "list_id")
+
+    val = val[["timestamp", "list_id", "user_idx", "item_idx", "target"]]
+    val = val.rename(columns={"user_idx": "user", "item_idx": "item"})
 
     # Mock test_data
     test = val.copy()  # test set == validation set (to change in the future!)
@@ -190,6 +190,7 @@ def process_bpr(
     stats["train_n_items"] = unique_train_items.size
     stats["val_n_users"] = unique_val_users.size
     stats["val_n_items"] = unique_val_items.size
+    stats["val_n_lists"] = val["list_id"].nunique()
     stats["val_n_clicks"] = int(val["target"].sum())
     stats["val_n_impressions"] = len(val) - stats["val_n_clicks"]
     stats["val_ctr"] = stats["val_n_clicks"] / stats["val_n_impressions"]
@@ -257,6 +258,11 @@ def _common(
     # Join positive interactions (clicks) with negative interactions (impressions)
     interactions = interactions.merge(impressions_dl, "inner", "recommendation_id")
 
+    # Create unique id per (recommandation_id, user_id) pairs
+    interactions["list_id"] = pd.factorize(
+        interactions[["recommendation_id", "user_id"]].apply(tuple, axis=1)
+    )[0]
+
     # Mark positive interactions with 1 and negative with 0
     interactions["target"] = np.where(
         interactions["series_id"] == interactions["recommended_series_list"],
@@ -266,8 +272,14 @@ def _common(
     interactions["target"] = interactions["target"].astype("int32")
 
     interactions = interactions[
-        ["utc_ts_milliseconds", "user_id", "recommended_series_list", "target"]
+        [
+            "utc_ts_milliseconds",
+            "list_id",
+            "user_id",
+            "recommended_series_list",
+            "target",
+        ]
     ]
-    interactions.columns = ["timestamp", "user", "item", "target"]
+    interactions.columns = ["timestamp", "list_id", "user", "item", "target"]
 
     return interactions

src/mypackage/training/datamodules/datamodule.py

@@ -27,11 +27,11 @@ def setup(self, stage: Optional[str] = None):
         if stage == "fit":
             self.train_dataset = SimpleDataset(self.hparams.train)
             self.val_dataset = SimpleDataset(self.hparams.val)
-            # self.val_dataset = UserGroupedDataset(self.hparams.val)
+            # self.val_dataset = ListGroupedDataset(self.hparams.val)
 
         if stage == "test":
             self.test_dataset = SimpleDataset(self.hparams.test)
-            # self.test_dataset = UserGroupedDataset(self.hparams.test)
+            # self.test_dataset = ListGroupedDataset(self.hparams.test)
 
     def train_dataloader(self):
         return DataLoader(
@@ -52,7 +52,7 @@ def val_dataloader(self):
         )
         # return DataLoader(
         #     dataset=self.val_dataset,
-        #     batch_sampler=UserBatchSampler(self.val_dataset),
+        #     batch_sampler=ListBatchSampler(self.val_dataset),
         #     collate_fn=collate_fn,
         #     num_workers=self.hparams.num_workers,
         #     pin_memory=self.hparams.pin_memory,

src/mypackage/training/datamodules/dataset.py

@@ -7,6 +7,7 @@
 
 class SimpleDataset(Dataset):
     def __init__(self, data: pd.DataFrame):
+        self.list_ids = torch.tensor(data["list_id"].to_numpy())
         self.users = torch.tensor(data["user"].to_numpy())
         self.items = torch.tensor(data["item"].to_numpy())
         self.targets = torch.tensor(data["target"].to_numpy(), dtype=torch.float32)
@@ -15,47 +16,48 @@ def __len__(self):
         return len(self.users)
 
     def __getitem__(self, idx: int):
-        return self.users[idx], self.items[idx], self.targets[idx]
+        return self.list_ids[idx], self.users[idx], self.items[idx], self.targets[idx]
 
 
-class UserGroupedDataset(Dataset):
+class ListGroupedDataset(Dataset):
     def __init__(self, data: pd.DataFrame):
         self.data = data
-        self.unique_users = list(self.data["user"].unique())
-        self.user_groups = {
-            user: data[data["user"] == user].index.tolist()
-            for user in self.unique_users
-        }  # indices per user
+        self.unique_list_ids = list(self.data["list_id"].unique())
+        self.list_id_groups = {
+            list_id: data[data["list_id"] == list_id].index.tolist()
+            for list_id in self.unique_list_ids
+        }  # indices per list_id
 
     def __len__(self):
-        return len(self.unique_users)
+        return len(self.unique_list_ids)
 
     def __getitem__(self, idx):
-        user = self.unique_users[idx]  # Get user at index
-        user_indices = self.user_groups[user]  # Get all rows for this user
-        user_data = self.data.iloc[user_indices]  # Fetch data for this user
+        list_id = self.unique_list_ids[idx]  # Get list_id at index
+        list_id_indices = self.list_id_groups[list_id]  # Get all rows for this list_id
+        list_id_data = self.data.iloc[list_id_indices]  # Fetch data for this list_id
 
-        users = torch.tensor(user_data["user"].to_numpy())
-        items = torch.tensor(user_data["item"].to_numpy())
-        targets = torch.tensor(user_data["target"].to_numpy(), dtype=torch.float32)
-        return users, items, targets  # Return user-wise batch
+        list_ids = torch.tensor(list_id_data["list_id"].to_numpy())
+        users = torch.tensor(list_id_data["user"].to_numpy())
+        items = torch.tensor(list_id_data["item"].to_numpy())
+        targets = torch.tensor(list_id_data["target"].to_numpy(), dtype=torch.float32)
+        return list_ids, users, items, targets  # Return user-wise batch
 
 
-class UserBatchSampler(Sampler):
+class ListBatchSampler(Sampler):
     def __init__(self, dataset):
-        self.unique_users = dataset.unique_users
+        self.unique_list_ids = dataset.unique_list_ids
 
     def __iter__(self):
-        for i in range(len(self.unique_users)):
-            yield [i]  # Yield dataset indices for each user
+        for i in range(len(self.unique_list_ids)):
+            yield [i]  # Yield dataset indices for each list_id
 
     def __len__(self):
-        return len(self.unique_users)
+        return len(self.unique_list_ids)
 
 
 def collate_fn(batch):
-    users, items, targets = zip(*batch)
-    return users[0], items[0], targets[0]
+    list_ids, users, items, targets = zip(*batch)
+    return list_ids[0], users[0], items[0], targets[0]
 
 
 class CustomIterableDataset(IterableDataset):