tokenizer.py

import os
import numpy as np
import json
from collections import defaultdict
import math
from math import ceil

import torch

from dataset import AbstractDataset

from sklearn.decomposition import PCA
from numpy.linalg import norm
from sklearn.cluster import KMeans

from datasets import load_from_disk, DatasetDict
from logging import getLogger



class AbstractTokenizer:
    def __init__(self, config: dict, dataset: AbstractDataset):
        self.config = config
        self.logger = getLogger()
        self.eos_token = None
        self.collate_fn = {'train': None, 'val': None, 'test': None}

    def _init_tokenizer(self):
        raise NotImplementedError('Tokenizer initialization not implemented.')

    def tokenize(self, datasets):
        raise NotImplementedError('Tokenization not implemented.')

    @property
    def vocab_size(self):
        raise NotImplementedError('Vocabulary size not implemented.')

    @property
    def padding_token(self):
        return 0

    @property
    def max_token_seq_len(self):
        raise NotImplementedError('Maximum token sequence length not implemented.')
    
    def log(self, message, level='info'):
        from utils import log
        return log(message,  self.logger, level=level)


class MDLMTokenizer(AbstractTokenizer):
    """
    Tokenizer for the MDLM model.
    using raw item feature
    use Faiss to generate rvq instead of training from scratch.
    An example when "rq_codebook_size == 128, rq_n_codebooks == 3":
        0: bos
        1-128: digit 1
        129-256: digit 2
        257-384: digit 3
        385-512: digit 4(aviod conflict)
        513: boi
        514: eos

    Args:
        config (dict): The configuration dictionary.
        dataset (AbstractDataset): The dataset object.

    Attributes:
        sid (dict): A dictionary mapping deviations to their semantic IDs.
        eos_token (int): The end-of-sequence token.
    init Saving :
        self.config["feature_type"]_sid.npy
    """
    def __init__(self, config: dict, dataset: AbstractDataset):
        super(MDLMTokenizer, self).__init__(config, dataset)
    
        self.bos_token = 0
        if self.config['cir'] == 'none':
            self.eos_token = dataset.n_items+1
        else:
            self.boi_token = 4*config['rq_codebook_size']+1 #config['rq_n_codebooks']*config['rq_codebook_size']+1
            self.eos_token = self.boi_token+1
         
        self.dataset_dir = dataset.dir
        self.weight, self.token, self.feature = self._init_tokenizer(dataset)
        self.eos_token_id = self.eos_token
        self.seq_len = int(config['seq_len'])
        
    def _load_emb_pca(self, dataset: AbstractDataset, pca_path: str):
        """
        load item embeddings for all items and use pca
        
        Args:
            dataset (AbstractDataset): The dataset containing the sentences to encode.
            
            output_path (str): The path to save the encoded sentence embeddings.

        Returns:
            numpy.ndarray: The pca sentence embeddings.
        """  
        sent_emb_path = os.path.join(
                    dataset.dir,
                    f'{self.config["feature_type"]}.pt')
        sent_embs = torch.load(sent_emb_path).detach().cpu().numpy()
    
        self.log(f'[TOKENIZER] Applying PCA to {self.config["feature_type"]} embeddings...')
        pca = PCA(n_components=self.config['sent_emb_pca'], whiten=True)
        sent_embs_pca = pca.fit_transform(sent_embs)

        np.save(pca_path, sent_embs_pca)
        self.log(f'[TOKENIZER] saving embeddings after PCA to: {pca_path}')        
        return sent_embs_pca


    # def _generate_semantic_id(
    #     self,
    #     rqvae_model: RQVAEModel,
    #     sent_embs: torch.Tensor,
    #     sem_ids_path: str
    # ) -> None:
    #     """
    #     Generates semantic IDs using the given RQVAE model and saves them to a file.

    #     Args:
    #         rqvae_model (RQVAEModel): The RQVAE model used for encoding sentence embeddings.
    #         sent_embs (torch.Tensor): The sentence embeddings to be encoded.
    #         sem_ids_path (str): The path to save the generated semantic IDs.

    #     Returns:
    #         None
    #     """
    #     rqvae_model.eval()
    #     rqvae_sem_ids = rqvae_model.encode(sent_embs)
    #     item2sem_ids = self._extend_semantic_ids(rqvae_sem_ids)
    #     self.log(f'[TOKENIZER] Saving semantic IDs to {sem_ids_path}...')
    #     with open(sem_ids_path, 'w') as f:
    #         json.dump(item2sem_ids, f)


    def _get_items_for_training(self, dataset: AbstractDataset) -> np.ndarray:
        """
        Get a boolean mask indicating which items are used for training.

        Args:
            dataset (AbstractDataset): The dataset containing the item sequences.

        Returns:
            np.ndarray: A boolean mask indicating which items are used for training.
        """
        # items_for_training = set()
        # for item_seq in dataset['train']['item_seq']:
        #     for item in item_seq:
        #         items_for_training.add(item)
        # self.log(f'[TOKENIZER] Items for training: {len(items_for_training)} of {dataset.n_items - 1}')
        self.log(f'Using all items for training.')
        # mask = np.zeros(dataset.n_items - 1, dtype=bool)
        mask =  np.ones(dataset.n_items, dtype=bool)  # Use all items for training
        # for item in items_for_training:
        #     mask[item - 1] = True
        return mask

    def _extend_semantic_ids(self, sem_ids: np.ndarray):
        """
        Extends the semantic IDs from k digits to (k + 1) digits to avoid conflict.

        Args:
            sem_ids (np.ndarray): The input array of semantic IDs.

        Returns:
            dict: A dictionary mapping item IDs to semantic IDs.
        """
        sem_id2item = defaultdict(list)
        item2sem_ids = {}
        max_conflict = 0
        for i in range(sem_ids.shape[0]):
            str_id = ' '.join(map(str, sem_ids[i].tolist()))
            sem_id2item[str_id].append(i)
            item2sem_ids[i] = (*tuple(sem_ids[i].tolist()), len(sem_id2item[str_id]))
            max_conflict = max(max_conflict, len(sem_id2item[str_id]))
        self.log(f'[TOKENIZER] RQ-VAE semantic IDs, maximum conflict: {max_conflict}')
        if max_conflict > self.n_codebook[-1]:
            raise ValueError(
                f'[TOKENIZER] RQ-VAE semantic IDs conflict with codebook size: '
                f'{max_conflict} > {self.n_codebook[-1]}. Please increase the codebook size.'
            )
        return item2sem_ids

    def _generate_semantic_id_faiss(
        self,
        sent_embs: np.ndarray,
        sid_path: str,
        weight_path: str
    ) -> None:

        n_bits = int(np.log2(self.config['rq_codebook_size']))

        import faiss
        faiss.omp_set_num_threads(self.config['faiss_omp_num_threads'])
        index = faiss.IndexResidualQuantizer(
            sent_embs.shape[-1],
            self.config['rq_n_codebooks'],
            n_bits,
            faiss.METRIC_INNER_PRODUCT
        )
        self.log(f'[TOKENIZER] Training index...')
        if isinstance(sent_embs, torch.Tensor):
            sent_embs = sent_embs.detach().cpu().numpy().astype(np.float32, copy=False)        
        index.train(sent_embs)
        index.add(sent_embs)
        faiss_sem_ids = []
        uint8_code = index.rq.compute_codes(sent_embs)
        n_bytes = uint8_code.shape[1]
        self.logger.info(f'[TOKENIZER] Generating semantic IDs...')
        for u8_code in uint8_code:
            bs = faiss.BitstringReader(faiss.swig_ptr(u8_code), n_bytes)
            code = []
            for i in range(self.config['rq_n_codebooks']):
                code.append(bs.read(n_bits))
            faiss_sem_ids.append(code)
        faiss_sem_ids = np.array(faiss_sem_ids)
        item2sem_ids = self._extend_semantic_ids(faiss_sem_ids)
        self.log(f'[TOKENIZER] Saving semantic IDs to {sid_path}...')
        np.save(sid_path, item2sem_ids)
        
        rq = index.rq
        M = int(rq.M)                      
        d = int(rq.d)                     
        nbits_array = faiss.vector_to_array(rq.nbits)
        ks = int(2 ** nbits_array[0]) 

        codebooks = faiss.vector_to_array(rq.codebooks).reshape(M, ks, d)
        merged_codebook = codebooks.reshape(-1, d)
        
        np.save(weight_path, merged_codebook)
        print(f"[TOKENIZER] Final codebook shape: {merged_codebook.shape}")
    
        return item2sem_ids,merged_codebook
    
    def _token_to_feature(self, token) -> np.ndarray:
        """
        Converts token to feature(token not in dataset)
        """ 
        # remove the last conflict-avoiding index and boi token
        token = token[:-1]
        # token -> semantic ids
        
        sid = []
        for digit in range(len(token)-1):
            sid.append(token[digit]-1) #-self.n_codebook[digit]*digit

        feature = torch.zeros(self.weight.shape[-1])
        for i in sid:
            feature+=self.weight[i]
        return feature

    def _sem_ids_to_tokens(self, sid,token_path) -> dict:
        """
        Converts semantic IDs to tokens.
        """
        for item in range(len(sid)):
            tokens = list(sid[item])
            for digit in range(self.n_digit):
                # "+ 1" as 0 is reserved for padding
                tokens[digit] += self.n_codebook[digit] * digit + 1
            tokens[-1] += self.n_codebook[-1] * self.n_digit 
            sid[item] = tuple(tokens)   
                 
        json.dump(sid, open(token_path, 'w'), indent=4)
        return sid


    def _init_tokenizer(self, dataset: AbstractDataset):
        """
        Initialize the tokenizer.

        Args:
            dataset (AbstractDataset): The dataset object.

        Returns:
            dict: A dictionary mapping items to semantic IDs.
        """
      
        # Load semantic IDs
        sid_path = os.path.join(dataset.dir, f'{self.config["feature_type"]}_sid.npy')
        weight_path = os.path.join(dataset.dir, f'{self.config["feature_type"]}_weight.npy')
        token_path = os.path.join(dataset.dir, f'{self.config["feature_type"]}_token.json')
        if self.config['sent_emb_pca'] > 0:
            feature_path=os.path.join(dataset.dir,f'{self.config["feature_type"]}_pca.npy')
            if not os.path.exists(feature_path):
                sent_embs = self._load_emb_pca(dataset, feature_path)
            else:
                sent_embs = np.load(feature_path)
        else:
            feature_path=os.path.join(dataset.dir,f'{self.config["feature_type"]}.pt')
            sent_embs = torch.load(feature_path).cpu().numpy()
        
        if not os.path.exists(sid_path) or not os.path.exists(weight_path) or not os.path.exists(token_path) :
            self.log(f'[TOKENIZER] embeddings shape: {sent_embs.shape}')
            
            # Generate semantic IDs
            # mask = self._get_items_for_training(dataset)
            if self.config['rq_faiss']:
                self.log(f'[TOKENIZER] Semantic IDs not found. Training index using Faiss...')
                sid, weight = self._generate_semantic_id_faiss(sent_embs,sid_path,weight_path)
                token = self._sem_ids_to_tokens(sid,token_path)
                return weight, token, sent_embs
        self.log(f'[TOKENIZER] Loading item Semantic IDs')
        sid = np.load(sid_path,allow_pickle=True)
        token = json.load(open(token_path, 'r'))
        weight = np.load(weight_path,allow_pickle=True)

        return weight ,token, sent_embs

    @property
    def n_digit(self):
        """
        Returns the number of digits for the tokenizer.
        """
        return self.config['rq_n_codebooks']

    @property
    def n_codebook(self):
        """
        Returns the codebook size for the TIGER tokenizer.

        If `rq_codebook_size` is a list, it returns the list as is.
        If `rq_codebook_size` is an integer, it returns a list with `n_digit` elements,
        where each element is equal to `rq_codebook_size`.

        Returns:
            list: The codebook size for the TIGER tokenizer.
        """
        if isinstance(self.config['rq_codebook_size'], list):
            return self.config['rq_codebook_size']
        else:
            return [self.config['rq_codebook_size']] * self.n_digit

    def _tokenize_once(self, item_seq, test_gt=False) -> list:
        """
        Tokenizes a single example."""
            
        input_ids = []
        input_ids.append(self.bos_token)

        for i in item_seq:
            i_token = self.token[i]
            if test_gt: 
                input_ids.extend(i_token) 
            else:                
                input_ids.extend([self.boi_token] + i_token) 
        input_ids.append(self.eos_token)
        
        return input_ids

    def tokenize_function(self, example: dict, split: str) -> dict:
        """
        Tokenizes the input example based on the specified split.

        Args:
            example (dict): The input example containing bundle and item sequence.
            split (str): The split type, either 'train' or any other value.

        """
        item_seq = example['item_seq'][0]     
        item_seq = item_seq[:self.seq_len]
        if split=='test':
            # Tokenize the example
            index = math.ceil(len(item_seq) / 2)
            input_part = self._tokenize_once(item_seq[:index])
            label_part = self._tokenize_once(item_seq[index:],test_gt=True)
            attention_mask = [1] * len(input_part)
            for i, token in enumerate(input_part):
                if token in [self.bos_token, self.eos_token, self.boi_token]: #
                    attention_mask[i] = 0
            return {
                'input_ids': [input_part], 
                'attention_mask': [attention_mask], 
                'labels': [label_part]
            }
        else:
            pass
            # # train & valid
            # input_ids = self._tokenize_once(item_seq)
              
            # attention_mask = [1] * len(input_ids)
            # for i, token in enumerate(input_ids):
            #     if token in [self.bos_token, self.eos_token,self.boi_token]: #
            #         attention_mask[i] = 0
            # return {
            #     'input_ids': [input_ids],
            #     'attention_mask': [attention_mask]}
        
    def raw_tokenize_function(self, example:dict, split: str) -> dict:
        item_seq = example['item_seq'][0]    
        item_seq = item_seq[:self.seq_len] 
        
        if split=='test':
            index = math.ceil(len(item_seq) / 2)
            input_part = [self.bos_token]+[int(x)+1 for x in item_seq[:index]]+[self.eos_token]
            label_part = [int(x)+1 for x in item_seq[index:]]
            attention_mask = [1] * len(input_part)
            for i, token in enumerate(input_part):
                if token in [self.bos_token, self.eos_token]: #, self.boi_token
                    attention_mask[i] = 0
            return {
                'input_ids': [input_part], 
                'attention_mask': [attention_mask], 
                'labels': [label_part]
            }
        else:
            # pass
            input_ids = [self.bos_token]+[int(x)+1 for x in item_seq]+[self.eos_token]
              
            attention_mask = [1] * len(input_ids)
            for i, token in enumerate(input_ids):
                if token in [self.bos_token, self.eos_token]: # self.boi_token
                    attention_mask[i] = 0
            return {
                'input_ids': [input_ids],
                'attention_mask': [attention_mask]}
            
        
    def _token_single_item(self, item: str) -> int:
        """
        Tokenizes a single item.

        Args:
            item (str): The item to be tokenized.

        Returns:
            list: The tokens corresponding to the item.
        """
        return self.item2tokens[item]
    

    def transfer(self, sequence: np.ndarray) -> np.ndarray:
        sequence = [int(i) for i in sequence]
        features = self.feature[sequence]  

        # Step 1: clustering into len(sequence) // 10 clusters
        num_clusters = len(sequence)//self.config['cir']
        kmeans = KMeans(n_clusters=num_clusters, random_state=42).fit(features)
        cluster_centers = kmeans.cluster_centers_  #  [num_clusters, D]

        # Step 2: use FAISS weight to get semantic id for each cluster center
        weight = self.weight.reshape(self.config['rq_n_codebooks'],self.config['rq_codebook_size'],-1)
        cluster_centers = cluster_centers.astype(np.float32)
        result = []
        for i in range(len(cluster_centers)):
            residual = cluster_centers[i].copy()
            code_indices = []

            for j in range(weight.shape[0]): 
                centers = weight[j]           
                distances = np.linalg.norm(residual - centers, axis=1)
                best_code = np.argmin(distances)
                residual = residual - centers[best_code]  
                code_indices.append(int(best_code)+j*self.config['rq_codebook_size']+1) #padding token
            result.extend([self.boi_token]+code_indices)
        return result
       

    def itemsid2comp(self, example: dict, split: str) -> dict: #单个处理
        item_seq = example['item_seq'][0]
        item_seq = item_seq[:self.config['seq_len']]   
        if split=='test':
            index = 10 #ceil(self.config['seq_len']/2/self.config['cir'])*self.config['cir']  
            
            # input component
            input_part = [self.bos_token] + self.transfer(item_seq[:index]) + [self.eos_token]
            # label --> item sequences
            label_part = self._tokenize_once(item_seq[index:],test_gt=True)
            
            attention_mask = [1] * len(input_part)
            for i, token in enumerate(input_part):
                if token in [self.bos_token, self.eos_token, self.boi_token]:
                    attention_mask[i] = 0         
            
            return {
                'input_ids': [input_part], 
                'attention_mask': [attention_mask], 
                'labels': [label_part]
            }
        else:
            # pass
            comp_seq = self.transfer(item_seq)
            input_ids = [self.bos_token] + comp_seq + [self.eos_token]
            attention_mask = [1] * len(input_ids)
            for i, token in enumerate(input_ids):
                if token in [self.bos_token, self.eos_token, self.boi_token]:
                    attention_mask[i] = 0

            return {
                'input_ids': [input_ids],
                'attention_mask': [attention_mask]}
    

    def transfor_tokenzie(self, datasets: dict) -> dict:
        comp_path = os.path.join(self.dataset_dir, f'{self.config["feature_type"]}_comp_{self.config["cir"]}_{self.config["seq_len"]}')
        if os.path.exists(comp_path):
            tokenized_datasets = load_from_disk(comp_path)
        else:
            tokenized_datasets = {}
            datasets['train'] = datasets['train'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
            datasets['valid'] = datasets['valid'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
            datasets['test'] = datasets['test'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
            for split in datasets.keys():
                tokenized_datasets[split] = datasets[split].map(
                    lambda t: self.itemsid2comp(t, split),
                    batched=True,
                    batch_size=1, 
                    remove_columns=datasets[split].column_names,
                    num_proc=self.config['num_proc'],
                    desc=f'Tokenizing {split} set: '
                )
            for split in datasets:
                tokenized_datasets[split].set_format(type='torch')
            
            tokenized_datasets = DatasetDict(tokenized_datasets)
            tokenized_datasets.save_to_disk(comp_path)
        return tokenized_datasets


    def raw_tokenize(self, datasets:dict) -> dict:
        """
        Tokenizes(Do not use rqvae)
        """
        tokenized_datasets = {}
        datasets['train'] = datasets['train'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
        datasets['valid'] = datasets['valid'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
        datasets['test'] = datasets['test'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
        for split in datasets.keys():
            tokenized_datasets[split] = datasets[split].map(
                lambda t: self.raw_tokenize_function(t, split),
                batched=True,
                batch_size=1,
                remove_columns=datasets[split].column_names,
                num_proc=self.config['num_proc'],
                desc=f'Tokenizing {split} set: '
            )

        for split in datasets:
            tokenized_datasets[split].set_format(type='torch')

        return tokenized_datasets
    
        
    def tokenize(self, datasets: dict) -> dict:
        """
        Tokenizes the given datasets.

        Args:
            datasets (dict): A dictionary of datasets to tokenize.

        Returns:
            dict: A dictionary of tokenized datasets.
        """
        tokenized_datasets = {}
        datasets['train'] = datasets['train'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
        datasets['valid'] = datasets['valid'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
        datasets['test'] = datasets['test'].filter(lambda x: len(x['item_seq']) >= self.config['seq_len'])
                        

        for split in datasets.keys():
            tokenized_datasets[split] = datasets[split].map(
                lambda t: self.tokenize_function(t, split),
                batched=True,
                batch_size=1,
                remove_columns=datasets[split].column_names,
                num_proc=self.config['num_proc'],
                desc=f'Tokenizing {split} set: '
            )


        for split in datasets:
            tokenized_datasets[split].set_format(type='torch')

        return tokenized_datasets

    @property
    def vocab_size(self) -> int:
        """
        Returns the vocabulary size for the MDLM tokenizer.
        """
        return self.eos_token + 1 #

    @property
    def max_token_seq_len(self) -> int:
        # +2 for bos token and eos token
        return self.config['max_item_seq_len'] * self.n_digit + 2