add: jsonl datasets

.gitattributes

@@ -56,3 +56,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+item_embeds.jsonl filter=lfs diff=lfs merge=lfs -text
+items.jsonl filter=lfs diff=lfs merge=lfs -text
+train_user_embeds.jsonl filter=lfs diff=lfs merge=lfs -text

item_embeds.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:532fbf779ba0eb43e912ba2b71d5a365ef81338cfa15b21f48a73dd9a9ad299b
+size 131523872

items.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe287350120532df4faebc2800fcf3a12fd1b6c9c64aef297201505ca526cc02
+size 22533508

train_user_embeds.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3aba551cdd6686fbde99e38a7e5e6c15d4d39e29a2dd767e9de390e2e1da25d6
+size 29748871

trainer.py

@@ -0,0 +1,303 @@
+from os import environ, path
+from transformers import BertTokenizerFast, FlaxAutoModel
+import jax.numpy as jnp
+import jax
+from flax.training.train_state import TrainState
+import pandas as pd
+from tyrec.trainer import BaseTrainer, loss, HFConfig
+from tyrec.recommendations.model import RecommendationModel
+from tyrec.utils import compute_mean, logger
+from tyrec.evaluator import RetrivalEvaluator
+from tyrec.utils import trange
+
+
+class RecommendationsTrainer(BaseTrainer):
+    def __init__(
+        self,
+        hf_config: HFConfig,
+        data_dir,
+        event_to_train,
+        threshold=0,
+        dimensions=0,
+        other_features=False,
+        *args,
+        **kwargs,
+    ):
+        self.model_name = hf_config.model_name
+        self.data_dir = data_dir
+        self.query_prompt = hf_config.query_prompt
+        self.doc_prompt = hf_config.doc_prompt
+        self.event_to_train = event_to_train
+        self.other_features = other_features
+        self.text_encoder = FlaxAutoModel.from_pretrained(self.model_name)
+        self.tokenizer = BertTokenizerFast.from_pretrained(self.model_name)
+        self.base_path = (
+            "/content/drive/MyDrive/"
+            if "COLAB_ENV" in environ and environ["COLAB_ENV"] == "true"
+            else "./"
+        )
+        self.train_file = path.join(self.base_path, data_dir, "train.jsonl")
+        self.eval_file = path.join(self.base_path, data_dir, "test.jsonl")
+        self.items_file = path.join(self.base_path, data_dir, "items.jsonl")
+        self.item_embeddings_file = path.join(
+            self.base_path, data_dir, "item_embeds.jsonl"
+        )
+        self.train_user_embeddings_file = path.join(
+            self.base_path, data_dir, "train_user_embeds.jsonl"
+        )
+        self.test_user_embeddings_file = path.join(
+            self.base_path, data_dir, "test_user_embeds.jsonl"
+        )
+        self.dimensions = (
+            dimensions if dimensions > 0 else self.text_encoder.config.hidden_size
+        )
+        model = RecommendationModel(self.dimensions)
+        super().__init__(*args, model=model, **kwargs)
+        self.dataloader = pd.read_json(self.train_file, lines=True)
+        self.dataloader = self.dataloader[
+            self.dataloader["event"] == self.event_to_train
+        ].reset_index(drop=True)
+        self.test_dataset = pd.read_json(self.eval_file, lines=True)
+        self.test_dataset = self.test_dataset[
+            self.test_dataset["event"] == self.event_to_train
+        ].reset_index(drop=True)
+        unique_did = (
+            pd.concat([self.dataloader, self.test_dataset], ignore_index=True)["did"]
+            .unique()
+            .tolist()
+        )
+        self.items = pd.read_json(self.items_file, lines=True)
+        self.items = self.items[self.items["did"].isin(unique_did)].reset_index(
+            drop=True
+        )
+        self.threshold = threshold
+        self.evaluator: RetrivalEvaluator | None = None
+        self.item_embeds = []
+        self.train_user_embeds = []
+        self.train_label_embeds = []
+        self.test_user_embeds = []
+        self.test_label_embeds = []
+        self.rng = jax.random.PRNGKey(0)
+
+    def embed_items(self, examples):
+        texts = [self.doc_prompt + x for x in examples["text"].tolist()]
+        tokens = self.tokenizer(
+            texts,
+            truncation=True,
+            padding="max_length",
+            return_tensors="jax",
+            max_length=70,
+        )
+        embeddings = self.text_encoder(**tokens).last_hidden_state
+        embeddings = self.mean_pooling(embeddings, tokens["attention_mask"])
+        embeddings = embeddings / jnp.linalg.norm(embeddings, axis=-1, keepdims=True)
+        if self.other_features:
+            embeddings = [embeddings[i] for i in range(embeddings.shape[0])]
+            features = examples["features"].tolist()
+            for i in range(len(embeddings)):
+                embeddings[i] = jnp.concatenate([embeddings[i], jnp.array(features[i])])
+            embeddings = jnp.array(embeddings)
+        return [embeddings[i] for i in range(embeddings.shape[0])]
+
+    def embed_events(self, df):
+        user_vecs = []
+        label_vecs = []
+        for _, row in df.iterrows():
+            label = self.items[self.items["did"] == row["label"]["did"]].index.tolist()[
+                0
+            ]
+            history = [x["did"] for x in row["data"]]
+            multi_hot = [0] * len(self.item_embeds)
+            indexes = (
+                self.items[self.items["did"].isin(history)]
+                .index.reindex(
+                    self.items[self.items["did"].isin(history)]["did"]
+                    .map(dict(zip(history, range(len(history)))))
+                    .sort_values()
+                    .index
+                )[0]
+                .tolist()
+            )
+            for idx in indexes:
+                multi_hot[idx] = 1
+            multi_hot = jnp.array(multi_hot)
+            user_vecs.append(compute_mean(self.item_embeds, multi_hot))
+            label_vecs.append(label)
+        return jnp.array(user_vecs), jnp.array(label_vecs)
+
+    def group_events(self, df):
+        df = df.sort_values(["sid", "ts"])
+
+        def group_to_dict_array(to_dict):
+            return to_dict.drop(["sid", "event"], axis=1).to_dict("records")
+
+        grouped_data = []
+        for (sid,), group in df.groupby(["sid"]):
+            data = group_to_dict_array(group)
+            if len(data) > 2:
+                grouped_data.append(
+                    {
+                        "sid": sid,
+                        "data": data[:-1],
+                        "label": data[-1],
+                    }
+                )
+        grouped_data = pd.DataFrame(grouped_data)
+        return grouped_data
+
+    @staticmethod
+    def users_to_sessions(file_path, threshold):
+        df = pd.read_json(file_path, lines=True)
+        if threshold > 0:
+
+            def create_intervals(group):
+                group = group.copy()
+                group["time_diff"] = group["ts"].diff()
+                group["interval"] = (group["time_diff"] > threshold).cumsum()
+                return group.drop("time_diff", axis=1)
+
+            df_list = [create_intervals(group) for _, group in df.groupby("sid")]
+            df = pd.concat(df_list, ignore_index=True)
+        else:
+            df["interval"] = 0
+
+        return df
+
+    def load_item_embeddings(self):
+        item_embeds = pd.read_json(self.item_embeddings_file, lines=True)
+        item_with_embeds = pd.merge(self.items, item_embeds, on="did", how="left")
+        return [jnp.array(x) for x in item_with_embeds["embed"]]
+
+    def load_user_embeddings(self, df, file_path):
+        user_embeds = pd.read_json(file_path, lines=True)
+        user_with_embeds = pd.merge(df, user_embeds, on="sid", how="left")
+        return jnp.array([jnp.array(x) for x in user_with_embeds["embed"]]), jnp.array(
+            [
+                self.items[self.items["did"] == x["did"]].index.tolist()[0]
+                for x in user_with_embeds["label"]
+            ]
+        )
+
+    def setup(self):
+        corpus = {
+            f"{self.items.loc[x]['did']}": self.items.loc[x]["text"]
+            for x in range(len(self.items))
+        }
+        if path.exists(self.item_embeddings_file):
+            logger.info("Found a saved item embedding file...")
+            self.item_embeds = self.load_item_embeddings()
+        else:
+            for start in trange(0, len(self.items), 128, desc="Embedding items"):
+                end = min(start + 128, len(self.items))
+                e = self.embed_items(self.items.loc[start : end - 1])
+                self.item_embeds.extend(e)
+        self.item_embeds = jnp.array(self.item_embeds)
+        self.dataloader = self.group_events(self.dataloader)
+        self.dataset_len = len(self.dataloader)
+        self.test_dataset = self.group_events(self.test_dataset)
+        self.dataset_len = len(self.dataloader)
+
+        if path.exists(self.train_user_embeddings_file):
+            logger.info("Found a saved train embedding file...")
+            self.train_user_embeds, self.train_label_embeds = self.load_user_embeddings(
+                self.dataloader, self.train_user_embeddings_file
+            )
+        else:
+            self.train_user_embeds, self.train_label_embeds = self.embed_events(
+                self.dataloader
+            )
+
+        if path.exists(self.test_user_embeddings_file):
+            logger.info("Found a saved test embedding file...")
+            self.test_user_embeds, self.test_label_embeds = self.load_user_embeddings(
+                self.test_dataset, self.test_user_embeddings_file
+            )
+        else:
+            self.test_user_embeds, self.test_label_embeds = self.embed_events(
+                self.test_dataset
+            )
+        users = {
+            f"{self.test_dataset.loc[x]['sid']}": self.test_dataset.loc[x]["sid"]
+            for x in range(len(self.test_dataset))
+        }
+        relevant_docs = {
+            f"{self.test_dataset.loc[x]['sid']}": [
+                f"{self.test_dataset.loc[x]['label']['did']}"
+            ]
+            for x in range(len(self.test_dataset))
+        }
+        self.evaluator = RetrivalEvaluator(
+            queries=users,
+            corpus=corpus,
+            relevant_docs=relevant_docs,
+            corpus_chunk_size=40000,
+            batch_size=512,
+            show_progress_bar=True,
+        )
+
+    def get_initial_params(self):
+        batch = jnp.array([jnp.zeros(self.text_encoder.config.hidden_size)])
+        params = self.model.init(jax.random.PRNGKey(0), batch, batch, training=False)
+        return params["params"]
+
+    def train_step(self, _batch, start, end):
+        self.rng, rng = jax.random.split(self.rng)
+        batch = jax.random.permutation(rng, jnp.array(self.train_user_embeds))[
+            start:end
+        ]
+        labels = jax.random.permutation(rng, jnp.array(self.train_label_embeds))[
+            start:end
+        ]
+        user_vec = jnp.array(batch)
+        items_vec = jnp.array(self.item_embeds)
+        state, l = train_step(self.state, user_vec, items_vec, labels, rng)
+        q, d = self.model.apply(
+            {"params": self.state.params},
+            jnp.array(self.test_user_embeds),
+            jnp.array(self.item_embeds),
+            training=False,
+            rngs=rng,
+        )
+        q = q / jnp.linalg.norm(q, axis=1, keepdims=True)
+        d = d / jnp.linalg.norm(d, axis=1, keepdims=True)
+        val_l = loss.sparse_categorical_cross_entropy(
+            q,
+            d,
+            self.test_label_embeds,
+        )
+        self.val_loss.append(val_l)
+        return state, l
+
+    def eval_step(self):
+        q, d = self.model.apply(
+            {"params": self.state.params},
+            jnp.array(self.test_user_embeds),
+            jnp.array(self.item_embeds),
+            training=False,
+        )
+        q = q / jnp.linalg.norm(q, axis=1, keepdims=True)
+        d = d / jnp.linalg.norm(d, axis=1, keepdims=True)
+        self.evaluator(query_embeddings=q, corpus_embeddings=d, metrics=["recall"])
+
+
+@jax.jit
+def train_step(state: TrainState, user_embeds, item_embeds, labels, rng):
+    def loss_fn(params):
+        u = user_embeds / jnp.linalg.norm(user_embeds, axis=-1, keepdims=True)
+        i = item_embeds / jnp.linalg.norm(item_embeds, axis=-1, keepdims=True)
+        u, i = state.apply_fn(
+            {"params": params},
+            u,
+            i,
+            training=True,
+            rngs={"dropout": rng},
+        )
+        u = u / jnp.linalg.norm(u, axis=-1, keepdims=True)
+        i = i / jnp.linalg.norm(i, axis=-1, keepdims=True)
+        l = loss.sparse_categorical_cross_entropy(u, i, labels)
+        return l
+
+    grad_fn = jax.value_and_grad(loss_fn)
+    l, grads = grad_fn(state.params)
+    state = state.apply_gradients(grads=grads)
+    return state, l