傳統的 hash 演算法只負責將原始內容儘量均勻隨機地對映為一個簽名值，原理上相當於偽隨機數產生演算法。產生的兩個簽名，如果相等，說明原始內容在一定概 率 下是相等的；如果不相等，除了說明原始內容不相等外，不再提供任何資訊，因為即使原始內容只相差一個位元組，所產生的簽名也很可能差別極大。從這個意義 上來 說，要設計一個 hash 演算法，對相似的內容產生的簽名也相近，是更為艱難的任務，因為它的簽名值除了提供原始內容是否相等的資訊外，還能額外提供不相等的 原始內容的差異程度的資訊。
而 Google 的 simhash 演算法產生的簽名，可以滿足上述要求。出人意料，這個演算法並不深奧，其思想是非常清澈美妙的。

1、Simhash 演算法簡介

simhash演算法的輸入是一個向量，輸出是一個 f 位的簽名值。為了陳述方便，假設輸入的是一個文件的特徵集合，每個特徵有一定的權重。比如特徵可以是文件中的詞，其權重可以是這個詞出現的次數。 simhash 演算法如下：
1，將一個 f 維的向量 V 初始化為 0 ； f 位的二進位制數 S 初始化為 0 ；
2，對每一個特徵：用傳統的 hash 演算法對該特徵產生一個 f 位的簽名 b 。對 i=1 到 f ：
如果b 的第 i 位為 1 ，則 V 的第 i 個元素加上該特徵的權重；
否則，V 的第 i 個元素減去該特徵的權重。 
3，如果 V 的第 i 個元素大於 0 ，則 S 的第 i 位為 1 ，否則為 0 ；
4，輸出 S 作為簽名。

2、演算法幾何意義和原理

這個演算法的幾何意義非常明瞭。它首先將每一個特徵對映為f維空間的一個向量，這個對映規則具體是怎樣並不重要，只要對很多不同的特徵來說，它們對所對應的向量是均勻隨機分佈的，並且對相同的特徵來說對應的向量是唯一的就行。比如一個特徵的4位hash簽名的二進位制表示為1010，那麼這個特徵對應的 4維向量就是(1, -1, 1, -1)T，即hash簽名的某一位為1，對映到的向量的對應位就為1，否則為-1。然後，將一個文件中所包含的各個特徵對應的向量加權求和，加權的係數等於該特徵的權重。得到的和向量即表徵了這個文件，我們可以用向量之間的夾角來衡量對應文件之間的相似度。最後，為了得到一個f位的簽名，需要進一步將其壓縮，如果和向量的某一維大於0，則最終簽名的對應位為1，否則為0。這樣的壓縮相當於只留下了和向量所在的象限這個資訊，而64位的簽名可以表示多達264個象限，因此只儲存所在象限的資訊也足夠表徵一個文件了。

明確了演算法了幾何意義，使這個演算法直觀上看來是合理的。但是，為何最終得到的簽名相近的程度，可以衡量原始文件的相似程度呢？這需要一個清晰的思路和證明。在simhash的發明人Charikar的論文中[2]並沒有給出具體的simhash演算法和證明，以下列出我自己得出的證明思路。

Simhash是由隨機超平面hash演算法演變而來的，隨機超平面hash演算法非常簡單，對於一個n維向量v，要得到一個f位的簽名(f<<n)，演算法如下：
1，隨機產生f個n維的向量r1,…rf；
2，對每一個向量ri，如果v與ri的點積大於0，則最終簽名的第i位為1，否則為0.

這個演算法相當於隨機產生了f個n維超平面，每個超平面將向量v所在的空間一分為二，v在這個超平面上方則得到一個1，否則得到一個0，然後將得到的 f個0或1組合起來成為一個f維的簽名。如果兩個向量u, v的夾角為θ，則一個隨機超平面將它們分開的概率為θ/π，因此u, v的簽名的對應位不同的概率等於θ/π。所以，我們可以用兩個向量的簽名的不同的對應位的數量，即漢明距離，來衡量這兩個向量的差異程度。

