推荐用户

背景与目标

  • 需求目标：帮助用户根据相似标签找到兴趣相同的朋友。
  • 问题本质：找到与目标用户标签相似的其他用户，计算他们的标签相似度，并根据相似度进行排序，返回最匹配的用户。

匹配算法分析

匹配对象：标签（tags）

  • 每个用户有一个标签集合（例如：[Java, 大一, 男]），通过这些标签与其他用户的标签进行比较。
  • 目标是找到标签相似度高的用户，标签相似度越高，匹配度越高。

匹配方法

  • 优先队列（Priority Queue）：用于保存最匹配的用户，根据标签相似度排序，确保返回相似度高的Top N用户。
  • 标签相似度计算：通过计算标签集合的交集来确定两个用户的相似度，交集的大小越大，相似度越高。

匹配过程详解

1. 标签相似度计算

  • 算法：通过计算两个标签集合的交集大小来确定相似度。
  • 例如，用户A和用户B的标签分别为：[Java, 大一, 男] 和 [Java, 大二, 男]。这两个集合的交集为：[Java, 男]，所以它们的相似度是2。
private int getCommonTagsCount(Set<String> set1, Set<String> set2) {
    Set<String> intersection = new HashSet<>(set1);
    intersection.retainAll(set2);
    return intersection.size();
}

2. 使用优先队列保存最匹配的用户

  • 优先队列：用于按相似度降序存储用户。优先队列在插入新的用户时，会自动调整顺序，保证队列中始终保存相似度最高的用户。
  • 操作：
    1. 对每个用户的标签与目标用户标签计算交集，得到相似度。
    2. 将相似度高的用户加入优先队列。
    3. 如果队列已满，则移除相似度最低的用户，确保队列中始终保存Top N个用户。
PriorityQueue<Pair<User, Integer>> priorityQueue = new PriorityQueue<>(
    (a, b) -> Integer.compare(b.getValue(), a.getValue()) // 按相似度降序排列
);

3. 查询匹配用户

  • 查询所有用户标签：从数据库中查询所有用户的标签，并计算与目标用户的标签相似度。
  • 优化：在数据量较大的情况下，可以通过只查询必要的字段（如ID和标签）来减少查询开销。
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "tags");
queryWrapper.isNotNull("tags");
List<User> userList = this.list(queryWrapper);

4. 从缓存中获取匹配用户

  • Redis缓存：为了提高性能，匹配结果会缓存到Redis中。首次请求时计算并缓存结果，后续请求直接从缓存获取。
// 从Redis获取缓存数据
String cachedData = (String) valueOperations.get(redisKey);
if (cachedData != null) {
    ObjectMapper objectMapper = new ObjectMapper();
    log.info("Redis缓存命中，key: {}", redisKey);
    return objectMapper.readValue(cachedData, new TypeReference<List<UserVO>>() {});
}
  • 缓存存储：匹配用户列表会以JSON格式存储到Redis中，设置30分钟的过期时间，减少频繁计算匹配的开销。
String userVOListJson = objectMapper.writeValueAsString(userVOList);
valueOperations.set(redisKey, userVOListJson, 30, TimeUnit.MINUTES); // 缓存30分钟

优化策略

1. 时间与空间的平衡

  • 优先队列：虽然优先队列会占用一些内存，但可以确保我们仅保留Top N个用户，从而避免处理大量不相关的数据。

2. 剔除无效数据

  • 自己匹配：确保当前用户不会与自己进行匹配。
  • 标签为空的用户：过滤掉没有标签的用户，避免不必要的计算。
if (StringUtils.isBlank(user.getTags()) || user.getId().equals(loginUser.getId())) {
    continue;
}

3. 数据查询优化

  • 按需查询：只查询用户的必要数据（如ID和标签），减少数据库负载。
queryWrapper.select("id", "tags");
queryWrapper.isNotNull("tags");

