nextrec 0.1.11__py3-none-any.whl → 0.2.2__py3-none-any.whl

nextrec/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.11"
+__version__ = "0.2.2"

nextrec/basic/activation.py

@@ -2,8 +2,7 @@
 Activation function definitions
 
 Date: create on 27/10/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 """
 
 import torch

nextrec/basic/callback.py

@@ -2,8 +2,7 @@
 EarlyStopper definitions
 
 Date: create on 27/10/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 """
 
 import copy

nextrec/basic/features.py

@@ -2,12 +2,11 @@
 Feature definitions
 
 Date: create on 27/10/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 """
-
-from typing import Optional
-from nextrec.utils import get_auto_embedding_dim
+from __future__ import annotations
+from typing import List, Sequence, Optional    
+from nextrec.utils.embedding import get_auto_embedding_dim
 
 class BaseFeature(object):
     def __repr__(self):
@@ -26,9 +25,9 @@ class SequenceFeature(BaseFeature):
         vocab_size: int,
         max_len: int = 20,
         embedding_name: str = '',
-        embedding_dim: Optional[int] = 4,
+        embedding_dim: int | None = 4,
         combiner: str = "mean",
-        padding_idx: Optional[int] = None,
+        padding_idx: int | None = None,
         init_type: str='normal',
         init_params: dict|None = None,
         l1_reg: float = 0.0,
@@ -55,7 +54,7 @@ class SparseFeature(BaseFeature):
                  name: str, 
                  vocab_size: int, 
                  embedding_name: str = '', 
-                 embedding_dim: int = 4, 
+                 embedding_dim: int | None  = 4, 
                  padding_idx: int | None = None,
                  init_type: str='normal',
                  init_params: dict|None = None,
@@ -84,4 +83,36 @@ class DenseFeature(BaseFeature):
         self.embedding_dim = embedding_dim
 
 
+class FeatureConfig:
+    """
+    Mixin that normalizes dense/sparse/sequence feature lists and target/id columns.
+    """
+
+    def _set_feature_config(
+        self,
+        dense_features: Sequence[DenseFeature] | None = None,
+        sparse_features: Sequence[SparseFeature] | None = None,
+        sequence_features: Sequence[SequenceFeature] | None = None,
+    ) -> None:
+        self.dense_features: List[DenseFeature] = list(dense_features) if dense_features else []
+        self.sparse_features: List[SparseFeature] = list(sparse_features) if sparse_features else []
+        self.sequence_features: List[SequenceFeature] = list(sequence_features) if sequence_features else []
+
+        self.all_features = self.dense_features + self.sparse_features + self.sequence_features
+        self.feature_names = [feat.name for feat in self.all_features]
+
+    def _set_target_config(
+        self,
+        target: str | Sequence[str] | None = None,
+        id_columns: str | Sequence[str] | None = None,
+    ) -> None:
+        self.target_columns = self._normalize_to_list(target)
+        self.id_columns = self._normalize_to_list(id_columns)
 
+    @staticmethod
+    def _normalize_to_list(value: str | Sequence[str] | None) -> list[str]:
+        if value is None:
+            return []
+        if isinstance(value, str):
+            return [value]
+        return list(value)

nextrec/basic/layers.py

@@ -2,8 +2,7 @@
 Layer implementations used across NextRec models.
 
 Date: create on 27/10/2025, update on 19/11/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 """
 
 from __future__ import annotations
@@ -17,7 +16,7 @@ import torch.nn.functional as F
 
 from nextrec.basic.activation import activation_layer
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
-from nextrec.utils.initializer import get_initializer_fn
+from nextrec.utils.initializer import get_initializer
 
 Feature = Union[DenseFeature, SparseFeature, SequenceFeature]
 
@@ -161,7 +160,7 @@ class EmbeddingLayer(nn.Module):
                 )
                 embedding.weight.requires_grad = feature.trainable
 
