java协同过滤推荐算法代码

这里提供一个基于用户的协同过滤推荐算法的Java代码示例：

public class UserCF {

    // 用户-物品评分矩阵
    private Map<Integer, Map<Integer, Double>> userItemScoreMap;

    // 用户之间的相似度矩阵
    private Map<Integer, Map<Integer, Double>> userSimMap;

    public UserCF(Map<Integer, Map<Integer, Double>> userItemScoreMap) {
        this.userItemScoreMap = userItemScoreMap;
        this.userSimMap = new HashMap<>();
    }

    /**
     * 计算用户之间的相似度
     */
    private void calcUserSim() {
        for (Integer user1 : userItemScoreMap.keySet()) {
            for (Integer user2 : userItemScoreMap.keySet()) {
                if (user1.equals(user2)) {
                    continue;
                }
                double sim = getUserSim(user1, user2);
                if (sim > 0) {
                    Map<Integer, Double> userSimMap1 = userSimMap.getOrDefault(user1, new HashMap<>());
                    userSimMap1.put(user2, sim);
                    userSimMap.put(user1, userSimMap1);
                }
            }
        }
    }

    /**
     * 计算用户之间的相似度
     */
    private double getUserSim(int user1, int user2) {
        Map<Integer, Double> user1ItemScoreMap = userItemScoreMap.get(user1);
        Map<Integer, Double> user2ItemScoreMap = userItemScoreMap.get(user2);
        double dotProduct = 0; // 用户1和用户2共同评分的物品的评分乘积之和
        double norm1 = 0; // 用户1的评分向量的模
        double norm2 = 0; // 用户2的评分向量的模
        for (Integer item : user1ItemScoreMap.keySet()) {
            if (user2ItemScoreMap.containsKey(item)) {
                dotProduct += user1ItemScoreMap.get(item) * user2ItemScoreMap.get(item);
            }
            norm1 += user1ItemScoreMap.get(item) * user1ItemScoreMap.get(item);
        }
        for (Integer item : user2ItemScoreMap.keySet()) {
            norm2 += user2ItemScoreMap.get(item) * user2ItemScoreMap.get(item);
        }
        double denominator = Math.sqrt(norm1) * Math.sqrt(norm2);
        if (denominator == 0) {
            return 0;
        }
        return dotProduct / denominator;
    }

    /**
     * 推荐TopN个物品给指定用户
     *
     * @param userId  指定用户
     * @param topN    推荐的物品数
     * @return        推荐的物品列表
     */
    public List<Integer> recommend(int userId, int topN) {
        calcUserSim();
        Map<Integer, Double> itemScoreMap = new HashMap<>(); // 物品评分累加器
        Map<Integer, Double> userSimMap1 = userSimMap.get(userId);
        for (Integer user : userSimMap1.keySet()) {
            double sim = userSimMap1.get(user);
            Map<Integer, Double> userItemScoreMap1 = userItemScoreMap.get(user);
            for (Integer item : userItemScoreMap1.keySet()) {
                if (!userItemScoreMap.get(userId).containsKey(item)) {
                    double itemScore = userItemScoreMap1.get(item);
                    itemScoreMap.put(item, itemScoreMap.getOrDefault(item, 0.0) + sim * itemScore);
                }
            }
        }
        List<Integer> itemList = new ArrayList<>(itemScoreMap.keySet());
        Collections.sort(itemList, (a, b) -> Double.compare(itemScoreMap.get(b), itemScoreMap.get(a)));
        return itemList.subList(0, Math.min(topN, itemList.size()));
    }
}

使用示例：

Map<Integer, Map<Integer, Double>> userItemScoreMap = new HashMap<>();
userItemScoreMap.put(1, Map.of(1, 5.0, 2, 3.0, 3, 4.0));
userItemScoreMap.put(2, Map.of(1, 4.0, 2, 4.0, 3, 3.0, 4, 5.0));
userItemScoreMap.put(3, Map.of(1, 4.0, 3, 5.0, 4, 3.0));
userItemScoreMap.put(4, Map.of(2, 5.0, 3, 2.0, 4, 4.0));
UserCF userCF = new UserCF(userItemScoreMap);
List<Integer> itemList = userCF.recommend(1, 2);
System.out.println(itemList); // [4, 1]

以上代码实现了基于用户的协同过滤推荐算法，通过用户之间的相似度来推荐物品。具体来说，先构建用户-物品评分矩阵，然后计算用户之间的相似度，最后根据指定用户的相似用户和相似度，以及相似用户对其他物品的评分，计算指定用户对其他物品的评分，并推荐TopN个物品。