4. 预热缓存（定时任务）

  • 缓存预热：为了加速匹配过程，可以通过定时任务预热常用用户的匹配结果。这些预热的数据会提前存储到Redis中，当用户请求时直接返回缓存数据，从而避免每次都进行计算。
@Scheduled(cron = "0 0 0 * * ?")
public void doCacheMatchUser() {
    // 通过定时任务定期预热缓存
}
  • 锁机制：通过分布式锁（Redisson锁）避免多个线程同时进行缓存预热任务，保证系统的一致性和稳定性。
RLock lock = redissonClient.getLock("FriendMarry:match:precache:lock");
if (lock.tryLock(0, 5, TimeUnit.MINUTES)) {
    // 获取锁并执行预热
}

完整的匹配流程

  1. 用户请求匹配：用户请求匹配功能，后端获取登录用户和请求参数（例如推荐用户数量）。
  2. 从Redis获取缓存：首先检查Redis缓存是否已经存在该用户的匹配数据，如果存在则直接返回缓存数据。
  3. 计算标签相似度：如果缓存未命中，计算所有用户与目标用户的标签相似度，使用优先队列保留相似度最高的Top N用户。
  4. 更新缓存：将计算得到的匹配用户列表存储到Redis缓存中，并设置缓存过期时间。
  5. 返回匹配用户：返回匹配结果给用户。

代码实现

controller:

/**
     * 获取最匹配的用户
     *
     * @param num     推荐的用户量
     * @param request 请求上下文
     * @return BaseResponse<List < User>>
     */
    @ApiOperation(value = "匹配用户", notes = "根据标签匹配用户")
    @ApiResponses({
            @ApiResponse(code = 200, message = "成功", response = List.class),
            @ApiResponse(code = 40000, message = "请求参数错误", response = BaseResponse.class),
    })
    @GetMapping("/match")
    public BaseResponse<List<UserVO>> matchUsers(long num, HttpServletRequest request) {
        if (num <= 0 || num > 20) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "请求参数错误");
        }
        UserVO loginUser = userService.getLoginUser(request);
        return ResultUtils.success(userService.matchUsers(num, loginUser.getId()));
    }

service:

  /**
     * 获取最匹配的用户
     *
     * @param num    推荐的用户量
     * @param userId 登录用户id
     * @return 匹配到的用户(脱敏)列表数据
     */
    List<UserVO> matchUsers(long num, long userId);

serviceimpl

