add: jsonl datasets

trainer.py

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