使用simhash以及海明距离判断内容相似程度

算法实现

packagecom.emcc.changedig.extractengine.util;

/**
*Function:simHash判断文本相似度，该示例程支持中文<br/>
*date:2013-8-6上午1:11:48<br/>
*@authorjune
*@version0.1
*/
importjava.io.IOException;
importjava.math.BigInteger;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;

importcom.hankcs.hanlp.seg.common.Term;

publicclassSimHash
{
privateStringtokens;

privateBigIntegerintSimHash;

privateStringstrSimHash;

privateinthashbits=64;

publicSimHash(Stringtokens)throwsIOException
{
this.tokens=tokens;
this.intSimHash=this.simHash();
}

publicSimHash(Stringtokens,inthashbits)throwsIOException
{
this.tokens=tokens;
this.hashbits=hashbits;
this.intSimHash=this.simHash();
}

HashMap<String,Integer>wordMap=newHashMap<String,Integer>();

publicBigIntegersimHash()throwsIOException
{
//定义特征向量/数组
int[]v=newint[this.hashbits];

Stringword=null;
List<Term>terms=SegmentationUtil.ppl(this.tokens);
for(Termterm:terms)
{
word=term.word;

//将每一个分词hash为一组固定长度的数列.比如64bit的一个整数.
BigIntegert=this.hash(word);
for(inti=0;i<this.hashbits;i++)
{
BigIntegerbitmask=newBigInteger("1").shiftLeft(i);

//建立一个长度为64的整数数组(假设要生成64位的数字指纹,也可以是其它数字),
//对每一个分词hash后的数列进行判断,如果是1000...1,那么数组的第一位和末尾一位加1,
//中间的62位减一,也就是说,逢1加1,逢0减1.一直到把所有的分词hash数列全部判断完毕.
if(t.and(bitmask).signum()!=0)
{
//这里是计算整个文档的所有特征的向量和
//这里实际使用中需要+-权重，比如词频，而不是简单的+1/-1，
v[i]+=1;
}
else
{
v[i]-=1;
}
}
}

BigIntegerfingerprint=newBigInteger("0");
StringBuffersimHashBuffer=newStringBuffer();
for(inti=0;i<this.hashbits;i++)
{
//4、最后对数组进行判断,大于0的记为1,小于等于0的记为0,得到一个64bit的数字指纹/签名.
if(v[i]>=0)
{
fingerprint=fingerprint.add(newBigInteger("1").shiftLeft(i));
simHashBuffer.append("1");
}
else
{
simHashBuffer.append("0");
}
}
this.strSimHash=simHashBuffer.toString();
returnfingerprint;
}

privateBigIntegerhash(Stringsource)
{
if(source==null||source.length()==0)
{
returnnewBigInteger("0");
}
else
{
char[]sourceArray=source.toCharArray();
BigIntegerx=BigInteger.valueOf(((long)sourceArray[0])<<7);
BigIntegerm=newBigInteger("1000003");
BigIntegermask=newBigInteger("2").pow(this.hashbits).subtract(
newBigInteger("1"));
for(charitem:sourceArray)
{
BigIntegertemp=BigInteger.valueOf((long)item);
x=x.multiply(m).xor(temp).and(mask);
}
x=x.xor(newBigInteger(String.valueOf(source.length())));
if(x.equals(newBigInteger("-1")))
{
x=newBigInteger("-2");
}
returnx;
}
}

/**
*计算海明距离
*
*@paramother
*被比较值
*@return海明距离
*/
publicinthammingDistance(SimHashother)
{

BigIntegerx=this.intSimHash.xor(other.intSimHash);
inttot=0;

while(x.signum()!=0)
{
tot+=1;
x=x.and(x.subtract(newBigInteger("1")));
}
returntot;
}

publicintgetDistance(Stringstr1,Stringstr2)
{
intdistance;
if(str1.length()!=str2.length())
{
distance=-1;
}
else
{
distance=0;
for(inti=0;i<str1.length();i++)
{
if(str1.charAt(i)!=str2.charAt(i))
{
distance++;
}
}
}
returndistance;
}

publicList<BigInteger>subByDistance(SimHashsimHash,intdistance)
{
//分成几组来检查
intnumEach=this.hashbits/(distance+1);
List<BigInteger>characters=newArrayList<BigInteger>();

StringBufferbuffer=newStringBuffer();

for(inti=0;i<this.intSimHash.bitLength();i++)
{
//当且仅当设置了指定的位时，返回true
booleansr=simHash.intSimHash.testBit(i);

if(sr)
{
buffer.append("1");
}
else
{
buffer.append("0");
}

if((i+1)%numEach==0)
{
//将二进制转为BigInteger
BigIntegereachValue=newBigInteger(buffer.toString(),2);
buffer.delete(0,buffer.length());
characters.add(eachValue);
}
}

returncharacters;
}

publicstaticvoidmain(String[]args)throwsIOException
{
Strings="传统的hash算法只负责将原始内容尽量均匀随机地映射为一个签名值，"
+"原理上相当于伪随机数产生算法。产生的两个签名，如果相等，说明原始内容在一定概率下是相等的；"
+"如果不相等，除了说明原始内容不相等外，不再提供任何信息，因为即使原始内容只相差一个字节，"
+"所产生的签名也很可能差别极大。从这个意义上来说，要设计一个hash算法，"
+"对相似的内容产生的签名也相近，是更为艰难的任务，因为它的签名值除了提供原始内容是否相等的信息外，"
+"还能额外提供不相等的原始内容的差异程度的信息。";
SimHashhash1=newSimHash(s,64);

//删除首句话，并加入两个干扰串
s="原理上相当于伪随机数产生算法。产生的两个签名，如果相等，说明原始内容在一定概率下是相等的；"
+"如果不相等，除了说明原始内容不相等外，不再提供任何信息，因为即使原始内容只相差一个字节，"
+"所产生的签名也很可能差别极大。从这个意义上来说，要设计一个hash算法，"
+"对相似的内容产生的签名也相近，是更为艰难的任务，因为它的签名值除了提供原始内容是否相等的信息外，"
+"干扰1还能额外提供不相等的原始内容的差异程度的信息。";
SimHashhash2=newSimHash(s,64);

//首句前添加一句话，并加入四个干扰串
s="imhash算法的输入是一个向量，输出是一个f位的签名值。为了陈述方便，"
+"假设输入的是一个文档的特征集合，每个特征有一定的权重。"
+"传统干扰4的hash算法只负责将原始内容尽量均匀随机地映射为一个签名值，"
+"原理上这次差异有多大呢3相当于伪随机数产生算法。产生的两个签名，如果相等，"
+"说明原始内容在一定概率下是相等的；如果不相等，除了说明原始内容不相等外，不再提供任何信息，"
+"因为即使原始内容只相差一个字节，所产生的签名也很可能差别极大。从这个意义上来说，"
+"要设计一个hash算法，对相似的内容产生的签名也相近，是更为艰难的任务，因为它的签名值除了提供原始"
+"内容是否相等的信息外，干扰1还能额外提供不相等的原始再来干扰2内容的差异程度的信息。";
SimHashhash3=newSimHash(s,64);

intdis12=hash1.getDistance(hash1.strSimHash,hash2.strSimHash);
System.out.println(hash1.strSimHash);
System.out.println(hash2.strSimHash);
System.out.println(dis12);

System.out.println("============================================");

intdis13=hash1.getDistance(hash1.strSimHash,hash3.strSimHash);

System.out.println(hash1.strSimHash);
System.out.println(hash3.strSimHash);
System.out.println(dis13);
}
}