/**
     * 获取最匹配的用户
     *
     * @param num    推荐的用户量
     * @param userId 登录用户id
     * @return 匹配到的用户(脱敏)列表数据
     */
    @Override
    public List<UserVO> matchUsers(long num, long userId) {
        User loginUser = this.getById(userId);
        String redisKey = String.format("FriendMarry:user:match:%s:%d", userId, num);
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();

        // 先尝试从 Redis 缓存获取数据
        List<UserVO> cachedUserList = getFromRedis_match(redisKey, valueOperations);
        if (cachedUserList != null) {
            return cachedUserList;
        }

        // 缓存没有命中，进行数据库查询和匹配计算
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("id", "tags");
        queryWrapper.isNotNull("tags");

        // 查询所有用户（只包含 id 和 tags 字段）
        List<User> userList = this.list(queryWrapper);

        Set<String> loginUserTags = new HashSet<>(Arrays.asList(loginUser.getTags().split(",")));

        // 优先队列存储与登录用户匹配的用户，按相似度降序排列
        PriorityQueue<Pair<User, Integer>> priorityQueue = new PriorityQueue<>(
                (a, b) -> Integer.compare(b.getValue(), a.getValue()) // 逆序
        );

        // 计算相似度并更新优先队列
        for (User user : userList) {
            // 忽略没有标签的用户和当前用户
            if (StringUtils.isBlank(user.getTags()) || user.getId().equals(loginUser.getId())) {
                continue;
            }

            Set<String> userTags = new HashSet<>(Arrays.asList(user.getTags().split(",")));
            // 计算标签交集的大小作为相似度
            int commonTagsCount = getCommonTagsCount(loginUserTags, userTags);

            // 使用优先队列保留 TOP N 的用户
            if (priorityQueue.size() < num) {
                priorityQueue.offer(new Pair<>(user, commonTagsCount));
            } else if (commonTagsCount > priorityQueue.peek().getValue()) {
                priorityQueue.poll();
                priorityQueue.offer(new Pair<>(user, commonTagsCount));
            }
        }

        // 从优先队列提取最匹配的用户ID
        List<Long> topUserIds = priorityQueue.stream()
                .map(pair -> pair.getKey().getId())
                .collect(Collectors.toList());

        // 查询这些用户的详细信息
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.in("id", topUserIds);

        List<User> topUsers = this.list(userQueryWrapper);

        // 将 User 对象转换为 UserVO 并返回
        Map<Long, User> userMap = topUsers.stream().collect(Collectors.toMap(User::getId, user -> user));
        List<UserVO> finalUserVOList = topUserIds.stream()
                .map(id -> UserVO.fromUser(userMap.get(id)))
                .collect(Collectors.toList());

        // 将匹配的用户列表写入 Redis 缓存
        saveToRedis(redisKey, finalUserVOList, valueOperations);

        return finalUserVOList;
    }

    /**
     * 从 Redis 获取缓存数据
     * utils for matchUsers
     */
    private List<UserVO> getFromRedis_match(String redisKey, ValueOperations<String, Object> valueOperations) {
        try {
            String cachedData = (String) valueOperations.get(redisKey);
            if (cachedData != null) {
                ObjectMapper objectMapper = new ObjectMapper();
                log.info("Redis缓存命中，key: {}", redisKey);
                return objectMapper.readValue(cachedData, new TypeReference<List<UserVO>>() {});
            }
        } catch (Exception e) {
            log.error("Redis缓存读取失败，key: {}", redisKey, e);
        }
        return null;
    }

    /**
     * 将查询结果写入 Redis 缓存
     * utils for matchUsers
     */
    private void saveToRedis(String redisKey, List<UserVO> userVOList, ValueOperations<String, Object> valueOperations) {
        try {
            if (userVOList != null) {
                ObjectMapper objectMapper = new ObjectMapper();
                String userVOListJson = objectMapper.writeValueAsString(userVOList);
                valueOperations.set(redisKey, userVOListJson, 30, TimeUnit.MINUTES); // 缓存过期时间为30分钟
                log.info("Redis缓存写入成功，key: {}", redisKey);
            } else {
                log.warn("查询到的匹配用户列表为空，未写入缓存，key: {}", redisKey);
            }
        } catch (Exception e) {
            log.error("Redis缓存写入失败，key: {}", redisKey, e);
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "缓存写入失败");
        }
    }

    /**
     * 获取两个标签集合的交集大小
     * utils for matchUsers
     */
    private int getCommonTagsCount(Set<String> set1, Set<String> set2) {
        Set<String> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        return intersection.size();
    }

定时任务

package com.zwnsyw.backend.job;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.zwnsyw.backend.pojo.vo.UserVO;

import com.zwnsyw.backend.service.UserService;

import lombok.extern.slf4j.Slf4j;

import org.redisson.api.RLock;

import org.redisson.api.RedissonClient;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.ValueOperations;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

import javax.annotation.Resource;

import java.util.Arrays;

import java.util.List;

import java.util.concurrent.TimeUnit;

/**

 * 匹配用户缓存预热任务

 * 为指定用户列表预热推荐内容缓存，范围为0到20条推荐内容

 *

 * @author Zwww

 */

@Component

@Slf4j

public class MatchCacheJob {

    @Resource

    private UserService userService;

    @Resource

    private RedisTemplate<String, Object> redisTemplate;

    @Resource

    private RedissonClient redissonClient;

    // 需要预热的用户列表