-                initialization = get_initializer_fn(
+                initialization = get_initializer(
                     init_type=feature.init_type,
                     activation="linear",
                     param=feature.init_params,

nextrec/basic/loggers.py

@@ -2,16 +2,18 @@
 NextRec Basic Loggers
 
 Date: create on 27/10/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 """
 
+
 import os
 import re
 import sys
 import copy
 import datetime
 import logging
+from pathlib import Path
+from nextrec.basic.session import resolve_save_path, create_session
 
 ANSI_CODES = {
     'black': '\033[30m',
@@ -89,16 +91,19 @@ def colorize(text: str, color: str | None = None, bold: bool = False) -> str:
 
     return result
 
-def setup_logger(log_dir: str | None = None):
+def setup_logger(session_id: str | os.PathLike | None = None):
     """Set up a logger that logs to both console and a file with ANSI formatting.
-       Only console output has colors; file output is stripped of ANSI codes.    
+       Only console output has colors; file output is stripped of ANSI codes.
+       Logs are stored under ``log/<experiment_id>/logs`` by default. A stable
+       log file is used per experiment so multiple components (e.g. data
+       processor and model training) append to the same file instead of creating
+       separate timestamped files.
     """
-    if log_dir is None:
-        project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        log_dir = os.path.join(project_root, "..", "logs")
-    
-    os.makedirs(log_dir, exist_ok=True)
-    log_file = os.path.join(log_dir, f"nextrec_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.log")
+
+    session = create_session(str(session_id) if session_id is not None else None)
+    log_dir = session.logs_dir
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / f"{session.experiment_id}.log"
 
     console_format = '%(message)s'
     file_format = '%(asctime)s - %(levelname)s - %(message)s'

nextrec/basic/metrics.py

@@ -2,8 +2,7 @@
 Metrics computation and configuration for model evaluation.
 
 Date: create on 27/10/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 """
 import logging
 import numpy as np

nextrec/basic/model.py

@@ -2,34 +2,35 @@
 Base Model & Base Match Model Class
 
 Date: create on 27/10/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Author: Yang Zhou,zyaztec@gmail.com
 """
 
 import os
 import tqdm
-import torch
 import logging
-import datetime
 import numpy as np
 import pandas as pd
+import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
+from pathlib import Path
 from typing import Union, Literal
 from torch.utils.data import DataLoader, TensorDataset
 
 from nextrec.basic.callback import EarlyStopper
-from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
+from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature, FeatureConfig
 from nextrec.basic.metrics import configure_metrics, evaluate_metrics
 
+from nextrec.loss import get_loss_fn, get_loss_kwargs
 from nextrec.data import get_column_data
+from nextrec.data.dataloader import build_tensors_from_data
 from nextrec.basic.loggers import setup_logger, colorize
-from nextrec.utils import get_optimizer_fn, get_scheduler_fn
-from nextrec.loss import get_loss_fn
+from nextrec.utils import get_optimizer, get_scheduler
+from nextrec.basic.session import resolve_save_path, create_session
 
 
-class BaseModel(nn.Module):
+class BaseModel(FeatureConfig, nn.Module):
     @property
     def model_name(self) -> str:
         raise NotImplementedError
@@ -43,6 +44,7 @@ class BaseModel(nn.Module):
                  sparse_features: list[SparseFeature] | None = None, 
                  sequence_features: list[SequenceFeature] | None = None,
                  target: list[str] | str | None = None,
+                 id_columns: list[str] | str | None = None,
                  task: str|list[str] = 'binary',
                  device: str = 'cpu',
                  embedding_l1_reg: float = 0.0,
@@ -50,26 +52,40 @@ class BaseModel(nn.Module):
                  embedding_l2_reg: float = 0.0, 
                  dense_l2_reg: float = 0.0,
                  early_stop_patience: int = 20, 
-                 model_path: str = './',
-                 model_id: str = 'baseline'): 
+                 session_id: str | None = None,): 
         
         super(BaseModel, self).__init__()
 
         try:
             self.device = torch.device(device)
         except Exception as e:
-            logging.warning(colorize("Invalid device , defaulting to CPU.", color='yellow'))
+            logging.warning("Invalid device , defaulting to CPU.")
             self.device = torch.device('cpu')
 
-        self.dense_features = list(dense_features) if dense_features is not None else []
-        self.sparse_features = list(sparse_features) if sparse_features is not None else []
-        self.sequence_features = list(sequence_features) if sequence_features is not None else []
-        
-        if isinstance(target, str):
-            self.target = [target]
-        else:
-            self.target = list(target) if target is not None else []
-        
+        self.session_id = session_id
+        self.session = create_session(session_id)
+        self.session_path = Path(self.session.logs_dir)
+        checkpoint_dir = self.session.checkpoints_dir / self.model_name
+
+        self.checkpoint = resolve_save_path(
+            path=None,
+            default_dir=checkpoint_dir,
+            default_name=self.model_name,
+            suffix=".model",
+            add_timestamp=True,
+        )
+
+        self.best = resolve_save_path(
+            path="best.model",
+            default_dir=checkpoint_dir,
+            default_name="best",
+            suffix=".model",
+        )
+
+        self._set_feature_config(dense_features, sparse_features, sequence_features)
+        self._set_target_config(target, id_columns)
+
+        self.target = self.target_columns
         self.target_index = {target_name: idx for idx, target_name in enumerate(self.target)}
 
         self.task = task
@@ -86,14 +102,6 @@ class BaseModel(nn.Module):
         self.early_stop_patience = early_stop_patience
         self._max_gradient_norm = 1.0   # Maximum gradient norm for gradient clipping
 
-        self.model_id = model_id
-
-        model_path = os.path.abspath(os.getcwd() if model_path in [None, './'] else model_path)
-        checkpoint_dir = os.path.join(model_path, "checkpoints", self.model_id)
-        os.makedirs(checkpoint_dir, exist_ok=True)
-        self.checkpoint = os.path.join(checkpoint_dir, f"{self.model_name}_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.model")
-        self.best = os.path.join(checkpoint_dir, f"{self.model_name}_{self.model_id}_best.model")
-
         self._logger_initialized = False
         self._verbose = 1
 
@@ -389,7 +397,9 @@ class BaseModel(nn.Module):
                 optimizer_params: dict | None = None,
                 scheduler: str | torch.optim.lr_scheduler._LRScheduler | type[torch.optim.lr_scheduler._LRScheduler] | None = None,
                 scheduler_params: dict | None = None,
-                loss: str | nn.Module | list[str | nn.Module] | None= "bce"):
+                loss: str | nn.Module | list[str | nn.Module] | None= "bce",
+                loss_params: dict | list[dict] | None = None):
+        
         if optimizer_params is None:
             optimizer_params = {}
         
@@ -404,9 +414,10 @@ class BaseModel(nn.Module):
             self._scheduler_name = None
         self._scheduler_params = scheduler_params or {}
         self._loss_config = loss
+        self._loss_params = loss_params
         
         # set optimizer
-        self.optimizer_fn = get_optimizer_fn(
+        self.optimizer_fn = get_optimizer(
             optimizer=optimizer, 
             params=self.parameters(), 
             **optimizer_params
@@ -419,7 +430,12 @@ class BaseModel(nn.Module):
             # For ranking and multitask, use pointwise training
             training_mode = 'pointwise' if self.task_type in ['ranking', 'multitask'] else None
             # Use task_type directly, not self.task_type for single task
-            self.loss_fn = [get_loss_fn(task_type=task_type, training_mode=training_mode, loss=loss_value)]
+            self.loss_fn = [get_loss_fn(
+                task_type=task_type,
+                training_mode=training_mode,
+                loss=loss_value,
+                **get_loss_kwargs(loss_params)
+            )]
         else:
             self.loss_fn = []
             for i in range(self.nums_task):
@@ -432,10 +448,15 @@ class BaseModel(nn.Module):
                 
                 # Multitask always uses pointwise training
                 training_mode = 'pointwise'
-                self.loss_fn.append(get_loss_fn(task_type=task_type, training_mode=training_mode, loss=loss_value))
+                self.loss_fn.append(get_loss_fn(
+                    task_type=task_type,
+                    training_mode=training_mode,
+                    loss=loss_value,
+                    **get_loss_kwargs(loss_params, i)
+                ))
         
         # set scheduler
-        self.scheduler_fn = get_scheduler_fn(scheduler, self.optimizer_fn, **(scheduler_params or {})) if scheduler else None
+        self.scheduler_fn = get_scheduler(scheduler, self.optimizer_fn, **(scheduler_params or {})) if scheduler else None
 
     def compute_loss(self, y_pred, y_true):
         if y_true is None:
@@ -456,54 +477,15 @@ class BaseModel(nn.Module):
     def _prepare_data_loader(self, data: dict|pd.DataFrame|DataLoader, batch_size: int = 32, shuffle: bool = True):
         if isinstance(data, DataLoader):
             return data
-        tensors = []
-        all_features = self.dense_features + self.sparse_features + self.sequence_features
-        
-        for feature in all_features:
-            column = get_column_data(data, feature.name)
-            if column is None:
-                raise KeyError(f"Feature {feature.name} not found in provided data.")
-            
-            if isinstance(feature, SequenceFeature):
-                if isinstance(column, pd.Series):
-                    column = column.values
-                if isinstance(column, np.ndarray) and column.dtype == object:
-                    column = np.array([np.array(seq, dtype=np.int64) if not isinstance(seq, np.ndarray) else seq for seq in column])
-                if isinstance(column, np.ndarray) and column.ndim == 1 and column.dtype == object:
-                    column = np.vstack([c if isinstance(c, np.ndarray) else np.array(c) for c in column])  # type: ignore
-                tensor = torch.from_numpy(np.asarray(column, dtype=np.int64)).to('cpu')
-            else:
-                dtype = torch.float32 if isinstance(feature, DenseFeature) else torch.long
-                tensor = self._to_tensor(column, dtype=dtype, device='cpu')
-            
-            tensors.append(tensor)
-        
-        label_tensors = []
-        for target_name in self.target:
-            column = get_column_data(data, target_name)
-            if column is None:
-                continue
-            label_tensor = self._to_tensor(column, dtype=torch.float32, device='cpu')
-            
-            if label_tensor.dim() == 1:
-                # 1D tensor: (N,) -> (N, 1)
-                label_tensor = label_tensor.view(-1, 1)
-            elif label_tensor.dim() == 2:
-                if label_tensor.shape[0] == 1 and label_tensor.shape[1] > 1:
-                    label_tensor = label_tensor.t()
-            
-            label_tensors.append(label_tensor)
-        
-        if label_tensors:
-            if len(label_tensors) == 1 and label_tensors[0].shape[1] > 1:
-                y_tensor = label_tensors[0]
-            else:
-                y_tensor = torch.cat(label_tensors, dim=1)
-
-            if y_tensor.shape[1] == 1:
-                y_tensor = y_tensor.squeeze(1)
-            tensors.append(y_tensor)
-        
+        tensors = build_tensors_from_data(
+            data=data,
+            raw_data=data,
+            features=self.all_features,
+            target_columns=self.target,
+            id_columns=getattr(self, "id_columns", []),
+            on_missing_feature="raise",
+        )
+        assert tensors is not None, "No tensors were created from provided data."
         dataset = TensorDataset(*tensors)
         return DataLoader(dataset, batch_size=batch_size, shuffle=shuffle)
 
@@ -549,7 +531,7 @@ class BaseModel(nn.Module):
 
         self.to(self.device)
         if not self._logger_initialized:
-            setup_logger()
+            setup_logger(session_id=self.session_id)
             self._logger_initialized = True
         self._verbose = verbose
         self._set_metrics(metrics) # add self.metrics, self.task_specific_metrics, self.best_metrics_mode, self.early_stopper
@@ -976,7 +958,11 @@ class BaseModel(nn.Module):
         )
 
 
-    def predict(self, data: str|dict|pd.DataFrame|DataLoader, batch_size: int = 32) -> np.ndarray:
+    def predict(self, 
+                data: str|dict|pd.DataFrame|DataLoader, 
+                batch_size: int = 32,
+                save_path: str | os.PathLike | None = None,
+                save_format: Literal["npy", "csv"] = "npy") -> np.ndarray:
         self.eval()
         # todo: handle file path input later
         if isinstance(data, (str, os.PathLike)):
@@ -999,12 +985,38 @@ class BaseModel(nn.Module):
 
         if len(y_pred_list) > 0:
             y_pred_all = np.concatenate(y_pred_list, axis=0)
-            return y_pred_all
         else:
-            return np.array([])
+            y_pred_all = np.array([])
+
+        if save_path is not None:
+            suffix = ".npy" if save_format == "npy" else ".csv"
+            target_path = resolve_save_path(
+                path=save_path,
+                default_dir=self.session.predictions_dir,
+                default_name="predictions",
+                suffix=suffix,
+                add_timestamp=True if save_path is None else False,
+            )
+
+            if save_format == "npy":
+                np.save(target_path, y_pred_all)
+            else:
+                pd.DataFrame(y_pred_all).to_csv(target_path, index=False)
+
+            if self._verbose:
+                logging.info(colorize(f"Predictions saved to: {target_path}", color="green"))
+
+        return y_pred_all
     
-    def save_weights(self, model_path: str):
-        torch.save(self.state_dict(), model_path)
+    def save_weights(self, model_path: str | os.PathLike | None):
+        target_path = resolve_save_path(
+            path=model_path,
+            default_dir=self.session.checkpoints_dir / self.model_name,
+            default_name=self.model_name,
+            suffix=".model",
+            add_timestamp=model_path is None,
+        )
+        torch.save(self.state_dict(), target_path)
     
     def load_weights(self, checkpoint):
         self.to(self.device)
@@ -1116,7 +1128,7 @@ class BaseModel(nn.Module):
         logger.info("Other Settings:")
         logger.info(f"  Early Stop Patience:   {self.early_stop_patience}")
         logger.info(f"  Max Gradient Norm:     {self._max_gradient_norm}")
-        logger.info(f"  Model ID:              {self.model_id}")
+        logger.info(f"  Session ID:            {self.session_id}")
         logger.info(f"  Checkpoint Path:       {self.checkpoint}")
         
         logger.info("")
@@ -1128,10 +1140,13 @@ class BaseMatchModel(BaseModel):
     Base class for match (retrieval/recall) models
     Supports pointwise, pairwise, and listwise training modes
     """
-    
+    @property
+    def model_name(self) -> str:
+        raise NotImplementedError
+
     @property
     def task_type(self) -> str:
-        return 'match'
+        raise NotImplementedError
     
     @property
     def support_training_modes(self) -> list[str]:
@@ -1161,7 +1176,7 @@ class BaseMatchModel(BaseModel):
                  embedding_l2_reg: float = 0.0,
                  dense_l2_reg: float = 0.0,
                  early_stop_patience: int = 20,
-                 model_id: str = 'baseline'):
+                 **kwargs):
         
         all_dense_features = []
         all_sparse_features = []