Simhash演算法與隨機超平面hash是怎麼聯絡起來的呢？在simhash演算法中，並沒有直接產生用於分割空間的隨機向量，而是間接產生的：第 k個特徵的hash簽名的第i位拿出來，如果為0，則改為-1，如果為1則不變，作為第i個隨機向量的第k維。由於hash簽名是f位的，因此這樣能產生 f個隨機向量，對應f個隨機超平面。下面舉個例子：
假設用5個特徵w1,…,w5來表示所有文件，現要得到任意文件的一個3維簽名。假設這5個特徵對應的3維向量分別為：
h(w1) = (1, -1, 1)T
h(w2) = (-1, 1, 1)T
h(w3) = (1, -1, -1)T
h(w4) = (-1, -1, 1)T
h(w5) = (1, 1, -1)T

按simhash演算法，要得到一個文件向量d=(w1=1, w2=2, w3=0, w4=3, w5=0) T的簽名，

先要計算向量m = 1*h(w1) + 2*h(w2) + 0*h(w3) + 3*h(w4) + 0*h(w5) = (-4, -2, 6) T，
然後根據simhash演算法的步驟3，得到最終的簽名s=001。

上面的計算步驟其實相當於，先得到3個5維的向量，第1個向量由h(w1),…,h(w5)的第1維組成：

r1=(1,-1,1,-1,1) T；
第2個5維向量由h(w1),…,h(w5)的第2維組成：
r2=(-1,1,-1,-1,1) T；
同理，第3個5維向量為：
r3=(1,1,-1,1,-1) T.
按隨機超平面演算法的步驟2，分別求向量d與r1,r2,r3的點積:
d T r1=-4 < 0，所以s1=0;
d T r2=-2 < 0，所以s2=0;
d T r3=6 > 0，所以s3=1.
故最終的簽名s=001，與simhash演算法產生的結果是一致的。

從上面的計算過程可以看出，simhash演算法其實與隨機超平面hash演算法是相同的，simhash演算法得到的兩個簽名的漢明距離，可以用來衡量原始向量的夾角。這其實是一種降維技術，將高維的向量用較低維度的簽名來表徵。衡量兩個內容相似度，需要計算漢明距離，這對給定簽名查詢相似內容的應用來說帶來了一些計算上的困難；我想，是否存在更為理想的simhash演算法，原始內容的差異度，可以直接由簽名值的代數差來表示呢？

3、比較相似度

海明距離： 兩個碼字的對應位元取值不同的位元數稱為這兩個碼字的海明距離。一個有效編碼集中, 任意兩個碼字的海明距離的最小值稱為該編碼集的海明距離。舉例如下： 10101 和 00110 從第一位開始依次有第一位、第四、第五位不同，則海明距離為 3.

異或： 只有在兩個比較的位不同時其結果是1 ，否則結果為 0 

對每篇文件根據SimHash 算出簽名後，再計算兩個簽名的海明距離（兩個二進位制異或後 1 的個數）即可。根據經驗值，對 64 位的 SimHash ，海明距離在 3 以內的可以認為相似度比較高。
假設對64 位的 SimHash ，我們要找海明距離在 3 以內的所有簽名。我們可以把 64 位的二進位制簽名均分成 4塊，每塊 16 位。根據鴿巢原理（也成抽屜原理，見組合數學），如果兩個簽名的海明距離在 3 以內，它們必有一塊完全相同。
我們把上面分成的4 塊中的每一個塊分別作為前 16 位來進行查詢。 建立倒排索引。

如果庫中有2^34 個（大概 10 億）簽名，那麼匹配上每個塊的結果最多有 2^(34-16)=262144 個候選結果(假設資料是均勻分佈， 16 位的資料，產生的像限為 2^16 個，則平均每個像限分佈的文件數則 2^34/2^16 = 2^(34-16))，四個塊返回的總結果數為 4* 262144 （大概 100 萬）。原本需要比較 10 億次，經過索引，大概就只需要處理 100 萬次了。由此可見，確實大大減少了計算量。 

