simHash 簡介以及 java 實現

時間 2019-11-06

標籤 simhash 簡介以及 java 實現欄目 Java 简体版

原文原文鏈接

傳統的 hash 算法只負責將原始內容儘可能均勻隨機地映射爲一個簽名值，原理上至關於僞隨機數產生算法。產生的兩個簽名，若是相等，說明原始內容在必定概率下是相等的；若是不相等，除了說明原始內容不相等外，再也不提供任何信息，由於即便原始內容只相差一個字節，所產生的簽名也極可能差異極大。從這個意義上來說，要設計一個 hash 算法，對類似的內容產生的簽名也相近，是更爲艱難的任務，由於它的簽名值除了提供原始內容是否相等的信息外，還能額外提供不相等的原始內容的差別程度的信息。
而 Google 的 simhash 算法產生的簽名，能夠知足上述要求。出人意料，這個算法並不深奧，其思想是很是清澈美妙的。html

一、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 做爲簽名。java

二、算法幾何意義和原理

這個算法的幾何意義很是明瞭。它首先將每個特徵映射爲f維空間的一個向量，這個映射規則具體是怎樣並不重要，只要對不少不一樣的特徵來講，它們對所對應的向量是均勻隨機分佈的，而且對相同的特徵來講對應的向量是惟一的就行。好比一個特徵的4位hash簽名的二進制表示爲1010，那麼這個特徵對應的 4維向量就是(1, -1, 1, -1)T，即hash簽名的某一位爲1，映射到的向量的對應位就爲1，不然爲-1。而後，將一個文檔中所包含的各個特徵對應的向量加權求和，加權的係數等於該特徵的權重。獲得的和向量即表徵了這個文檔，咱們能夠用向量之間的夾角來衡量對應文檔之間的類似度。最後，爲了獲得一個f位的簽名，須要進一步將其壓縮，若是和向量的某一維大於0，則最終簽名的對應位爲1，不然爲0。這樣的壓縮至關於只留下了和向量所在的象限這個信息，而64位的簽名能夠表示多達264個象限，所以只保存所在象限的信息也足夠表徵一個文檔了。 git

明確了算法了幾何意義，使這個算法直觀上看來是合理的。可是，爲什麼最終獲得的簽名相近的程度，能夠衡量原始文檔的類似程度呢？這須要一個清晰的思路和證實。在simhash的發明人Charikar的論文中[2]並無給出具體的simhash算法和證實，如下列出我本身得出的證實思路。程序員

Simhash是由隨機超平面hash算法演變而來的，隨機超平面hash算法很是簡單，對於一個n維向量v，要獲得一個f位的簽名(f<<n)，算法以下：< span="">
1，隨機產生f個n維的向量r1,…rf；
2，對每個向量ri，若是v與ri的點積大於0，則最終簽名的第i位爲1，不然爲0. github

這個算法至關於隨機產生了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維組成：app

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算法，原始內容的差別度，能夠直接由簽名值的代數差來表示呢？

三、比較類似度

海明距離：兩個碼字的對應比特取值不一樣的比特數稱爲這兩個碼字的海明距離。一個有效編碼集中, 任意兩個碼字的海明距離的最小值稱爲該編碼集的海明距離。舉例以下： 10101 和 00110 從第一位開始依次有第一位、第4、第五位不一樣，則海明距離爲 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 萬次了。因而可知，確實大大減小了計算量。

四、示例代碼：

/**
 * Function: 注：該示例程序暫不支持中文

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

 * @author   june: decli@qq.com
 */
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<string, integer=""> wordMap = new HashMap<string, integer="">();

	public BigInteger simHash() {
		// 定義特徵向量/數組
		int[] v = new int[this.hashbits];
		// 一、將文本去掉格式後, 分詞.
		StringTokenizer stringTokens = new StringTokenizer(this.tokens);
		while (stringTokens.hasMoreTokens()) {
			String temp = stringTokens.nextToken();
			// 二、將每個分詞hash爲一組固定長度的數列.好比 64bit 的一個整數.
			BigInteger t = this.hash(temp);
			for (int i = 0; i < this.hashbits; i++) {
				BigInteger bitmask = new BigInteger("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;
				}
			}
		}
		BigInteger fingerprint = new BigInteger("0");
		StringBuffer simHashBuffer = new StringBuffer();
		for (int i = 0; i < this.hashbits; i++) {
			// 四、最後對數組進行判斷,大於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]+"));
		}*/

	}
}

五、適用場景：

simHash在短文本的可行性：

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

類似度矩陣：

simHash碼：

勘誤：0.667, Hm:13 是對比的msg 1與2。
可見：類似度在0.8左右的Hamming距離爲7，只有類似度高到0.9412，Hamming距離才近到4，此時，反觀Google對此算法的應用場景：網頁近重複。
鏡像網站、內容複製、嵌入廣告、計數改變、少許修改。
以上緣由對於長文原本說形成的類似度都會比較高，而對於短文原本說，如何處理海量數據的類似度文本更爲合適的？

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