torch-rechub 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

torch_rechub/models/ranking/din.py

@@ -1,91 +1,93 @@
-"""
-Date: create on 23/04/2022, update on 30/04/2022
-References: 
-    paper: (KDD'2018) Deep Interest Network for Click-Through Rate Prediction 
-    url: https://arxiv.org/abs/1706.06978
-    code: https://github.com/huawei-noah/benchmark/blob/main/FuxiCTR/fuxictr/pytorch/models/DIN.py
-Authors: Mincai Lai, laimincai@shanghaitech.edu.cn
-"""
-
-import torch
-import torch.nn as nn
-
-from ...basic.layers import EmbeddingLayer, MLP
-
-
-class DIN(nn.Module):
-    """Deep Interest Network
-    Args:
-        features (list): the list of `Feature Class`. training by MLP. It means the user profile features and context features in origin paper, exclude history and target features.
-        history_features (list): the list of `Feature Class`,training by ActivationUnit. It means the user behaviour sequence features, eg.item id sequence, shop id sequence.
-        target_features (list): the list of `Feature Class`, training by ActivationUnit. It means the target feature which will execute target-attention with history feature.
-        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
-        attention_mlp_params (dict): the params of the ActivationUnit module, keys include:`{"dims":list, "activation":str, "dropout":float, "use_softmax":bool`}
-    """
-
-    def __init__(self, features, history_features, target_features, mlp_params, attention_mlp_params):
-        super().__init__()
-        self.features = features
-        self.history_features = history_features
-        self.target_features = target_features
-        self.num_history_features = len(history_features)
-        self.all_dims = sum([fea.embed_dim for fea in features + history_features + target_features])
-
-        self.embedding = EmbeddingLayer(features + history_features + target_features)
-        self.attention_layers = nn.ModuleList(
-            [ActivationUnit(fea.embed_dim, **attention_mlp_params) for fea in self.history_features])
-        self.mlp = MLP(self.all_dims, activation="dice", **mlp_params)
-
-    def forward(self, x):
-        embed_x_features = self.embedding(x, self.features)  #(batch_size, num_features, emb_dim)
-        embed_x_history = self.embedding(
-            x, self.history_features)  #(batch_size, num_history_features, seq_length, emb_dim)
-        embed_x_target = self.embedding(x, self.target_features)  #(batch_size, num_target_features, emb_dim)
-        attention_pooling = []
-        for i in range(self.num_history_features):
-            attention_seq = self.attention_layers[i](embed_x_history[:, i, :, :], embed_x_target[:, i, :])
-            attention_pooling.append(attention_seq.unsqueeze(1))  #(batch_size, 1, emb_dim)
-        attention_pooling = torch.cat(attention_pooling, dim=1)  #(batch_size, num_history_features, emb_dim)
-
-        mlp_in = torch.cat([
-            attention_pooling.flatten(start_dim=1),
-            embed_x_target.flatten(start_dim=1),
-            embed_x_features.flatten(start_dim=1)
-        ],
-                           dim=1)  #(batch_size, N)
-
-        y = self.mlp(mlp_in)
-        return torch.sigmoid(y.squeeze(1))
-
-
-class ActivationUnit(nn.Module):
-    """Activation Unit Layer mentioned in DIN paper, it is a Target Attention method.
-
-    Args:
-        embed_dim (int): the length of embedding vector.
-        history (tensor):
-    Shape:
-        - Input: `(batch_size, seq_length, emb_dim)`
-        - Output: `(batch_size, emb_dim)`
-    """
-
-    def __init__(self, emb_dim, dims=None, activation="dice", use_softmax=False):
-        super(ActivationUnit, self).__init__()
-        if dims is None:
-            dims = [36]
-        self.emb_dim = emb_dim
-        self.use_softmax = use_softmax
-        self.attention = MLP(4 * self.emb_dim, dims=dims, activation=activation)
-
-    def forward(self, history, target):
-        seq_length = history.size(1)
-        target = target.unsqueeze(1).expand(-1, seq_length, -1)  #batch_size,seq_length,emb_dim
-        att_input = torch.cat([target, history, target - history, target * history],
-                              dim=-1)  # batch_size,seq_length,4*emb_dim
-        att_weight = self.attention(att_input.view(-1, 4 * self.emb_dim))  #  #(batch_size*seq_length,4*emb_dim)
-        att_weight = att_weight.view(-1, seq_length)  #(batch_size*seq_length, 1) -> (batch_size,seq_length)
-        if self.use_softmax:
-            att_weight = att_weight.softmax(dim=-1)
-        # (batch_size, seq_length, 1) * (batch_size, seq_length, emb_dim)
-        output = (att_weight.unsqueeze(-1) * history).sum(dim=1)  #(batch_size,emb_dim)
-        return output
+"""
+Date: create on 23/04/2022, update on 30/04/2022
+References:
+    paper: (KDD'2018) Deep Interest Network for Click-Through Rate Prediction
+    url: https://arxiv.org/abs/1706.06978
+    code: https://github.com/huawei-noah/benchmark/blob/main/FuxiCTR/fuxictr/pytorch/models/DIN.py
+Authors: Mincai Lai, laimincai@shanghaitech.edu.cn
+"""
+
+import torch
+import torch.nn as nn
+
+from ...basic.layers import MLP, EmbeddingLayer
+
+
+class DIN(nn.Module):
+    """Deep Interest Network
+    Args:
+        features (list): the list of `Feature Class`. training by MLP. It means the user profile features and context features in origin paper, exclude history and target features.
+        history_features (list): the list of `Feature Class`,training by ActivationUnit. It means the user behaviour sequence features, eg.item id sequence, shop id sequence.
+        target_features (list): the list of `Feature Class`, training by ActivationUnit. It means the target feature which will execute target-attention with history feature.
+        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
+        attention_mlp_params (dict): the params of the ActivationUnit module, keys include:`{"dims":list, "activation":str, "dropout":float, "use_softmax":bool`}
+    """
+
+    def __init__(self, features, history_features, target_features, mlp_params, attention_mlp_params):
+        super().__init__()
+        self.features = features
+        self.history_features = history_features
+        self.target_features = target_features
+        self.num_history_features = len(history_features)
+        self.all_dims = sum([fea.embed_dim for fea in features + history_features + target_features])
+
+        self.embedding = EmbeddingLayer(features + history_features + target_features)
+        self.attention_layers = nn.ModuleList([ActivationUnit(fea.embed_dim, **attention_mlp_params) for fea in self.history_features])
+        self.mlp = MLP(self.all_dims, activation="dice", **mlp_params)
+
+    def forward(self, x):
+        # (batch_size, num_features, emb_dim)
+        embed_x_features = self.embedding(x, self.features)
+        # (batch_size, num_history_features, seq_length, emb_dim)
+        embed_x_history = self.embedding(x, self.history_features)
+        # (batch_size, num_target_features, emb_dim)
+        embed_x_target = self.embedding(x, self.target_features)
+        attention_pooling = []
+        for i in range(self.num_history_features):
+            attention_seq = self.attention_layers[i](embed_x_history[:, i, :, :], embed_x_target[:, i, :])
+            attention_pooling.append(attention_seq.unsqueeze(1))  # (batch_size, 1, emb_dim)
+        # (batch_size, num_history_features, emb_dim)
+        attention_pooling = torch.cat(attention_pooling, dim=1)
+
+        mlp_in = torch.cat([attention_pooling.flatten(start_dim=1), embed_x_target.flatten(start_dim=1), embed_x_features.flatten(start_dim=1)], dim=1)  # (batch_size, N)
+
+        y = self.mlp(mlp_in)
+        return torch.sigmoid(y.squeeze(1))
+
+
+class ActivationUnit(nn.Module):
+    """Activation Unit Layer mentioned in DIN paper, it is a Target Attention method.
+
+    Args:
+        embed_dim (int): the length of embedding vector.
+        history (tensor):
+    Shape:
+        - Input: `(batch_size, seq_length, emb_dim)`
+        - Output: `(batch_size, emb_dim)`
+    """
+
+    def __init__(self, emb_dim, dims=None, activation="dice", use_softmax=False):
+        super(ActivationUnit, self).__init__()
+        if dims is None:
+            dims = [36]
+        self.emb_dim = emb_dim
+        self.use_softmax = use_softmax
+        self.attention = MLP(4 * self.emb_dim, dims=dims, activation=activation)
+
+    def forward(self, history, target):
+        seq_length = history.size(1)
+        # batch_size,seq_length,emb_dim
+        target = target.unsqueeze(1).expand(-1, seq_length, -1)
+        att_input = torch.cat([target, history, target - history, target * history], dim=-1)  # batch_size,seq_length,4*emb_dim
+        # (batch_size*seq_length,4*emb_dim)
+        att_weight = self.attention(att_input.view(-1, 4 * self.emb_dim))
+        # (batch_size*seq_length, 1) -> (batch_size,seq_length)
+        att_weight = att_weight.view(-1, seq_length)
+        if self.use_softmax:
+            att_weight = att_weight.softmax(dim=-1)
+
+
+# (batch_size, seq_length, 1) * (batch_size, seq_length, emb_dim)
+# (batch_size,emb_dim)
+        output = (att_weight.unsqueeze(-1) * history).sum(dim=1)
+        return output