@@ -1192,7 +1207,7 @@ class BaseMatchModel(BaseModel):
             embedding_l2_reg=embedding_l2_reg,
             dense_l2_reg=dense_l2_reg,
             early_stop_patience=early_stop_patience,
-            model_id=model_id
+            **kwargs
         )
         
         self.user_dense_features = list(user_dense_features) if user_dense_features else []
@@ -1207,45 +1222,47 @@ class BaseMatchModel(BaseModel):
         self.num_negative_samples = num_negative_samples
         self.temperature = temperature
         self.similarity_metric = similarity_metric
-    
+
+        self.user_feature_names = [f.name for f in (
+            self.user_dense_features + self.user_sparse_features + self.user_sequence_features
+        )]
+        self.item_feature_names = [f.name for f in (
+            self.item_dense_features + self.item_sparse_features + self.item_sequence_features
+        )]
+
     def get_user_features(self, X_input: dict) -> dict:
-        user_input = {}
-        all_user_features = self.user_dense_features + self.user_sparse_features + self.user_sequence_features
-        for feature in all_user_features:
-            if feature.name in X_input:
-                user_input[feature.name] = X_input[feature.name]
-        return user_input
-    
+        return {
+            name: X_input[name]
+            for name in self.user_feature_names
+            if name in X_input
+        }
+
     def get_item_features(self, X_input: dict) -> dict:
