项目简介

nlp-hanzi-similar 为汉字提供相似性的计算。

在线体验

创作目的

有一位小伙伴说自己在做语言认知科学方向的课题研究，看了我以前写的 NLP 中文形近字相似度计算思路，就想问下有没有源码或者相关资料。

国内对于文本的相似度计算，开源的工具是比较丰富的。但是对于两个汉字之间的相似度计算，国内基本一片空白。国内的参考资料少得可怜，国外相关文档也是如此。

于是我将以前写的相似度算法整理开源，希望能帮到这位小伙伴。

本项目旨在抛砖引玉，实现一个基本的相似度计算工具，为汉字 NLP 贡献一点绵薄之力。

推荐阅读：

NLP 中文形近字相似度计算思路

中文形近字相似度算法实现，为汉字 NLP 尽一点绵薄之力

当代中国最贵的汉字是什么？

NLP 开源形近字算法补完计划（完结篇）

NLP 开源形近字算法之形近字列表（番外篇）

开源项目在线化 中文繁简体转换/敏感词/拼音/分词/汉字相似度/markdown 目录

特性

• fluent 方法，一行代码搞定一切

• 高度自定义，允许用户定义自己的实现

• 词库自定义，适应各种应用场景

• 丰富的实现策略

默认实现了基于 四角编码+拼音+汉字结构+汉字偏旁+笔画数+拆字 的相似度比较。

• 支持返回一个字的相似列表

变更日志

变更日志

快速开始

需要

jdk1.7+

maven 3.x+

maven 引入

<dependency>
    <groupId>com.github.houbb</groupId>
    <artifactId>nlp-hanzi-similar</artifactId>
    <version>1.4.0</version>
</dependency>

快速开始

基本用法

HanziSimilarHelper.similar 获取两个汉字的相似度。

double rate1 = HanziSimilarHelper.similar('末', '未');

结果为：

0.9629629629629629

自定义权重

默认是根据 四角编码+拼音+汉字结构+汉字偏旁+笔画数 进行相似度比较。

如果默认的系统权重无法满足你的需求，你可以通过自定义权重调整：

double rate = HanziSimilarBs.newInstance()
                .jiegouRate(10)
                .sijiaoRate(8)
                .bushouRate(6)
                .bihuashuRate(2)
                .pinyinRate(1)
                .chaiziRate(8)    
                .init()
                .similar('末', '未');

自定义相似度

有些情况下，系统的计算是无法满足的。

用户可以在根目录下 hanzi_similar_define.txt 进行自定义。

入人 0.9
人入 0.9

这样在计算 人 和 入 的相似度时，会优先以用户自定义的为准。

double rate = HanziSimilarHelper.similar('人', '入');

此时的结果为用户自定义的值。

返回单个汉字的相似字列表

HanziSimilarHelper.similarList 可以返回指定汉字的相似列表，最多支持返回 100 个。

默认返回10个。

使用

List<String> list = HanziSimilarHelper.similarList('爱');
Assert.assertEquals("[爰, 爯, 受, 爭, 妥, 憂, 李, 爳, 叐, 雙]", list.toString());

引导类

引导类配置写法

double rate = HanziSimilarBs.newInstance()
                // 笔画数数据
                .bihuashuData(HanziSimilarDatas.bihuashu())
                // 笔画数相似算法
                .bihuashuSimilar(HanziSimilars.bihuashu())
                // 笔画数权重
                .bihuashuRate(HanziSimilarRateConst.BIAHUASHU)

                // 结构数据
                .jiegouData(HanziSimilarDatas.jiegou())
                // 结构相似算法
                .jiegouSimilar(HanziSimilars.jiegou())
                // 结构权重
                .jiegouRate(HanziSimilarRateConst.JIEGOU)

                // 部首数据
                .bushouData(HanziSimilarDatas.bushou())
                // 部首相似算法
                .bushouSimilar(HanziSimilars.bushou())
                // 部首权重
                .bushouRate(HanziSimilarRateConst.BUSHOU)

                // 四角数据
                .sijiaoData(HanziSimilarDatas.sijiao())
                // 四角相似算法
                .sijiaoSimilar(HanziSimilars.sijiao())
                // 四角权重
                .sijiaoRate(HanziSimilarRateConst.SIJIAO)

                // 拼音权重
                .pinyinRate(HanziSimilarRateConst.PINYIN)
                // 拼音相似算法
                .pinyinSimilar(HanziSimilars.pinyin())

                // 拆字权重
                .chaiziRate(HanziSimilarRateConst.CHAIZI)
                // 拆字相似算法
                .chaiziSimilar(HanziSimilars.chaizi())
                // 初始化
                .init()
                
                // 执行文本相似度对比
                .similar('末', '未');