torch_rechub/models/ranking/edcn.py

@@ -1,117 +1,101 @@
-"""
-Date: create on 09/13/2022
-References:
-    paper: (KDD'21) EDCN: Enhancing Explicit and Implicit Feature Interactions via Information Sharing for Parallel Deep CTR Models
-    url: https://dlp-kdd.github.io/assets/pdf/DLP-KDD_2021_paper_12.pdf
-Authors: lailai, lailai_zxy@tju.edu.cn
-"""
-
-import torch
-from torch import nn
-from ...basic.layers import LR, MLP, CrossLayer,  EmbeddingLayer
-
-
-class EDCN(torch.nn.Module):
-    """Deep & Cross Network with a mixture of low-rank architecture
-
-    Args:
-        features (list[Feature Class]): training by the whole module.
-        n_cross_layers (int) : the number of layers of feature intersection layers
-        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
-        bridge_type (str): the type interaction function, in ["hadamard_product", "pointwise_addition", "concatenation", "attention_pooling"]
-        use_regulation_module (bool): True, whether to use regulation module
-        temperature (int): the temperature coefficient to control distribution
-    """
-
-    def __init__(self, features, n_cross_layers, mlp_params, bridge_type="hadamard_product", use_regulation_module=True,
-                 temperature=1):
-        super().__init__()
-        self.features = features
-        self.n_cross_layers = n_cross_layers
-        self.num_fields = len(features)
-        self.dims = sum([fea.embed_dim for fea in features])
-        self.fea_dims = [fea.embed_dim for fea in features]
-        self.embedding = EmbeddingLayer(features)
-        self.cross_layers = nn.ModuleList([CrossLayer(self.dims) for _ in range(n_cross_layers)])
-        self.bridge_modules = nn.ModuleList([BridgeModule(self.dims, bridge_type) for _ in range(n_cross_layers)])
-        self.regulation_modules = nn.ModuleList([RegulationModule(self.num_fields,
-                                                   self.fea_dims,
-                                                   tau=temperature,
-                                                   use_regulation=use_regulation_module) for _ in range(n_cross_layers)])
-        mlp_params["dims"] = [self.dims, self.dims]
-        self.mlps = nn.ModuleList([MLP(self.dims, output_layer=False, **mlp_params) for _ in range(n_cross_layers)])
-        self.linear = LR(self.dims * 3)
-
-    def forward(self, x):
-        embed_x = self.embedding(x, self.features, squeeze_dim=True)
-        cross_i, deep_i = self.regulation_modules[0](embed_x)
-        cross_0 = cross_i
-        for i in range(self.n_cross_layers):
-            if i>0:
-                cross_i, deep_i = self.regulation_modules[i](bridge_i)
-            cross_i = cross_i + self.cross_layers[i](cross_0, cross_i)
-            deep_i = self.mlps[i](deep_i)
-            bridge_i = self.bridge_modules[i](cross_i, deep_i)
-        x_stack = torch.cat([cross_i, deep_i, bridge_i], dim=1)
-        y = self.linear(x_stack)
-        return torch.sigmoid(y.squeeze(1))
-
-
-class BridgeModule(torch.nn.Module):
-    def __init__(self, input_dim, bridge_type):
-        super(BridgeModule, self).__init__()
-        assert bridge_type in ["hadamard_product", "pointwise_addition", "concatenation",
-                               "attention_pooling"], 'bridge_type= is not supported'.format(bridge_type)
-        self.bridge_type = bridge_type
-        if bridge_type=="concatenation":
-            self.concat_pooling = nn.Sequential(nn.Linear(input_dim * 2, input_dim),
-                                                nn.ReLU())
-        elif bridge_type=="attention_pooling":
-            self.attention_x = nn.Sequential(nn.Linear(input_dim, input_dim),
-                                             nn.ReLU(),
-                                             nn.Linear(input_dim, input_dim,bias=False),
-                                             nn.Softmax(dim=-1))
-            self.attention_h = nn.Sequential(nn.Linear(input_dim, input_dim),
-                                             nn.ReLU(),
-                                             nn.Linear(input_dim, input_dim,bias=False),
-                                             nn.Softmax(dim=-1))
-    def forward(self, x, h):
-        if self.bridge_type == "hadamard_product":
-            out = x * h
-        elif self.bridge_type == "pointwise_addition":
-            out = x + h
-        elif self.bridge_type == "concatenation":
-            out = self.concat_pooling(torch.cat([x, h], dim=-1))
-        elif self.bridge_type == "attention_pooling":
-            out = self.attention_x(x) * x + self.attention_h(h) * h
-        return out
-
-
-class RegulationModule(torch.nn.Module):
-    def __init__(self, num_fields,
-                 dims,
-                 tau,
-                 use_regulation=True):
-        super(RegulationModule, self).__init__()
-        self.use_regulation = use_regulation
-        if self.use_regulation:
-            self.num_fields = num_fields
-            self.dims = dims
-            self.tau = tau
-            self.g1 = nn.Parameter(torch.ones(num_fields))
-            self.g2 = nn.Parameter(torch.ones(num_fields))
-
-    def forward(self, x):
-        if self.use_regulation:
-            g1 = torch.cat([(self.g1[i]/ self.tau).softmax(dim=-1).unsqueeze(-1).repeat(1, self.dims[i]) for i in range(self.num_fields)], dim=-1)
-            g2 = torch.cat([(self.g2[i] / self.tau).softmax(dim=-1).unsqueeze(-1).repeat(1, self.dims[i]) for i in range(self.num_fields)], dim=-1)
-
-            out1, out2 = g1*x, g2*x
-        else:
-            out1, out2 = x, x
-        return out1, out2
-
-
-
-
-
+"""
+Date: create on 09/13/2022
+References:
+    paper: (KDD'21) EDCN: Enhancing Explicit and Implicit Feature Interactions via Information Sharing for Parallel Deep CTR Models
+    url: https://dlp-kdd.github.io/assets/pdf/DLP-KDD_2021_paper_12.pdf
+Authors: lailai, lailai_zxy@tju.edu.cn
+"""
+
+import torch
+from torch import nn
+
+from ...basic.layers import LR, MLP, CrossLayer, EmbeddingLayer
+
+
+class EDCN(torch.nn.Module):
+    """Deep & Cross Network with a mixture of low-rank architecture
+
+    Args:
+        features (list[Feature Class]): training by the whole module.
+        n_cross_layers (int) : the number of layers of feature intersection layers
+        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
+        bridge_type (str): the type interaction function, in ["hadamard_product", "pointwise_addition", "concatenation", "attention_pooling"]
+        use_regulation_module (bool): True, whether to use regulation module
+        temperature (int): the temperature coefficient to control distribution
+    """
+
+    def __init__(self, features, n_cross_layers, mlp_params, bridge_type="hadamard_product", use_regulation_module=True, temperature=1):
+        super().__init__()
+        self.features = features
+        self.n_cross_layers = n_cross_layers
+        self.num_fields = len(features)
+        self.dims = sum([fea.embed_dim for fea in features])
+        self.fea_dims = [fea.embed_dim for fea in features]
+        self.embedding = EmbeddingLayer(features)
+        self.cross_layers = nn.ModuleList([CrossLayer(self.dims) for _ in range(n_cross_layers)])
+        self.bridge_modules = nn.ModuleList([BridgeModule(self.dims, bridge_type) for _ in range(n_cross_layers)])
+        self.regulation_modules = nn.ModuleList([RegulationModule(self.num_fields, self.fea_dims, tau=temperature, use_regulation=use_regulation_module) for _ in range(n_cross_layers)])
+        mlp_params["dims"] = [self.dims, self.dims]
+        self.mlps = nn.ModuleList([MLP(self.dims, output_layer=False, **mlp_params) for _ in range(n_cross_layers)])
+        self.linear = LR(self.dims * 3)
+
+    def forward(self, x):
+        embed_x = self.embedding(x, self.features, squeeze_dim=True)
+        cross_i, deep_i = self.regulation_modules[0](embed_x)
+        cross_0 = cross_i
+        for i in range(self.n_cross_layers):
+            if i > 0:
+                cross_i, deep_i = self.regulation_modules[i](bridge_i)
+            cross_i = cross_i + self.cross_layers[i](cross_0, cross_i)
+            deep_i = self.mlps[i](deep_i)
+            bridge_i = self.bridge_modules[i](cross_i, deep_i)
+        x_stack = torch.cat([cross_i, deep_i, bridge_i], dim=1)
+        y = self.linear(x_stack)
+        return torch.sigmoid(y.squeeze(1))
+
+
+class BridgeModule(torch.nn.Module):
+
+    def __init__(self, input_dim, bridge_type):
+        super(BridgeModule, self).__init__()
+        assert bridge_type in ["hadamard_product", "pointwise_addition", "concatenation", "attention_pooling"], 'bridge_type= is not supported'.format(bridge_type)
+        self.bridge_type = bridge_type
+        if bridge_type == "concatenation":
+            self.concat_pooling = nn.Sequential(nn.Linear(input_dim * 2, input_dim), nn.ReLU())
+        elif bridge_type == "attention_pooling":
+            self.attention_x = nn.Sequential(nn.Linear(input_dim, input_dim), nn.ReLU(), nn.Linear(input_dim, input_dim, bias=False), nn.Softmax(dim=-1))
+            self.attention_h = nn.Sequential(nn.Linear(input_dim, input_dim), nn.ReLU(), nn.Linear(input_dim, input_dim, bias=False), nn.Softmax(dim=-1))
+
+    def forward(self, x, h):
+        if self.bridge_type == "hadamard_product":
+            out = x * h
+        elif self.bridge_type == "pointwise_addition":
+            out = x + h
+        elif self.bridge_type == "concatenation":
+            out = self.concat_pooling(torch.cat([x, h], dim=-1))
+        elif self.bridge_type == "attention_pooling":
+            out = self.attention_x(x) * x + self.attention_h(h) * h
+        return out
+
+
+class RegulationModule(torch.nn.Module):
+
+    def __init__(self, num_fields, dims, tau, use_regulation=True):
+        super(RegulationModule, self).__init__()
+        self.use_regulation = use_regulation
+        if self.use_regulation:
+            self.num_fields = num_fields
+            self.dims = dims
+            self.tau = tau
+            self.g1 = nn.Parameter(torch.ones(num_fields))
+            self.g2 = nn.Parameter(torch.ones(num_fields))
+
+    def forward(self, x):
+        if self.use_regulation:
+            g1 = torch.cat([(self.g1[i] / self.tau).softmax(dim=-1).unsqueeze(-1).repeat(1, self.dims[i]) for i in range(self.num_fields)], dim=-1)
+            g2 = torch.cat([(self.g2[i] / self.tau).softmax(dim=-1).unsqueeze(-1).repeat(1, self.dims[i]) for i in range(self.num_fields)], dim=-1)
+
+            out1, out2 = g1 * x, g2 * x
+        else:
+            out1, out2 = x, x
+        return out1, out2

