nextrec 0.4.21__py3-none-any.whl → 0.4.23__py3-none-any.whl

nextrec/models/ranking/eulernet.py

@@ -32,7 +32,7 @@ EulerNet 使用欧拉公式将特征嵌入映射到复数域，通过复数相
 """
 
 from __future__ import annotations
-
+from typing import Literal
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -61,7 +61,7 @@ class EulerInteractionLayer(nn.Module):
         num_fields: int,
         num_orders: int,
         use_implicit: bool = True,
-        norm: str | None = "ln",  # None | "bn" | "ln"
+        norm: Literal["bn", "ln"] | None = "ln",  # None | "bn" | "ln"
         eps: float = 1e-9,
     ):
         super().__init__()
@@ -203,42 +203,22 @@ class EulerNet(BaseModel):
         num_layers: int = 2,
         num_orders: int = 8,
         use_implicit: bool = True,
-        norm: str | None = "ln",
+        norm: Literal["bn", "ln"] | None = "ln",
         use_linear: bool = False,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
         dense_features = dense_features or []
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(EulerNet, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
         self.use_linear = use_linear
 
         self.linear_features = dense_features + sparse_features + sequence_features
@@ -303,13 +283,6 @@ class EulerNet(BaseModel):
             embedding_attr="embedding", include_modules=modules
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         field_emb = self.embedding(
             x=x, features=self.interaction_features, squeeze_dim=False

nextrec/models/ranking/ffm.py

@@ -63,35 +63,16 @@ class FFM(BaseModel):
         dense_features: list[DenseFeature] | None = None,
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
         dense_features = dense_features or []
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(FFM, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
@@ -154,13 +135,6 @@ class FFM(BaseModel):
             embedding_attr="field_aware_embeddings", include_modules=["linear_dense"]
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def field_aware_key(
         self, src_feature: SparseFeature | SequenceFeature, target_field
     ) -> str:

nextrec/models/ranking/fibinet.py

@@ -41,8 +41,7 @@ FiBiNET 是一个 CTR 预估模型，通过 SENET 重新分配特征字段的重
 """
 
 import torch
