UserCF的设计流程（Python，Java）

基本介绍：

在推荐系统领域，协同过滤（Collaborative Filtering）是一种常见且有效的推荐算法。其中，基于用户的协同过滤（UserCF）是一种流行的方法，它通过分析用户之间的行为和偏好来进行推荐。

UserCF设计基本流程：

1. 数据准备
   UserCF算法的实施需要一定的数据支持。首先，我们需要获得用户对项目（或物品）的评分数据，可以是用户对电影的评分、用户对商品的购买行为等。其次，我们需要构建用户-项目的评分矩阵，矩阵的行表示用户，列表示项目，矩阵中的每个元素表示用户对项目的评分。

2. 相似度计算
   在UserCF算法中，我们需要计算用户之间的相似度。常用的相似度计算方法包括余弦相似度、皮尔逊相关系数等。

3. 用户相似度矩阵构建
   根据相似度计算的结果，我们可以构建用户相似度矩阵。该矩阵的行和列分别表示用户，矩阵中的每个元素表示对应用户之间的相似度。我们可以使用一个二维数组或字典来表示该矩阵，其中数组或字典的键可以是用户的唯一标识符。

4. 候选项目生成
   在UserCF算法中，我们需要为目标用户生成一组候选项目。这些候选项目是由与目标用户相似的其他用户喜欢的项目组成的。具体而言，对于目标用户，我们可以通过相似度矩阵找到与其相似度最高的K个用户，然后将这些用户喜欢的项目加入候选项目列表。

5. 推荐列表生成
   基于候选项目列表，我们可以生成最终的推荐列表。一种常用的方法是根据候选项目的流行度进行排序，选择热门度较高的项目作为推荐结果。另一种方法是根据候选项目与目标用户的相似度加权进行排序，选择与目标用户更为相似的项目作为推荐结果。

简单实现：

根据用户对于景点的评分，给用户推荐景点（python）

# 用字典的形式表示测试数据data，其中键是用户id，值是另一个字典，该字典的键是景点id，值是对该景点评分
data = {
    "user1": {"spot1": 5, "spot2": 3, "spot3": 2},
    "user2": {"spot1": 5, "spot2": 1, "spot3": 2, "spot4": 4, "spot5": 5},
    "user3": {"spot1": 1, "spot4": 4, "spot6": 5},
    "user4": {"spot1": 1, "spot2": 2, "spot3": 5},
    "user5": {"spot1": 5, "spot2": 3, "spot7": 4}
}


# 基于皮尔相关系数计算两个用户之间相似度
def cal_similarity(user1, user2):
    # 1.获取两个用户都评论的景点，避免不必要计算
    common_spots = set(data[user1]).intersection(data[user2])
    n = len(common_spots)
    if n == 0:
        return 0

    # 2.计算用户对景点评分和
    ''' sum1 = 0
        for spot in common_spots:
            sum1 += data[user1][spot] '''
    sum1 = sum(data[user1][spot] for spot in common_spots)
    sum2 = sum(data[user2][spot] for spot in common_spots)

    # 3.计算评分平方和
    sumsq1 = sum(pow(data[user1][spot], 2) for spot in common_spots)
    sumsq2 = sum(pow(data[user2][spot], 2) for spot in common_spots)

    # 4.乘积和
    pSum = sum(data[user1][spot] * data[user2][spot] for spot in common_spots)

    # 4.计算系数
    num = pSum - (sum1 * sum2) / n
    den = ((sumsq1 - pow(sum1, 2) / n) * (sumsq2 - pow(sum2, 2) / n)) ** 0.5
    if den == 0:
        return 0
    r = round(num / den, 2)
    return r


# 计算与目标用户的n个相似度最高的用户
def nearst_user(username, n=1):
    similarities = []
    for user in data:
        if user != username:
            sim = cal_similarity(user, username)
            similarities.append((user, sim))
    # 使用第二个字段（相似度） 从大到小排序
    similarities.sort(key=lambda x: x[1], reverse=True)
    # 返回前n个人
    return similarities[:n]


# 根据这些相似用户给目标用户进行推荐
def recommend(username, n=1):
    recommendations = {}
    users = nearst_user(username, n)
    print(users)
    for user, _ in users:
        for spot in data[user]:
            if spot not in data[username] or data[username][spot] == 0:
                if spot not in recommendations:
                    recommendations[spot] = 0
                # recommendations => 景点：评分
                recommendations[spot] = data[user][spot]
    # 根据推荐分数排序
    re_spots = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)
    return re_spots[:n]


