recommend-model/recommend-model-produce/src/main/python/models/dssm/net.py

import paddle
import paddle.nn as nn
import paddle.nn.functional as F
import numpy as np

class DSSMLayer(nn.Layer):
    def __init__(self, feature_nums=[5,5,5,5,5], embedding_dim=8, output_dim=16, 
                 hidden_layers=[40, 32], hidden_acts=["relu", "relu"]):
        super(DSSMLayer, self).__init__()
        tag_features_dict = {
            "vid":3407301,
            "cate1":42,
            "cate2":67,
            "video_style":6517,
            "valid_time":728,
            "captions_color":656,
            "audience_age_group":65,
            "audience_value_type":61,
            "font_size":49,
            "cover_persons_num":44,
            "audience_gender":37,
            "sentiment_tendency":11,
            "video_type":8,
            "background_music_type":6,
            "captions":3,
            "has_end_credit_guide":2
        }
                
        self.stat_features_num = 47 
        self.stat_features_num_embeddings = 100
        
        self.feature_num = len(list(tag_features_dict.values()))
        feature_nums = list(tag_features_dict.values())
        self.embedding_dim = embedding_dim
        self.output_dim = output_dim
        # 第一层的输入维度是所有特征的embedding拼接
        self.hidden_layers = [self.feature_num * embedding_dim + 47*3*embedding_dim] + hidden_layers + [output_dim]
        self.hidden_acts = hidden_acts
        
        
        # 为每个特征创建对应维度的Embedding层
        self.left_embeddings = nn.LayerList()
        for i in range(self.feature_num): # 视频的静态特征
            layer = nn.Embedding(
                num_embeddings=feature_nums[i],
                embedding_dim=embedding_dim,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                )
            )
            self.left_embeddings.append(layer)
        for i in range(self.stat_features_num): #长短期和品类的表现 分桶后映射成index
            layer = nn.Embedding(
                num_embeddings=self.stat_features_num_embeddings,
                embedding_dim=embedding_dim,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                )
            )
            self.left_embeddings.append(layer)
        for i in range(self.stat_features_num*2): # 长短期和品类的表现，hive表的原始值映射到0-1之间的小数 + hive表的原始值
            layer = nn.Linear(
                in_features=1,
                out_features=embedding_dim,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                )
            )
            self.left_embeddings.append(layer)                        
        

        self.right_embeddings = nn.LayerList()
        for i in range(self.feature_num): # 视频的静态特征
            layer = nn.Embedding(
                num_embeddings=feature_nums[i],
                embedding_dim=embedding_dim,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                )
            )
            self.right_embeddings.append(layer)
        for i in range(self.stat_features_num): #长短期和品类的表现 分桶后映射成index
            layer = nn.Embedding(
                num_embeddings=self.stat_features_num_embeddings,
                embedding_dim=embedding_dim,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                )
            )
            self.right_embeddings.append(layer)
        for i in range(self.stat_features_num*2): # 长短期和品类的表现，hive表的原始值映射到0-1之间的小数 + hive表的原始值
            layer = nn.Linear(
                in_features=1,
                out_features=embedding_dim,
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                )
            )
            self.right_embeddings.append(layer)  


        # 左视频塔
        self._left_tower = []
        for i in range(len(self.hidden_layers) - 1):
            linear = paddle.nn.Linear(
                in_features=self.hidden_layers[i],
                out_features=self.hidden_layers[i + 1],
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                ),
                bias_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.Constant(value=0.0)
                )
            )
            self.add_sublayer('left_linear_%d' % i, linear)
            self._left_tower.append(linear)
            
            if i < len(hidden_acts) and self.hidden_acts[i] == "relu":
                act = paddle.nn.ReLU()
                self.add_sublayer('left_act_%d' % i, act)
                self._left_tower.append(act)

        # 右视频塔
        self._right_tower = []
        for i in range(len(self.hidden_layers) - 1):
            linear = paddle.nn.Linear(
                in_features=self.hidden_layers[i],
                out_features=self.hidden_layers[i + 1],
                weight_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.XavierNormal()
                ),
                bias_attr=paddle.ParamAttr(
                    initializer=paddle.nn.initializer.Constant(value=0.0)
                )
            )
            self.add_sublayer('right_linear_%d' % i, linear)
            self._right_tower.append(linear)
            
            if i < len(hidden_acts) and self.hidden_acts[i] == "relu":
                act = paddle.nn.ReLU()
                self.add_sublayer('right_act_%d' % i, act)
                self._right_tower.append(act)

    def _process_features(self, features, embeddings):
        # 将每个特征转换为embedding
        embedded_features = []
        for i in range(self.feature_num):
            feature = paddle.slice(
                features, 
                axes=[1], 
                starts=[i], 
                ends=[i+1]
            )
            feature = paddle.cast(feature, dtype='int64')
            embedded = embeddings[i](feature)

            embedded_features.append(embedded)
        
        # 将所有embedding连接起来
   
        return paddle.concat(embedded_features, axis=1)

    def forward(self, left_features, right_features, is_infer=False):
        if is_infer:
            left_vec = self.get_leftvectors(left_features)
            return left_vec
        else:
            # 获取两个视频的特征表示      
            left_vec, right_vec = self.get_vectors(left_features, right_features)

            # 计算相似度
            sim_score = F.cosine_similarity(
                left_vec, 
                right_vec, 
                axis=1
            ).reshape([-1, 1])

            return sim_score, left_vec, right_vec



    def get_leftvectors(self, left_features):
        """获取两个视频的16维特征向量"""
        # 处理左视频特征
        
        left_embedded = self._process_features(left_features, self.left_embeddings)
        
        # left_vec = left_embedded
        left_vec = paddle.reshape(left_embedded, [-1, self.feature_num * self.embedding_dim])
              
        for i, layer in enumerate(self._left_tower):
            left_vec = layer(left_vec)
        
        return left_vec





    def get_rightvectors(self,right_features):        
        # 处理右视频特征
        right_embedded = self._process_features(right_features, self.right_embeddings)
        # right_vec = right_embedded
        right_vec = paddle.reshape(right_embedded, [-1, self.feature_num * self.embedding_dim])  

        for layer in self._right_tower:
            right_vec = layer(right_vec)

            
        # 确保输出是L2归一化的
        left_vec = F.normalize(left_vec, p=2, axis=1)
        right_vec = F.normalize(right_vec, p=2, axis=1)
        
        return right_vec






    def get_vectors(self, left_features, right_features):
        """获取两个视频的16维特征向量"""
        # 处理左视频特征
        
        left_embedded = self._process_features(left_features, self.left_embeddings)
        
        # left_vec = left_embedded
        left_vec = paddle.reshape(left_embedded, [-1, self.feature_num * self.embedding_dim])
              
        

        
        
        
        for i, layer in enumerate(self._left_tower):
            left_vec = layer(left_vec)

        
        # 处理右视频特征
        right_embedded = self._process_features(right_features, self.right_embeddings)
        # right_vec = right_embedded
        right_vec = paddle.reshape(right_embedded, [-1, self.feature_num * self.embedding_dim])  

        for layer in self._right_tower:
            right_vec = layer(right_vec)

            
        # 确保输出是L2归一化的
        left_vec = F.normalize(left_vec, p=2, axis=1)
        right_vec = F.normalize(right_vec, p=2, axis=1)
        
        return left_vec, right_vec