feat: add ONNX export, hash ID mapping, and map_item_ids

- Add hash-based ID mapping (splitmix64) as alternative to dense
  torch.unique mapping in build_sequences and align_embeddings.
- Add UniSRecModel.export_to_onnx() for native ONNX export of
  encoder and item embeddings (project_all).
- Add UniSRecModel.map_item_ids() for external→internal ID conversion
  at inference time (works for both dense and hash modes).
- Remove FlatSASRecModel/FlatSASRecLightning (RecTools-coupled wrappers
  that duplicated UniSRecModel functionality).
- Add tests: hash mapping (including string-derived IDs),
  ONNX export roundtrip, map_item_ids for both modes.

Author: TOPAPEC

rectools/fast_transformers/__init__.py

@@ -1,8 +1,6 @@
 """Fast Transformers: flat sequential recommenders without ItemNet hierarchy."""
 
-from .gpu_data import GPUBatchDataset, align_embeddings, build_sequences, make_dataloader
-from .lightning_wrap import FlatSASRecLightning
-from .model import FlatSASRecConfig, FlatSASRecModel
+from .gpu_data import GPUBatchDataset, align_embeddings, build_sequences, hash_item_ids, make_dataloader
 from .net import FlatSASRec, SASRecBlock
 from .ranking import rank_topk
 from .unisrec_lightning import UniSRecLightning
@@ -12,13 +10,11 @@
 __all__ = [
     "build_sequences",
     "align_embeddings",
+    "hash_item_ids",
     "GPUBatchDataset",
     "make_dataloader",
     "FlatSASRec",
     "SASRecBlock",
-    "FlatSASRecLightning",
-    "FlatSASRecModel",
-    "FlatSASRecConfig",
     "rank_topk",
     "UniSRec",
     "FeedForward",

rectools/fast_transformers/gpu_data.py

@@ -7,20 +7,49 @@
 from torch.utils.data import Dataset as TorchDataset
 
 
+def _splitmix64(x: torch.Tensor) -> torch.Tensor:
+    """Vectorized splitmix64 bit-mixer: element-wise int64 hash over a torch tensor.
+
+    Standard library hashes (``hash()``, ``hashlib``) operate on scalar Python objects
+    and cannot be vectorized across GPU tensors.  Splitmix64 is pure int64 arithmetic,
+    so it maps naturally to ``torch.Tensor`` ops and runs on any device.
+
+    Reference: https://xorshift.di.unimi.it/splitmix64.c (Vigna, 2015).
+    """
+    x = x.long()
+    x = (x ^ (x >> 30)) * (-4658895280553007687)  # 0xbf58476d1ce4e5b9 as signed int64
+    x = (x ^ (x >> 27)) * (-7723592293110705685)  # 0x94d049bb133111eb as signed int64
+    return x ^ (x >> 31)
+
+
+def hash_item_ids(item_ids: torch.Tensor, dict_size: int) -> torch.Tensor:
+    """Map arbitrary integer item IDs to [1, dict_size] via splitmix64 hash."""
+    return _splitmix64(item_ids) % dict_size + 1
+
+
 def build_sequences(
     user_ids: torch.Tensor,
     item_ids: torch.Tensor,
     timestamps: torch.Tensor,
     max_len: int,
     min_interactions: int = 2,
     device: str = "cuda",
+    id_mapping: str = "dense",
 ) -> tp.Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
     user_ids = user_ids.to(device)
     item_ids = item_ids.to(device)
     timestamps = timestamps.to(device)
 
-    unique_items, item_inv = torch.unique(item_ids, return_inverse=True)
-    internal_items = item_inv + 1
+    unique_items = torch.unique(item_ids)
+    n_unique = len(unique_items)
+
+    if id_mapping == "dense":
+        _, item_inv = torch.unique(item_ids, return_inverse=True)
+        internal_items = item_inv + 1
+    elif id_mapping == "hash":
+        internal_items = hash_item_ids(item_ids, n_unique)
+    else:
+        raise ValueError(f"Unknown id_mapping: {id_mapping}. Use 'dense' or 'hash'")
 
     unique_users, user_inv = torch.unique(user_ids, return_inverse=True)
 
@@ -74,16 +103,23 @@ def align_embeddings(
     pretrained: torch.Tensor,
     unique_items: torch.Tensor,
     n_items: int,
+    id_mapping: str = "dense",
 ) -> torch.Tensor:
     idx = unique_items.long().cpu()
     valid = (idx >= 0) & (idx < pretrained.shape[0])
 
     if pretrained.ndim == 2:
         aligned = torch.zeros(n_items + 1, pretrained.shape[1])
-        aligned[1:][valid] = pretrained[idx[valid]]
     else:
         aligned = torch.zeros(n_items + 1, pretrained.shape[1], pretrained.shape[2])
+
+    if id_mapping == "dense":
         aligned[1:][valid] = pretrained[idx[valid]]
+    elif id_mapping == "hash":
+        positions = hash_item_ids(idx, n_items)
+        aligned[positions[valid]] = pretrained[idx[valid]]
+    else:
+        raise ValueError(f"Unknown id_mapping: {id_mapping}. Use 'dense' or 'hash'")
 
     return aligned