推荐算法在商城系统实践

一、简介

本文博主给大师讲授若何在自己开源的电商项目「newbee-mall-pro」中利用协同过滤算法来到达给用户更好的购物体验结果。
「newbee-mall-pro」项目地址:

• 源码地址：https://github.com/wayn111/newbee-mall-pro
  
• 在线地址：http://121.4.124.33/newbeemall
  

<hr/>二、协同过滤算法

协同过滤算法是一种基于用户大概物品的类似度来保举商品的方式，它可以有用地处理商城系统中的信息过载题目。协同过滤算法的理论首要包括以下几个步调：

• 数据收集和预处置。这一步需要从商城系统中获得用户的行为数据，如阅读、采办、评价等，然落后行一些需要的清洗和转换，以便后续的分析和计较。
  
• 类似度计较。这一步需要按照用户大概物品的特征大概行为，采用合适的类似度怀抱方式，如余弦类似度、皮尔逊相关系数、Jaccard指数等，来计较用户之间大概物品之间的类似度矩阵。
  
• 保举天生。这一步需要按照类似度矩阵和用户的历史行为，采用合适的保举战略，如基于邻域的方式、基于模子的方式、基于矩阵分化的方式等，来天生针对每个用户的本性化保举列表。
  
• 保举评价和优化。这一步需要按照一些评价目标，如正确率、召回率、覆盖率、多样性等，来评价保举系统的结果，并按照反应信息和营业需求，停止一些参数调剂和算法优化，以进步保举系统的性能和用户满足度。
  

<hr/>在原本的商城首页「为你保举」栏目是利用背景设置的商品列表，基于报酬设置。在项目商品用户延续增加的情况下，纷歧定能给用户保举用户能够想要的商品。
是以在「v2.4.1」版本中，商城首页「为你保举」栏目增加了协同过滤算法。依照UserCF基于用户的协同过滤、ItemCF基于物品的协同过滤。 实现了两种分歧的保举逻辑。

• 「UserCF」：基于用户的协同过滤。当一个用户A需要本性化保举的时辰，我们可以先找到和他有类似爱好的其他用户，然后把那些用户喜好的，而用户A没有听说过的物品保举给A。
  

假定用户 A 喜好物品 A、物品 C，用户 B 喜好物品 B，用户 C 喜好物品 A 、物品 C 和物品 D；从这些用户的历史爱好信息中，我们可以发现用户 A 和用户 C 的口胃和偏好是比力类似的，同时用户 C 还喜好物品 D，那末我们可以揣度用户 A 能够也喜好物品 D，是以可以将物品 D 保举给用户 A。具体代码在 ltd.newbee.mall.recommend.core.UserCF 中。

• 「itemCF」：基于物品的协同过滤。预先按照一切用户的历史偏好数据计较物品之间的类似度，然后把与用户喜好的物品相类似的物品保举给用户。
  

假如用户A喜好物品A和物品C，用户B喜好物品A、物品B和物品C，用户C喜好物品A，从这些用户的历史爱好中可以以为物品A与物品C比力类似，喜好物品A的都喜好物品C，基于这个判定用户C能够也喜好物品C，所以保举系统将物品C保举给用户C。 具体代码在 ltd.newbee.mall.recommend.core.ItemCF 中。

三、保举算法代码理论

3.1 数据收集和预处置

在「newbee-mall-pro」中，我们基于用户下单的商品数据停止收集和预处置。

1. /**
2. * 按照一切用户采办商品的记录停止数据手机
3. *
4. * @return List<RelateDTO>
5. */
6. @Override
7. public List<RelateDTO> getRelateData() {
8.     List<RelateDTO> relateDTOList = new ArrayList<>();
9.     // 获得一切定单以及定单关联商品的调集
10.     List<Order> newBeeMallOrders = orderDao.selectOrderIds();
11.     List<Long> orderIds = newBeeMallOrders.stream().map(Order::getOrderId).toList();
12.     List<OrderItemVO> newBeeMallOrderItems = orderItemDao.selectByOrderIds(orderIds);
13.     Map<Long, List<OrderItemVO>> listMap = newBeeMallOrderItems.stream()
14.             .collect(Collectors.groupingBy(OrderItemVO::getOrderId));
15.     Map<Long, List<OrderItemVO>> goodsListMap = newBeeMallOrderItems.stream()
16.             .collect(Collectors.groupingBy(OrderItemVO::getGoodsId));
17.     // 遍历定单，天生预处置数据
18.     for (Order newBeeMallOrder : newBeeMallOrders) {
19.         Long orderId = newBeeMallOrder.getOrderId();
20.         for (OrderItemVO newBeeMallOrderItem : listMap.getOrDefault(orderId, Collections.emptyList())) {
21.             Long goodsId = newBeeMallOrderItem.getGoodsId();
22.             Long categoryId = newBeeMallOrderItem.getCategoryId();
23.             RelateDTO relateDTO = new RelateDTO();
24.             ...
25.             relateDTOList.add(relateDTO);
26.         }
27.     }
28.     return relateDTOList;
29. }

