利用Hownet进行语义相似度计算的类(

最新推荐文章于 2021-03-22 08:46:50 发布
最新推荐文章于 2021-03-22 08:46:50 发布
阅读量2.5k 收藏 4
点赞数 1

转自：http://blog.sina.com.cn/s/blog_4a8c215101000c1i.html

///在这里要感谢在UIUC攻读博士学位的小胖子同学，本代码是在他的C#版本上的改
///写,希望小胖子同学早日毕业！！
#if !defined HownetPrimitive_H
#define HownetPrimitive_H
#include <string.h>
/// <summary>
/// Hownet的义原
/// </summary>
class HownetPrimitive
{
public:
HownetPrimitive(string strLine):name(""),parent(0),id(0)
{
char *token;
token=strtok((char*)strLine.c_str()," \t\n");
//while()
if(token!=NULL)
{
id=atoi(token);
token=strtok(NULL," \t\n");
}
if(token!=NULL)
{
name = string(token);
//name=name.substr(0,name.length()-1);
token=strtok(NULL," \t\n");
}
if(token!=NULL)
{
parent=atoi(token);
}
}

// 义原名称
string name ;

// 义原的上一级义原的ID
int parent;

// 义原的ID
int id ;
};
#endif

#if !defined HownetWord_H
#define HownetWord_H
/// <summary>
/// Hownet的词的表示（只考虑四大部分而忽略概念，即具体词）,与刘群算法不同，对于一个词的多次出现进行合并，因此所谓第一义原也不止一个
/// </summary>
class HownetWord
{
public:
HownetWord(string strLine):word("")
{
char* token;
token=strtok((char*)strLine.c_str()," \t");
if(token!=NULL)
{
word=string(token);
token=strtok(NULL," \t");
}
if(token!=NULL)
{
token=strtok(NULL," \t");
}
if(token!=NULL)
{
char *ttok=strtok(token,",");
while(ttok!=NULL)
{
char firstC=ttok[0];
string strP="";
string ps(ttok);
string::size_type pos=ps.find(" ");
// 关系义原
if(pos!=string::npos)
{
strP = ps.substr(pos+1,ps.length()-pos-1);
}
// 基本义原
else if(firstC>='a'&&firstC<='z'||firstC>='A'&&firstC<='Z')
{
strP=ps;
}
// 关系符号描述
else if(firstC != '(')
{
strP=ps.substr(1,ps.length()-1);
}

if(strP.length()>0&&relationPrimitives.find(strP)==relationPrimitives.end())
{
relationPrimitives.insert(map<string,int>::value_type(strP,NULL));
}
// 忽略具体词
ttok=strtok(NULL,",\n");
}
}
}

/// <summary>
/// 关系义原描述
/// </summary>
map<string,int> relationPrimitives ;
/// <summary>
/// 词
/// </summary>
string word ;
};
#endif

// WordRelvanceCalculator.cpp: implementation of the CWordRelvanceCalculator class.
//
//

#include "WordRelvanceCalculator.h"

//
// Construction/Destruction
//

CWordRelvanceCalculator::CWordRelvanceCalculator():Alpha(1.60),Gama(0.20)
{

TCHAR szPhraseFileName[200]={'\0'};
LPTSTR lpPhraseFileName=szPhraseFileName;
lpPhraseFileName = szPhraseFileName;
lpPhraseFileName += GetSystemDirectory(szPhraseFileName,200);
if (*(lpPhraseFileName-1) != _T('\\'))
*lpPhraseFileName++ = _T('\\');
string strDir(szPhraseFileName);

Initialize(strDir);
}

CWordRelvanceCalculator::~CWordRelvanceCalculator()
{

}
void CWordRelvanceCalculator::Initialize(string &strDictDir)
{

LoadPrimitiveDict(strDictDir + "WHOLE.DAT");

LoadWordDict(strDictDir + "glossary.dat");
}
//读取义原词典
void CWordRelvanceCalculator::LoadPrimitiveDict(string &strDictPath)
{
FILE* fhandle=fopen(strDictPath.c_str(),"r");
if(!fhandle)
{
}
else
{
char in_line[1024];
fgets(in_line,1024,fhandle);
while(!feof(fhandle))
{
string line(in_line);
HownetPrimitive hp(line);
// 如果义原在义原词典中重复出现，则只保留最前面一个（暂时先这么做）
if(m_oNamePrimitiveMap.find(hp.name)==m_oNamePrimitiveMap.end())
{
m_oNamePrimitiveMap.insert(map<string,HownetPrimitive>::value_type(hp.name,hp));
}
m_oIdParentMap.insert(map<int,int>::value_type(hp.id,hp.parent));
fgets(in_line,1024,fhandle);
}
fclose(fhandle);
}
}
//读取词汇字典
void CWordRelvanceCalculator::LoadWordDict(string &strDictPath)
{
FILE* fhandle=fopen(strDictPath.c_str(),"r");
if(!fhandle)
{
}
else
{
char in_line[1024];
fgets(in_line,1024,fhandle);
while(!feof(fhandle))
{
string line(in_line);
HownetWord hw(line);
// 如果该词在前面已经出现过，则将所有这些词的义原进行合并（暂时先这么做）
map<string,HownetWord>::iterator hwIte;
if((hwIte=m_oWordMap.find(hw.word))!=m_oWordMap.end())
{
HownetWord prevHW=hwIte->second;
map<string,int>::iterator ite2;
for(ite2=hw.relationPrimitives.begin();ite2!=hw.relationPrimitives.end();ite2++)
{
if(prevHW.relationPrimitives.find(ite2->first)!=prevHW.relationPrimitives.end())
{
prevHW.relationPrimitives.insert(map<string,int>::value_type(ite2->first,ite2->second));
}
}
}
else
{
m_oWordMap.insert(map<string,HownetWord>::value_type(hw.word, hw));
}
fgets(in_line,1024,fhandle);
}
fclose(fhandle);
}
}
/*
* 利用hownet计算两个义原之间的关联度
*/
double CWordRelvanceCalculator::ComputePrimitiveSimilarity(string &strPrimitive1, string &strPrimitive2)
{
if(strPrimitive1==strPrimitive2)
return 1.0;
// 两个义原之间的距离
int distance = 0;

// 如果两个义原有任何一个不是合法的义原，则返回一个默认值
map<string,HownetPrimitive>::iterator ite=m_oNamePrimitiveMap.find(strPrimitive1);
if(ite==m_oNamePrimitiveMap.end()) return Gama;
HownetPrimitive firstP = ite->second;

ite=m_oNamePrimitiveMap.find(strPrimitive2);
if(ite==m_oNamePrimitiveMap.end()) return Gama;
HownetPrimitive secondP = ite->second;

// 计算两个义原之间的距离
int firstID = firstP.id;
int secondID = secondP.id;
while(firstID != secondID)
{
// 将id较大的义原沿着树上升一级，直至两个id相等
if(firstID > secondID)
{
int tmpID = firstID;
firstID = secondID;
secondID = tmpID;
}
int parentID = m_oIdParentMap[secondID];
// 如果有某个ID没有父义原，则返回一个较小值
if(secondID == parentID)
{
distance = 15;
break;
}
secondID = parentID;
distance++;
}

return Alpha / (distance + Alpha);
}
/*
* 计算两个词语的相关度
*/
double CWordRelvanceCalculator::ComputeRelevance(const string &strCnWord1, const string &strCnWord2)
{
if(strCnWord1==strCnWord2)
{
return 1.0;
}

map<string,HownetWord>::iterator myite= m_oWordMap.find(strCnWord1);
if(myite==m_oWordMap.end()) return Gama;
HownetWord &hw1=myite->second;

myite= m_oWordMap.find(strCnWord2);
if(myite==m_oWordMap.end()) return Gama;
HownetWord &hw2 = myite->second;


// 相似度
double fSim = 0;

// 矩阵的长边和短边
int length = hw1.relationPrimitives.size();
int width = hw2.relationPrimitives.size();
if(length < width)
{
length = hw2.relationPrimitives.size();
width = hw1.relationPrimitives.size();
}
if(length == 0 || width == 0)
{
return Gama;
}

// 矩阵用以存两两之间的相似度
vector<vector<double> > simMatrix;
for(int i=0; i < hw1.relationPrimitives.size()+1; i++)
{
vector<double> tv;
simMatrix.push_back(tv);
vector<double> & tv2 = simMatrix[i];
tv2.resize(hw2.relationPrimitives.size()+1);
//vector<double> & tv3 = simMatrix[i];
//cout << tv3.size() << "\t";
//simMatrix[i] = new double[hw2.relationPrimitives.size()];
}

// 计算两两义原之间的相似度
map<string,int>::iterator ite=hw1.relationPrimitives.begin();
int row = 0;
for(;ite!=hw1.relationPrimitives.end();ite++)
{
// 第一个词的第i个义原
string strP1=ite->first;
int col=0;
map<string,int>::iterator ite2=hw1.relationPrimitives.begin();
for(;ite2!=hw1.relationPrimitives.end();ite2++)
{
string strP2=ite2->first;
simMatrix[row][col] = ComputePrimitiveSimilarity(strP1, strP2);
col++;
}
row++;
}

// 从矩阵中找出最大值，然后把该值所在行列清零
double fSimSum = 0;
int MaxRow = -1;
int MaxCol = -1;
double MaxSim = 0;
for(i=0; i < width; i++)
{
// 找出当前对大的值
for(int m=0; m < hw1.relationPrimitives.size(); m++)
{
for(int n=0; n < hw2.relationPrimitives.size(); n++)
{
if(simMatrix[m][n] > MaxSim)
{
MaxRow = m;
MaxCol = n;
MaxSim = simMatrix[m][n];
}
}
}
fSimSum += MaxSim;
MaxSim = 0;

// 将最大值所在行列全部清零
for(int j=0; j < hw2.relationPrimitives.size(); j++)
{
simMatrix[MaxRow][j] = 0;
}
for(j=0; j < hw1.relationPrimitives.size(); j++)
{
simMatrix[j][MaxCol] = 0;
}
}

// 计算最终相似度，公式推导过程:
// 如果length和width越接近，fSimSum越接近width，则最终的相似度应该越大；
// 所以我们假设那些没有对齐的部分的默认相似度不应该是固定的，我们用(width / length) * (fSimSum / width) = fSimSum / length表示
// 所以总共需要补充到fSimSum的数值为: (length - width) * SimSum / length
// 最后的相似度还要除以 length
// 最后得到下面的计算公式
fSim = fSimSum * (2.0 / length - width * 1.0 / (length * length));

return fSim;
}

// WordRelvanceCalculator.h: interface for the CWordRelvanceCalculator class.
//
//

#if !defined(AFX_WORDRELVANCECALCULATOR_H__C5D16340_1E8E_450C_A65F_7101DA8D638C__INCLUDED_)
#define AFX_WORDRELVANCECALCULATOR_H__C5D16340_1E8E_450C_A65F_7101DA8D638C__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#pragma warning(disable:4786)

#include "MyIME.h"
#include "HownetPrimitive.h"
#include "HownetWord.h"
/*
* 利用hownet进行语意相似度计算
* 包括相关度，相似度两个方面
*/
class CWordRelvanceCalculator
{
public:
CWordRelvanceCalculator();
virtual ~CWordRelvanceCalculator();
private:
void Initialize(string &strDir);
/// <summary>
/// 载入义原词典
/// </summary>
/// <param name="strDictPath"></param>
void LoadPrimitiveDict(string &strDictPath);
/// <summary>
/// 载入词典
/// </summary>
/// <param name="strDictPath"></param>
void LoadWordDict(string &strDictPath);
/// <summary>
/// 计算两个义原的相似度
/// </summary>
/// <param name="strPrimitive1"></param>
/// <param name="strPrimitive2"></param>
/// <returns></returns>
double ComputePrimitiveSimilarity(string &strPrimitive1, string &strPrimitive2);
public:
/// <summary>
/// 计算两个词的相关度
/// </summary>
/// <param name="strCnWord1"></param>
/// <param name="strCnWord2"></param>
/// <returns></returns>
double ComputeRelevance(const string &strCnWord1, const string &strCnWord2);
private:
/// <summary>
/// 存储每个词及其相关的义原描述
/// </summary>
map<string,HownetWord> m_oWordMap ;

/// <summary>
/// 存储每个义原的名称与该义原的对应关系，用于按义原名称检索义原
/// </summary>
map<string,HownetPrimitive> m_oNamePrimitiveMap ;

/// <summary>
/// 存储每个义原的ID与其父义原的ID的对应关系，用于从低一级义原往上层回溯
/// </summary>
map<int,int> m_oIdParentMap ;

/// <summary>
/// 计算义原相似度的参数
/// </summary>
const double Alpha ;

/// <summary>
/// 当一个义原没有对应义原的时候，赋予一个默认值
/// </summary>
const double Gama ;

};

#endif // !defined(AFX_WORDRELVANCECALCULATOR_H__C5D16340_1E8E_450C_A65F_7101DA8D638C__INCLUDED_)

 

知网(HowNet)简介
08-01
知网(英文名称 HowNet)是一个以汉语和英语的词语所代表的概念为描述对象,以揭示概念与概念之间以及概念所具有的属性之间的关系为基本内容的常识知识库。
基于《知网》的词汇语义相似度计算以及复现
weixin_43592833的博客
06-30 2282
问题描述： “西红柿”和“茄子”这两个词，基于字面检测相似度为0，但是我们都知道它是一个东西，所以引入基于语义的相似度检测。 语义相似定义 两个任意的词语如果在不同的上下文中可以相互替换且不改变文本的语义的可能性越大，那么两者之间的相似度就越高，否则相似度就越低。 （参考文献：刘群，李素建，基于《知网》的词汇语义相似度计算，中文计算语言学，2002，7(2):59-76.） 语义距离 定义：数值在0到正无穷，0表示相似度为1，正无穷表示相似度为0。 检测方法： 1.基于世界知识。根据世界知识方法一般是利
python调用hownet API计算两个词的相似度
qq_31157999的博客
03-30 5401
1.注册成为知网用户，获取个人密匙。http://www.yuzhinlp.com2.python调用API代码：import requests import json def hownet_word_sim(word1,word2): data = {'apiKey':yourApiKey,'word1':word1,'word2':word2} url = 'http://yuzhinl...
转载：基于《知网》的词汇语义相似度计算
randy_01的博客
04-21 1222
转载：基于《知网》的词汇语义相似度计算 基于《知网》的词汇语义相似度计算[1] 刘群†‡李素建† {liuqun,lisujian}@ict.ac.cn † 中国科学院计算技术研究所 ‡ 北京大学计算语言学研究所 摘要： 《知网》是一部比较详尽的语义知识词典。在基于实例的机器翻译中，词语相似度计算是一个重要的环节。不过，由于《知网》中对于一个词的语...
HowNet介绍及相关API的使用方法
大数据开发、JAVA开发、人工智能AI
03-22 1万+
HowNet Introduction 知网(英文名称HowNet)，是一个以汉语和英语的词语所代表的的概念为描述对象，以揭示概念与概念之间以及概念所具有的属性之间的关系为基本内容的常识知识库。 HowNet是董振东先生、董强先生父子毕三十年之功标注的大型语言知识库，主要面向中文（也包括英文）的词汇与概念。HowNet秉承还原论思想，认为词汇/词义可以用更小的语义单位来描述。这种语义单位被称为“义原”（Sememe），顾名思义就是原子语义，即最基本的、不宜再分割的最小语义单位。在不断标注的过程中，HowNe
hownet相似度计算
10-13
关于知网相似度计算的ppt，以及如何实现基于知网的语义相似度
汉语词语语义相似度计算研究1
08-03
【汉语词语语义相似度计算】是中文信息处理领域中的核心任务，对于自动问答、情报检索、文本聚类等应用场景至关重要。传统的计算方法包括字面相似度算法和基于词素的相似度测定，但这些方法存在局限性，尤其是在处理...
基于语义相似度计算的词汇语义自动分类系统
04-15
另一种则是利用自动化手段，基于语义相似度计算来实现词汇的自动分类。 #### 二、基于语义相似度的词汇语义自动分类系统概述 本文介绍的是一种基于语义相似度计算的词汇语义自动分类系统。该系统采用了双向索引...
基于HowNet的词相似度计算
04-05
词相似度计算有重要应用在许多领域，例如自然语言处理，情报信息检索，文档聚类，自动应答， 词义歧义消除，机器翻译等。本文对基于词的相似度计算进行了深入研究知网和单词相似度的计算分为三个步骤：（1） 计算词素相似度，（2）计算概念相似度使用权重相似度的加权和方法，（3）取概念的最大相似度是单词相似度。 本文主要介绍对音素的编号，并介绍更多分解概念描述类型的准确方法。 这实验表明，提出了词相似度算法本文简单可行，计算结果为与意识相对一致。
python中文相似度_python文本相似度计算
weixin_39628041的博客
11-21 418
步骤分词、去停用词词袋模型向量化文本TF-IDF模型向量化文本LSI模型向量化文本计算相似度理论知识两篇中文文本，如何计算相似度？相似度是数学上的概念，自然语言肯定无法完成，所有要把文本转化为向量。两个向量计算相似度就很简单了，欧式距离、余弦相似度等等各种方法，只需要中学水平的数学知识。那么如何将文本表示成向量呢？词袋模型最简单的表示方法是词袋模型。把一篇文本想象成一个个词构成的，所有词放入一个袋...
基于多重继承与信息内容的知网词语相似度计算 - 论文及代码讲解
GreatXiang888的博客
01-08 421
论文：《基于多重继承与信息内容的知网词语相似度计算》-2017-张波，陈宏朝等 查看 代码：https://github.com/yaleimeng/Final_word_Similarity 总体感受： 太乱了，有可能是之前没怎么接触这块。 看论文，搞不懂怎么回事，义项、义原是啥，怎么这么多定义，到头来还是不懂两个词的相似度怎么计算，比哈工大词林那篇论文复杂多了。 看代码，函数调来调去，一会这个...
语义相似度的计算方法
panjiao119的博客
11-02 8285
词语的语义相似度计算主要有两种方法 ： 一类是通过语义词典，把有关词语的概念组织在一个树形的结构中来计算； 另一类主要是通过词语上下文的信息，运用统计的方法进行求解。  1. 语义相似度 Dekang Lin认为任何两个词语的相似度取决于它们的共性(Commonality)和个性(Differences)，然后从信息论的角度给出了定义公式： 其中，分子
matlab源代码 语义相似度计算,[转载][源代码]利用Hownet进行语义相似度计算的类...
weixin_29100927的博客
03-19 202
#if !defined HownetWord_H#define HownetWord_H/// ///Hownet的词的表示(只考虑四大部分而忽略概念，即具体词),与刘群算法不同，对于一个词的多次出现进行合并，因此所谓第一义原也不止一个/// class HownetWord{public:HownetWord(string strLine):word(""){char* token;token...
关于情感词典计算情感倾向强度值的两种方法
热门推荐
MrZhangZZ的博客
03-04 1万+
一、SO-HowNet      情感倾向强度值计算公式为： 其中，Pwords代表正面情感种子词语集合，Nwords代表负面种子词语集合。 word1和word2相似度就是各概念之间相似度的最大值。 计算两个义原相似度公式如下： 其中，p1,p2为两个需要计算比较的义原，Depth(p)是义原层次体系中的深度，Spd
HowNet
Guix
11-30 8838
目录知 网（HowNet） 1. 问题的提出 2. 知网的哲学 3. 知网的特色 4. 知网建设的方法 4.1. 义原的提取 4.2. 义原的考核与确定 5. 知网系统的概貌 5.1. 知网系统包括下列数据文件和程序 5.2. 知识词典的记录样式 5.2.1. 词语及其概念的选择 5.2.2. 关于词语的例子6. 概念定义的标注方法和规定 6.1
AAAI、IJCAI和ACL录用三名清华本科生成果，华人NLP最杰出HowNet成功融入DL模型
weixin_33955681的博客
01-10 531
什么是HowNet HowNet是董振东先生、董强先生父子毕数十年之功标注的大型语言知识库，主要面向中文（也包括英文）的词汇与概念[1]。 HowNet秉承还原论思想，认为词汇/词义可以用更小的语义单位来描述。这种语义单位被称为“义原”（Sememe），顾名思义就是原子语义，即最基本的、不宜再分割的最小语义单位。在不断标注的过程中，HowNet逐渐构建出...
文章学习_基于HowNet 的词汇语义倾向计算
啃啃木头
12-21 2698
  基于HowNet 的词汇语义倾向计算1、文章介绍了知网(HowNet)的基本情况2、文章利用知网的相识度和相关度计算来判别词语的褒贬性   1、文章介绍了知网(HowNet)的基本情况知网（HowNet）,www.keenage.com. ）是一个以汉语和英语的词语所代表的概念为描述对象，以揭示概念与概念之间以及概念所具有的属性之间的关系为基本内容的常识知识库。该数
基于Hownet的语义相似度计算方法与应用深度探讨
1. **概念之间的语义相似度计算方法**（SSBC，Semantic Similarity Between Concepts）：该方法充分利用本体中赋予概念的结构信息和语义信息，通过构建概念的语义扩展集来描述其特征，并借助模糊集合理论来衡量两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值