记第一次推荐开发实践遇到的问题

算法实践问题

问题一：样本采样问题

问题二：负样本采样问题

问题三：测试数据中的负样本

• 如果需要评估召回质量则需要负样本：可以帮助你评估模型是否能有效地区分用户感兴趣和不感兴趣的项目。通过计算如精确率、召回率、F1分数等指标，可以更全面地了解召回模型的性能。

• 如果只关注召回覆盖率则不一定需要负样本：如果主要目标是测试召回模型是否能覆盖到用户实际感兴趣的项目，那么负样本的存在不是必须的。通过看评分指标的公式即可得知，评估指标在计算时用不到负样本（负样本没什么用，并且只会增大评分指标的分母）（本次采用的方法）

• 实践建议：在实际应用中，包含负样本在测试集中可以提供更全面的评估，尤其是在召回和排序（精排）阶段结合使用的场景下。负样本可以帮助你评估模型是否只是随机召回项目，还是真的学到了用户的偏好。此外，包含负样本也有助于模拟真实场景，因为在实际的推荐系统中，用户会遇到他们不感兴趣的项目。

问题四：如何预测

问题五：数据变动引发的报错

• 问题背景：模型在输入数据时，会分为稀疏特征和稠密特征，稀疏特征会进行编码并嵌入成一个张量，张量的大小为：(特征词典大小：嵌入维度)，特征词典大小的意思是这个特征有多少个值，嵌入维度是认为指定的参数，16/32 等。

