Java를 사용하여 추천 시스템 기반 소셜 네트워크 애플리케이션을 작성하는 방법

현대 소셜 네트워크 애플리케이션에서 추천 시스템은 필수적인 기능이 되었습니다. 사용자에게 친구 추천, 관심 주제 추천, 관련 상품 추천, 더 가치 있는 콘텐츠 추천 등 추천 시스템은 사용자 경험과 지속성을 효과적으로 향상시킬 수 있습니다.

이 기사에서는 Java를 사용하여 추천 시스템 기반 소셜 네트워크 애플리케이션을 작성하는 방법을 소개합니다. 독자들이 기본 추천 시스템을 빠르게 이해하고 구현할 수 있도록 실제 코드와 세부 단계를 결합해 보겠습니다.

1. 데이터 수집 및 처리

추천 시스템을 구현하기 전에 우리는 많은 양의 데이터를 수집하고 처리해야 합니다. 소셜 네트워크 애플리케이션에서 사용자 정보, 게시물, 댓글, 좋아요 및 기타 데이터는 모두 귀중한 데이터 소스입니다.

시연을 용이하게 하기 위해 오픈 소스 가상 데이터 생성기를 사용하여 이러한 데이터를 생성할 수 있습니다. 구체적인 단계는 다음과 같습니다.