-        item_input = {}
-        all_item_features = self.item_dense_features + self.item_sparse_features + self.item_sequence_features
-        for feature in all_item_features:
-            if feature.name in X_input:
-                item_input[feature.name] = X_input[feature.name]
-        return item_input
-    
+        return {
+            name: X_input[name]
+            for name in self.item_feature_names
+            if name in X_input
+        }
+        
     def compile(self, 
-                optimizer = "adam",
+                optimizer: str | torch.optim.Optimizer = "adam",
                 optimizer_params: dict | None = None,
                 scheduler: str | torch.optim.lr_scheduler._LRScheduler | type[torch.optim.lr_scheduler._LRScheduler] | None = None,
                 scheduler_params: dict | None = None,
-                loss: str | nn.Module | list[str | nn.Module] | None= None):
+                loss: str | nn.Module | list[str | nn.Module] | None = "bce",
+                loss_params: dict | list[dict] | None = None):
         """
         Compile match model with optimizer, scheduler, and loss function.
-        Validates that training_mode is supported by the model.
+        Mirrors BaseModel.compile while adding training_mode validation for match tasks.
         """
-        from nextrec.loss import validate_training_mode
-        
-        # Validate training mode is supported
-        validate_training_mode(
-            training_mode=self.training_mode,
-            support_training_modes=self.support_training_modes,
-            model_name=self.model_name
-        )
-        
+        if self.training_mode not in self.support_training_modes:
+            raise ValueError(
+                f"{self.model_name} does not support training_mode='{self.training_mode}'. "
+                f"Supported modes: {self.support_training_modes}"
+            )
+
         # Call parent compile with match-specific logic