-import torch.nn as nn
-
+from typing import Literal
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import (
     LR,
@@ -71,19 +70,13 @@ class FiBiNET(BaseModel):
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
         mlp_params: dict | None = None,
-        interaction_combo: str = "11",  # "0": Hadamard, "1": Bilinear
-        bilinear_type: str = "field_interaction",
+        interaction_combo: Literal[
+            "01", "11", "10", "00"
+        ] = "11",  # "0": Hadamard, "1": Bilinear
+        bilinear_type: Literal[
+            "field_all", "field_each", "field_interaction"
+        ] = "field_interaction",
         senet_reduction: int = 3,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
@@ -91,24 +84,14 @@ class FiBiNET(BaseModel):
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
         mlp_params = mlp_params or {}
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(FiBiNET, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
         self.linear_features = sparse_features + sequence_features
         self.interaction_features = sparse_features + sequence_features
 
@@ -166,7 +149,7 @@ class FiBiNET(BaseModel):
         num_pairs = self.num_fields * (self.num_fields - 1) // 2
         interaction_dim = num_pairs * self.embedding_dim * 2
         self.mlp = MLP(input_dim=interaction_dim, **mlp_params)
-        self.prediction_layer = TaskHead(task_type=self.default_task)
+        self.prediction_layer = TaskHead(task_type=self.task)
 
         # Register regularization weights
         self.register_regularization_weights(
@@ -180,13 +163,6 @@ class FiBiNET(BaseModel):
             ],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         input_linear = self.embedding(
             x=x, features=self.linear_features, squeeze_dim=True

nextrec/models/ranking/fm.py

@@ -38,8 +38,6 @@ FM 是一种通过分解二阶特征交互矩阵、以线性复杂度建模特
 - 结构简单、表现强健，常作 CTR 基线
 """
 
-import torch.nn as nn
-
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import FM as FMInteraction
 from nextrec.basic.heads import TaskHead
@@ -61,16 +59,6 @@ class FM(BaseModel):
         dense_features: list[DenseFeature] | None = None,
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
@@ -82,19 +70,9 @@ class FM(BaseModel):
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
-        if self.loss is None:
-            self.loss = "bce"
-
         self.fm_features = sparse_features + sequence_features
         if len(self.fm_features) == 0:
             raise ValueError("FM requires at least one sparse or sequence feature.")
@@ -111,13 +89,6 @@ class FM(BaseModel):
             embedding_attr="embedding", include_modules=["linear"]
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         input_fm = self.embedding(x=x, features=self.fm_features, squeeze_dim=False)
         y_linear = self.linear(input_fm.flatten(start_dim=1))

nextrec/models/ranking/lr.py

@@ -38,8 +38,6 @@ LR 是 CTR/排序任务中最经典的线性基线模型。它将稠密、稀疏
 - 权重可解释性强
 """
 
-import torch.nn as nn
-
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import EmbeddingLayer, LR as LinearLayer
 from nextrec.basic.heads import TaskHead
@@ -60,41 +58,20 @@ class LR(BaseModel):
         dense_features: list[DenseFeature] | None = None,
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
         dense_features = dense_features or []
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(LR, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
-
         self.embedding = EmbeddingLayer(features=self.all_features)
         linear_input_dim = self.embedding.input_dim
         self.linear = LinearLayer(linear_input_dim)
@@ -104,13 +81,6 @@ class LR(BaseModel):
             embedding_attr="embedding", include_modules=["linear"]
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         input_linear = self.embedding(x=x, features=self.all_features, squeeze_dim=True)
         y = self.linear(input_linear)

nextrec/models/ranking/masknet.py

@@ -56,7 +56,7 @@ embedding 表示生成一个个性化的 “mask” 向量，通过逐元素的
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-
+from typing import Literal
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
 from nextrec.basic.heads import TaskHead
@@ -167,48 +167,28 @@ class MaskNet(BaseModel):
         dense_features: list[DenseFeature] | None = None,
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
-        architecture: str = "parallel",  # "serial" or "parallel"
+        architecture: Literal[
+            "serial", "parallel"
+        ] = "parallel",  # "serial" or "parallel"
         num_blocks: int = 3,
         mask_hidden_dim: int = 64,
         block_hidden_dim: int = 256,
         block_dropout: float = 0.0,
         mlp_params: dict | None = None,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
         dense_features = dense_features or []
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
-        target = target or []
         mlp_params = mlp_params or {}
-        optimizer_params = optimizer_params or {}
 
         super().__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        if loss is None:
-            loss = "bce"
-        self.loss = loss
-
         self.dense_features = dense_features
         self.sparse_features = sparse_features
         self.sequence_features = sequence_features
@@ -293,12 +273,6 @@ class MaskNet(BaseModel):
             self.register_regularization_weights(
                 embedding_attr="embedding", include_modules=["mask_blocks", "final_mlp"]
             )
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
 
     def forward(self, x: dict[str, torch.Tensor]) -> torch.Tensor:
         field_emb = self.embedding(x=x, features=self.mask_features, squeeze_dim=False)

nextrec/models/ranking/pnn.py

@@ -36,7 +36,7 @@ PNN 是一种 CTR 预估模型，通过将线性信号与乘积信号结合，
 
 import torch
 import torch.nn as nn
-
+from typing import Literal
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
 from nextrec.basic.heads import TaskHead
@@ -59,18 +59,10 @@ class PNN(BaseModel):
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
         mlp_params: dict | None = None,
-        product_type: str = "inner",  # "inner" (IPNN), "outer" (OPNN), "both" (PNN*)
+        product_type: Literal[
+            "inner", "outer", "both"
+        ] = "inner",  # "inner" (IPNN), "outer" (OPNN), "both" (PNN*)
         outer_product_dim: int | None = None,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
@@ -80,20 +72,11 @@ class PNN(BaseModel):
         mlp_params = mlp_params or {}
         if outer_product_dim is not None and outer_product_dim <= 0:
             raise ValueError("outer_product_dim must be a positive integer.")
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(PNN, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
@@ -144,13 +127,6 @@ class PNN(BaseModel):
             embedding_attr="embedding", include_modules=modules
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def compute_inner_products(self, field_emb: torch.Tensor) -> torch.Tensor:
         interactions = []
         for i in range(self.num_fields - 1):

nextrec/models/ranking/widedeep.py

@@ -38,8 +38,6 @@ Wide & Deep 同时使用宽线性部分（记忆共现/手工交叉）与深网
 - 共享特征空间，减少工程开销
 """
 
-import torch.nn as nn
-
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import LR, MLP, EmbeddingLayer
 from nextrec.basic.heads import TaskHead
@@ -61,40 +59,16 @@ class WideDeep(BaseModel):
         sparse_features: list[SparseFeature],
         sequence_features: list[SequenceFeature],
         mlp_params: dict,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
-        if target is None:
-            target = []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
-
         super(WideDeep, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
-
         # Wide part: use all features for linear model
         self.wide_features = sparse_features + sequence_features
         # Deep part: use all features
@@ -117,12 +91,6 @@ class WideDeep(BaseModel):
         self.register_regularization_weights(
             embedding_attr="embedding", include_modules=["linear", "mlp"]
         )
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
 
     def forward(self, x):
         # Deep part

nextrec/models/ranking/xdeepfm.py

@@ -121,41 +121,18 @@ class xDeepFM(BaseModel):
         mlp_params: dict,
         cin_size: list[int] | None = None,
         split_half: bool = True,
-        target: list[str] | str | None = None,
-        task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
         cin_size = cin_size or [128, 128]
-        if target is None:
-            target = []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(xDeepFM, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
-
         # Linear part and CIN part: use sparse and sequence features
         self.linear_features = sparse_features + sequence_features
 
@@ -195,13 +172,6 @@ class xDeepFM(BaseModel):
             embedding_attr="embedding", include_modules=["linear", "cin", "mlp"]
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         # Get embeddings for linear and CIN (sparse features only)
         input_linear = self.embedding(

nextrec/models/retrieval/dssm.py

@@ -10,7 +10,6 @@ Reference:
 from typing import Literal
 
 import torch
-import torch.nn as nn
 
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
@@ -54,17 +53,6 @@ class DSSM(BaseMatchModel):
         dense_l1_reg=0.0,
         embedding_l2_reg=0.0,
         dense_l2_reg=0.0,
-        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 = "bce",
-        loss_params: dict | list[dict] | None = None,
         **kwargs,
     ):
 
@@ -159,18 +147,6 @@ class DSSM(BaseMatchModel):
             embedding_attr="item_embedding", include_modules=["item_dnn"]
         )
 
-        if optimizer_params is None:
-            optimizer_params = {"lr": 1e-3, "weight_decay": 1e-5}
-
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def user_tower(self, user_input: dict) -> torch.Tensor:
         """
         User tower encodes user features into embeddings.

nextrec/models/retrieval/dssm_v2.py

@@ -9,7 +9,6 @@ DSSM v2 - DSSM with pairwise training using BPR loss
 from typing import Literal
 
 import torch
-import torch.nn as nn
 
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
@@ -50,17 +49,6 @@ class DSSM_v2(BaseMatchModel):
         dense_l1_reg: float = 0.0,
         embedding_l2_reg: float = 0.0,
         dense_l2_reg: float = 0.0,
-        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 = "bce",
-        loss_params: dict | list[dict] | None = None,
         **kwargs,
     ):
 
@@ -151,18 +139,6 @@ class DSSM_v2(BaseMatchModel):
             embedding_attr="item_embedding", include_modules=["item_dnn"]
         )
 
-        if optimizer_params is None:
-            optimizer_params = {"lr": 1e-3, "weight_decay": 1e-5}
-
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def user_tower(self, user_input: dict) -> torch.Tensor:
         """User tower"""
         all_user_features = (