复制代码

3.2 类似度计较

在保举算法中，类似度建立是一个很是重要的进程，它标志着算法准不正确，能不能给用户带来好的保举体验。在「newbee-mall-pro」中，我们将用户之间下单的商品停止类似度计较，由于假如两个用户采办了同一个商品，那末我们以为这两个用户之间是存在联系而且都存在付费行为。

1. // 遍历定单商品
2. for (OrderItemVO newBeeMallOrderItem : listMap.getOrDefault(orderId, Collections.emptyList())) {
3.     Long goodsId = newBeeMallOrderItem.getGoodsId();
4.     Long categoryId = newBeeMallOrderItem.getCategoryId();
5.     RelateDTO relateDTO = new RelateDTO();
6.     relateDTO.setUserId(newBeeMallOrder.getUserId());
7.     relateDTO.setProductId(goodsId);
8.     relateDTO.setCategoryId(categoryId);
9.     // 经过计较商品采办次数，来建立类似度
10.     List<OrderItemVO> list = goodsListMap.getOrDefault(goodsId, Collections.emptyList());
11.     int sum = list.stream().mapToInt(OrderItemVO::getGoodsCount).sum();
12.     relateDTO.setIndex(sum);
13.     relateDTOList.add(relateDTO);
14. }

复制代码

经过余弦类似度算法计较用户与商品之间的类似度，从而为用户保举最类似的商品。当两个用户采办了同一个商品时，我们就以为两个用户发生了关联，是以针对两个用户采办的同一个商品停止类似度计较，来建立用户之间的类似度。

❝ 余弦类似度是一种用于权衡两个向量之间的类似度的方式，它经过计较两个向量的夹角的余弦值来获得。在商城系统中，余弦类似度可以用于实现基于内容的保举算法，即按照用户的历史采办或阅读行为，为用户保举与其爱好类似的商品。具体来说，可以将每个商品暗示为一个特征向量，例如商品的种别、价格、评分等，然后将每个用户暗示为一个偏好向量，例如用户采办或阅读过的商品的特征向量的加权均匀。这样，便可以操纵余弦类似度来计较用户和商品之间的类似度，从而为用户保举最类似的商品。
❞

计较相关系数，传入用户ID大概物品ID，计较类似度

1. /**
2. * 计较相关系数并排序
3. *
4. * @param key  基于用户协同代表用户id，基于物品协同代表武平id
5. * @param map  预处置数据集
6. * @param type 范例0基于用户保举利用余弦类似度 1基于物品保举利用余弦类似度
7. * @return Map<Double, Long>
8. */
9. public static Map<Double, Long> computeNeighbor(Long key,
10.                           Map<Long, List<RelateDTO>> map, int type) {
11.     Map<Double, Long> distMap = new TreeMap<>();
12.     List<RelateDTO> items = map.get(key);
13.     map.forEach((k, v) -> {
14.         // 解除此用户
15.         if (!k.equals(key)) {
16.             // 计较关系系数
17.             double coefficient = relateDist(v, items, type);
18.             distMap.put(coefficient, k);
19.         }
20.     });
21.     return distMap;
22. }

复制代码

计较两个用户间的相关系数