torch_rechub/models/ranking/fibinet.py

@@ -1,50 +1,42 @@
-"""
-Date: create on 10/19/2022
-References:
-    paper: (RecSys '19) FiBiNET: combining feature importance and bilinear feature interaction for click-through rate prediction
-    url: https://dl.acm.org/doi/abs/10.1145/3298689.3347043
-Authors: lailai, lailai_zxy@tju.edu.cn
-"""
-import torch
-from torch import nn
-from ...basic.layers import  MLP, EmbeddingLayer, SENETLayer, BiLinearInteractionLayer
-from ...basic.features import SparseFeature
-class FiBiNet(torch.nn.Module):
-    """
-        Args:
-        features (list[Feature Class]): training by the whole module.
-        reduction_ratio (int) : Hidden layer reduction factor of SENET layer
-        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
-        bilinear_type (str): the type bilinear interaction function, in ["field_all", "field_each", "field_interaction"], field_all means that all features share a W, field_each means that a feature field corresponds to a W_i, field_interaction means that a feature field intersection corresponds to a W_ij
-    """
-    def __init__(self, features, mlp_params, reduction_ratio=3, bilinear_type="field_interaction", **kwargs):
-        super(FiBiNet, self).__init__()
-        self.features = features
-        self.embedding = EmbeddingLayer(features)
-        embedding_dim = max([fea.embed_dim for fea in features])
-        num_fields = len([fea.embed_dim for fea in features if isinstance(fea, SparseFeature) and fea.shared_with == None])
-        self.senet_layer = SENETLayer(num_fields, reduction_ratio)
-        self.bilinear_interaction = BiLinearInteractionLayer(embedding_dim, num_fields,  bilinear_type)
-        self.dims = num_fields * (num_fields - 1) * embedding_dim
-        self.mlp = MLP(self.dims, **mlp_params)
-
-    def forward(self, x):
-        embed_x = self.embedding(x, self.features)
-        embed_senet = self.senet_layer(embed_x)
-        embed_bi1 = self.bilinear_interaction(embed_x)
-        embed_bi2 = self.bilinear_interaction(embed_senet)
-        shallow_part = torch.flatten(torch.cat([embed_bi1, embed_bi2], dim=1), start_dim=1)
-        mlp_out = self.mlp(shallow_part)
-        return torch.sigmoid(mlp_out.squeeze(1))
-
-
-
-
-
-
-
-
-
-
-
-
+"""
+Date: create on 10/19/2022
+References:
+    paper: (RecSys '19) FiBiNET: combining feature importance and bilinear feature interaction for click-through rate prediction
+    url: https://dl.acm.org/doi/abs/10.1145/3298689.3347043
+Authors: lailai, lailai_zxy@tju.edu.cn
+"""
+import torch
+from torch import nn
+
+from ...basic.features import SparseFeature
+from ...basic.layers import MLP, BiLinearInteractionLayer, EmbeddingLayer, SENETLayer
+
+
+class FiBiNet(torch.nn.Module):
+    """
+        Args:
+        features (list[Feature Class]): training by the whole module.
+        reduction_ratio (int) : Hidden layer reduction factor of SENET layer
+        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
+        bilinear_type (str): the type bilinear interaction function, in ["field_all", "field_each", "field_interaction"], field_all means that all features share a W, field_each means that a feature field corresponds to a W_i, field_interaction means that a feature field intersection corresponds to a W_ij
+    """
+
+    def __init__(self, features, mlp_params, reduction_ratio=3, bilinear_type="field_interaction", **kwargs):
+        super(FiBiNet, self).__init__()
+        self.features = features
+        self.embedding = EmbeddingLayer(features)
+        embedding_dim = max([fea.embed_dim for fea in features])
+        num_fields = len([fea.embed_dim for fea in features if isinstance(fea, SparseFeature) and fea.shared_with is None])
+        self.senet_layer = SENETLayer(num_fields, reduction_ratio)
+        self.bilinear_interaction = BiLinearInteractionLayer(embedding_dim, num_fields, bilinear_type)
+        self.dims = num_fields * (num_fields - 1) * embedding_dim
+        self.mlp = MLP(self.dims, **mlp_params)
+
+    def forward(self, x):
+        embed_x = self.embedding(x, self.features)
+        embed_senet = self.senet_layer(embed_x)
+        embed_bi1 = self.bilinear_interaction(embed_x)
+        embed_bi2 = self.bilinear_interaction(embed_senet)
+        shallow_part = torch.flatten(torch.cat([embed_bi1, embed_bi2], dim=1), start_dim=1)
+        mlp_out = self.mlp(shallow_part)
+        return torch.sigmoid(mlp_out.squeeze(1))