说明

为了便于用户自定义，HanziSimilarBs 支持用户进行自定义配置。

HanziSimilarBs 中允许自定义的配置列表如下：

所有的配置都可以基于接口，用户进行自定义。

python 版本

说明

NLP 的很多小伙伴都是 python 语言的使用者。

为了便于大家学习，提供了 python 的简易版本实现，可以自行修改。

python 版本

实现

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

'''
描述: 初始化字典
作者: 老马啸西风
日期: 2021-11-24
'''
def initDict(path):
   dict = {}; 
   with open(path, 'r', encoding='utf-8', errors='ignore') as f:
        for line in f.readlines():
            # 移除换行符，并且根据空格拆分
            splits = line.strip('\n').split(' ');
            key = splits[0];
            value = splits[1];
            dict[key] = value; 
   return dict;
   
# 字典初始化 
bihuashuDict = initDict('./db/bihuashu_2w.txt');
hanzijiegouDict = initDict('./db/hanzijiegou_2w.txt');
pianpangbushouDict = initDict('./db/pianpangbushou_2w.txt');
sijiaobianmaDict = initDict('./db/sijiaobianma_2w.txt');

# 权重定义（可自行调整）
hanzijiegouRate = 10;
sijiaobianmaRate = 8;
pianpangbushouRate = 6;
bihuashuRate = 2;

计算核心方法

''' 描述：笔画数相似度 ''' def 笔画数相似(字符一, 字符二): 值一 = 笔画数字典[字符一] 值二 = 笔画数字典[字符二]

数一 = int(值一)
数二 = int(值二)

差值 = 1 - abs((数一 - 数二) / max(数一, 数二))
return 笔画数权重 * 差值 * 1.0

''' 描述：汉字结构相似度 ''' def 汉字结构相似(字符一, 字符二): 值一 = 汉字结构字典[字符一] 值二 = 汉字结构字典[字符二]

if 值一 == 值二:
    # 后续可以优化为相近的结构
    return 汉字结构权重 * 1
return 0

''' 描述：四角编码相似度 ''' def 四角编码相似(字符一, 字符二): 值一 = 四角编码字典[字符一] 值二 = 四角编码字典[字符二]

总分 = 0.0
最小长度 = min(len(值一), len(值二))

for i in range(最小长度):
    if 值一[i] == 值二[i]:
        总分 += 1.0

总分 = 总分 / 最小长度 * 1.0
return 总分 * 四角编码权重

''' 描述：偏旁部首相似度 ''' def 偏旁部首相似(字符一, 字符二): 值一 = 偏旁部首字典[字符一] 值二 = 偏旁部首字典[字符二]

if 值一 == 值二:
    # 后续可以优化为字的拆分
    return 偏旁部首权重 * 1
return 0

''' 描述：计算两个汉字的相似度 ''' def 相似度(字符一, 字符二): if 字符一 == 字符二: return 1.0

四角分数 = 四角编码相似(字符一, 字符二)
结构分数 = 汉字结构相似(字符一, 字符二)
部首分数 = 偏旁部首相似(字符一, 字符二)
笔画分数 = 笔画数相似(字符一, 字符二)

总分 = 四角分数 + 结构分数 + 部首分数 + 笔画分数
总权重 = 汉字结构权重 + 四角编码权重 + 偏旁部首权重 + 笔画数权重

结果 = 总分 * 1.0 / 总权重 * 1.0
print('总分：' + str(总分) + ', 总权重: ' + str(总权重) + ', 结果:' + str(结果))
print('四角编码：' + str(四角分数))
print('汉字结构：' + str(结构分数))
print('偏旁部首：' + str(部首分数))
print('笔画数：' + str(笔画分数))
return 结果

这里"末"和"未"相似度为1，因为没有拼音的差异。四角编码一致。

可以手动替换下面的字，或者读取文件，循环计算

''' $ python main.py 总分：25.428571428571427, 总权重: 26, 结果:0.978021978021978 四角编码：8.0 汉字结构：10 偏旁部首：6 笔画数：1.4285714285714286 '''

相似度('末', '来')

快速体验