1. /**
2. * 计较两个序列间的相关系数
3. *
4. * @param xList
5. * @param yList
6. * @param type  范例0基于用户保举利用余弦类似度 1基于物品保举利用余弦类似度 2基于用户保举利用皮尔森系数计较
7. * @return
8. */
9. private static double relateDist(List<RelateDTO> xList,
10.                               List<RelateDTO> yList, Integer type) {
11.     List<Integer> xs = Lists.newArrayList();
12.     List<Integer> ys = Lists.newArrayList();
13.     xList.forEach(x -> yList.forEach(y -> {
14.         if (type == 0) {
15.             // 基于用户保举时假如两个用户采办的商品不异，则计较类似度
16.             if (x.getProductId().longValue() == y.getProductId().longValue()) {
17.                 xs.add(x.getIndex());
18.                 ys.add(y.getIndex());
19.             }
20.         } else if (type == 1) {
21.             // 基于物品保举时假如两个用户id不异，则计较类似度
22.             if (x.getUserId().longValue() == y.getUserId().longValue()) {
23.                 xs.add(x.getIndex());
24.                 ys.add(y.getIndex());
25.             }
26.         }
27.     }));
28.     if (ys.size() == 0 || xs.size() == 0) {
29.         return 0d;
30.     }
31.     // 余弦类似度计较
32.     return cosineSimilarity(xs, ys);
33. }

复制代码

余弦类似度计较

1. /**
2. * 来计较向量之间的余弦类似度，
3. * 也就是计较两个用户大概两个物品之间的类似度
4. * @param xs
5. * @param xs
6. * @return double
7. */
8. private static double cosineSimilarity(List<Integer> xs,
9.                                                 List<Integer> ys) {
10.     double dotProduct = 0;
11.     double norm1 = 0;
12.     double norm2 = 0;
13.     for (int i = 0; i < xs.size(); i++) {
14.         Integer x = xs.get(i);
15.         Integer y = ys.get(i);
16.         dotProduct += x * y;
17.         norm1 += Math.pow(x, 2);
18.         norm2 += Math.pow(y, 2);
19.     }
20.     return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
21. }

复制代码

3.3 保举天生

基于用户协同的保举天生，我们可以先找到和方针用户有类似爱好的其他用户，然后把其他用户喜好的，而方针用户没有买过的物品保举给方针用户。

1. public class UserCF {
2.     /**
3.      * 物用户协同保举
4.      *
5.      * @param userId 用户ID
6.      * @param num    返回数目
7.      * @param list   预处置数据
8.      * @return 商品id调集
9.      */
10.     public static List<Long> recommend(Long userId, Integer num,
11.                                        List<RelateDTO> list, Integer type) {
12.         // 对每个用户的采办商品记录停止分组
13.         Map<Long, List<RelateDTO>> userMap = list.stream()
14.                 .collect(Collectors.groupingBy(RelateDTO::getUserId));
15.         // 获得其他用户与当前用户的关系值
16.         Map<Double, Long> userDisMap = CoreMath.computeNeighbor(userId, userMap, type);
17.         List<Long> similarUserIdList = new ArrayList<>();
18.         List<Double> values = new ArrayList<>(userDisMap.keySet());
19.         values.sort(Collections.reverseOrder());
20.         List<Double> scoresList = values.stream().limit(3).toList();
21.         // 获得关系比来的用户
22.         for (Double aDouble : scoresList) {
23.             similarUserIdList.add(userDisMap.get(aDouble));
24.         }
25.         List<Long> similarProductIdList = new ArrayList<>();
26.         for (Long similarUserId : similarUserIdList) {
27.             // 获得类似用户采办商品的记录
28.             List<Long> collect = userMap.get(similarUserId).stream()
29.                     .map(RelateDTO::getProductId).toList();
30.             // 过滤掉反复的商品
31.             List<Long> collect1 = collect.stream()
32.                     .filter(e -> !similarProductIdList.contains(e)).toList();
33.             similarProductIdList.addAll(collect1);
34.         }
35.         // 当前登录用户采办过的商品
36.         List<Long> userProductIdList = userMap.getOrDefault(userId,
37.                         Collections.emptyList()).stream().map(RelateDTO::getProductId).toList();
38.         // 类似用户买过，可是当前用户没买过的商品作为保举
39.         List<Long> recommendList = new ArrayList<>();
40.         for (Long similarProduct : similarProductIdList) {
41.             if (!userProductIdList.contains(similarProduct)) {
42.                 recommendList.add(similarProduct);
43.             }
44.         }
45.         Collections.sort(recommendList);
46.         return recommendList.stream().distinct().limit(num).toList();
47.     }
48. }

复制代码

基于物品协同的保举天生，找出与方针用户采办过的商品中最类似的前几个商品中方针用户也没有买过的商品保举给用户。