1. Mockaroo(https://www.mockaroo.com/)와 같은 가상 데이터 생성기를 다운로드하여 설치합니다.
2. 사용자 정보, 게시물, 댓글 등을 포함하여 생성해야 하는 데이터 세트를 정의합니다.
3. 데이터를 생성하고 CSV 파일로 내보냅니다.
4. Java 코드를 사용하여 CSV 파일의 데이터를 읽고 데이터베이스에 저장합니다. MySQL 및 Oracle과 같은 널리 사용되는 관계형 데이터베이스를 사용하여 데이터를 저장할 수 있습니다. 여기서는 데이터 저장용 데이터베이스로 MySQL 8.0을 사용합니다.

2. 사용자와 아이템의 표현

추천 시스템에서는 사용자와 아이템의 유사성을 계산하거나 추천을 하기 위해 벡터나 행렬 형태로 변환해야 합니다. 소셜 네트워크 애플리케이션에서는 다음 방법을 사용하여 사용자와 항목을 나타낼 수 있습니다.

1. 사용자 벡터: 사용자가 팔로우하는 주제, 게시된 게시물, 상호 작용하는 친구 등과 같은 데이터를 사용하여 사용자의 정보를 나타낼 수 있습니다. 벡터. 예를 들어, 사용자 A가 Java, Python, JavaScript 등의 주제를 팔로우하고 "Java를 잘 배우는 방법" 및 "Java 시작하기"를 게시하고 사용자 B 및 C와 상호작용하는 경우 다음 벡터를 사용할 수 있습니다. 사용자 A를 나타냅니다.

사용자 A = [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0 , 0, 1]

여기서 벡터 길이는 24이고 각 위치는 주제나 게시물을 나타냅니다. 1은 사용자 A가 해당 주제를 팔로우했거나 게시물을 게시했음을 의미하고, 0은 그렇지 않음을 의미합니다.

2. 항목 벡터: 각 게시물의 태그, 콘텐츠, 댓글 및 기타 데이터를 사용하여 게시물의 벡터를 나타낼 수 있습니다. 예를 들어 게시물에 "Java, 프로그래밍"이라는 태그가 지정되고 콘텐츠가 "Java 프로그래밍 학습을 위한 네 가지 제안"이며 댓글이 10개라면 다음 벡터를 사용하여 게시물을 나타낼 수 있습니다.

Post A = [1 , 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0]

여기서 , 벡터 길이는 24이고 각 위치는 레이블 또는 통계 데이터를 나타냅니다. 1은 게시물에 태그나 콘텐츠가 포함되어 있음을 의미하고, 0은 포함되지 않음을 의미합니다.

3. 사용자 기반 협업 필터링 추천

사용자 기반 협업 필터링은 추천 시스템에서 흔히 사용되는 방식입니다. 여기서는 사용자 기반 협업 필터링을 사용하여 사용자에게 적합한 게시물을 추천합니다. 구체적인 단계는 다음과 같습니다.

1. 사용자 간의 유사성을 계산합니다. 여기서는 유사성 측정항목으로 Pearson 상관계수를 사용합니다.
2. 타겟 유저의 관심분야와 가장 유사한 K명의 유저를 선택하세요.
3. 각 사용자에 대해 자신이 좋아하지만 대상 사용자가 보지 못한 N개의 게시물을 선택하세요.
4. 선택한 N개의 게시물에 대해 각 게시물의 추천 점수를 계산하여 높은 순으로 정렬합니다.
5. 점수가 가장 높은 M개의 게시물을 추천 결과로 선택하세요.

다음은 이 알고리즘의 Java 코드 구현입니다.

public class CollaborativeFiltering {

    /**
     * 计算用户间的皮尔逊相关系数
     * @param user1 用户1
     * @param user2 用户2
     * @param data 数据集
     * @return 皮尔逊相关系数
     */
    public double pearsonCorrelation(Map<Integer, Double> user1, Map<Integer, Double> user2,
                                      Map<Integer, Map<Integer, Double>> data) {
        double sum1 = 0, sum2 = 0, sum1Sq = 0, sum2Sq = 0, pSum = 0;
        int n = 0;
        for (int item : user1.keySet()) {
            if (user2.containsKey(item)) {
                sum1 += user1.get(item);
                sum2 += user2.get(item);
                sum1Sq += Math.pow(user1.get(item), 2);
                sum2Sq += Math.pow(user2.get(item), 2);
                pSum += user1.get(item) * user2.get(item);
                n++;
            }
        }
        if (n == 0)
            return 0;
        double num = pSum - (sum1 * sum2 / n);
        double den = Math.sqrt((sum1Sq - Math.pow(sum1, 2) / n) *
                (sum2Sq - Math.pow(sum2, 2) / n));
        if (den == 0)
            return 0;
        return num / den;
    }

    /**
     * 基于用户的协同过滤推荐算法
     * @param data 数据集
     * @param userId 目标用户 ID
     * @param K 最相似的 K 个用户
     * @param N 推荐的 N 个帖子
     * @return 推荐的帖子 ID 列表
     */
    public List<Integer> userBasedCollaborativeFiltering(Map<Integer, Map<Integer, Double>> data,
                                                          int userId, int K, int N) {
        Map<Integer, Double> targetUser = data.get(userId); // 目标用户
        List<Map.Entry<Integer, Double>> similarUsers = new ArrayList<>(); // 与目标用户兴趣相似的用户
        for (Map.Entry<Integer, Map<Integer, Double>> entry: data.entrySet()) {
            int id = entry.getKey();
            if (id == userId)
                continue;
            double sim = pearsonCorrelation(targetUser, entry.getValue(), data); // 计算皮尔逊相关系数
            if (sim > 0)
                similarUsers.add(new AbstractMap.SimpleEntry<>(id, sim));
        }
        Collections.sort(similarUsers, (a, b) -> b.getValue().compareTo(a.getValue())); // 按相似度从高到低排序
        List<Integer> itemIds = new ArrayList<>();
        for (int i = 0; i < K && i < similarUsers.size(); i++) {
            Map.Entry<Integer, Double> entry = similarUsers.get(i);
            int userId2 = entry.getKey();
            Map<Integer, Double> user2 = data.get(userId2);
            for (int itemId: user2.keySet()) {
                if (!targetUser.containsKey(itemId)) { // 如果目标用户没看过该帖子
                    itemIds.add(itemId);
                }
            }
        }
        Map<Integer, Double> scores = new HashMap<>();
        for (int itemId: itemIds) {
            double score = 0;
            int count = 0;
            for (Map.Entry<Integer, Double> entry: similarUsers) {
                int userId2 = entry.getKey();
                Map<Integer, Double> user2 = data.get(userId2);
                if (user2.containsKey(itemId)) { // 如果用户 2 看过该帖子
                    score += entry.getValue() * user2.get(itemId);
                    count++;
                    if (count == N)
                        break;
                }
            }
            scores.put(itemId, score);
        }
        List<Integer> pickedItemIds = new ArrayList<>();
        scores.entrySet().stream().sorted((a, b) -> b.getValue().compareTo(a.getValue()))
                .limit(N).forEach(entry -> pickedItemIds.add(entry.getKey())); // 按得分从高到低排序并选出前N个
        return pickedItemIds;
    }
}

4. 콘텐츠 기반 추천 알고리즘

콘텐츠 기반 추천 알고리즘은 추천 시스템의 또 다른 일반적인 방법입니다. 이는 항목 속성의 유사성을 기반으로 항목을 추천합니다. . 여기서는 콘텐츠 기반 추천 알고리즘을 사용하여 사용자에게 적합한 게시물을 추천합니다. 구체적인 단계는 다음과 같습니다.

1. 대상 사용자의 경우 팔로우하는 주제, 게시물 및 기타 콘텐츠를 선택하세요.
2. 이러한 콘텐츠를 바탕으로 각 게시물과 타겟 사용자의 관심분야의 유사도를 계산합니다.
3. 타겟 사용자의 관심사와 가장 유사한 상위 N개의 게시물을 선택하세요.
4. 점수를 높은 순으로 정렬하고, 점수가 가장 높은 M개의 게시물을 추천 결과로 선택하세요.

다음은 콘텐츠 기반 추천 알고리즘의 Java 코드 구현입니다.

public class ContentBasedRecommendation {

    /**
     * 计算两个向量的余弦相似度
     * @param v1 向量1
     * @param v2 向量2
     * @return 余弦相似度
     */
    public double cosineSimilarity(double[] v1, double[] v2) {
        double dotProduct = 0;
        double norma = 0;
        double normb = 0;
        for (int i = 0; i < v1.length; i++) {
            dotProduct += v1[i] * v2[i];
            norma += Math.pow(v1[i], 2);
            normb += Math.pow(v2[i], 2);
        }
        if (norma == 0 || normb == 0)
            return 0;
        return dotProduct / (Math.sqrt(norma) * Math.sqrt(normb));
    }

    /**
     * 基于内容的推荐算法
     * @param data 数据集
     * @param userId 目标用户 ID
     * @param N 推荐的 N 个帖子
     * @return 推荐的帖子 ID 列表
     */
    public List<Integer> contentBasedRecommendation(Map<Integer, Map<Integer, Double>> data,
                                                     int userId, int N) {
        Map<Integer, Double> targetUser = data.get(userId); // 目标用户
        int[] pickedItems = new int[data.size()];
        double[][] itemFeatures = new double[pickedItems.length][24]; // 物品特征矩阵
        for (Map.Entry<Integer, Map<Integer, Double>> entry: data.entrySet()) {
            int itemId = entry.getKey();
            Map<Integer, Double> item = entry.getValue();
            double[] feature = new double[24];
            for (int i = 0; i < feature.length; i++) {
                if (item.containsKey(i+1)) {
                    feature[i] = item.get(i+1);
                } else {
                    feature[i] = 0;
                }
            }
            itemFeatures[itemId-1] = feature; // 物品 ID 从 1 开始，需要减一
        }
        for (int itemId: targetUser.keySet()) {
            pickedItems[itemId-1] = 1; // 物品 ID 从 1 开始，需要减一
        }
        double[] similarities = new double[pickedItems.length];
        for (int i = 0; i < similarities.length; i++) {
            if (pickedItems[i] == 0) {
                similarities[i] = cosineSimilarity(targetUser.values().stream().mapToDouble(Double::doubleValue).toArray(), itemFeatures[i]);
            }
        }
        List<Integer> itemIds = new ArrayList<>();
        while (itemIds.size() < N) {
            int maxIndex = -1;
            for (int i = 0; i < similarities.length; i++) {
                if (pickedItems[i] == 0 && (maxIndex == -1 || similarities[i] > similarities[maxIndex])) {
                    maxIndex = i;
                }
            }
            if (maxIndex == -1 || similarities[maxIndex] < 0) {
                break; // 找不到更多相似的物品了
            }
            itemIds.add(maxIndex + 1); // 物品 ID 从 1 开始，需要加一
            pickedItems[maxIndex] = 1;
        }
        Map<Integer, Double> scores = new HashMap<>();
        for (int itemId: itemIds) {
            double[] features = itemFeatures[itemId-1]; // 物品 ID 从 1 开始，需要减一
            double score = cosineSimilarity(targetUser.values().stream().mapToDouble(Double::doubleValue).toArray(), features);
            scores.put(itemId, score);
        }
        List<Integer> pickedItemIds = new ArrayList<>();
        scores.entrySet().stream().sorted((a, b) -> b.getValue().compareTo(a.getValue()))
                .limit(N).forEach(entry -> pickedItemIds.add(entry.getKey())); // 按得分从高到低排序并选出前N个
        return pickedItemIds;
    }
}

5. 추천 알고리즘을 애플리케이션에 통합합니다.

위의 두 가지 추천 알고리즘 구현을 완료한 후 이를 애플리케이션에 통합할 수 있습니다. . 구체적인 단계는 다음과 같습니다.

1. 데이터를 로드하고 데이터베이스에 저장합니다. Hibernate와 같은 ORM 프레임워크를 사용하여 데이터베이스 액세스 작업을 단순화할 수 있습니다.
2. HTTP 요청을 수락하고 응답을 JSON 형식으로 반환하는 RESTful API를 정의하세요. Spring Framework를 사용하여 RESTful API를 구축하고 배포할 수 있습니다.
3. 사용자 기반 협업 필터링 추천과 콘텐츠 기반 추천 알고리즘을 구현하고 이를 RESTful API에 통합합니다.

다음은 애플리케이션의 Java 코드 구현입니다.

@RestController
@RequestMapping("/recommendation")
public class RecommendationController {

    private CollaborativeFiltering collaborativeFiltering = new CollaborativeFiltering();
    private ContentBasedRecommendation contentBasedRecommendation = new ContentBasedRecommendation();

    @Autowired
    private UserService userService;

    @GetMapping("/userbased/{userId}")
    public List<Integer> userBasedRecommendation(@PathVariable Integer userId) {
        List<User> allUsers = userService.getAllUsers();
        Map<Integer, Map<Integer, Double>> data = new HashMap<>();
        for (User user: allUsers) {
            Map<Integer, Double> userVector = new HashMap<>();
            List<Topic> followedTopics = user.getFollowedTopics();
            for (Topic topic: followedTopics) {
                userVector.put(topic.getId(), 1.0);
            }
            List<Post> posts = user.getPosts();
            for (Post post: posts) {
                userVector.put(post.getId() + 1000, 1.0);
            }
            List<Comment> comments = user.getComments();
            for (Comment comment: comments) {
                userVector.put(comment.getId() + 2000, 1.0);
            }
            List<Like> likes = user.getLikes();
            for (Like like: likes) {
                userVector.put(like.getId() + 3000, 1.0);
            }
            data.put(user.getId(), userVector);
        }
        List<Integer> itemIds = collaborativeFiltering.userBasedCollaborativeFiltering(data, userId, 5, 10);
        return itemIds;
    }

    @GetMapping("/contentbased/{userId}")
    public List<Integer> contentBasedRecommendation(@PathVariable Integer userId) {
        List<User> allUsers = userService.getAllUsers();
        Map<Integer, Map<Integer, Double>> data = new HashMap<>();
        for (User user: allUsers) {
            Map<Integer, Double> userVector = new HashMap<>();
            List<Topic> followedTopics = user.getFollowedTopics();
            for (Topic topic: followedTopics) {
                userVector.put(topic.getId(), 1.0);
            }
            List<Post> posts = user.getPosts();
            for (Post post: posts) {
                userVector.put(post.getId() + 1000, 1.0);
            }
            List<Comment> comments = user.getComments();
            for (Comment comment: comments) {
                userVector.put(comment.getId() + 2000, 1.0);
            }
            List<Like> likes = user.getLikes();
            for (Like like: likes) {
                userVector.put(like.getId() + 3000, 1.0);
            }

위 내용은 Java를 사용하여 추천 시스템 기반 소셜 네트워크 애플리케이션을 작성하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!