精华内容
下载资源
问答
  • 缺点: (1)词向量效果和语料库大小和质量有较大关系(2)用most_similar() 得到往往不是“同义词”,而是“共现词” from gensim.models.keyedvectors import KeyedVectors wv = KeyedVectors.load...

    方案一:利用预训练好的词向量模型

    优点: (1)能把词进行语义上的向量化(2)能得到词与词的相似度

    缺点: (1)词向量的效果和语料库的大小和质量有较大的关系(2)用most_similar() 得到往往不是“同义词”,而是“共现词”

    from gensim.models.keyedvectors import KeyedVectors
    
    wv = KeyedVectors.load_word2vec_format('model/w2v_chisim_300d.bin', binary=True)
    print "wv.vector_size:", wv.vector_size  # 300
    print "len(wv.vocab):", len(wv.vocab)  # 414638
    
    def get_similar_words(kw):
        if kw in wv.vocab:
            print kw, "/".join([word for word, sim in wv.most_similar(kw, topn=10)])
            # for word, sim in wv.most_similar(kw):  # most_similar()的默认topn=10
            #     print word, sim  # 相似词、相似度
    
    if __name__ == '__main__':
        kws = [u"群众", u"男人", u"女人", u"国王", u"皇后"]
        for kw in kws:
            get_similar_words(kw)
    
    """
    wv.vector_size: 300
    len(wv.vocab): 414638
    群众 广大群众/百姓/职工群众/村民/老百姓/干部群众/农民/党员干部/困难群众/居民
    男人 女人/女孩子/伴侣/女性/你/异性/男性/闺蜜/她们/花心
    女人 男人/女孩子/女性/她们/你/花心/闺蜜/伴侣/异性/男性
    国王 五世/王后/四世/君主/七世/六世/教皇/伊莉莎白/二世/路易十四
    皇后 娘娘/公主/妃子/皇太后/皇帝/日本天皇/武则天/董鄂氏/太后/那拉氏
    """

     

    方案二:同义词近义词库

    比较经典的是哈工大社会计算与信息检索研究中心同义词词林扩展版

    把词条按照树状的层次结果组织到一起,并区分了同义词和近义词,例如:

     

    为了和上面词向量的结果进行对比,这里贴出了词林的结果:

    Aa01B02= 群众 大众 公众 民众 万众 众生 千夫
    Ab01A01= 男人 男子 男子汉 男儿 汉子 汉 士 丈夫 官人 男人家 光身汉 须眉 壮汉 男士
    Ab01B01= 女人 女子 女性 女士 女儿 女 娘 妇 妇女 妇道 妇人 女人家 小娘子 女郎 巾帼 半边天 娘子军 石女 红装 家庭妇女 农妇 才女
    Af05A01= 皇帝 帝 王 上 君 天子 天皇 帝王 君王 国王 国君 君主 当今 皇上 圣上 陛下 主公 九五 九五之尊 可汗 单于 大帝 沙皇 天骄 天王 五帝 太岁 王者 至尊 统治者
    Af05B02= 皇后 王后 娘娘

    可以看到词林在“同义”上的效果会更好一些。

     

    1. 数据下载

    哈工大同义词词林扩展版官网:https://www.ltp-cloud.com/download/#down_cilin

    注册账户之后会看到下载链接和密码(z55c)

     

    我在linux下打开文件出现乱码,需要用iconv命令进行转码(参考本人前面的文章Linux下打开windows中文文本乱码问题

    如果文件中因存在不能识别的字符导致转码失败,用gedit打开并把那一行的非法字符删除就可以了。原有17817行,转码之后我保留了17815行。

    (本来想贴到这里来的,但因为包含了gongchandang, jiangzemin, dalai, qietingqi等等,博客园会报错“Post operation failed. The error message related to this problem was as follows: 博文中含有违规内容: xxx!”......)

     

    2. 数据处理和应用

    在哈工大的同义词词林中,由于它给词分了类别,同一个词在不同的类别下可能会有不同的同义词,例如“男人”的同义词有:

    Ab01A01= 男人 男子 男子汉 男儿 汉子 汉 士 丈夫 官人 男人家 光身汉 须眉 壮汉 男士
    Ah08A01= 夫 丈夫 爱人 男人 先生 女婿 老公 汉子 当家的 人夫 那口子

    为方便后续的应用,这里把这两行的词都合并到“男人”的同义词列表中,并在词后面加上type(=或者#),方便区分同义词与近义词,生成字典{词type: 同义词列表},例如:

    {"毛乎乎=": ["", "毛糙", "", "", "粗糙"], "车次#": ["等次", "名次", "班次", "航次", "场次"]}

    代码如下:

    def get_kw2similar_words(fin, fout):
        kw2similar_words = defaultdict(set)  # 去重
        with codecs.open(fin, "r", "utf-8") as fr:
            for idx, line in enumerate(fr):
                try:
                    row = line.strip().split(" ")
                    if row[0][-1] == u"@": continue
                    for kw in row[1:]:
                        row.remove(kw)
                        kw_and_type = kw + row[0][-1]
                        kw2similar_words[kw_and_type].update(row[1:])
                        row.insert(-1, kw)
                except Exception as error:
                    print "Error line", idx, line, error
                if idx % 1000 == 0: print idx
        for kw, similar_words in kw2similar_words.iteritems():
            kw2similar_words[kw] = list(similar_words)  # kw2similar_words = defaultdict(list)
        json.dump(kw2similar_words, open(fout, "w"), ensure_ascii=False)
    
    get_kw2similar_words(fin="data/cilin.txt", fout="data/kw2similar_words.json")

     

    测试:

    if __name__ == '__main__':
        kw2similar_words = json.load(open("data/kw2similar_words.json", "r"))
        keys_set = set(kw2similar_words.keys())
        kws = [u"群众", u"男人", u"女人", u"国王", u"皇后"]
        for kw in kws:
            for kw_and_type in [kw + u"=", kw + u"#"]:
                if kw_and_type in keys_set:
                    print kw_and_type, "/".join(kw2similar_words[kw_and_type])
    
    """
    群众= 大众/万众/民众/公众/众生/千夫
    男人= 男人家/爱人/女婿/先生/壮汉/汉/汉子/士/人夫/男士/老公/那口子/官人/丈夫/男子汉/男子/男儿/当家的/光身汉/须眉/夫
    女人= 妇道/太太/妇/老婆/娘/娘子/女人家/红装/妻子/女儿/媳妇儿/老婆子/内/家/婆姨/妻/女性/巾帼/婆娘/家庭妇女/娘儿们/女子/小娘子/妻妾/老小/娘子军/农妇/女郎/才女/妻室/妇女/半边天/内助/贤内助/石女/爱妻/爱人/家里/妇人/女士/女/老伴/夫人
    国王= 可汗/王/上/沙皇/至尊/君王/君/帝/帝王/主公/圣上/五帝/君主/大帝/国君/天王/单于/统治者/天骄/天皇/九五/九五之尊/皇帝/陛下/皇上/王者/天子/当今/太岁
    皇后= 娘娘/王后
    """

     

    3. 中文同义词近义词的其它在线词典

    词林在线词典 http://www.cilin.org/

    同义词库 http://chinese.abcthesaurus.com/

    汉典 http://www.zdic.net/

     

    参考:

    中文的同义词近义词词典或网站有哪些值得推荐?

    [汉语]类书、叙词表、分类词典、同义词、反义词词典...

    同义词、近义词、反义词词典 

    中英文维基百科语料上的Word2Vec实验

    哈工大同义词词林 python 使用范例

    转载于:https://www.cnblogs.com/bymo/p/8440722.html

    展开全文
  • 包含中文同义词近义词共计万七千余条,词条收录内容包含CSDN平台主要同类词库资源,压缩包中包括个access版本和个excel版本以及pdg格式现代汉语分类词典,希望支持
  • 收集汇总去重整理后的一万三千多条同义词近义词替换库,方便伪原创同义词替换使用!同义词都经过人工整理过,错误很少,但也难免有不少量不准确,也请大家谅解
  • 方案:利用预训练好词向量模型 ...方案二:同义词近义词库 比较经典是哈工大社会计算与信息检索研究中心同义词词林扩展版 把词条按照树状层次结果组织到一起,并区分了同义词和近义词,例如: ...

    方案一:利用预训练好的词向量模型
    优点: (1)能把词进行语义上的向量化(2)能得到词与词的相似度

    缺点: (1)词向量的效果和语料库的大小和质量有较大的关系(2)用most_similar() 得到往往不是“同义词”,而是“共现词”


    方案二:同义词近义词库
    比较经典的是哈工大社会计算与信息检索研究中心同义词词林扩展版

    把词条按照树状的层次结果组织到一起,并区分了同义词和近义词,例如:

    from gensim.models.keyedvectors import KeyedVectors
    
    wv = KeyedVectors.load_word2vec_format('model/w2v_chisim_300d.bin', binary=True)
    print "wv.vector_size:", wv.vector_size  # 300
    print "len(wv.vocab):", len(wv.vocab)  # 414638
    
    def get_similar_words(kw):
        if kw in wv.vocab:
            print kw, "/".join([word for word, sim in wv.most_similar(kw, topn=10)])
            # for word, sim in wv.most_similar(kw):  # most_similar()的默认topn=10
            #     print word, sim  # 相似词、相似度
    
    if __name__ == '__main__':
        kws = [u"群众", u"男人", u"女人", u"国王", u"皇后"]
        for kw in kws:
            get_similar_words(kw)
    
    """
    wv.vector_size: 300
    len(wv.vocab): 414638
    群众 广大群众/百姓/职工群众/村民/老百姓/干部群众/农民/党员干部/困难群众/居民
    男人 女人/女孩子/伴侣/女性/你/异性/男性/闺蜜/她们/花心
    女人 男人/女孩子/女性/她们/你/花心/闺蜜/伴侣/异性/男性
    国王 五世/王后/四世/君主/七世/六世/教皇/伊莉莎白/二世/路易十四
    皇后 娘娘/公主/妃子/皇太后/皇帝/日本天皇/武则天/董鄂氏/太后/那拉氏
    """

    为了和上面词向量的结果进行对比,这里贴出了词林的结果:

    Aa01B02= 群众 大众 公众 民众 万众 众生 千夫
    Ab01A01= 男人 男子 男子汉 男儿 汉子 汉 士 丈夫 官人 男人家 光身汉 须眉 壮汉 男士
    Ab01B01= 女人 女子 女性 女士 女儿 女 娘 妇 妇女 妇道 妇人 女人家 小娘子 女郎 巾帼 半边天 娘子军 石女 红装 家庭妇女 农妇 才女
    Af05A01= 皇帝 帝 王 上 君 天子 天皇 帝王 君王 国王 国君 君主 当今 皇上 圣上 陛下 主公 九五 九五之尊 可汗 单于 大帝 沙皇 天骄 天王 五帝 太岁 王者 至尊 统治者
    Af05B02= 皇后 王后 娘娘


    1. 数据下载
    哈工大同义词词林扩展版官网:https://www.ltp-cloud.com/download/#down_cilin

    我在linux下打开文件出现乱码,需要用iconv命令进行转码(参考本人前面的文章Linux下打开windows中文文本乱码问题)

    如果文件中因存在不能识别的字符导致转码失败,用gedit打开并把那一行的非法字符删除就可以了。原有17817行,转码之后我保留了17815行。

    (本来想贴到这里来的,但因为包含了gongchandang, jiangzemin, dalai, qietingqi等等,博客园会报错“Post operation failed. The error message related to this problem was as follows: 博文中含有违规内容: xxx!”......)

     

    2. 数据处理和应用
    在哈工大的同义词词林中,由于它给词分了类别,同一个词在不同的类别下可能会有不同的同义词,例如“男人”的同义词有:
    Ab01A01= 男人 男子 男子汉 男儿 汉子 汉 士 丈夫 官人 男人家 光身汉 须眉 壮汉 男士
    Ah08A01= 夫 丈夫 爱人 男人 先生 女婿 老公 汉子 当家的 人夫 那口子

    为方便后续的应用,这里把这两行的词都合并到“男人”的同义词列表中,并在词后面加上type(=或者#),方便区分同义词与近义词,生成字典{词type: 同义词列表},例如:
    {"毛乎乎=": ["糙", "毛糙", "麻", "毛", "粗糙"], "车次#": ["等次", "名次", "班次", "航次", "场次"]}

    代码如下:

    def get_kw2similar_words(fin, fout):
        kw2similar_words = defaultdict(set)  # 去重
        with codecs.open(fin, "r", "utf-8") as fr:
            for idx, line in enumerate(fr):
                try:
                    row = line.strip().split(" ")
                    if row[0][-1] == u"@": continue
                    for kw in row[1:]:
                        row.remove(kw)
                        kw_and_type = kw + row[0][-1]
                        kw2similar_words[kw_and_type].update(row[1:])
                        row.insert(-1, kw)
                except Exception as error:
                    print "Error line", idx, line, error
                if idx % 1000 == 0: print idx
        for kw, similar_words in kw2similar_words.iteritems():
            kw2similar_words[kw] = list(similar_words)  # kw2similar_words = defaultdict(list)
        json.dump(kw2similar_words, open(fout, "w"), ensure_ascii=False)
    
    get_kw2similar_words(fin="data/cilin.txt", fout="data/kw2similar_words.json")
    
    测试:
    if __name__ == '__main__':
        kw2similar_words = json.load(open("data/kw2similar_words.json", "r"))
        keys_set = set(kw2similar_words.keys())
        kws = [u"群众", u"男人", u"女人", u"国王", u"皇后"]
        for kw in kws:
            for kw_and_type in [kw + u"=", kw + u"#"]:
                if kw_and_type in keys_set:
                    print kw_and_type, "/".join(kw2similar_words[kw_and_type])
    
    """
    群众= 大众/万众/民众/公众/众生/千夫
    男人= 男人家/爱人/女婿/先生/壮汉/汉/汉子/士/人夫/男士/老公/那口子/官人/丈夫/男子汉/男子/男儿/当家的/光身汉/须眉/夫
    女人= 妇道/太太/妇/老婆/娘/娘子/女人家/红装/妻子/女儿/媳妇儿/老婆子/内/家/婆姨/妻/女性/巾帼/婆娘/家庭妇女/娘儿们/女子/小娘子/妻妾/老小/娘子军/农妇/女郎/才女/妻室/妇女/半边天/内助/贤内助/石女/爱妻/爱人/家里/妇人/女士/女/老伴/夫人
    国王= 可汗/王/上/沙皇/至尊/君王/君/帝/帝王/主公/圣上/五帝/君主/大帝/国君/天王/单于/统治者/天骄/天皇/九五/九五之尊/皇帝/陛下/皇上/王者/天子/当今/太岁
    皇后= 娘娘/王后
    """


    3. 中文同义词近义词的其它在线词典
    词林在线词典 http://www.cilin.org/

    同义词库 http://chinese.abcthesaurus.com/

    汉典 http://www.zdic.net/

    展开全文
  • txt格式,同义词行,多个之间用英文逗号分隔,前后都有逗号。形如:“,后继有人 ,后来居上 ,后来者居上 ,后起之秀 ,略胜一筹 ,棋高一着 ,青出于蓝,”。 注意是9836组,不是9836条,已经归类绝无重复。去除了...
  • 用于伪原创的同义词近义词库,4万多条都在个txt文档里,每行都是组同义词。
  • 相对完善SEO伪原创词库,20.1万对,有这个基本上可用,不想骗分。。
  • 源码地址:https://github.com/XBWer/WordSimilarity 1.确定要解决问题及意义在基于代码片段分类过程中,由于程序员对数据变量名选取可能具有一定...“transaction”,“deal”等同义词),在某些情况下,它...

    源码地址:https://github.com/XBWer/WordSimilarity

     

       1.确定要解决的问题及意义

    在基于代码片段的分类过程中,由于程序员对数据变量名的选取可能具有一定的规范性,在某一特定业务处理逻辑代码中,可能多个变量名之间具有关联性或相似性(如“trade”(商品交易)类中,可能存在“business”,“transaction”,“deal”等同义词),在某些情况下,它们以不同的词语表达了相同的含义。因此,为了能够对代码片段做出更加科学的类别判断,更好地识别这些同义词,我们有必要寻找一种能够解决避免由于同义词的存在而导致误分类的方法。说白了,就是要去判断词语之间的相似度(即确定是否为近义词),并找出代码段中出现次数最多的一组语义。

     

    2.要达到的效果

    即在给定的代码段中,能够发现哪些词是属于同义词,并且能够实现分类。

    Eg.public static void function(){

          String trade=”money”;

          Int deal=5;

          Long long business=0xfffffff;

          Boolen transaction=TRUE;

          ……

    }

    Output:同义词有:trade,deal,business,transaction

    这段代码很可能与trade有关

     

    3.初识WordNet

    问题确定了之后,通过网上的搜索,发现了WordNetword2vec这两个相关的词汇。(后知后觉,这本身就是一个找近义词的过程)

     

      3.1 WordNet是什么

    首先,来看WordNet。搜了一下相关介绍:

    WordNet是一个由普林斯顿大学认识科学实验室在心理学教授乔治·A·米勒的指导下建立和维护的英语字典。开发工作从1985年开始,从此以后该项目接受了超过300万美元的资助(主要来源于对机器翻译有兴趣的政府机构)。

    由于它包含了语义信息,所以有别于通常意义上的字典。WordNet根据词条的意义将它们分组,每一个具有相同意义的字条组称为一个synset(同义词集合)。WordNet为每一个synset提供了简短,概要的定义,并记录不同synset之间的语义关系。

    WordNet的开发有两个目的:

    它既是一个字典,又是一个辞典,它比单纯的辞典或词典都更加易于使用。

    支持自动的文本分析以及人工智能应用。

    WordNet内部结构

    在WordNet中,名词动词形容词副词各自被组织成一个同义词的网络,每个同义词集合都代表一个基本的语义概念,并且这些集合之间也由各种关系连接。(一个多义词将出现在它的每个意思的同义词集合中)。在WordNet的第一版中(标记为1.x),四种不同词性的网络之间并无连接。WordNet的名词网络是第一个发展起来的。

    名词网络的主干是蕴涵关系的层次(上位/下位关系),它占据了关系中的将近80%。层次中的最顶层是11个抽象概念,称为基本类别始点(unique beginners),例如实体(entity,“有生命的或无生命的具体存在”),心理特征(psychological feature,“生命有机体的精神上的特征)。名词层次中最深的层次是16个节点。

                                                                                                                                   (wikipedia)

             通俗地来说,WordNet是一个结构化很好的知识库,它不但包括一般的词典功能,另外还有词的分类信息。目前,基于WordNet的方法相对来说比较成熟,比如路径方法 (lch)、基于信息论方法(res)等。(详见参考文献)

     

        3.2 WordNet的安装与配置

    有了WordNet ,也就等于是有了我们所要的单词库。所以,暂时先不考虑相似度的计算,把WordNet下载下来再说。

        参考http://hi.baidu.com/buptyoyo/item/f13dfe463c061e3afb896028。顺利地下载,安装以及跑demo。

        之后,一起来看一下WordNet的文件结构:

     

        bin目录下,有可执行文件WordNet 2.1.exe:

     

      

               可以看到,WordNet对所有的英文单词都进行的分类,并且形成了一棵语义树。在本例中,entity——>abstract entity——>abstraction——>attribute——>state——>feeling——> emotion——>love;

    从叶子节点到根节点

         WordNet名次分类中的25个基本类:

     

    dict目录里面存放的就是资源库了,可以看到,它以形容词,副词,名词,动词来分类:

     

    doc为WordNet的用户手册文件文件夹

    lib为WordNet软件使用Windows资源的函数库

    src为源码文件夹

     

    4.解决问题的大致思路

    我们首先以 WordNet 的词汇语义分类作为基础,抽取出其中的同义词,然后采用基于向量空间的方法计算出相似度。工作流程如下:

     

    5.基于WordNet的相似度计算

             以下摘自:《基于WordNet的英语词语相似度计算》

             5.1   特征提取

     

             5.2   意义相似度和词语相似度的计算

      

     

      

     

     

     6.实现效果

       

    与“trade”的相似度比较:

    分析:

     

    先看第一组:trade vs trade

     

    自己和自己当然是相似度100%

     

    再看第二组:trade#n#5   vs deal#n#1

     

    相似度竟然和第一组是一样的!根据结果,trade作为名词时,它的第5种含义和deal作为名词时的第1种含义是完全相似的。让我们去库里看个究竟:

      trade#n#5:

    deal#n#1:

    再来看一组不是很好理解的:

    trade#n#7   vs deal#n#2

     

        他们的相似度达到了0.14+,算是比较高的了,这是为什么呢?

     

      trade#n#7:

    sunshine#n#2:

    相信聪明的你一定明白了为什么。

     

    与“cat”的相似度比较:

      7.代码分析

    工程结构图:

                    

      test.java

    复制代码
     1 package JWordNetSim.test;
     2 
     3 import java.io.FileInputStream;
     4 import java.util.HashMap;
     5 import java.util.Map;
     6 
     7 import net.didion.jwnl.JWNL;
     8 import net.didion.jwnl.data.IndexWord;
     9 import net.didion.jwnl.data.POS;
    10 import net.didion.jwnl.dictionary.Dictionary;
    11 import shef.nlp.wordnet.similarity.SimilarityMeasure;
    12 
    13 /**
    14  * A simple test of this WordNet similarity library.
    15  * @author Mark A. Greenwood
    16  */
    17 public class Test
    18 {
    19     public static void main(String[] args) throws Exception
    20     {    
    21         //在运行代码前,必须在本机上安装wordnet2.0,只能装2.0,装了2.1会出错
    22         JWNL.initialize(new FileInputStream("D:\\JAVAProjectWorkSpace\\jwnl\\JWordNetSim\\test\\wordnet.xml"));
    23         
    24         //建议一个映射去配置相关参数
    25         Map<String,String> params = new HashMap<String,String>();
    26         
    27         //the simType parameter is the class name of the measure to use
    28         params.put("simType","shef.nlp.wordnet.similarity.JCn");
    29         
    30         //this param should be the URL to an infocontent file (if required
    31         //by the similarity measure being loaded)
    32         params.put("infocontent","file:D:\\JAVAProjectWorkSpace\\jwnl\\JWordNetSim\\test\\ic-bnc-resnik-add1.dat");
    33         
    34         //this param should be the URL to a mapping file if the
    35         //user needs to make synset mappings
    36         params.put("mapping","file:D:\\JAVAProjectWorkSpace\\jwnl\\JWordNetSim\\test\\domain_independent.txt");
    37         
    38         //create the similarity measure
    39         SimilarityMeasure sim = SimilarityMeasure.newInstance(params);
    40         
    41         //取词
    42 //        Dictionary dict = Dictionary.getInstance();        
    43 //        IndexWord word1 = dict.getIndexWord(POS.NOUN, "trade");            //这里把trade和dog完全定义为名词来进行处理
    44 //        IndexWord word2 = dict.getIndexWord(POS.NOUN,"dog");                //
    45 //        
    46 //        //and get the similarity between the first senses of each word
    47 //        System.out.println(word1.getLemma()+"#"+word1.getPOS().getKey()+"#1  " + word2.getLemma()+"#"+word2.getPOS().getKey()+"#1  " + sim.getSimilarity(word1.getSense(1), word2.getSense(1)));        
    48         
    49 //        //get similarity using the string methods (note this also makes use
    50 //        //of the fake root node)
    51 //        System.out.println(sim.getSimilarity("trade#n","deal#n"));
    52         
    53         //get a similarity that involves a mapping
    54         System.out.println(sim.getSimilarity("trade", "trade"));
    55         System.out.println(sim.getSimilarity("trade", "deal"));
    56         System.out.println(sim.getSimilarity("trade", "commerce"));
    57         System.out.println(sim.getSimilarity("trade", "transaction"));        
    58         System.out.println(sim.getSimilarity("trade", "finance"));
    59         System.out.println(sim.getSimilarity("trade", "financial"));
    60         System.out.println(sim.getSimilarity("trade", "business"));
    61         System.out.println(sim.getSimilarity("trade", "economy"));        
    62         System.out.println(sim.getSimilarity("trade", "school"));
    63         System.out.println(sim.getSimilarity("trade", "dog"));
    64         System.out.println(sim.getSimilarity("trade", "cat"));
    65         System.out.println(sim.getSimilarity("trade", "book"));
    66         System.out.println(sim.getSimilarity("trade", "sunshine"));
    67         System.out.println(sim.getSimilarity("trade", "smile"));
    68         System.out.println(sim.getSimilarity("trade", "nice"));
    69         System.out.println(sim.getSimilarity("trade", "hardly"));
    70         System.out.println(sim.getSimilarity("trade", "beautiful"));
    71     }
    72 }
    复制代码

    SimilarityMeasure.java

    复制代码
      1 package shef.nlp.wordnet.similarity;
      2 
      3 import java.io.BufferedReader;
      4 import java.io.InputStreamReader;
      5 import java.net.URL;
      6 import java.util.Arrays;
      7 import java.util.HashMap;
      8 import java.util.HashSet;
      9 import java.util.LinkedHashMap;
     10 import java.util.Map;
     11 import java.util.Set;
     12 
     13 import net.didion.jwnl.JWNLException;
     14 import net.didion.jwnl.data.IndexWord;
     15 import net.didion.jwnl.data.POS;
     16 import net.didion.jwnl.data.Synset;
     17 import net.didion.jwnl.dictionary.Dictionary;
     18 
     19 /**
     20  * An abstract notion of a similarity measure that all provided
     21  * implementations extend.
     22  * @author Mark A. Greenwood
     23  */
     24 public abstract class SimilarityMeasure
     25 {    
     26     /**
     27      * A mapping of terms to specific synsets. Usually used to map domain
     28      * terms to a restricted set of synsets but can also be used to map
     29      * named entity tags to appropriate synsets.
     30      */
     31     private Map<String,Set<Synset>> domainMappings = new HashMap<String,Set<Synset>>();
     32     
     33     /**
     34      * The maximum size the cache can grow to
     35      */
     36     private int cacheSize = 5000;
     37     
     38     /**
     39      * To speed up computation of the similarity between two synsets
     40      * we cache each similarity that is computed so we only have to
     41      * do each one once.
     42      */
     43     private Map<String,Double> cache = new LinkedHashMap<String,Double>(16,0.75f,true)
     44     {
     45         public boolean removeEldestEntry(Map.Entry<String,Double> eldest)
     46         {
     47             //if the size is less than zero then the user is asking us
     48             //not to limit the size of the cache so return false
     49             if (cacheSize < 0) return false;
     50             
     51             //if the cache has crown bigger than it's max size return true
     52             return size() > cacheSize;
     53         }
     54     }; 
     55     
     56     /**
     57      * Get a previously computed similarity between two synsets from the cache.
     58      * @param s1 the first synset between which we are looking for the similarity.
     59      * @param s2 the other synset between which we are looking for the similarity.
     60      * @return The similarity between the two sets or null
     61      *         if it is not in the cache.
     62      */
     63     protected final Double getFromCache(Synset s1, Synset s2)
     64     {
     65         return cache.get(s1.getKey()+"-"+s2.getKey());
     66     }
     67     
     68     /**
     69      * Add a computed similarity between two synsets to the cache so that
     70      * we don't have to compute it if it is needed in the future.
     71      * @param s1 one of the synsets between which we are storring a similarity.
     72      * @param s2 the other synset between which we are storring a similarity.
     73      * @param sim the similarity between the two supplied synsets.
     74      * @return the similarity score just added to the cache.
     75      */
     76     protected final double addToCache(Synset s1, Synset s2, double sim)
     77     {
     78         cache.put(s1.getKey()+"-"+s2.getKey(),sim);
     79         
     80         return sim;
     81     }
     82     
     83     /**
     84      * Configures the similarity measure using the supplied parameters.
     85      * @param params a set of key-value pairs that are used to configure
     86      *        the similarity measure. See concrete implementations for details
     87      *        of expected/possible parameters. 
     88      * @throws Exception if an error occurs while configuring the similarity measure.
     89      */
     90     protected abstract void config(Map<String,String> params) throws Exception;
     91     
     92     /**
     93      * Create a new instance of a similarity measure.
     94      * @param confURL the URL of a configuration file. Parameters are specified
     95      *        one per line as key:value pairs.
     96      * @return a new instance of a similairy measure as defined by the
     97      *         supplied configuration URL.
     98      * @throws Exception if an error occurs while creating the similarity measure.
     99      */
    100     public static SimilarityMeasure newInstance(URL confURL) throws Exception
    101     {
    102         //create map to hold the key-value pairs we are going to read from
    103         //the configuration file
    104         Map<String,String> params = new HashMap<String,String>();
    105         
    106         //create a reader for the config file
    107         BufferedReader in = null;
    108         
    109         try
    110         {
    111             //open the config file
    112             in = new BufferedReader(new InputStreamReader(confURL.openStream()));
    113                     
    114             String line = in.readLine();
    115             while (line != null)
    116             {
    117                 line = line.trim();
    118                 
    119                 if (!line.equals(""))
    120                 {
    121                     //if the line contains something then
    122                     
    123                     //split the data so we get the key and value
    124                     String[] data = line.split("\\s*:\\s*",2);
    125                     
    126                     if (data.length == 2)
    127                     {
    128                         //if the line is valid add the two parts to the map
    129                         params.put(data[0], data[1]);
    130                     }
    131                     else
    132                     {
    133                         //if the line isn't valid tell the user but continue on
    134                         //with the rest of the file
    135                         System.out.println("Config Line is Malformed: " + line);
    136                     }
    137                 }
    138                 
    139                 //get the next line ready to process
    140                 line = in.readLine();
    141             }
    142         }
    143         finally
    144         {
    145             //close the config file if it got opened
    146             if (in != null) in.close();
    147         }
    148         
    149         //create and return a new instance of the similarity measure specified
    150         //by the config file
    151         return newInstance(params);
    152     }
    153     
    154     /**
    155      * Creates a new instance of a similarity measure using the supplied parameters.
    156      * @param params a set of key-value pairs which define the similarity measure.
    157      * @return the newly created similarity measure.
    158      * @throws Exception if an error occurs  while creating the similarity measure.
    159      */
    160     public static SimilarityMeasure newInstance(Map<String,String> params) throws Exception
    161     {
    162         //get the class name of the implementation we need to load
    163         String name = params.remove("simType");
    164         
    165         //if the name hasn't been specified then throw an exception
    166         if (name == null) throw new Exception("Must specifiy the similarity measure to use");
    167         
    168         //Get hold of the class we need to load
    169         @SuppressWarnings("unchecked") Class<SimilarityMeasure> c = (Class<SimilarityMeasure>)Class.forName(name);
    170         
    171         //create a new instance of the similarity measure
    172         SimilarityMeasure sim = c.newInstance();
    173         
    174         //get the cache parameter from the config params
    175         String cSize = params.remove("cache");
    176         
    177         //if a cache size was specified then set it
    178         if (cSize != null) sim.cacheSize = Integer.parseInt(cSize);
    179         
    180         //get the url of the domain mapping file
    181         String mapURL = params.remove("mapping");
    182         
    183         if (mapURL != null)
    184         {
    185             //if a mapping file has been provided then 
    186                         
    187             //open a reader over the file
    188             BufferedReader in = new BufferedReader(new InputStreamReader((new URL(mapURL)).openStream()));
    189             
    190             //get the first line ready for processing
    191             String line = in.readLine();
    192             
    193             while (line != null)
    194             {
    195                 if (!line.startsWith("#"))
    196                 {
    197                     //if the line isn't a comment (i.e. it doesn't start with #) then...
    198                     
    199                     //split the line at the white space
    200                     String[] data = line.trim().split("\\s+");
    201                     
    202                     //create a new set to hold the mapped synsets
    203                     Set<Synset> mappedTo = new HashSet<Synset>();
    204                     
    205                     for (int i = 1 ; i < data.length ; ++i)
    206                     {
    207                         //for each synset mapped to get the actual Synsets
    208                         //and store them in the set
    209                         mappedTo.addAll(sim.getSynsets(data[i]));
    210                     }
    211                     
    212                     //if we have found some actual synsets then
    213                     //store them in the domain mappings
    214                     if (mappedTo.size() > 0) sim.domainMappings.put(data[0], mappedTo);
    215                 }
    216                 
    217                 //get the next line from the file
    218                 line = in.readLine();
    219             }
    220             
    221             //we have finished with the mappings file so close it
    222             in.close();
    223         }        
    224         
    225         //make sure it is configured properly
    226         sim.config(params);
    227         
    228         //then return it
    229         return sim;
    230     }
    231     
    232     /**
    233      * This is the method responsible for computing the similarity between two
    234      * specific synsets. The method is implemented differently for each
    235      * similarity measure so see the subclasses for detailed information.
    236      * @param s1 one of the synsets between which we want to know the similarity.
    237      * @param s2 the other synset between which we want to know the similarity.
    238      * @return the similarity between the two synsets.
    239      * @throws JWNLException if an error occurs accessing WordNet.
    240      */
    241     public abstract double getSimilarity(Synset s1, Synset s2) throws JWNLException;
    242     
    243     /**
    244      * Get the similarity between two words. The words can be specified either
    245      * as just the word or in an encoded form including the POS tag and possibly
    246      * the sense number, i.e. cat#n#1 would specifiy the 1st sense of the noun cat.
    247      * @param w1 one of the words to compute similarity between.
    248      * @param w2 the other word to compute similarity between.
    249      * @return a SimilarityInfo instance detailing the similarity between the
    250      *         two words specified.
    251      * @throws JWNLException if an error occurs accessing WordNet.
    252      */
    253     public final SimilarityInfo getSimilarity(String w1, String w2) throws JWNLException
    254     {
    255         //Get the (possibly) multiple synsets associated with each word
    256         Set<Synset> ss1 = getSynsets(w1);
    257         Set<Synset> ss2 = getSynsets(w2);
    258                 
    259         //assume the words are not at all similar
    260         SimilarityInfo sim = null;
    261         
    262         for (Synset s1 : ss1)
    263         {
    264             for (Synset s2 : ss2)
    265             {
    266                 //for each pair of synsets get the similarity
    267                 double score = getSimilarity(s1, s2);
    268                                 
    269                 if (sim == null || score > sim.getSimilarity())
    270                 {
    271                     //if the similarity is better than we have seen before
    272                     //then create and store an info object describing the
    273                     //similarity between the two synsets
    274                     sim = new SimilarityInfo(w1, s1, w2, s2, score);
    275                 }
    276             }
    277         }
    278         
    279         //return the maximum similarity we have found
    280         return sim;    
    281     }
    282     
    283     /**
    284      * Finds all the synsets associated with a specific word.
    285      * @param word the word we are interested. Note that this may be encoded
    286      *        to include information on POS tag and sense index.
    287      * @return a set of synsets that are associated with the supplied word
    288      * @throws JWNLException if an error occurs accessing WordNet
    289      */
    290     private final Set<Synset> getSynsets(String word) throws JWNLException
    291     {        
    292         //get a handle on the WordNet dictionary
    293         Dictionary dict = Dictionary.getInstance();
    294         
    295         //create an emptuy set to hold any synsets we find
    296         Set<Synset> synsets = new HashSet<Synset>();
    297         
    298         //split the word on the # characters so we can get at the
    299         //upto three componets that could be present: word, POS tag, sense index
    300         String[] data = word.split("#");
    301         
    302         //if the word is in the domainMappings then simply return the mappings
    303         if (domainMappings.containsKey(data[0])) return domainMappings.get(data[0]);
    304         
    305         if (data.length == 1)
    306         {
    307             //if there is just the word
    308                 
    309             for (IndexWord iw : dict.lookupAllIndexWords(data[0]).getIndexWordArray())
    310             {
    311                 //for each matching word in WordNet add all it's senses to
    312                 //the set we are building up
    313                 synsets.addAll(Arrays.asList(iw.getSenses()));
    314             }
    315             
    316             //we have finihsed so return the synsets we found
    317             return synsets;
    318         }
    319     
    320         //the calling method specified a POS tag as well so get that
    321         POS pos = POS.getPOSForKey(data[1]);
    322         
    323         //if the POS tag isn't valid throw an exception
    324         if (pos == null) throw new JWNLException("Invalid POS Tag: " + data[1]);
    325         
    326         //get the word with the specified POS tag from WordNet
    327         IndexWord iw = dict.getIndexWord(pos, data[0]);
    328         
    329         if (data.length > 2)
    330         {
    331             //if the calling method specified a sense index then
    332             //add just that sysnet to the set we are creating
    333             synsets.add(iw.getSense(Integer.parseInt(data[2])));
    334         }
    335         else
    336         {
    337             //no sense index was specified so add all the senses of
    338             //the word to the set we are creating
    339             synsets.addAll(Arrays.asList(iw.getSenses()));
    340         }
    341         
    342         //return the set of synsets we found for the specified word
    343         return synsets;
    344     }
    345 }
    复制代码

     

      每个函数都有详细注解,大家应该都看的明白。

    262~277的循环过程如下:

        

      JCN.java

    复制代码
      1 /************************************************************************
      2  *         Copyright (C) 2006-2007 The University of Sheffield          *
      3  *      Developed by Mark A. Greenwood <m.greenwood@dcs.shef.ac.uk>     *
      4  *                                                                      *
      5  * This program is free software; you can redistribute it and/or modify *
      6  * it under the terms of the GNU General Public License as published by *
      7  * the Free Software Foundation; either version 2 of the License, or    *
      8  * (at your option) any later version.                                  *
      9  *                                                                      *
     10  * This program is distributed in the hope that it will be useful,      *
     11  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
     12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
     13  * GNU General Public License for more details.                         *
     14  *                                                                      *
     15  * You should have received a copy of the GNU General Public License    *
     16  * along with this program; if not, write to the Free Software          *
     17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.            *
     18  ************************************************************************/
     19 
     20 package shef.nlp.wordnet.similarity;
     21 
     22 import net.didion.jwnl.JWNLException;
     23 import net.didion.jwnl.data.Synset;
     24 
     25 /**
     26  * An implementation of the WordNet similarity measure developed by Jiang and
     27  * Conrath. For full details of the measure see:
     28  * <blockquote>Jiang J. and Conrath D. 1997. Semantic similarity based on corpus
     29  * statistics and lexical taxonomy. In Proceedings of International
     30  * Conference on Research in Computational Linguistics, Taiwan.</blockquote>
     31  * @author Mark A. Greenwood
     32  */
     33 public class JCn extends ICMeasure
     34 {
     35     /**
     36      * Instances of this similarity measure should be generated using the
     37      * factory methods of {@link SimilarityMeasure}.
     38      */
     39     protected JCn()
     40     {
     41         //A protected constructor to force the use of the newInstance method
     42     }
     43     
     44     @Override public double getSimilarity(Synset s1, Synset s2) throws JWNLException
     45     {
     46         //if the POS tags are not the same then return 0 as this measure
     47         //only works with 2 nouns or 2 verbs.
     48         if (!s1.getPOS().equals(s2.getPOS())) return 0;
     49         
     50         //see if the similarity is already cached and...
     51         Double cached = getFromCache(s1, s2);
     52         
     53         //if it is then simply return it
     54         if (cached != null) return cached.doubleValue();
     55         
     56         //Get the Information Content (IC) values for the two supplied synsets
     57         double ic1 = getIC(s1);
     58         double ic2 = getIC(s2);
     59 
     60         //if either IC value is zero then cache and return a sim of 0
     61         if (ic1 == 0 || ic2 == 0) return addToCache(s1,s2,0);
     62         
     63         //Get the Lowest Common Subsumer (LCS) of the two synsets
     64         Synset lcs = getLCSbyIC(s1,s2);
     65         
     66         //if there isn't an LCS then cache and return a sim of 0
     67         if (lcs == null) return addToCache(s1,s2,0);
     68         
     69         //get the IC valueof the LCS
     70         double icLCS = getIC(lcs);
     71         
     72         //compute the distance between the two synsets
     73         //NOTE: This is the original JCN measure
     74         double distance = ic1 + ic2 - (2 * icLCS);
     75         
     76         //assume the similarity between the synsets is 0
     77         double sim = 0;
     78         
     79         if (distance == 0)
     80         {
     81             //if the distance is 0 (i.e. ic1 + ic2 = 2 * icLCS) then...
     82             
     83             //get the root frequency for this POS tag
     84             double rootFreq = getFrequency(s1.getPOS());
     85             
     86             if (rootFreq > 0.01)
     87             {
     88                 //if the root frequency has a value then use it to generate a
     89                 //very large sim value
     90                 sim = 1/-Math.log((rootFreq - 0.01) / rootFreq);
     91             }            
     92         }
     93         else
     94         {
     95             //this is the normal case so just convert the distance
     96             //to a similarity by taking the multiplicative inverse
     97             sim = 1/distance;
     98         }
     99         
    100         //cache and return the calculated similarity
    101         return addToCache(s1,s2,sim);
    102     }
    103 }
    复制代码

    LIN.java

    复制代码
     1 package shef.nlp.wordnet.similarity;
     2 
     3 import net.didion.jwnl.JWNLException;
     4 import net.didion.jwnl.data.Synset;
     5 
     6 /**
     7  * An implementation of the WordNet similarity measure developed by Lin. For
     8  * full details of the measure see:
     9  * <blockquote>Lin D. 1998. An information-theoretic definition of similarity. In
    10  * Proceedings of the 15th International Conference on Machine
    11  * Learning, Madison, WI.</blockquote>
    12  * @author Mark A. Greenwood
    13  */
    14 public class Lin extends ICMeasure
    15 {
    16     /**
    17      * Instances of this similarity measure should be generated using the
    18      * factory methods of {@link SimilarityMeasure}.
    19      */
    20     protected Lin()
    21     {
    22         //A protected constructor to force the use of the newInstance method
    23     }
    24     
    25     @Override public double getSimilarity(Synset s1, Synset s2) throws JWNLException
    26     {
    27         //if the POS tags are not the same then return 0 as this measure
    28         //only works with 2 nouns or 2 verbs.
    29         if (!s1.getPOS().equals(s2.getPOS())) return 0;
    30         
    31         //see if the similarity is already cached and...
    32         Double cached = getFromCache(s1, s2);
    33         
    34         //if it is then simply return it
    35         if (cached != null) return cached.doubleValue();
    36         
    37         //Get the Information Content (IC) values for the two supplied synsets
    38         double ic1 = getIC(s1);
    39         double ic2 = getIC(s2);
    40         
    41         //if either IC value is zero then cache and return a sim of 0
    42         if (ic1 == 0 || ic2 == 0) return addToCache(s1,s2,0);
    43         
    44         //Get the Lowest Common Subsumer (LCS) of the two synsets
    45         Synset lcs = getLCSbyIC(s1,s2);
    46         
    47         //if there isn't an LCS then cache and return a sim of 0
    48         if (lcs == null) return addToCache(s1,s2,0);
    49         
    50         //get the IC valueof the LCS
    51         double icLCS = getIC(lcs);
    52         
    53         //caluclaue the similarity score
    54         double sim = (2*icLCS)/(ic1+ic2);
    55         
    56         //cache and return the calculated similarity
    57         return addToCache(s1,s2,sim);
    58     }
    59 }
    复制代码

     

     

    参考文献:

    《基于维基百科的语义相似度计算》盛志超,陶晓鹏(复旦大学计算机科学技术学院);

    《基于WordNet的英语词语相似度计算》颜伟,荀恩东(北京语言大学 语言信息处理研究所)

    WordNet中的名词:http://ccl.pku.edu.cn/doubtfire/semantics/wordnet/c-wordnet/nouns-in-wordnet.htm

    MIT的JWI(Java WordNet Interface)和JWNL(Java WordNet Library)比较  

    http://jxr19830617.blog.163.com/blog/static/163573067201301985219857/

    http://jxr19830617.blog.163.com/blog/static/1635730672013019105255295/

    展开全文
  • 在搜索引擎中,我们会碰到大量的同义词需求。用户在描述同个东西的时候,会有各种各样的描述。 在电商搜索环境中,同义词分成好几类: 1. 品牌同义词:nokia=诺基亚,Adidas=阿迪达斯 2. 产品同义词:投影仪...

    在搜索引擎中,我们会碰到大量的同义词需求。用户在描述同一个东西的时候,会有各种各样的描述。

          在电商搜索环境中,同义词分成好几类:

         1. 品牌同义词:nokia=诺基亚,Adidas=阿迪达斯

         2. 产品同义词:投影仪≈投影机,电话≈cell phone; automobile 和car。

         3.旧词和新词:自行车  -> 脚踏车

         4.南方用词和北方用词:番茄-> 西红柿。

         5.传统的同义词:储物柜和收纳柜。

         6.错别字同义词:瑜伽和瑜珈(错误写为斜王旁)

           对应英文来说,还有词干提取,如单复数、动词原形和ing形式;英文还有一个特殊的现象,例如两个单词可以分开写,也可以合并在一起,例如keychain和key chian(钥匙链),boyfriend 和boy friend。

           近义词就比较多了: 包括size 大码≈大号;短裤和热裤;边疆和边疆。

          上位词:苹果手机上位词 是手机。

           反义词:宽松和修身。当我们做query改写的时候,改写千万不能改写出反义词。

     

           如果我们仔细观察,我们会发现有的词可以互相替换,有些词是只能单向替换(换一个方向就不对了,例如周杰伦可以替换为周董,但是周董只能在一定情况下替换为周董)。

    如何挖掘得到同义词呢?

            我们可以从用户搜索词、商品标题、搜索和点击来获取。最根本的来源还是商家对商品标题的优化,聪明的商家会把同义词堆叠在标题中,以期望获取到更多的流量。

            从点击日志上看,如果w1和w2是同义词,那么搜索w1和搜索w2,理论上会有大量的共同点击的商品x1、x2、x3等等。

             标题商品标题得到大量的语料,例如投影仪和投影机,拉杆箱(draw bar box)和旅行箱(luggage)。

     

           通过统计或者word2vec训练词的相关性,找到高相关度的词。统计这些词在标题中共同出现次数,即w1和w2的共现次数。

    以下代码查看word2vec的效果


    fromgensim.test.utilsimportcommon_texts,get_tmpfile

    fromgensim.modelsimportWord2Vec

    model_path="./data/word2vec_en_50d.model"

    model=Word2Vec.load(model_path)

    model.wv['computer']

    Out[6]:

    array([-0.48867282, -0.10507897, -0.23138586, -0.10871041,  0.1514824 ,

          -0.01487145, -0.385491  ,  0.01792672, -0.32512784, -0.9063424 ,

          -0.5428677 ,  0.6565156 ,  0.02183418,  0.07939139,  0.03485253,

            0.319492  , -0.27633888,  0.52685845, -0.0582791 , -0.4844649 ,

            0.249212  ,  0.8144138 , -0.03233343, -0.36086813,  0.34835583,

          -0.07177112,  0.0828275 ,  0.6612073 ,  0.74526566, -0.12676844,

          -0.08891173, -0.08520225, -0.04619604,  0.13580324,  0.183159  ,

            0.15528682,  0.01727525, -0.43599448, -0.2579532 , -0.23192754,

          -0.32965428,  0.09547858,  0.00419413, -0.06285212,  0.18150753,

          -0.21699691,  0.60977536, -0.06555454,  0.35746607, -0.06610812],

          dtype=float32)

    In[13]:

    model.wv.similarity('case','cover')    # case 和cover在描述手机壳的时候基本是同义词

    Out[13]:

    0.8538678

    In[22]:

    defget_top_sim(word):

    similary_words=model.wv.most_similar(word,topn=10)

    forw,sinsimilary_words:

    print(word,"=",w,s)

    get_top_sim('case')

    case = holder 0.8879926800727844

    case = clamshell 0.887456476688385

    case = tablet 0.8748524188995361

    case = storage 0.8703626990318298

    case = carrying 0.8672872185707092

    case = hardcase 0.8580055236816406

    case = carring 0.8558304309844971

    case = seal 0.8552369475364685

    case = cover 0.8538679480552673

    case = stand 0.8476276993751526

     

            通过word2vec,我们可以找出原始词和最相似的10个单词,然后我们统计origin 和substitute(原始词和替代词)在标题中的共现次数,通过这种挖掘,我们找到大量的候选词对,这种词通过人工review可以作为同义词的候选。

           对这种情况稍微做一些扩展,我们就能得到同义query到同义query之间的对应关系。


            统计分析上位词,统计每个商品类目下的产品词,出现次数top n的产品词w,对应到商品的类目词c,那么w -> c很可能 就是一个上位词关系。

    人工词表

           在维护词表的时候,我们一定不能忘记人工词表。人工词表的维护必须要有后台工具。

    我们如何应用人工词表:

            1、在商品标题对应的索引词中做同义词扩展,当不用不管用同义词的哪一个来搜索的时候都可以搜索到。

            2、在QueryProcess模块中,对词做同义词扩展、做近义词改写,改写出来的近义词的权重要比原始词的权重更小。在改写中,我们还会遇到一个问题,Q(分词为w1,w2,w3)改写成q1(w1,w2)和q2(w2,w3)的时候,我们会遇到q1和q2分别和Q如何计算相关性的问题。

             3、当query 做同义词改写的时候,需要一些词做context(上下文)。如“周董的新歌”可以修改为“周杰伦的新歌”,但是“周董的公司”就未必是周杰伦的公司了。

     

    参考文献:

    1、搜索引擎同义词反馈机制【百度搜索研发部】

    2、https://www.docin.com/p-1136208118.html

    3、面向检索信息的同义词挖掘

    展开全文
  • 万八千个同义词收集汇总去重整理后精选三千四百多条同义词近义词替换库,方便伪原创同义词替换使用!同义词都经过人工整理过,错误很少,但也难免有不少量不准确,也请大家谅解
  • 没细数,几万个应该有,我自己在用。两个组,中间到逗号隔开了。可以另存入数据库或Excel或根据软件导入规则,稍做修改,就可直接导入伪原创类软件。灵活使用。
  • 本人手工整理,数量大概在60000个左右,因为词比较多,所以没办法个人核对,是否完全都是同义近义词.但是数量上是没打折扣,绝对没有重复,实打实六万干货. 有需要朋友下载吧,我自己之前也下载过几个号称十...
  • 我们可以使用NLP技术,具体词向量技术来训练模型,生成word2vec,然后来寻找单词的近义词,现在网上搜索大多是源码,对于非专业开发人员来说使用起来不是很友好,我找了晚上找到了个比较好用库,可以...
  • 同义词挖掘干货

    2021-01-28 17:24:34
    用维基百科中文语料训练的同义词工具,直接pip即可,输入词即可直接返回top k的近义词,可以通过top p准确说叫top distance来通过阈值选取同义词。这样非常的方便,但是一些词会出现OOV,因为具
  • 今天卖家精灵就以女士内衣为例,给大家介绍如何找到款产品在本土不同称呼,也就是其核心关键词以及同义词近义词,用来做Listing关键词优化和PPC关键词优化。这也是亚马逊运营的一项基本功。、类目名称关键词...
  • 近义词搜索

    千次阅读 2017-03-23 16:14:48
    “西语”是“西班牙语”简称,当我搜“西语”时,我希望搜索结果也包含“西班牙语”。 所以我要为分词器,加上层过滤器,... 近义词过滤器,要实现是将同义词加入到TokenStream中,并且和原词是相同位置。
  •  概念说明:同义词大体意思是指,当用户输入个词时,solr会把相关有相同意思的近义词的同义词的term语段内容从索引中取出,展示给用户,提高交互友好性(当然这些同义词的定义是要在配置文件中事先定义好...
  • solr(五)同义词

    2013-04-09 13:08:39
     概念说明:同义词大体意思是指,当用户输入个词时,solr会把相关有相同意思的近义词的同义词的term语段内容从索引中取出,展示给用户,提高交互友好性(当然这些同义词的定义是要在配置文件中事先定义好...
  • 考研英语近义词与反义词·十一

    千次阅读 2017-04-05 16:24:49
    quarterly:季度,按季度;按季地,次地;n季刊 quest:(历时较长)寻求;调查研究;v寻找,寻求;同义词:inquiry,pursuit,pursue,seek ...同义词:basic,fundamental,extreme,utm
  • 一直想找到个好的同义词解决方案,在百度和google查找,大家对于这个问题都只是寥寥数语,不愿讲清,我在javaeye搜此类信息也求不到,后来发了个提问贴也只有浏览数而无回复,不知道这是什么原因,无奈之下我只有...
  • 考研英语近义词与反义词·四

    千次阅读 2017-04-04 14:36:04
    同义词:harm,hurt,ruin,upset;反义词:repair,benefit damn:(表示厌烦、失望等)该死,讨厌;指责,谴责,周妈;使失败,注定要失败;n丝毫,点点;同义词:curse,swear,doom,condemn,denounce;...
  • 在getSameWords()方法中,我们使用map临时存放了两个键值对用来测试,实际开发中,往往需要很多这种键值对来处理,比如从某个同义词词典里面获取值之类,所以说,我们需要个类,根据key提供近义词。...
  • 自然语言处理之近义词包 Synonyms

    千次阅读 2018-04-12 10:43:58
    目前很缺乏质量好的中文近义词库,于是便考虑使用 word2vec 训练个高质量的同义词库将“非标准表述”映射到“标准表述”,这就是 Synonyms 的起源。在经典的信息检索系统中,相似度的计算是基于匹配的,而且是 ...
  • java使用wordnet获取近义词

    千次阅读 2015-05-14 00:20:42
    资料来源:基于WordNet英文同义词近义词相似度评估及代码实现初识WordNetWordNet是什么 首先,来看WordNet。搜了一下相关介绍: WordNet是个由普林斯顿大学认识科学实验室在心理学教授乔治·A·米勒指导下...

空空如也

空空如也

1 2 3 4
收藏数 80
精华内容 32
关键字:

一的同义词近义词