说明

如果Java不是你的主要开发语言，你可以通过下面的exe文件快速体验一下。

下载地址

https://github.com/houbb/nlp-hanzi-similar/releases/download/exe/hanzi-similar.zip

下载后直接解压得到hanzi-similar.exe免安装的可执行文件。

执行效果

界面是使用Java Swing实现的，所以美观什么的，已经完全放弃治疗 T_T。

使用exe4j打包。

字符一输入一个汉字，字符二输入另一个汉字，点击计算，则可以获取对应的相似度。

字典的弊端

这个项目开源，是因为有一位小伙伴有相关的需求，但是他不懂Java。

一开始想把项目设计成为字典的形式，两个字对应一个相似度。

但是有一个问题，2万汉字和2万汉字的相似度字典，数量已经是近亿的数据量。

空间复杂度过高，同时会导致时间复杂度问题。

所以目前采用的是实时计算，有时间做一下其他语言的迁移 :)

实现原理

实现思路

不同于文本相似度，汉字相似度的单位是汉字。

所以相似度是对于汉字的拆解，比如笔画，拼音，部首，结构等。

推荐阅读：

NLP 中文形近字相似度计算思路 The calculation approach describes the principle of implementation, but some partners reported that they didn't know how to implement it, so this project was created.

Core Code

The core implementation is as follows, which is a weighted calculation of various similarity measures.

/**
 * Similarity
 *
 * @param context Context
 * @return Result
 * @since 1.0.0
 */
@Override
public double similar(final IHanziSimilarContext context) {
    final String charOne = context.charOne();
    final String charTwo = context.charTwo();

    //1. Check if identical
    if(charOne.equals(charTwo)) {
        return 1.0;
    }

    //2. Check if user-defined
    Map<String, Double> defineMap = context.userDefineData().dataMap();
    String defineKey = charOne+charTwo;
    if(defineMap.containsKey(defineKey)) {
        return defineMap.get(defineKey);
    }

    //3. Calculate through weighted measures
    //3.1 Four-corner encoding
    IHanziSimilar sijiaoSimilar = context.sijiaoSimilar();
    double sijiaoScore = sijiaoSimilar.similar(context);

    //3.2 Structure
    IHanziSimilar jiegouSimilar = context.jiegouSimilar();
    double jiegouScore = jiegouSimilar.similar(context);

    //3.3 Radical
    IHanziSimilar bushouSimilar = context.bushouSimilar();
    double bushouScore = bushouSimilar.similar(context);

    //3.4 Stroke count
    IHanziSimilar biahuashuSimilar = context.bihuashuSimilar();
    double bihuashuScore = biahuashuSimilar.similar(context);

    //3.5 Pinyin
    IHanziSimilar pinyinSimilar = context.pinyinSimilar();
    double pinyinScore = pinyinSimilar.similar(context);

    //4. Calculate total score
    double totalScore = sijiaoScore + jiegouScore + bushouScore + bihuashuScore + pinyinScore;
    //4.1 Avoid floating-point comparison issues
    if(totalScore <= 0) {
        return 0;
    }

    //4.2 Normalize
    double limitScore = context.sijiaoRate() + context.jiegouRate()
            + context.bushouRate() + context.bihuashuRate() + context.pinyinRate();

    return totalScore / limitScore;
}

For specific details, if interested, you can read the source code yourself.

Open Source Address

To facilitate everyone's learning and use, this project has been open-sourced.

Open source address:

https://github.com/houbb/nlp-hanzi-similar

Welcome everyone to fork and star to encourage Lao Ma~

Advantages and Disadvantages of the Algorithm

Advantages

Few papers approach from the structure of Chinese characters.

This algorithm introduces a method combining four-corner encoding, structure, radical, stroke count, and pinyin, making it more in line with domestic intuitive use.

Disadvantages

Due to data issues at the time, the radical part actually has flaws.

In the future, we plan to introduce a character decomposition dictionary to compare all components of Chinese characters, rather than the current simple radical.

NLP Open Source Matrix

pinyin Chinese character to pinyin conversion

pinyin2hanzi Pinyin to Chinese character conversion

segment High-performance Chinese word segmentation

opencc4j Chinese Traditional-Simplified conversion

nlp-hanzi-similar Chinese character similarity

word-checker Spell checking

sensitive-word Sensitive word detection

Future Road-MAP

• Enrich similarity strategies

• Optimize default weights

• Optimize exe interface