Java實現LSH（Locality Sensitive Hash ）

　　在對大批量數據進行圖像處理的時候，比如說我提取SIFT特征，數據集為10W張圖片，一個SIFT特征點是128維，一張圖片提取出500個特征點，這樣我們在處理的時候就是對5000萬個128維的數據進行處理，這樣處理所需要的耗時太長了，不符合實際生產的需要。我們需要用一種方法降低運算量，比如說降維。

　　看了一些論文，提到的較多的方法是LSH（Locality Sensitive Hash），就是局部敏感哈希。我們利用LSH方法在5000萬個特征點中篩選出極少量的我們需要的特征點，在對這些極少量的數據進行計算，就可以得到我們想要的結果啦。

package com.demo.lsh;

import com.demo.config.Constant;
import com.demo.dao.FeatureDao;
import com.demo.dao.FeatureTableDao;
import com.demo.dao.HashTableDao;
import com.demo.entity.HashTable;
import com.demo.utils.MD5Util;
import com.demo.utils.MathUtil;
import org.opencv.core.Mat;
import org.springframework.util.StringUtils;

import java.io.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;

public class LSH {
    //維度大小，例如對於sift特征來說就是128
    private int dimention = Constant.DIMENTION;
    //所需向量中元素可能的上限，譬如對於RGB來說，就是255
    private int max = Constant.MAX;
    //哈希表的數量，用於更大程度地削減false positive
    private int hashCount = Constant.HASHCOUNT;
    //LSH隨機選取的采樣位數，該值越小，則近似查找能力越大，但相應的false positive也越大；若該值等於size，則為由近似查找退化為精確匹配
    private int bitCount = Constant.BITCOUNT;
    //轉化為01字符串之后的位數，等於max乘以dimensions
    private int size = dimention * max;
    //LSH哈希族，保存了隨機采樣點的INDEX
    private int[][] hashFamily;
    private HashTableDao hashTableDao;
    /**
     * 構造函數
     */
    public LSH(HashTableDao hashTableDao) {
        this.hashTableDao = hashTableDao;
        dimention = Constant.DIMENTION;
        max = Constant.MAX;
        hashCount = Constant.HASHCOUNT;
        bitCount = Constant.BITCOUNT;
        size = dimention * max;
        hashFamily = new int[hashCount][bitCount];
        generataHashFamily();
    }

    /**
     * 生成隨機的投影點 ，在程序第一次執行時生成。投影點可以理解為后面去數組的索引值
     */
    private void generataHashFamily() {
        if (new File("/home/fanxuan/data/1.txt").exists()) {
            try {
                InputStream in = new FileInputStream("/home/fanxuan/data/1.txt");
                ObjectInputStream oin = new ObjectInputStream(in);
                hashFamily = (int[][]) (oin.readObject());
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }else {
            Random rd = new Random();
            for (int i = 0; i < hashCount; i++) {
                for (int j = 0; j < bitCount; j++) {
                    hashFamily[i][j] = rd.nextInt(size);
                }
            }
            try {
                OutputStream out = new FileOutputStream("/home/fanxuan/data/1.txt");
                ObjectOutputStream oout = new ObjectOutputStream(out);
                oout.writeObject(hashFamily);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //將向量轉化為二進制字符串，比如元素的最大范圍255，則元素65就被轉化為65個1以及190個0
    private int[] unAray(int[] data) {
        int unArayData[] = new int[size];
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i]; j++) {
                unArayData[i * max + j] = 1;
            }
        }
        return unArayData;
    }

    /**
     * 將向量映射為LSH中的key
     */
    private String generateHashKey(int[] list, int hashNum) {
        StringBuilder sb = new StringBuilder();
        int[] tempData = unAray(list);
        int[] hashedData = new int[bitCount];
        //首先將向量轉為二進制字符串
        for (int i = 0; i < bitCount; i++) {
            hashedData[i] = tempData[hashFamily[hashNum][i]];
            sb.append(hashedData[i]);
        }
        //再用常規hash函數比如MD5對key進行壓縮
        MessageDigest messageDigest = null;
        try{
            messageDigest = MessageDigest.getInstance("MD5");
        }catch (NoSuchAlgorithmException e) {

        }
        byte[] binary = sb.toString().getBytes();
        byte[] hash = messageDigest.digest(binary);
        String hashV = MD5Util.bufferToHex(hash);
        return hashV;
    }

    /**
     * 將Sift特征點轉換為Hash存表
     */
    public void generateHashMap(String id, int[] vercotr, int featureId) {
        for (int j = 0; j < hashCount; j++) {
            String key = generateHashKey(vercotr, j);
            HashTable hashTableUpdateOrAdd = new HashTable();
            HashTable hashTable = hashTableDao.findHashTableByBucketId(key);
            if (hashTable != null) {
                String featureIdValue = hashTable.getFeatureId() + "," + featureId;
                hashTableUpdateOrAdd.setFeatureId(featureIdValue);
                hashTableUpdateOrAdd.setBucketId(key);
                hashTableDao.updateHashTableFeatureId(hashTableUpdateOrAdd);
            } else {
                hashTableUpdateOrAdd.setBucketId(key);
                hashTableUpdateOrAdd.setFeatureId(String.valueOf(featureId));
                hashTableDao.insertHashTable(hashTableUpdateOrAdd);
            }
        }
    }

    // 查詢與輸入向量最接近（海明空間）的向量
    public List<String> queryList(int[] data) {
        List<String> result = new ArrayList<>();
        for (int j = 0; j < hashCount; j++) {
            String key = generateHashKey(data, j);
            result.add(key);
            HashTable hashTable = hashTableDao.findHashTableByBucketId(key);
            if (!StringUtils.isEmpty(hashTable.getFeatureId())) {
                String[] str = hashTable.getFeatureId().split(",");
                for (String string : str) {
                    result.add(string);
                }
            }
        }
        return result;
    }

}

 　　

package com.demo.config;

public class Constant {
    //維度大小，例如對於sift特征來說就是128
    public static final int DIMENTION = 128;
    //所需向量中元素可能的上限，譬如對於RGB來說，就是255
    public static final int MAX = 255;
    //哈希表的數量，用於更大程度地削減false positive
    public static final int HASHCOUNT = 12;
    //LSH隨機選取的采樣位數，該值越小，則近似查找能力越大，但相應的false positive也越大；若該值等於size，則為由近似查找退化為精確匹配
    public static final int BITCOUNT = 32;
}

　　簡單的介紹下代碼，構造函數LSH（）用來建立LSH對象，hashTableDao為數據表操作對象，不多說;因為局部敏感哈希依賴與一套隨機數，每次產生的結果都不一致，所以我們需要在程序第一次運行的時候將隨機數生成並固定下來，我采用的方法是存放在本地磁盤中，也可以存放在數據庫中。generateHashMap（）方法為數據訓練函數，int[] vercotr為特征向量，其他兩個參數為我需要的標志位。queryList（）方法是篩選方法。

 

　　感謝http://grunt1223.iteye.com/blog/944894的文章。