    private List<Long> mainUserList = Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L);

    /**

     * 每天定时预热用户匹配缓存

     */

    @PostConstruct //debug 启动时立即执行的缓存预热任务

//    @Scheduled(cron = "0 0 0 * * ?")

    public void doCacheMatchUser() {

        RLock lock = redissonClient.getLock("FriendMarry:match:precache:lock");

        try {

            // 只有一个线程能获取到锁，避免多个线程同时执行预热任务

            if (lock.tryLock(0, 5, TimeUnit.MINUTES)) {

                log.info("获取锁成功，线程ID: {}", Thread.currentThread().getId());

                // 遍历每个用户ID

                for (Long userId : mainUserList) {

                    for (int num = 0; num <= 20; num++) { // 遍历推荐条数范围

                        try {

                            // 获取匹配用户列表

                            List<UserVO> matchUserList = userService.matchUsers(num, userId);

                            if (matchUserList != null) {

                                // 构造缓存键

                                String redisKey = String.format("FriendMarry:user:match:%s:%d", userId, num);

                                ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();

                                // 设置缓存过期时间

                                long cacheTimeout = 30 * 60; // 30 分钟

                                valueOperations.set(redisKey, matchUserList, cacheTimeout, TimeUnit.SECONDS);

                                log.info("缓存写入成功，key: {}, 推荐用户数: {}", redisKey, matchUserList.size());

                            } else {

                                log.warn("没有查询到匹配用户数据，userId: {}, 推荐条数: {}", userId, num);

                            }

                        } catch (Exception e) {

                            log.error("用户 {} 的推荐数据预热失败, 推荐条数: {}", userId, num, e);

                        }

                    }

                }

            } else {

                log.warn("无法获取缓存预热锁，当前线程ID: {}", Thread.currentThread().getId());

            }

        } catch (InterruptedException e) {

            log.error("缓存预热任务中断", e);

        } finally {

            if (lock.isHeldByCurrentThread()) {

                lock.unlock();

                log.info("释放锁，线程ID: {}", Thread.currentThread().getId());

            }

        }

    }

}

总结

  • 通过优先队列按相似度排序，确保匹配结果高效且准确。
  • 使用Redis缓存减少计算频次，提高性能。
  • 通过定时任务预热缓存，并加锁避免竞争条件，保障系统稳定性。

分析

当前方法通过计算两个用户的标签交集和并集的比例来评估相似度，实际上是基于 Jaccard相似度 的一种变体。

利用了用户标签集合的交集（共享标签数量）和并集（所有独特标签的数量）来衡量相似度。

这个方法的优点是它直观、简洁，且对标签集合数量不太敏感。

复杂度分析

执行流程大致如下：

  1. 遍历每一个用户：

    • 首先，你需要遍历每个目标用户（假设有 N 个用户），这通常是一个大循环。

  2. 提取用户的标签集合：

    • 对于每一个用户，你从数据库或数据结构中提取该用户的标签集合。假设每个用户有 M 个标签（有可能不同用户的标签数量不一样）。

  3. 计算标签集合的交集与并集：

    • 你将当前用户的标签集合与其他用户的标签集合进行交集和并集计算。
    • 交集：你计算两个用户标签集合的公共标签。
    • 并集：你计算两个用户标签集合的所有标签（去重后）。

  4. 计算相似度：

    • 根据计算出的交集和并集，你计算 Jaccard 相似度或其他相似度度量。

      例如：

    \(Jaccard 相似度=交集大小并集大小\text{Jaccard 相似度} = \frac{\text{交集大小}}{\text{并集大小}}\)

  5. 重复计算：

    • 对于每一对用户，你都需要执行上述计算过程（步骤 3 和步骤 4）。

  6. 最终输出：

    • 基于计算的相似度，输出相似度较高的用户对，或者用于进一步处理。

时间复杂度

假设：

  • 有 N 个用户。
  • 每个用户有 M 个标签。