-        if optimizer_params is None:
-            optimizer_params = {}
+        optimizer_params = optimizer_params or {}
         
         self._optimizer_name = optimizer if isinstance(optimizer, str) else optimizer.__class__.__name__
         self._optimizer_params = optimizer_params
@@ -1258,24 +1275,42 @@ class BaseMatchModel(BaseModel):
             self._scheduler_name = None
         self._scheduler_params = scheduler_params or {}
         self._loss_config = loss
+        self._loss_params = loss_params
         
         # set optimizer
-        self.optimizer_fn = get_optimizer_fn(
+        self.optimizer_fn = get_optimizer(
             optimizer=optimizer, 
             params=self.parameters(), 
             **optimizer_params
         )
         
         # Set loss function based on training mode
-        loss_value = loss[0] if isinstance(loss, list) else loss
+        default_losses = {
+            'pointwise': 'bce',
+            'pairwise': 'bpr',
+            'listwise': 'sampled_softmax',
+        }
+
+        if loss is None:
+            loss_value = default_losses.get(self.training_mode, "bce")
+        elif isinstance(loss, list):
+            loss_value = loss[0] if loss and loss[0] is not None else default_losses.get(self.training_mode, "bce")
+        else:
+            loss_value = loss
+
+        # Pairwise/listwise modes do not support BCE, fall back to sensible defaults
+        if self.training_mode in {"pairwise", "listwise"} and loss_value in {"bce", "binary_crossentropy"}:
+            loss_value = default_losses.get(self.training_mode, loss_value)
+
         self.loss_fn = [get_loss_fn(
             task_type='match',
             training_mode=self.training_mode,
-            loss=loss_value
+            loss=loss_value,
+            **get_loss_kwargs(loss_params, 0)
         )]
         
         # set scheduler
-        self.scheduler_fn = get_scheduler_fn(scheduler, self.optimizer_fn, **(scheduler_params or {})) if scheduler else None
+        self.scheduler_fn = get_scheduler(scheduler, self.optimizer_fn, **(scheduler_params or {})) if scheduler else None
 
     def compute_similarity(self, user_emb: torch.Tensor, item_emb: torch.Tensor) -> torch.Tensor:
         if self.similarity_metric == 'dot':