4、示例

程式碼1：

import java.io.IOException;
import java.io.StringReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;


/**
 * 
* @ProjectName gppos
* @ClassName SimHash 
* @Description TODO(判斷文字相似度，只支援中文) 
* @author makang
* @date 2016-5-27 下午4:57:56 
* @version V1.0
 */
public class SimHash {
private String tokens;
    private BigInteger intSimHash;
    private String strSimHash;
    private int hashbits = 64;
    public SimHash(String tokens) throws IOException {
        this.tokens = tokens;
        this.intSimHash = this.simHash();
    }
    public SimHash(String tokens, int hashbits) throws IOException {
        this.tokens = tokens;
        this.hashbits = hashbits;
        this.intSimHash = this.simHash();
    }
    HashMap<String, Integer> wordMap = new HashMap<String, Integer>();
    public BigInteger simHash() throws IOException {
        // 定義特徵向量/陣列
        int[] v = new int[this.hashbits];
        // 英文分詞
        // StringTokenizer stringTokens = new StringTokenizer(this.tokens);
        // while (stringTokens.hasMoreTokens()) {
        // String temp = stringTokens.nextToken();
        // }
        // 1、中文分詞，分詞器採用 IKAnalyzer3.2.8 ，僅供演示使用，新版 API 已變化。
        StringReader reader = new StringReader(this.tokens);
        // 當為true時，分詞器進行最大詞長切分
        IKSegmenter ik = new IKSegmenter(reader, true);
        Lexeme lexeme = null;
        String word = null;
       // String temp = null;
        while ((lexeme = ik.next()) != null) {
            word = lexeme.getLexemeText();
            // 注意停用詞會被幹掉
            // System.out.println(word);
            // 2、將每一個分詞hash為一組固定長度的數列.比如 64bit 的一個整數.
            BigInteger t = this.hash(word);
            for (int i = 0; i < this.hashbits; i++) {
                BigInteger bitmask = new BigInteger("1").shiftLeft(i);
                // 3、建立一個長度為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;
                }
            }
        }


