关于Embedding的两种实现方式

news2024/9/22 19:33:23

言简意赅

假设现在有一段话：“我爱你中国”，在训练入模的时候，常用的方法分别有：onehot、embedding、hash，如果词表很大、特征很多，那么onehot之后会极其稀疏，hash也会有一定的hash冲突，所以这其中emb是最常用的方法。

我们希望，通过一个向量去表征每一个词，以“我爱你中国”为例，将其映射成为一个二维矩阵，矩阵的维度即（词表大小，emb维度）。

对于结构化数据而言，假设我们现在有2个特征分别为“性别”、“设备品牌”，这里规范下概念方便代码实现，如下图：

一个类别特征对应一个Field，但是对应多个Feature：

所以按照上面的例子，field有两个，分别为“性别”、“设备品牌”，假设性别有男女2个，设备品牌有3个，它们则分别对应着feature，即特征值。按照emb的方式，我们需要对每一个feature都去学习一个向量表征。

下面方法均以此例为基础讲解

x1、x2分别代表“性别”、“设备品牌”，为特征域field
经过编码后特征值分别为2个、3个，即0 1、0 1 2
batch_size = 3
emb_dim = 10

在这里插入图片描述

方式一

推荐使用方式二

思路：对于每一个特征field定义一个emb向量，然后进行拼接。

1.定义每个特征field的词表大小，即有多少个特征值；
2.为每一个特征field定义一个emb向量；
3.拼接每个特征的emb向量。

'''   用于 spare field embedding   '''
def sparseFeature(feat, vocabulary_size, embed_dim):
    return {'spare': feat, 'vocabulary_size': vocabulary_size, 'embed_dim': embed_dim}

# 每个特征field的词表大小，即有多少个特征值
spare_feature_columns = [sparseFeature(x, data[x].max() + 1, emb_dim) for x in ['x1', 'x2']]
print('spare_feature_columns: ', spare_feature_columns)

# 为每一个特征field定义一个emb向量
embedding_layer = nn.ModuleDict({'embed_layer{}'.format(i): nn.Embedding(feat['vocabulary_size'], feat['embed_dim'])
                                 for i, feat in enumerate(spare_feature_columns)})
# 初始化权重
for i in range(len(spare_feature_columns)):
    torch.nn.init.xavier_uniform_(embedding_layer['embed_layer{}'.format(i)].weight.data)

print('embedding_layer: ', embedding_layer)    

tensor = tensor.long()  # 转成long类型才能作为nn.embedding的输入
# 拼接每个特征的emb向量
sparse_emb = torch.cat([embedding_layer['embed_layer{}'.format(i)](tensor[:, i])
                          for i in range(tensor.shape[1])], dim=1)
print(sparse_emb.shape)
print(sparse_emb)

'''
spare_feature_columns:  [{'spare': 'x1', 'vocabulary_size': 2, 'embed_dim': 10}, {'spare': 'x2', 'vocabulary_size': 3, 'embed_dim': 10}]

embedding_layer:  ModuleDict(
  (embed_layer0): Embedding(2, 10)  
  (embed_layer1): Embedding(3, 10)
)

torch.Size([3, 20])

tensor([[ 0.4941,  0.3774, -0.5872, -0.5937,  0.6413, -0.6516,  0.6855, -0.2272,          
          0.3905, -0.5630, -0.0726,  0.6481,  0.0143,  0.0614,  0.0460, -0.2215,         
         -0.6515,  0.0103, -0.4000,  0.5353],       
        [ 0.4941,  0.3774, -0.5872, -0.5937,  0.6413, -0.6516,  0.6855, -0.2272,          
          0.3905, -0.5630,  0.5236,  0.3958, -0.1983,  0.4128, -0.0349, -0.5609,          
          0.4050, -0.4603,  0.3048, -0.6483],        
        [-0.2146, -0.4806,  0.2180,  0.3497,  0.1291, -0.4531, -0.6532,  0.2385,          
          0.3290, -0.7043,  0.1372, -0.1554,  0.0272, -0.4285, -0.2797, -0.0988,          
          0.2602,  0.6084,  0.0169,  0.0712]])
'''

方式二

这个是比较推荐的方式，并且经过实践这个方式比第一种方式效果还要好。

我们引入一个offset的概念，它的作用就是给每列特征的label加入之前特征的类别总和，来达到所有特征的label。以上述为例来理解下：

feature_fields = [2, 3]，它代表“性别”、“设备品牌”各有几个特征值。

offsets = [0 2]，它其实就代表着look up table。

即实际look up table中：

0 - 1 行，对应特征性别，它的取值为0、1，所以dim为2，即feature_fields[0]；
2 - 4 行，对应特征设备品牌，它的取值为0、1、2，所以dim为3，即feature_fields[1]；

但实际特征取值 forward(self, x) 的x大小只在自身词表内取值:

比如性别取值为1的时候，对应embedding内行数就是 offsets[性别] + 性别 = 0 + 1 = 1，也就是当x_性别取值为1的时候，对应emb的行数为1，注意是索引；
再比如设备品牌取值为1的时候，对应embedding内行数就是 offsets[设备品牌] + 设备品牌 = 2 + 1 = 3；