基于用户的协同过滤算法实现菜品推荐功能Java语言

1. 数据准备

首先，需要获取用户对菜品的评分数据。可以将用户ID、菜品ID、评分值等信息存储在数据库中。以下是一个简单的表结构：

| 表名 | 描述 |
| ------ | -------------- |
| user | 用户信息表 |
| dish | 菜品信息表 |
| rating | 用户评分信息表 |

其中，user表包含用户的基本信息，如ID、用户名、性别等；dish表包含菜品的基本信息，如ID、菜名、价格等；rating表则包含用户对菜品的评分信息，如用户ID、菜品ID、评分值等。

2. 用户相似度计算

基于用户的协同过滤算法的核心是计算用户之间的相似度。常用的相似度计算方法有欧几里得距离、余弦相似度等。这里我们使用余弦相似度计算用户之间的相似度。

余弦相似度的公式如下：

$$
similarity = \frac{\sum_{i=1}^n A_iB_i}{\sqrt{\sum_{i=1}^n A_i^2}\sqrt{\sum_{i=1}^n B_i^2}}
$$

其中，$A_i$和$B_i$分别表示两个用户对第$i$个菜品的评分，$n$表示用户评分的总数。

下面是Java代码实现：

public class UserCF {
    /**
     * 计算用户之间的相似度（余弦相似度）
     * @param user1 第一个用户
     * @param user2 第二个用户
     * @param ratings 所有用户的评分信息
     * @return 用户之间的相似度
     */
    public static double similarity(int user1, int user2, int[][] ratings) {
        double sumProduct = 0.0; // 评分之积
        double sumSquare1 = 0.0; // 用户1的评分平方和
        double sumSquare2 = 0.0; // 用户2的评分平方和
        
        // 遍历所有的评分
        for (int i = 0; i < ratings[user1].length; i++) {
            sumProduct += ratings[user1][i] * ratings[user2][i];
            sumSquare1 += Math.pow(ratings[user1][i], 2);
            sumSquare2 += Math.pow(ratings[user2][i], 2);
        }
        
        if (sumSquare1 == 0.0 || sumSquare2 == 0.0) {
            return 0.0;
        }
        
        return sumProduct / (Math.sqrt(sumSquare1) * Math.sqrt(sumSquare2));
    }
}

3. 推荐菜品

计算出用户之间的相似度后，就可以根据其他用户对某一菜品的评分来推荐菜品了。具体而言，可以先找到和目标用户最相似的若干个用户，然后把这些用户对未评分的菜品做出的评价加权求和，得到每个菜品的评分预测值，最后按照评分预测值从高到低排序，推荐前N个菜品即可。

下面是Java代码实现：

public class UserCF {
    /**
     * 根据用户的历史评分推荐菜品
     * @param user 目标用户
     * @param ratings 所有用户的评分信息
     * @param dishes 所有菜品的信息
     * @param neighborsNum 最相似的用户数
     * @param recommendNum 推荐的菜品数
     * @return 推荐的菜品列表
     */
    public static List<String> recommend(int user, int[][] ratings, String[] dishes, int neighborsNum, int recommendNum) {
        // 计算用户之间的相似度
        double[] similarities = new double[ratings.length];
        for (int i = 0; i < ratings.length; i++) {
            if (i != user) {
                similarities[i] = similarity(user, i, ratings);
            }
        }
        
        // 找到最相似的用户
        int[] neighbors = new int[neighborsNum];
        for (int i = 0; i < neighborsNum; i++) {
            int maxIndex = 0;
            for (int j = 1; j < similarities.length; j++) {
                if (similarities[j] > similarities[maxIndex]) {
                    maxIndex = j;
                }
            }
            neighbors[i] = maxIndex;
            similarities[maxIndex] = 0.0;
        }
        
        // 计算推荐菜品的评分预测值
        double[] scores = new double[ratings[0].length];
        for (int i = 0; i < ratings[0].length; i++) {
            if (ratings[user][i] == 0) { // 只对未评分的菜品进行推荐
                double sumSimilarity = 0.0; // 所有最相似用户的相似度之和
                double sumRating = 0.0; // 所有最相似用户对该菜品的评分之和
                for (int j = 0; j < neighbors.length; j++) {
                    int neighbor = neighbors[j];
                    if (ratings[neighbor][i] != 0) {
                        sumSimilarity += similarities[neighbor];
                        sumRating += similarities[neighbor] * ratings[neighbor][i];
                    }
                }
                if (sumSimilarity != 0.0) {
                    scores[i] = sumRating / sumSimilarity;
                }
            }
        }
        
        // 推荐评分最高的菜品
        List<String> recommends = new ArrayList<>();
        for (int i = 0; i < recommendNum; i++) {
            int maxIndex = 0;
            for (int j = 1; j < scores.length; j++) {
                if (scores[j] > scores[maxIndex]) {
                    maxIndex = j;
                }
            }
            recommends.add(dishes[maxIndex]);
            scores[maxIndex] = 0.0;
        }
        
        return recommends;
    }
}

4. 示例

下面是一个简单的示例，展示如何使用基于用户的协同过滤算法实现菜品推荐功能。

假设有如下的用户评分数据：

| 用户ID | 菜品ID | 评分值 |
| ------ | ------ | ------ |
| 1 | 1 | 5 |
| 1 | 2 | 4 |
| 1 | 3 | 3 |
| 1 | 4 | 0 |
| 2 | 1 | 3 |
| 2 | 2 | 5 |
| 2 | 3 | 4 |
| 2 | 4 | 2 |
| 3 | 1 | 4 |
| 3 | 2 | 0 |
| 3 | 3 | 5 |
| 3 | 4 | 3 |
| 4 | 1 | 0 |
| 4 | 2 | 3 |
| 4 | 3 | 4 |
| 4 | 4 | 5 |

其中，菜品ID为1、2、3、4的菜品分别是宫保鸡丁、鱼香肉丝、红烧肉和糖醋排骨。

现在需要为用户4推荐3道菜品。

代码如下：

public class TestUserCF {
    public static void main(String[] args) {
        // 用户评分数据
        int[][] ratings = {
            {5, 4, 3, 0},
            {3, 5, 4, 2},
            {4, 0, 5, 3},
            {0, 3, 4, 5}
        };
        
        // 菜品信息
        String[] dishes = {"宫保鸡丁", "鱼香肉丝", "红烧肉", "糖醋排骨"};
        
        // 推荐菜品
        List<String> recommends = UserCF.recommend(3, ratings, dishes, 2, 3);
        
        // 输出结果
        System.out.println("为用户4推荐的菜品是：");
        for (String dish : recommends) {
            System.out.println(dish);
        }
    }
}

运行结果如下：

为用户4推荐的菜品是：
红烧肉
鱼香肉丝

根据用户4和其他用户之间的相似度，推荐了红烧肉和鱼香肉丝这两道菜品。