        BigInteger fingerprint = new BigInteger("0");
        StringBuffer simHashBuffer = new StringBuffer();
        for (int i = 0; i < this.hashbits; i++) {
            // 4、最後對陣列進行判斷,大於0的記為1,小於等於0的記為0,得到一個 64bit 的數字指紋/簽名.
            if (v[i] >= 0) {
                fingerprint = fingerprint.add(new BigInteger("1").shiftLeft(i));
                simHashBuffer.append("1");
            } else {
                simHashBuffer.append("0");
            }
        }
        this.strSimHash = simHashBuffer.toString();
        System.out.println(this.strSimHash + " length " + this.strSimHash.length());
        return fingerprint;
    }


    private BigInteger hash(String source) {
        if (source == null || source.length() == 0) {
            return new BigInteger("0");
        } else {
            char[] sourceArray = source.toCharArray();
            BigInteger x = BigInteger.valueOf(((long) sourceArray[0]) << 7);
            BigInteger m = new BigInteger("1000003");
            BigInteger mask = new BigInteger("2").pow(this.hashbits).subtract(new BigInteger("1"));
            for (char item : sourceArray) {
                BigInteger temp = BigInteger.valueOf((long) item);
                x = x.multiply(m).xor(temp).and(mask);
            }
            x = x.xor(new BigInteger(String.valueOf(source.length())));
            if (x.equals(new BigInteger("-1"))) {
                x = new BigInteger("-2");
            }
            return x;
        }
    }


    public int hammingDistance(SimHash other) {


        BigInteger x = this.intSimHash.xor(other.intSimHash);
        int tot = 0;


        // 統計x中二進位制位數為1的個數
        // 我們想想，一個二進位制數減去1，那麼，從最後那個1（包括那個1）後面的數字全都反了，
        // 對吧，然後，n&(n-1)就相當於把後面的數字清0，
        // 我們看n能做多少次這樣的操作就OK了。


        while (x.signum() != 0) {
            tot += 1;
            x = x.and(x.subtract(new BigInteger("1")));
        }
        return tot;
    }


    public int getDistance(String str1, String str2) {
        int distance;
        if (str1.length() != str2.length()) {
            distance = -1;
        } else {
            distance = 0;
            for (int i = 0; i < str1.length(); i++) {
                if (str1.charAt(i) != str2.charAt(i)) {
                    distance++;
                }
            }
        }
        return distance;
    }


    public List<Object> subByDistance(SimHash simHash, int distance) {
        // 分成幾組來檢查
        int numEach = this.hashbits / (distance + 1);
        List<Object> characters = new ArrayList<Object>();


        StringBuffer buffer = new StringBuffer();


       // int k = 0;
        for (int i = 0; i < this.intSimHash.bitLength(); i++) {
            // 當且僅當設定了指定的位時，返回 true
            boolean sr = simHash.intSimHash.testBit(i);


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


            if ((i + 1) % numEach == 0) {
                // 將二進位制轉為BigInteger
                BigInteger eachValue = new BigInteger(buffer.toString(), 2);
                System.out.println("----" + eachValue);
                buffer.delete(0, buffer.length());
                characters.add(eachValue);
            }
        }


        return characters;
    }


    public static void main(String[] args) throws IOException {
        String s = "傳統的 hash 演算法只負責將原始內容儘量均勻隨機地對映為一個簽名值，" 
                + "原理上相當於偽隨機數產生演算法。產生的兩個簽名，如果相等，說明原始內容在一定概 率 下是相等的；"
                + "如果不相等，除了說明原始內容不相等外，不再提供任何資訊，因為即使原始內容只相差一個位元組，" 
                + "所產生的簽名也很可能差別極大。從這個意義 上來 說，要設計一個 hash 演算法，"
                + "對相似的內容產生的簽名也相近，是更為艱難的任務，因為它的簽名值除了提供原始內容是否相等的資訊外，" 
                + "還能額外提供不相等的 原始內容的差異程度的資訊。";
        SimHash hash1 = new SimHash(s, 64);
        System.out.println(hash1.intSimHash + "  " + hash1.intSimHash.bitLength());
        // 計算 海明距離 在 3 以內的各塊簽名的 hash 值
        hash1.subByDistance(hash1, 3);


        // 刪除首句話，並加入兩個干擾串
        s = "原理上相當於偽隨機數產生演算法。產生的兩個簽名，如果相等，說明原始內容在一定概 率 下是相等的；"
                + "如果不相等，除了說明原始內容不相等外，不再提供任何資訊，因為即使原始內容只相差一個位元組，" 
                + "所產生的簽名也很可能差別極大。從這個意義 上來 說，要設計一個 hash 演算法，"
                + "對相似的內容產生的簽名也相近，是更為艱難的任務，因為它的簽名值除了提供原始內容是否相等的資訊外，" 
                + "干擾1還能額外提供不相等的 原始內容的差異程度的資訊。";
        SimHash hash2 = new SimHash(s, 64);
        System.out.println(hash2.intSimHash + "  " + hash2.intSimHash.bitCount());
        hash1.subByDistance(hash2, 3);


        // 首句前新增一句話，並加入四個干擾串
        s = "imhash演算法的輸入是一個向量，輸出是一個 f 位的簽名值。為了陳述方便，" 
                + "假設輸入的是一個文件的特徵集合，每個特徵有一定的權重。"
                + "傳統干擾4的 hash 演算法只負責將原始內容儘量均勻隨機地對映為一個簽名值，" 
                + "原理上這次差異有多大呢3相當於偽隨機數產生演算法。產生的兩個簽名，如果相等，"
                + "說明原始內容在一定概 率 下是相等的；如果不相等，除了說明原始內容不相等外，不再提供任何資訊，"
                + "因為即使原始內容只相差一個位元組，所產生的簽名也很可能差別極大。從這個意義 上來 說，"
                + "要設計一個 hash 演算法，對相似的內容產生的簽名也相近，是更為艱難的任務，因為它的簽名值除了提供原始"
                + "內容是否相等的資訊外，干擾1還能額外提供不相等的 原始再來干擾2內容的差異程度的資訊。";
        SimHash hash3 = new SimHash(s, 64);
        System.out.println(hash3.intSimHash + "  " + hash3.intSimHash.bitCount());
        hash1.subByDistance(hash3, 3);


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


        int dis = hash1.getDistance(hash1.strSimHash, hash2.strSimHash);
        System.out.println(hash1.hammingDistance(hash2) + " " + dis);
        // 根據鴿巢原理（也成抽屜原理，見組合數學），如果兩個簽名的海明距離在 3 以內，它們必有一塊簽名subByDistance()完全相同。
        int dis2 = hash1.getDistance(hash1.strSimHash, hash3.strSimHash);
        System.out.println(hash1.hammingDistance(hash3) + " " + dis2);
    }
} 程式碼2：