那么：

  1. 遍历用户：需要对每一个用户进行遍历。这个操作的时间复杂度是 O(N)。

  2. 计算标签的交集和并集：

    • 对于每一对用户，计算交集和并集的时间复杂度是 O(M)，因为需要遍历每个用户的标签集合。
    • 对于所有用户，需要执行 N * (N-1) / 2 次这样的比较（在最坏情况下，每个用户都要和其他所有用户比较一次）。

    所以，计算所有用户的相似度 的时间复杂度为：

    \(O(N2⋅M)O(N^2 \cdot M)\)

    这意味着当用户数量和标签数量都很大时，计算复杂度会迅速增加。

空间复杂度

空间复杂度主要体现在以下几个方面：

  1. 存储用户标签集合：对于每个用户，你需要存储该用户的标签集合。假设每个用户有最多 M 个标签，那么所有用户标签的存储空间复杂度是：

    \(O(N⋅M)O(N \cdot M)\)

  2. 存储交集和并集结果：每对用户计算交集和并集时，最坏情况下需要存储两个标签集合。最坏情况下，每个用户的标签集合大小为 M，所以交集和并集的空间复杂度为 O(M)。

    所以，总体空间复杂度为：

    \(O(N⋅M)O(N \cdot M)\)

总结

  • 时间复杂度：O(N^2 * M)，其中 N 是用户数量，M 是每个用户的标签数量。随着用户数量和标签数量增加，计算开销会显著增长。
  • 空间复杂度：O(N * M)，你需要存储每个用户的标签集合。

优化建议

  • 避免重复计算：可以通过缓存用户之间的相似度值，避免重复计算。
  • 并行化计算：如果你有多核 CPU 或分布式环境，可以将相似度计算分配给多个线程或机器，从而加速计算过程。
  • 剪枝优化：如果两个用户的标签集合交集较小（比如小于某个阈值），可以提前终止计算，以减少不必要的计算。
  • 基于倒排索引的优化：如果你使用的是数据库存储标签，可以通过倒排索引（inverted index）来加速标签查找，从而提高效率。

进一步优化的方向

  • 改进标签表示：例如将标签转化为向量，采用TF-IDF 或 Word2Vec，可以在一定程度上减少标签集合比较的计算复杂度，尤其是标签量很大时。
  • 使用更高效的相似度计算方法：例如利用 局部敏感哈希（LSH）来加速高维空间中的相似度计算，避免逐一计算每对用户的相似度。

优缺点

  • 优点：
    • 简洁易懂：该方法通过标签交集和并集直接计算相似度，非常易于理解和实现。
    • 适用性广：如果标签本身不含复杂语义，单纯的标签匹配非常高效。
    • 较低的计算复杂度：当标签集合不大时，计算量较小，适合实时匹配场景。
  • 缺点：
    • 标签差异较小时表现有限：如果两个用户的标签只有一个小的差异（例如一个是“Java”另一个是“JavaScript”），这种方法可能无法很好地捕捉到它们的实际相似度。
    • 缺乏语义分析：如果标签间有语义差异（例如“Python”与“编程语言”），该方法无法识别标签之间的语义相似性。

其他可能实现方法：

除了基于标签的交集计算相似度，还有其他几种常见的相似度计算方法可以用于用户匹配，这些方法在不同的场景中有不同的优缺点。以下是几种可能的实现方法，以及它们的适用情况：

1. 最短编辑距离（Levenshtein距离）

概念

最短编辑距离（Levenshtein距离）衡量的是将一个字符串转换成另一个字符串所需的最小操作数。

允许的操作包括：插入、删除或替换字符。

这个方法非常适用于处理字符串匹配的问题。

应用于用户标签匹配

可以使用最短编辑距离计算两个用户标签集合之间的相似度。如果标签是字符串类型，可以直接计算标签字符串之间的Levenshtein距离。例如：

  • 标签集合1：[Java, 大一, 男]
  • 标签集合2：[Java, 大二, 男] 可以将标签集合转换成字符串（如 "Java, 大一, 男" 和 "Java, 大二, 男"），然后计算这两个字符串的Levenshtein距离。

