關於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()+"\n";
    }

    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  輸出結果