/**
 * Function: 注：該示例程式暫不支援中文

 * Date:     2013-8-4 下午11:01:45 

 * @author   june: [email protected]
 */
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.StringTokenizer;

public class SimHash {

	private String tokens;

	private BigInteger intSimHash;

	private String strSimHash;

	private int hashbits = 64;

	public SimHash(String tokens) {
		this.tokens = tokens;
		this.intSimHash = this.simHash();
	}

	public SimHash(String tokens, int hashbits) {
		this.tokens = tokens;
		this.hashbits = hashbits;
		this.intSimHash = this.simHash();
	}

	HashMap wordMap = new HashMap();

	public BigInteger simHash() {
		// 定義特徵向量/陣列
		int[] v = new int[this.hashbits];
		// 1、將文字去掉格式後, 分詞.
		StringTokenizer stringTokens = new StringTokenizer(this.tokens);
		while (stringTokens.hasMoreTokens()) {
			String temp = stringTokens.nextToken();
			// 2、將每一個分詞hash為一組固定長度的數列.比如 64bit 的一個整數.
			BigInteger t = this.hash(temp);
			for (int i = 0; i < this.hashbits; i++) {
				BigInteger bitmask = new BigInteger("1").shiftLeft(i);
				// 3、建立一個長度為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;
				}
			}
		}
		BigInteger fingerprint = new BigInteger("0");
		StringBuffer simHashBuffer = new StringBuffer();
		for (int i = 0; i < this.hashbits; i++) {
			// 4、最後對陣列進行判斷,大於0的記為1,小於等於0的記為0,得到一個 64bit 的數字指紋/簽名.
			if (v[i] >= 0) {
				fingerprint = fingerprint.add(new BigInteger("1").shiftLeft(i));
				simHashBuffer.append("1");
			} else {
				simHashBuffer.append("0");
			}
		}
		this.strSimHash = simHashBuffer.toString();
		System.out.println(this.strSimHash + " length " + this.strSimHash.length());
		return fingerprint;
	}

	private BigInteger hash(String source) {
		if (source == null || source.length() == 0) {
			return new BigInteger("0");
		} else {
			char[] sourceArray = source.toCharArray();
			BigInteger x = BigInteger.valueOf(((long) sourceArray[0]) << 7);
			BigInteger m = new BigInteger("1000003");
			BigInteger mask = new BigInteger("2").pow(this.hashbits).subtract(new BigInteger("1"));
			for (char item : sourceArray) {
				BigInteger temp = BigInteger.valueOf((long) item);
				x = x.multiply(m).xor(temp).and(mask);
			}
			x = x.xor(new BigInteger(String.valueOf(source.length())));
			if (x.equals(new BigInteger("-1"))) {
				x = new BigInteger("-2");
			}
			return x;
		}
	}

	public int hammingDistance(SimHash other) {

		BigInteger x = this.intSimHash.xor(other.intSimHash);
		int tot = 0;

		// 統計x中二進位制位數為1的個數
		// 我們想想，一個二進位制數減去1，那麼，從最後那個1（包括那個1）後面的數字全都反了，對吧，然後，n&(n-1)就相當於把後面的數字清0，
		// 我們看n能做多少次這樣的操作就OK了。

		while (x.signum() != 0) {
			tot += 1;
			x = x.and(x.subtract(new BigInteger("1")));
		}
		return tot;
	}

	public int getDistance(String str1, String str2) {
		int distance;
		if (str1.length() != str2.length()) {
			distance = -1;
		} else {
			distance = 0;
			for (int i = 0; i < str1.length(); i++) {
				if (str1.charAt(i) != str2.charAt(i)) {
					distance++;
				}
			}
		}
		return distance;
	}

	public List subByDistance(SimHash simHash, int distance) {
		// 分成幾組來檢查
		int numEach = this.hashbits / (distance + 1);
		List characters = new ArrayList();

		StringBuffer buffer = new StringBuffer();

		int k = 0;
		for (int i = 0; i < this.intSimHash.bitLength(); i++) {
			// 當且僅當設定了指定的位時，返回 true
			boolean sr = simHash.intSimHash.testBit(i);

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

			if ((i + 1) % numEach == 0) {
				// 將二進位制轉為BigInteger
				BigInteger eachValue = new BigInteger(buffer.toString(), 2);
				System.out.println("----" + eachValue);
				buffer.delete(0, buffer.length());
				characters.add(eachValue);
			}
		}

		return characters;
	}

	public static void main(String[] args) {
		String s = "This is a test string for testing";
		SimHash hash1 = new SimHash(s, 64);
		System.out.println(hash1.intSimHash + "  " + hash1.intSimHash.bitLength());
		hash1.subByDistance(hash1, 3);

		s = "This is a test string for testing, This is a test string for testing abcdef";
		SimHash hash2 = new SimHash(s, 64);
		System.out.println(hash2.intSimHash + "  " + hash2.intSimHash.bitCount());
		hash1.subByDistance(hash2, 3);
		
		s = "This is a test string for testing als";
		SimHash hash3 = new SimHash(s, 64);
		System.out.println(hash3.intSimHash + "  " + hash3.intSimHash.bitCount());
		hash1.subByDistance(hash3, 4);
		
		System.out.println("============================");
		
		int dis = hash1.getDistance(hash1.strSimHash, hash2.strSimHash);
		System.out.println(hash1.hammingDistance(hash2) + " " + dis);

		int dis2 = hash1.getDistance(hash1.strSimHash, hash3.strSimHash);
		System.out.println(hash1.hammingDistance(hash3) + " " + dis2);
		
		//通過Unicode編碼來判斷中文
		/*String str = "中國chinese";
		for (int i = 0; i < str.length(); i++) {
			System.out.println(str.substring(i, i + 1).matches("[\\u4e00-\\u9fbb]+"));
		}*/

	}
}

5、適用場景：

simHash在短文字的可行性：

測試相似文字的相似度與漢明距離
測試文字：20個城市名作為詞串：北京,上海,香港,深圳,廣州,臺北,南京,大連,蘇州,青島,無錫,佛山,重慶,寧波,杭州,成都,武漢,澳門,天津,瀋陽

相似度矩陣：

simHash碼：

勘誤：0.667, Hm:13 是對比的msg 1與2。
可見：相似度在0.8左右的Hamming距離為7，只有相似度高到0.9412，Hamming距離才近到4，

此時，反觀Google對此演算法的應用場景：網頁近重複、映象網站、內容複製、嵌入廣告、計數改變、少量修改。
以上原因對於長文字來說造成的相似度都會比較高，而對於短文字來說，如何處理海量資料的相似度文字更為合適的？

測試短文字（長度在8箇中文字元～45箇中文字元之間）相似性的誤判率如下圖所示：

REF：

1、simHash 簡介以及java實現

2、對simhash演算法的一些思考

3、Simhash演算法原理和網頁查重應用

4、其它

求二進位制數中1的個數

海量資料相似度計算之simhash短文字查詢（提升查詢效率）