关于SimHash算法的实现及测试V4.0

@祁俊辉，2017年6月15日测试。

1  说明

• 本程序衔接关于SimHash算法的实现及测试V3.0；
• 改进1：增加TF-IDF算法，用于计算词权重（本地新增100篇txt文本库）；
• 改进2：各个程序衔接，详情见流程图。

2  程序

目前项目中存在4个类，分别是分词“FenCi”，计算某个词在多少个文档中出现过“TxtComparison”，计算TF-IDF值“TF_IDF”，计算SimHash值及相似度比较“SimHash128Txt”。

2.1  FenCi

/* 【函数作用】对指定txt文档分词，存入另一文档中
 * 【说明】1.该程序采用IK分词包（前向）进行分词
 * 【时间】祁俊辉->2017.6.9
 * */
import java.io.*;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.wltea.analyzer.lucene.IKAnalyzer;

public class FenCi {
    static String txt_ys = "./SimHash文档库/原始文档9.txt";
    static String txt_fch = "./SimHash文档库/分词后文档9.txt";
    static String txt_zh = "./SimHash文档库/最终文档9.txt";
    
    //输入字符串，输出分词后的字符串
    public static String Seg(String sentence) throws IOException {
        String text="";
        //创建分词对象
        Analyzer anal=new IKAnalyzer(true);
        StringReader reader=new StringReader(sentence);
        //分词
        TokenStream ts=anal.tokenStream("", reader);
        CharTermAttribute term=ts.getAttribute(CharTermAttribute.class);
        //遍历分词数据
        while(ts.incrementToken()){
            text+=term.toString()+"/";
        }
        reader.close();
        anal.close();
        return text.trim()+"
";
    }