• 报错 1：在特征嵌入时会提示：IndexError: index out of range in self
报错信息
IndexError                                Traceback (most recent call last)
File /Users/ayd/Nutstore Files/坚果云/工作/亚信/项目管理/广东/智能推荐/5-模型开发/dssm_recall_infer_V4.py:305
    303 print('\n\n产品和用户开始嵌入成向量！ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
    304 # 产品嵌入
--> 305 item_embedding = trainer.inference_embedding(model=model, mode="item", data_loader=x_prdct_dl, model_path=save_dir) 
    307 # # -------------单进程用户嵌入
    308 # x_user_ = df_to_dict(user_features_df)
    309 # x_user_dl_set_ = MatchDataGenerator(x=x_user_).dataset
   (...)
    312 # print('=========单进程 >',user_embedding.shape)
    313 # -------------多进程用户嵌入
    314 start_time_ = time.time()    

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch_rechub/trainers/match_trainer.py:169, in MatchTrainer.inference_embedding(self, model, mode, data_loader, model_path)
    167     for i, x_dict in enumerate(tk0):
    168         x_dict = {k: v.to(self.device) for k, v in x_dict.items()}
--> 169         y_pred = model(x_dict)
    170         predicts.append(y_pred.data)
    171 return torch.cat(predicts, dim=0)

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/module.py:1511, in Module._wrapped_call_impl(self, *args, **kwargs)
   1509     return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
   1510 else:
-> 1511     return self._call_impl(*args, **kwargs)

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/module.py:1520, in Module._call_impl(self, *args, **kwargs)
   1515 # If we don't have any hooks, we want to skip the rest of the logic in
   1516 # this function, and just call forward.
   1517 if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
   1518         or _global_backward_pre_hooks or _global_backward_hooks
   1519         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1520     return forward_call(*args, **kwargs)
   1522 try:
   1523     result = None

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch_rechub/models/matching/dssm.py:41, in DSSM.forward(self, x)
     39 def forward(self, x):
     40     user_embedding = self.user_tower(x)
---> 41     item_embedding = self.item_tower(x)
     42     if self.mode == "user":
     43         return user_embedding

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch_rechub/models/matching/dssm.py:63, in DSSM.item_tower(self, x)
     61 if self.mode == "user":
     62     return None
---> 63 input_item = self.embedding(x, self.item_features, squeeze_dim=True)  #[batch_size, num_features*embed_dim]
     64 item_embedding = self.item_mlp(input_item)  #[batch_size, item_params["dims"][-1]]
     65 item_embedding = F.normalize(item_embedding, p=2, dim=1)

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/module.py:1511, in Module._wrapped_call_impl(self, *args, **kwargs)
   1509     return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
   1510 else:
-> 1511     return self._call_impl(*args, **kwargs)

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/module.py:1520, in Module._call_impl(self, *args, **kwargs)
   1515 # If we don't have any hooks, we want to skip the rest of the logic in
   1516 # this function, and just call forward.
   1517 if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
   1518         or _global_backward_pre_hooks or _global_backward_hooks
   1519         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1520     return forward_call(*args, **kwargs)
   1522 try:
   1523     result = None

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch_rechub/basic/layers.py:70, in EmbeddingLayer.forward(self, x, features, squeeze_dim)
     68 if isinstance(fea, SparseFeature):
     69     if fea.shared_with == None:
---> 70         sparse_emb.append(self.embed_dict[fea.name](x[fea.name].long()).unsqueeze(1))
     71     else:
     72         sparse_emb.append(self.embed_dict[fea.shared_with](x[fea.name].long()).unsqueeze(1))

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/module.py:1511, in Module._wrapped_call_impl(self, *args, **kwargs)
   1509     return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
   1510 else:
-> 1511     return self._call_impl(*args, **kwargs)

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/module.py:1520, in Module._call_impl(self, *args, **kwargs)
   1515 # If we don't have any hooks, we want to skip the rest of the logic in
   1516 # this function, and just call forward.
   1517 if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
   1518         or _global_backward_pre_hooks or _global_backward_hooks
   1519         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1520     return forward_call(*args, **kwargs)
   1522 try:
   1523     result = None

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/sparse.py:163, in Embedding.forward(self, input)
    162 def forward(self, input: Tensor) -> Tensor:
--> 163     return F.embedding(
    164         input, self.weight, self.padding_idx, self.max_norm,
    165         self.norm_type, self.scale_grad_by_freq, self.sparse)

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/functional.py:2237, in embedding(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)
   2231     # Note [embedding_renorm set_grad_enabled]
   2232     # XXX: equivalent to
   2233     # with torch.no_grad():
   2234     #   torch.embedding_renorm_
   2235     # remove once script supports set_grad_enabled
   2236     _no_grad_embedding_renorm_(weight, input, max_norm, norm_type)
-> 2237 return torch.embedding(weight, input, padding_idx, scale_grad_by_freq, sparse)

IndexError: index out of range in self
 
• 报错原因1：如果某一个特征 A 的值的个数比训练时的值要多，那么在嵌入这个特征的时候，多出来的编码号码拿去模型对应的嵌入层去检索就会导致检索下标越界
• 报错原因2：如果某一个特征 A 的值的个数正常（没有超过词典大小），但是其中的某些数值比嵌入维度的最大值要大，也可能会导致这个报错。比如嵌入维度是（n*16），n 是词表大小，如果预测的时候对 A 进行编码时，编码后的部分数值大于 n（即使个数没有超过），则也会导致报此错误。这个时候可能是编码阶段出了问题。

• 报错 2：在加载模型时会提示：size mismatch for embedding.embed_dict.u_user_star_level.weight: copying a param with shape torch.Size([6, 16]) from checkpoint, the shape in current model is torch.Size([7, 16]).
报错信息
RuntimeError                              Traceback (most recent call last)
Cell In[23], line 2
      1 print("inference embedding") 
----> 2 item_embedding = trainer.inference_embedding(model=model, mode="item", data_loader=x_prdct_dl, model_path=save_dir) 
      3 user_embedding2 = trainer.inference_embedding(model=model, mode="user", data_loader=x_user_dl, model_path=save_dir) 
      4 # # 召回

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch_rechub/trainers/match_trainer.py:161, in MatchTrainer.inference_embedding(self, model, mode, data_loader, model_path)
    159 assert mode in ["user", "item"], "Invalid mode={}.".format(mode)
    160 model.mode = mode
--> 161 model.load_state_dict(torch.load(os.path.join(model_path, "model.pth")))
    162 model = model.to(self.device)
    163 model.eval()

File ~/miniconda3/envs/rec-deploy/lib/python3.8/site-packages/torch/nn/modules/module.py:2153, in Module.load_state_dict(self, state_dict, strict, assign)
   2148         error_msgs.insert(
   2149             0, 'Missing key(s) in state_dict: {}. '.format(
   2150                 ', '.join(f'"{k}"' for k in missing_keys)))
   2152 if len(error_msgs) > 0:
-> 2153     raise RuntimeError('Error(s) in loading state_dict for {}:\n\t{}'.format(
   2154                        self.__class__.__name__, "\n\t".join(error_msgs)))
   2155 return _IncompatibleKeys(missing_keys, unexpected_keys)

RuntimeError: Error(s) in loading state_dict for DSSM:
	size mismatch for embedding.embed_dict.u_user_star_level.weight: copying a param with shape torch.Size([6, 16]) from checkpoint, the shape in current model is torch.Size([7, 16]).
	size mismatch for embedding.embed_dict.user_id.weight: copying a param with shape torch.Size([42, 16]) from checkpoint, the shape in current model is torch.Size([198, 16]).
	size mismatch for embedding.embed_dict.u_main_plan_id.weight: copying a param with shape torch.Size([21, 16]) from checkpoint, the shape in current model is torch.Size([41, 16]).
	size mismatch for embedding.embed_dict.u_prodlist_in_use.weight: copying a param with shape torch.Size([21, 16]) from checkpoint, the shape in current model is torch.Size([41, 16]).
	size mismatch for embedding.embed_dict.p_product_name.weight: copying a param with shape torch.Size([50, 16]) from checkpoint, the shape in current model is torch.Size([55, 16]).
	size mismatch for embedding.embed_dict.product_id.weight: copying a param with shape torch.Size([50, 16]) from checkpoint, the shape in current model is torch.Size([55, 16]).
 
• 报错原因：如果某一个特征 A 的值比训练时的值要少，那么在嵌入这个特征的时候不会报错，但是此时的特征词典大小就与之前训练的时候不一致了，所以嵌入后的特征张量在维度上就与之前训练好的不一致，就会导致尺寸匹配不上

• 解决方法：这个问题本质上就是训练时特征值与预测数据的特征值有差异（预测时某些特征遇到了新的值或者新数据中少了一些值）最本质的方法就是（在全量数据上）人工处理稀疏特征编码将其保存，在预测阶段使用同样的特征编码。并且特征词典大小也保持一致。
代码如下

  ############   对类别特征进行编码处理，并保存   ###########
  feature_max_idx = {}   # 记录每个字段的最大索引
  feature_encoder = {}   # 记录每个字段的编码
  feature_decoder = {}   # 记录每个字段的编码
  sparse_features_original = user_multiClass_cols_original+prod_multiClass_cols_original+['u_is_unlimited_gprs','u_gprs_restrain','p_stackable']   # 後面這三個理論上是布爾值，但是被填充了字符串，歸一化處理不了，會導致後面報錯，所以當作多類別處理
  sparse_features_original = [i for i in sparse_features_original if i in list(user_info.columns)+list(prdct_info.columns)]   # 过滤一遍，避免错误
  # sparse_features_original = [i for i in sparse_features_original if i not in ['user_id','product_id']]   # 去除用户和产品 id    
  for feat in sparse_features_original:
      if feat in list(user_info.columns):
          user_info[feat] = user_info[feat].fillna('999')   # 先填充再编码
          feat_encoder = {v:k+1 for k,v in enumerate(list(user_info[feat].unique()))}
          feat_encoder['unknown'] = len(list(user_info[feat].unique())) + 1
          feature_max_idx[feat] =  len(list(user_info[feat].unique())) + 2
      else:
          prdct_info[feat] = prdct_info[feat].fillna('999')
          feat_encoder = {v:k+1 for k,v in enumerate(list(prdct_info[feat].unique()))}
          feat_encoder['unknown'] = len(list(prdct_info[feat].unique())) + 1
          feature_max_idx[feat] =  len(list(prdct_info[feat].unique())) + 2
      feature_encoder[feat] = feat_encoder
      feat_decoder = {v:k for k,v in feat_encoder.items()}
      feature_decoder[feat] = feat_decoder
      
  with open('./result/feature_encoder.pkl', 'wb') as file:
      pickle.dump(feature_encoder, file)
  with open('./result/feature_decoder.pkl', 'wb') as file:
      pickle.dump(feature_decoder, file)
  with open('./result/feature_max_idx.pkl', 'wb') as file:
      pickle.dump(feature_max_idx, file)
        
        
        
  ###########   预测时加载并使用   ###########
      # 加载文件
  with open('./result/feature_max_idx.pkl', 'rb') as file:
      feature_max_idx = pickle.load(file)
  with open('./result/feature_encoder.pkl', 'rb') as file:
      feature_encoder = pickle.load(file)
  with open('./result/feature_decoder.pkl', 'rb') as file:
      feature_decoder = pickle.load(file)
# 稀疏字段处理
  sparse_features = user_multiClass_cols+prod_multiClass_cols+['u_is_unlimited_gprs','u_gprs_restrain','p_stackable']   # 後面這三個理論上是布爾值，但是被填充了字符串，歸一化處理不了，會導致後面報錯，所以當作多類別處理
  sparse_features = [i for i in sparse_features if i in samples_features_df_columns]   # 过滤一遍，避免错误
  # print('稀疏特征：',sparse_features)
  for feat in sparse_features:
      if feat == 'user_id' or feat == 'product_id':       # lbe.classes_的值会随着 lbe.fit_transform 处理的数据而变化，有对应关系；leb.classes_是类属性
          lbe = LabelEncoder()
          samples_features_df[feat] = lbe.fit_transform(samples_features_df[feat])
          id_map = {encode_id: raw_id for encode_id, raw_id in enumerate(lbe.classes_)}  #encode user id: raw user id
      else:
          feat_encoder = feature_encoder[feat]
          samples_features_df[feat] = samples_features_df[feat].map(lambda x: feat_encoder.get(x, feat_encoder['unknown']))   # 用字典映射
      feature_max_idx[feat] = samples_features_df[feat].max() + 1   # 这里会作为词典大小，加1是为未知数据做保留

此外，由于用户 id 和物品 id 时随时变化的，所以只要求保持单次预测的数量在训练数据的特征字典之内就行，而且需要在预测完之后对其进行还原，所以对这两个字段单独使用LabelEncoder方法来编码

问题六：Dataloader引发死锁

• 问题现象：并没有实际报错，但是运行的程序会卡住，一个进程开了几个子进程，子进程在开着但是很快就不工作了，也不占用 cpu 资源

• 发现问题：通过日志发现，运行输出是卡在训练那一步，结果一直以为是训练那里出了问题；还以为是服务器会限制进程开启子进程的数量，一顿乱找结果毫无进展。后面发现训练并不会在cpu 上开启多进程；发现训练调用的函数里使用了pytorch 的数据加载 Dataloader，其中有个 num_workers 参数会指定加载数据的进程数，最终确定是这里的问题，

• 解决方法：
• possible deadlock in dataloader #1355（【pytorch】由dataloader引发的死锁）
• 将num_workers设置为 0 或者 2 解决问题，我是设置成了 2（设置成 2 可以运行也是需要运气，成功率比较随机）。
• 或者设置参数persistent_workers=True；persistent_workers (bool, optional) – If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers Dataset instances alive. (default: False)（貌似也不行（dataloader在循环里，不知道在没有循环的情况下行不行））

问题七：无法开启多进程

• 暂未解决，不过怀疑是服务器系统的原因（华为欧拉）

问题八：召回结果的含义，正相关还是负相关

问题九：训练计算损失时，提示预测值不在 0-1 之间

Traceback (most recent call last):
  File "dssm_recall_train_V6_optimize_20240814.py", line 745, in <module>
    trainer.fit(train_dl)
  File "/usr/local/lib/python3.8/site-packages/torch_rechub/trainers/match_trainer.py", line 110, in fit
    self.train_one_epoch(train_dataloader)
  File "/usr/local/lib/python3.8/site-packages/torch_rechub/trainers/match_trainer.py", line 83, in train_one_epoch
    loss = self.criterion(y_pred, y)
  File "/usr/local/lib/python3.8/site-packages/torch/nn/modules/module.py", line 1511, in _wrapped_call_impl
    return self._call_impl(*args, **kwargs)
  File "/usr/local/lib/python3.8/site-packages/torch/nn/modules/module.py", line 1520, in _call_impl
    return forward_call(*args, **kwargs)
  File "/usr/local/lib/python3.8/site-packages/torch/nn/modules/loss.py", line 618, in forward
    return F.binary_cross_entropy(input, target, weight=self.weight, reduction=self.reduction)
  File "/usr/local/lib/python3.8/site-packages/torch/nn/functional.py", line 3127, in binary_cross_entropy
    return torch._C._nn.binary_cross_entropy(input, target, weight, reduction_enum)
RuntimeError: all elements of input should be between 0 and 1

问题十：Docker 相关问题

1. 训练程序挂起不运行：在 Docker 容器外面配置定时调用 python 训练程序的时候，训练程序会卡在开始训练的地方一直没有日志输出。只能在容器内调用程序执行；

2. 在 Docker 外运行预测程序没有文件生成，这是路径的问题，需要将相对路径转换为绝得路径。

问题十一： ’list’ object has no attribute ‘to’

• 出现这个问题的直接原因是：某些字段在进行张量转换的时候没有转换成功，还是list类型

• 类型转换失败的原因是这个字段中的数据类型有问题（没有转换成数字、数据是混合类型等）

• 数据类型问题最根本原因是数据处理的时候没有正确处理相应字段（比如某些字段是汉字的是和否，并没有将其处理成0、1）

问题十二：预测的结果中有些产品的所有用户分数一致

• 数据不平衡，影响模型效果：产品的订购数据严重不平衡，最多的产品订购数量2w加，最少的只有1条订购数据，总的600多产品

• 模型过拟合：模型训练的不够好，导致在嵌入用户特征和产品特征的时候不够有区分度；

• 向量数据库检索的问题：在召回时使用了annoy向量数据库，n_trees设置为60导致向量计算的精度不够；

• 向量数据库的n_trees由50增加到100

• 优化模型参数：防止模型过拟合，增加特征维度以增强表达
• 学习率：0.01 —— 0.0001
• L2衰减权重：0.0001 —— 0.001
• 嵌入纬度：[128, 64] —— [256, 128, 64]

问题十三：预测的结果中有些产品的所有用户分数普片偏低或偏高

内存管理问题

# 原来的处理
match_res_df = pd.concat(match_res_df_l, ignore_index=True) 


# 改进后的处理
match_res_df = match_res_df_l[0]
for df in match_res_df_l[1:]:
    match_res_df = pd.concat([match_res_df, df], ignore_index=True) 

del user_info_
del user_info_df_l   # 删除中间数据，减少内存占用

import gc
gc.collect()         # 强制进行垃圾回收

20241014更新

• 数据处理和嵌入阶段分批处理，保证内存的使用曲线更平滑，过程中严格控制中间变量的使用和删除，没用的变量立刻清理回收

• 数据召回阶段分块处理，将数据分成多块，没块数据单独构建向量数据库索引，然后召回相应数量的用户数，每个块处理完之后立刻释放内存
• 召回阶段分块的好处，不仅能够减轻内存的压力，又能够在召回时减少相同分数的数量（annoy向量数据库的索引逻辑是将数据分布在不同的块区间，在匹配时相同块区间的数据分数相同或相近）。

• 内存映射内存映射的原理是将数据保存到文件，在使用时分批读取，这样能减轻内存的压力，但是缺点是在某些需要同时使用所有数据的场景行不通（如训练模型，向量数据库构建索引），但是在本方法中，召回阶段是分段的，每段数据单独构建向量数据库的索引，所以可以使用内存映射来处理数据。（理论方法，未实现）

• 加入内存监控

GPT回答的问题

召回结果分数一致问题

向量数据库分段召回问题

内存优化问题