优缺点

  • 优点：
    • 适用于细微差异：Levenshtein距离非常适合检测和处理两个字符串间的细微差异。例如，“Java”与“JavaScript”之间可能只有一个字符的不同，Levenshtein能够敏感地反映这种差异。
    • 灵活性高：可以处理拼写错误等情况。
  • 缺点：
    • 计算复杂度高：Levenshtein距离的时间复杂度为 O(n * m)，其中 n 和 m 是字符串的长度。因此，它不适合处理大量标签的场景，尤其是标签数量较大时，计算开销较大。
    • 缺乏语义理解：与标签集合的交集方法类似，Levenshtein也仅从字符级别计算相似度，对于语义理解较弱。

代码示例（Java）

public static int levenshteinDistance(String s1, String s2) {
    int len1 = s1.length();
    int len2 = s2.length();
    int[][] dp = new int[len1 + 1][len2 + 1];

    for (int i = 0; i <= len1; i++) {
        for (int j = 0; j <= len2; j++) {
            if (i == 0) {
                dp[i][j] = j;
            } else if (j == 0) {
                dp[i][j] = i;
            } else {
                int cost = (s1.charAt(i - 1) == s2.charAt(j - 1)) ? 0 : 1;
                dp[i][j] = Math.min(Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1), dp[i - 1][j - 1] + cost);
            }
        }
    }
    return dp[len1][len2];
}

2. 余弦相似度

概念

余弦相似度（Cosine Similarity）是通过计算两个向量之间的夹角来衡量它们的相似度。夹角越小，相似度越高。公式如下：

\(cosine_similarity(A,B)=A⋅B∥A∥∥B∥\text{cosine\_similarity}(A, B) = \frac{A \cdot B}{\|A\| \|B\|}\)

其中 \(A⋅BA \cdot B\) 是两个向量的点积， \(∥A∥\|A\|\) 和 \(∥B∥\|B\|\)是它们的模长。

应用于用户标签匹配

将用户的标签表示为一个向量，向量的每个维度代表一个标签。标签的频率或存在与否可以用1或0表示。然后通过计算这些向量之间的余弦相似度来衡量两个用户之间的相似性。

  • 步骤：
    1. 将每个用户的标签转化为向量。
    2. 计算所有用户与目标用户的标签向量之间的余弦相似度。

优缺点

  • 优点：
    • 适应大规模标签数据：余弦相似度能够高效地计算高维稀疏向量的相似度，适合处理大规模的标签集合。
    • 语义层面的相似度：对于标签转化为向量后，余弦相似度能够捕捉标签之间的某些语义关系。例如，“Python”和“编程语言”在向量空间中可能比较接近。
  • 缺点：
    • 需要向量表示：将标签转换为向量需要额外的处理，比如使用TF-IDF或Word2Vec等方法，这会增加实现的复杂度。
    • 无语法理解：余弦相似度在不考虑标签实际语义的情况下，无法有效处理没有显著词义差异的标签（例如，“Java”和“C#”）。

代码示例（Java）

public static double cosineSimilarity(Set<String> set1, Set<String> set2) {
    // 计算两个标签集合的余弦相似度
    Set<String> intersection = new HashSet<>(set1);
    intersection.retainAll(set2);

    double dotProduct = intersection.size();
    double magnitude1 = Math.sqrt(set1.size());
    double magnitude2 = Math.sqrt(set2.size());

    return dotProduct / (magnitude1 * magnitude2);
}

3. Jaccard相似度

概念

Jaccard相似度是两个集合的交集与并集的大小比率，通常用于集合之间的相似度计算。公式为：

\(Jaccard_similarity(A,B)=∣A∩B∣∣A∪B∣\text{Jaccard\_similarity}(A, B) = \frac{|A \cap B|}{|A \cup B|}\)