    public static void main(String[] args) {
        File file_ys = new File(FenCi.txt_ys);//原始文件
        File file_fch = new File(FenCi.txt_fch);//分词后文件
        try {
            FileReader fr = new FileReader(file_ys);
            BufferedReader bufr = new BufferedReader(fr);
            FileWriter fw = new FileWriter(file_fch);
            BufferedWriter bufw = new BufferedWriter(fw);
            String s = null;
            int i = 0;
            while((s = bufr.readLine()) != null) {
                i++;
                String s_fch = FenCi.Seg(s);
                System.out.println("第"+i+"行的原始数据：");
                System.out.println(s);
                System.out.println("第"+i+"行分词后的结果：");
                System.out.println(s_fch);
                bufw.write(s_fch);
                bufw.newLine();
            }
            bufr.close();
            fr.close();
            bufw.close();
            fw.close();
            System.out.println("文件处理完毕，已生成该文档的分词后文档！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2  TxtComparison

/* 【函数作用】判断str字符串在多少个文档中出现过
 * 【说明】1.目前文件库有100篇文档，查找总耗时小于1秒
 * 【说明】2.调用时，用"TxtComparison.Txt(str)"，返回值为(出现次数+1)
 * 【说明】3.之所以加1，是因为如果该词在文件库没有出现，则计算IDF值时会出错
 * 【时间】祁俊辉->2017.6.14
 * */
import java.io.*;

public class TxtComparison {
    public static int Txt(String str) {
        int text_num = 0;//定义总出现次数
        for(int i=0; i<100; i++){//遍历100篇文档
            String filename = "./SimHash文档库/文件库/参考文档";
            filename += (i+".txt");//组合定义文件路径及文件名
            File file_name = new File(filename);//创建文件路径
            try {
                InputStreamReader isr = new InputStreamReader(new FileInputStream(file_name),"UTF-8");
                //编码方式UTF-8，防止中文乱码
                BufferedReader bufr = new BufferedReader(isr);
                String s = null;//临时存储每行数据
                boolean num = false;//临时存储目标文档是否含有指定字符串
                while((s = bufr.readLine()) != null) {//遍历目标文档每行
                    //System.out.println(s);
                    if(s.contains(str)){//如果含有指定字符串
                        //System.out.println("第" + i + "篇文章中有");
                        num = true;//标志位赋值
                        break;//退出（节省时间）
                    }
                }
                bufr.close();
                isr.close();
                if(num) {//根据标志位状态，让总出现次数增加
                    text_num ++;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return text_num+1;//返回总出现次数+1
    }
}

2.3  TF_IDF

/* 【函数作用】计算分词后的文档各词的IF-IDF值
 * 【说明】1.目前文件库有100篇文档，查找总耗时小于1秒
 * 【说明】2.调用时，用"TxtComparison.Txt(str)"，返回值为(出现次数+1)
 * 【说明】3.之所以加1，是因为如果该词在文件库没有出现，则计算IDF值时会出错
 * 【时间】祁俊辉->2017.6.14
 * */
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class TF_IDF {
    
    public static void main(String[] args) throws IOException {
        //生成的最终文件
        File file_zh = new File(FenCi.txt_zh);//最终文件
        FileWriter fw = new FileWriter(file_zh);
        BufferedWriter bufw = new BufferedWriter(fw);
        //对分词后的文档进行处理
        String s = SimHash128Txt.Txt_read(FenCi.txt_fch);
        String[] WordArray = s.split("/");
        
        for(int i=0; i<WordArray.length; i++){//遍历每个词
            /*第一步：计算TF值*/
            int TF_Fre = 0;//定义频率为0
            //计算每个词的频率
            for(int j=0; j<WordArray.length; j++){
                if(WordArray[i].equals(WordArray[j])){
                    TF_Fre++;
                }
            }
            //频率归一化
            float TF = (float) (1.0*TF_Fre/WordArray.length);
            //System.out.println(WordArray[i]+"的TF值为"+TF);
            /*第二步：计算IDF值*/
            //计算每个词在文件库出现的文件数
            int IDF_a = TxtComparison.Txt(WordArray[i]);
            //System.out.println(WordArray[i]+"在文件库中出现了"+IDF_a);
            //总文件数  除以  该词在文件库中出现的次数
            float IDF_b = (float) (101.0/IDF_a);
            //System.out.println(IDF_b);
            //IDF = log 2 (IDF_b)
            float IDF = (float) (Math.log(IDF_b)/Math.log(2));
            //System.out.println(WordArray[i]+"的IDF值为"+IDF);
            /*第三步：计算TF-IDF值*/
            float TFIDF = TF * IDF;
            System.out.println(WordArray[i]+"的TF-IDF值为"+TFIDF);
            /*第四步：将计算结果写入txt文件*/
            bufw.write(WordArray[i] + "##" + TFIDF + "/");
            bufw.newLine();
        }
        bufw.close();
        fw.close();
        System.out.println("文件处理完毕，已生成该文档的最终文档！");
    }
}

2.4  SimHash128Txt

/* 【算法】SimHash->128位
 * 【说明】1.加上权重（TF-IDF值）
 * 【说明】2.经IK分词后，将分词后的文件存储，该程序进行读取
 * 【时间】祁俊辉->2017.6.15
 * */

import java.io.*;
import java.math.BigInteger;
import java.security.MessageDigest;

public class SimHash128Txt {
    //以下两个文档为新增文档，两段话，检测相似度
    static String s9 = SimHash128Txt.Txt_read("./SimHash文档库/最终文档9.txt");
    static String s10 = SimHash128Txt.Txt_read("./SimHash文档库/最终文档10.txt");
    /* 函数名：Txt_read(String name)
     * 功能：读取name文件的内容，name为txt文件名
     * */
    static String Txt_read(String name){
        String s = "";
        File file = new File(name);//原始文件
        try {
            FileReader fr = new FileReader(file);
            BufferedReader bufr = new BufferedReader(fr);
            String s_x = null;
            //int i = 0;
            while((s_x = bufr.readLine()) != null) {
                //i++;
                //System.out.println("第"+i+"行的原始数据：");
                s += s_x;
            }
            bufr.close();
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return s;
    }
    /* 函数名：MD5_Hash(String str)
     * 功能：计算字符串str的128位hash值，并将其以String型返回
     * */
    static String MD5_Hash(String str){
        try{
            // 生成一个MD5加密计算摘要
            MessageDigest md = MessageDigest.getInstance("MD5");
            // 计算md5函数
            //System.out.println("字符串:"+str);
            //System.out.println("字符串的MD5_Hash:"+md.digest(str.getBytes()));
            // digest()最后确定返回md5 hash值，返回值为8为字符串。因为md5 hash值是16位的hex值，实际上就是8位的字符
            // BigInteger函数则将8位的字符串转换成16位hex值，用字符串来表示；得到字符串形式的hash值
            return new BigInteger(1,md.digest(str.getBytes("UTF-8"))).toString(2);
        }catch(Exception e){
            e.printStackTrace();
            return str;
        }
    }
    /* 函数名：First_FC(String str)
     * 功能：1.先创建一个存储SimHash值的128数组，并初始化为0
     * 功能：2.将str字符串分词，并存入临时数组
     * 功能：3.计算此字符串的SimHash值（加权、但没有降维），存储在数组中
     * 功能：4.将数组中的SimHash值降维，并以字符串形式返回
     * */
    static String First_FC(String str){
        //1.先创建一个存储SimHash值的128数组，并初始化为0
        float Hash_SZ[] = new float[128];
        for(int i=0;i<Hash_SZ.length;i++)
            Hash_SZ[i]=0;
        //2.将str字符串分词，并将词和权重存入临时数组
        String[] word_and_tfidf = str.split("/");//先分割
        String[] word = new String[word_and_tfidf.length];//创建一个词数组，大小为词个数
        String[] tfidf = new String[word_and_tfidf.length];//创建一个权重数组，大小为词个数
        //分割词，存入数组
        for(int i=0; i<word_and_tfidf.length; i++){
            String[] linshi = word_and_tfidf[i].split("##");
            word[i] = linshi[0];
            tfidf[i] = linshi[1];
            //System.out.println(word[i]+" "+tfidf[i]);
        }
        //3.计算此字符串的SimHash值（加权、但没有降维），存储在数组中
        for(int i=0;i<word.length;i++){//循环传入字符串的每个词
            String str_hash = SimHash128Txt.MD5_Hash(word[i]);//先计算每一个词的Hash值（128位）
            //MD5哈希计算时，二进制转换若最高位为7以下，也就是转换成二进制最高位为0，会不存储该0，导致后面程序出错
            //这里主要是为了保证它是128位的二进制
            if(str_hash.length() < 128){
                int que = 128 - str_hash.length();
                for(int j=0;j<que;j++){
                    str_hash = "0" + str_hash;
                }
            }
            //System.out.println(str_hash);//输出该词的128位MD5哈希值
            char str_hash_fb[]=str_hash.toCharArray();//将该词的哈希值转为数组，方便检查
            //对每个词的Hash值（128位）求j位是1还是0,1的话加上该词的权重，0的话减去该词的权重
            for(int j=0;j<Hash_SZ.length;j++){
                if(str_hash_fb[j] == '1'){
                    Hash_SZ[j] += Float.parseFloat(tfidf[i]);//Hash_SZ中，0是最高位，依次排低
                }else{
                    Hash_SZ[j] -= Float.parseFloat(tfidf[i]);
                }
            }
        }
        //4.将数组中的SimHash值降维，并以字符串形式返回
        String SimHash_number="";//存储SimHash值
        for(int i=0;i<Hash_SZ.length;i++){//从高位到低位
            System.out.print(Hash_SZ[i]+" ");//输出未降维的串
            if(Hash_SZ[i]<=0)//小于等于0，就取0
                SimHash_number += "0";
            else//大于0，就取1
                SimHash_number += "1";
        }
        System.out.println("");//换行
        return SimHash_number;
    }
    /* 函数名：HMJL(String a,String b)
     * 功能：a、b都是以String存储的二进制数，计算他们的海明距离，并将其返回
     * */
    static int HMJL(String a,String b){
        char[] FW1 = a.toCharArray();//将a每一位都存入数组中
        char[] FW2 = b.toCharArray();//将b每一位都存入数组中
        int haiming=0;
        if(FW1.length == FW2.length){//确保a和b的位数是相同的
            for(int i=0;i<FW1.length;i++){
                if(FW1[i] != FW2[i])//如果该位不同，海明距离加1
                    haiming++;
            }
        }
        return haiming;
    }
    
    public static void main(String[] args) {
        String a9 = SimHash128Txt.First_FC(s9);
        String a10 = SimHash128Txt.First_FC(s10);
        System.out.println("【s9】的SimHash值为："+a9);
        System.out.println("【s10】的SimHash值为："+a10);
        System.out.println("【s9】和【s10】的海明距离为：" + SimHash128Txt.HMJL(a9,a10) + "，相似度为：" + (100-SimHash128Txt.HMJL(a9,a10)*100/128)+"%");
    }
}

3  测试结果

3.1  文件说明

100篇文档（现代小说）：

生成的文档（1篇待比较文本有3个文档：原始、分词后、最终）：

3.2  输出结果