torch_rechub/models/ranking/widedeep.py

@@ -1,41 +1,41 @@
-"""
-Date: create on 22/04/2022
-References: 
-    paper: (DLRS'2016) Wide & Deep Learning for Recommender Systems 
-    url: https://arxiv.org/abs/1606.07792
-Authors: Mincai Lai, laimincai@shanghaitech.edu.cn
-"""
-
-import torch
-
-from ...basic.layers import LR, MLP, EmbeddingLayer
-
-
-class WideDeep(torch.nn.Module):
-    """Wide & Deep Learning model.
-
-    Args:
-        wide_features (list): the list of `Feature Class`, training by the wide part module.
-        deep_features (list): the list of `Feature Class`, training by the deep part module.
-        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
-    """
-
-    def __init__(self, wide_features, deep_features, mlp_params):
-        super(WideDeep, self).__init__()
-        self.wide_features = wide_features
-        self.deep_features = deep_features
-        self.wide_dims = sum([fea.embed_dim for fea in wide_features])
-        self.deep_dims = sum([fea.embed_dim for fea in deep_features])
-        self.linear = LR(self.wide_dims)
-        self.embedding = EmbeddingLayer(wide_features + deep_features)
-        self.mlp = MLP(self.deep_dims, **mlp_params)
-
-    def forward(self, x):
-        input_wide = self.embedding(x, self.wide_features, squeeze_dim=True)  #[batch_size, wide_dims]
-        input_deep = self.embedding(x, self.deep_features, squeeze_dim=True)  #[batch_size, deep_dims]
-
-        y_wide = self.linear(input_wide)  #[batch_size, 1]
-        y_deep = self.mlp(input_deep)  #[batch_size, 1]
-        y = y_wide + y_deep
-        y = torch.sigmoid(y.squeeze(1))
-        return y
+"""
+Date: create on 22/04/2022
+References:
+    paper: (DLRS'2016) Wide & Deep Learning for Recommender Systems
+    url: https://arxiv.org/abs/1606.07792
+Authors: Mincai Lai, laimincai@shanghaitech.edu.cn
+"""
+
+import torch
+
+from ...basic.layers import LR, MLP, EmbeddingLayer
+
+
+class WideDeep(torch.nn.Module):
+    """Wide & Deep Learning model.
+
+    Args:
+        wide_features (list): the list of `Feature Class`, training by the wide part module.
+        deep_features (list): the list of `Feature Class`, training by the deep part module.
+        mlp_params (dict): the params of the last MLP module, keys include:`{"dims":list, "activation":str, "dropout":float, "output_layer":bool`}
+    """
+
+    def __init__(self, wide_features, deep_features, mlp_params):
+        super(WideDeep, self).__init__()
+        self.wide_features = wide_features
+        self.deep_features = deep_features
+        self.wide_dims = sum([fea.embed_dim for fea in wide_features])
+        self.deep_dims = sum([fea.embed_dim for fea in deep_features])
+        self.linear = LR(self.wide_dims)
+        self.embedding = EmbeddingLayer(wide_features + deep_features)
+        self.mlp = MLP(self.deep_dims, **mlp_params)
+
+    def forward(self, x):
+        input_wide = self.embedding(x, self.wide_features, squeeze_dim=True)  # [batch_size, wide_dims]
+        input_deep = self.embedding(x, self.deep_features, squeeze_dim=True)  # [batch_size, deep_dims]
+
+        y_wide = self.linear(input_wide)  # [batch_size, 1]
+        y_deep = self.mlp(input_deep)  # [batch_size, 1]
+        y = y_wide + y_deep
+        y = torch.sigmoid(y.squeeze(1))
+        return y

torch_rechub/trainers/__init__.py

@@ -1,3 +1,4 @@
-from .ctr_trainer import CTRTrainer
-from .match_trainer import MatchTrainer
-from .mtl_trainer import MTLTrainer
+from .ctr_trainer import CTRTrainer
+from .match_trainer import MatchTrainer
+from .mtl_trainer import MTLTrainer
+from .seq_trainer import SeqTrainer