应用于用户标签匹配

  • 将用户的标签集合转化为集合类型。
  • 计算两个用户标签集合的Jaccard相似度。

优缺点

  • 优点：
    • 简洁且计算简单：Jaccard相似度本质上和现在所用的方法相似，计算非常简便，适用于标签数量较少的场景。
    • 不需要考虑标签顺序：只关心标签是否存在，而不关心标签的顺序或频率。
  • 缺点：
    • 标签集合较大时计算性能差：如果标签集合非常大（如几百个标签），计算交集和并集的操作可能会变得很慢。
    • 无语义分析：与Levenshtein距离一样，Jaccard相似度不会考虑标签之间的语义关系，只关心是否相同。

代码示例（Java）

public static double jaccardSimilarity(Set<String> set1, Set<String> set2) {
    Set<String> intersection = new HashSet<>(set1);
    intersection.retainAll(set2);

    Set<String> union = new HashSet<>(set1);
    union.addAll(set2);

    return (double) intersection.size() / union.size();
}

4. 汉明距离

概念

汉明距离（Hamming Distance）是计算两个字符串（或向量）对应位置不同字符的个数。它仅适用于长度相同的字符串。

应用于用户标签匹配

  • 如果标签是由固定长度的字符串（例如通过某种编码方式）表示的，可以计算汉明距离。例如，标签集合可以通过哈希或二进制表示。

优缺点

  • 优点：
    • 适用于相同长度的标签：如果标签长度固定，并且标签之间只有少量字符差异，汉明距离能够快速计算。
  • 缺点：
    • 无法处理不同长度的标签集合：这个方法只适用于固定长度的标签或标签编码。对于长度不一致的标签集合无法适用。

5. 基于深度学习的相似度度量（如Word2Vec，BERT）

概念

通过深度学习模型（如Word2Vec、BERT等）将标签转化为向量，然后计算这些向量之间的相似度。

Word2Vec将词语映射到低维空间，使得语义相近的词语在空间上也较为接近。

应用于用户标签匹配

  • 将标签转换为向量后，使用余弦相似度、欧几里得距离等方法计算标签之间的相似度。
  • 可以通过预训练的BERT模型进行句子级的语义匹配。

优缺点

  • 优点：
    • 捕捉深层语义：这些方法能够更好地捕捉标签之间的深层语义关系。例如，“Java”和“编程语言”之间，Word2Vec或BERT会识别它们之间的语义联系，而其他方法可能无法做到。
    • 对拼写差异和同义词的容错性强：能处理标签之间的同义词和拼写错误。
  • 缺点：
    • 计算开销大：训练深度学习模型需要大量的计算资源，且向量计算过程较慢。
    • 实现复杂：需要借助外部工具库（如TensorFlow、PyTorch）以及预训练的模型，导致实现较为复杂。
    • 实时性差：对于需要快速响应的系统，可能不适用。

总结：不同方法的选择

  • Levenshtein距离：适合用于字符串匹配，但计算复杂度较高，不适用于大规模标签集合。
  • 余弦相似度：适用于标签向量化后的相似度计算，尤其在标签数量较多时表现良好。
  • Jaccard相似度：适合用于直接比较标签集合，计算简单直观，适用于标签集合较小的情况。
  • 汉明距离：适用于固定长度字符串的匹配，但对于标签集合长度不等时不适用。
  • 基于深度学习的相似度：适用于复杂的标签匹配，能够捕捉深层语义关系，但计算开销较大，实时性能较差。

推荐选择

  • 如果标签较少，且差异较小，Levenshtein距离和Jaccard相似度是较为简单且快速的选择。
  • 如果标签多且稀疏，余弦相似度是更好的选择，尤其适用于大规模数据集。
  • 如果标签的语义重要，Word2Vec或BERT等基于深度学习的方法可以进一步提高准确性。

项目分区导航：⬅️ 10-swagger-knife4j | 11-推荐用户 | ➡️ 12-搜索标签serviceimpl