# user1 = 'user1'
# user2 = 'user2'
# similarity = cal_similarity(user1, user2)
# print(f'用户{user1}和用户{user2}的相似度为: {similarity}')

print(recommend('user1', 4))

Java版本：

public class UserCF {

    private static Map<String, Map<String, Integer>> data = new HashMap<>();

    public static void main(String[] args) {
        // 初始化数据
        initData();

        // 计算相似用户
        List<Map.Entry<String, Double>> similarUsers = nearestUser("user1", 2);
        System.out.println(similarUsers);

        // 生成推荐列表
        List<Map.Entry<String, Integer>> recommendations = recommend("user1", 3);
        System.out.println(recommendations);
    }

    private static void initData() {
        Map<String, Integer> user1 = new HashMap<>();
        user1.put("spot1", 5);
        user1.put("spot2", 3);
        user1.put("spot3", 2);

        Map<String, Integer> user2 = new HashMap<>();
        user2.put("spot1", 5);
        user2.put("spot2", 1);
        user2.put("spot3", 2);
        user2.put("spot4", 4);
        user2.put("spot5", 5);

        Map<String, Integer> user3 = new HashMap<>();
        user3.put("spot1", 1);
        user3.put("spot4", 4);
        user3.put("spot6", 5);

        Map<String, Integer> user4 = new HashMap<>();
        user4.put("spot1", 1);
        user4.put("spot2", 2);
        user4.put("spot3", 5);

        Map<String, Integer> user5 = new HashMap<>();
        user5.put("spot1", 5);
        user5.put("spot2", 3);
        user5.put("spot7", 4);

        data.put("user1", user1);
        data.put("user2", user2);
        data.put("user3", user3);
        data.put("user4", user4);
        data.put("user5", user5);
    }

    public static double calSimilarity(String user1, String user2) {
        Set<String> commonSpots = new HashSet<>(data.get(user1).keySet());
        commonSpots.retainAll(data.get(user2).keySet());

        int n = commonSpots.size();
        if (n == 0) {
            return 0;
        }

        int sum1 = commonSpots.stream().mapToInt(spot -> data.get(user1).get(spot)).sum();
        int sum2 = commonSpots.stream().mapToInt(spot -> data.get(user2).get(spot)).sum();

        double sumsq1 = commonSpots.stream().mapToDouble(spot -> Math.pow(data.get(user1).get(spot), 2)).sum();
        double sumsq2 = commonSpots.stream().mapToDouble(spot -> Math.pow(data.get(user2).get(spot), 2)).sum();

        int pSum = commonSpots.stream().mapToInt(spot -> data.get(user1).get(spot) * data.get(user2).get(spot)).sum();

        double num = pSum - (sum1 * sum2) / (double) n;
        double den = Math.sqrt((sumsq1 - Math.pow(sum1, 2) / (double) n) * (sumsq2 - Math.pow(sum2, 2) / (double) n));
        if (den == 0) {
            return 0;
        }

        return Math.round(num / den * 100) / 100.0;
    }

    public static List<Map.Entry<String, Double>> nearestUser(String username, int n) {
        List<Map.Entry<String, Double>> similarities = new ArrayList<>();
        for (String user : data.keySet()) {
            if (!user.equals(username)) {
                double sim = calSimilarity(user, username);
                similarities.add(new AbstractMap.SimpleEntry<>(user, sim));
            }
        }

        similarities.sort((a, b) -> Double.compare(b.getValue(), a.getValue()));
        return similarities.subList(0, Math.min(n, similarities.size()));
    }

    public static List<Map.Entry<String, Integer>> recommend(String username, int n) {
        Map<String, Integer> recommendations = new HashMap<>();
        List<Map.Entry<String, Double>> similarUsers = nearestUser(username, n);

        for (Map.Entry<String, Double> similarUser : similarUsers) {
            String user = similarUser.getKey();
            for (Map.Entry<String, Integer> entry : data.get(user).entrySet()) {
                String spot = entry.getKey();
                int rating = entry.getValue();
                if (!data.get(username).containsKey(spot) || data.get(username).get(spot) == 0) {
                    recommendations.put(spot, recommendations.getOrDefault(spot, 0) + rating);
                }
            }
        }

        List<Map.Entry<String, Integer>> sortedRecommendations = new ArrayList<>(recommendations.entrySet());
        sortedRecommendations.sort((a, b) -> Integer.compare(b.getValue(), a.getValue()));
        return sortedRecommendations.subList(0, Math.min(n, sortedRecommendations.size()));
    }
}