1. public class ItemCF {
3.     /**
4.      * 物品协同保举
5.      *
6.      * @param userId 用户ID
7.      * @param num    返回数目
8.      * @param list   预处置数据
9.      * @return 商品id调集
10.      */
11.     public static List<Long> recommend(Long userId, Integer num,
12.                                         List<RelateDTO> list) {
13.         // 按物品分组
14.         Map<Long, List<RelateDTO>> userMap = list.stream()
15.                 .collect(Collectors.groupingBy(RelateDTO::getUserId));
16.         List<Long> userProductItems = userMap.get(userId).stream()
17.                 .map(RelateDTO::getProductId).toList();
18.         Map<Long, List<RelateDTO>> itemMap = list.stream()
19.                 .collect(Collectors.groupingBy(RelateDTO::getProductId));
20.         List<Long> similarProductIdList = new ArrayList<>();
21.         Multimap<Double, Long> itemTotalDisMap = TreeMultimap.create();
22.         for (Long itemId : userProductItems) {
23.             // 获得其他物品与当前物品的关系值
24.             Map<Double, Long> itemDisMap = CoreMath.computeNeighbor(itemId, itemMap, 1);
25.             itemDisMap.forEach(itemTotalDisMap::put);
26.         }
28.         List<Double> values = new ArrayList<>(itemTotalDisMap.keySet());
29.         values.sort(Collections.reverseOrder());
30.         List<Double> scoresList = values.stream().limit(num).toList();
31.         // 获得关系比来的用户
32.         for (Double aDouble : scoresList) {
33.             Collection<Long> longs = itemTotalDisMap.get(aDouble);
34.             for (Long productId : longs) {
35.                 if (!userProductItems.contains(productId)) {
36.                     similarProductIdList.add(productId);
37.                 }
38.             }
39.         }
40.         return similarProductIdList.stream().distinct().limit(num).toList();
41.     }
42. }

复制代码

3.4 保举评价和优化

在「newbee-mall-pro」中可以针对「为你保举」栏目中保举的商品做曝光率、点击率、下单数等作为监控目标来评价保举结果。
四、用户协同和物品协同利用处景

用户协同和物品协同都是两种常用的保举系统算法，它们别离操纵用户之间和物品之间的类似度来给用户供给本性化的保举。用户协同和物品协同的利用处景有以下几种：

• 用户协同适用于用户数目相对较少，用户爱好相对稳定，物品数目相对较多，物品更新频次较高的场景。例如，电影保举、音乐保举、图书保举等。
  
• 物品协同适用于用户数目相对较多，用户爱好相对多变，物品数目相对较少，物品更新频次较低的场景。例如，消息保举、广告保举、交际收集保举等。
  
• 用户协同和物品协同也可以连系起来，构成夹杂保举系统，以进步保举的正确性和覆盖率。例如，电商平台可以按照用户的采办历史和评价，以及物品的属性和销量，综合利用用户协同和物品协同来给用户保举商品。
  

商城系统利用用户协同还是物品协同，这是一个需要按照具体情况停止挑选的题目。用户协同是指按照用户之间的类似度，为用户保举他们能够感爱好的物品。物品协同是指按照物品之间的类似度，为用户保举与他们已经采办或阅读过的物品类似的物品。两种方式各有优弱点，需要综合斟酌商城系统的方针、范围、数据量、稀疏度等身分。一般来说，假如商城系统的方针是增加用户的多样性和摸干脆，那末用户协同能够更合适，由于它可以为用户供给更普遍的挑选。假如商城系统的方针是增加用户的满足度和虔诚度，那末物品协同能够更合适，由于它可以为用户供给更精准的保举
在一般商城系统中，早期用户数目少可以利用用户协同，前期用户数远超商品数，利用物品协同会更好些，这两者也可以连系利用。保举算法是不会原封不动的，它需要按照某些目标数据不竭优化调剂升值甚至重构利用别的的算法。
五、冷启动题目

商城协同算法冷启动题目是指在商城系统中，当新用户或新商品加入时，由于缺少充足的交互数据，致使协同过滤算法没法为其供给正确的保举成果。

❝ 在「newbee-mall-pro」就是指新用户还未下单
❞

这类题目会影响商城的用户体验和转化率，是以需要有用的处理计划。一种常见的方式是利用风行度算法。
操纵基于风行度的算法很是简单粗鲁，类似于各大消息、微博热榜、商城等，按照PV、UV、点击率、搜索率、下单商品排行等数据来按某种热度排序来保举给用户。
总结

到这里，本文所分享「保举算法在商城系统理论」就全数先容完了，希望对大师实现保举系统落地有所帮助，喜好的朋友们可以点赞加关注 。

❝ 公众号【waynblog】每周更新博主最新技术文章，接待大师关注
❞