def loadHashmap(self, feature_size=129, result_n=1000): #这里参数没有用到 ''' feature_size: hash空间维数大小 result_n :返回多少个最近邻 ''' # Create redis storage adapter redis_object = Redis(host='localhost', port=6379, db=0) redis_storage = RedisStorage(redis_object) try: # Get hash config from redis config = redis_storage.load_hash_configuration('test') # Config is existing, create hash with None parameters lshash = RandomBinaryProjections(None, None) # Apply configuration loaded from redis lshash.apply_config(config) except: # Config is not existing, create hash from scratch, with 10 projections lshash = RandomBinaryProjections('test', 0) # Create engine for feature space of 100 dimensions and use our hash. # This will set the dimension of the lshash only the first time, not when # using the configuration loaded from redis. Use redis storage to store # buckets. nearest = NearestFilter(result_n) #self.engine = Engine(feature_size, lshashes=[], vector_filters=[]) self.engine = Engine(feature_size, lshashes=[lshash], vector_filters=[nearest], storage=redis_storage, distance=EuclideanDistance()) # Do some stuff like indexing or querying with the engine... # Finally store hash configuration in redis for later use redis_storage.store_hash_configuration(lshash)
def load_hashmap(self): # Create redis storage adapter # need to start redis service redis_object = Redis(host='localhost', port=6379, db=14) redis_storage = RedisStorage(redis_object) try: config = redis_storage.load_hash_configuration('test') lshash = RandomBinaryProjections(None, None) lshash.apply_config(config) except: # Config is not existing, create hash from scratch, with 10 projections lshash = RandomBinaryProjections('test', 10) nearest = NearestFilter(self.nn) # self.engine = Engine(feature_size, lshashes=[], vector_filters=[]) self.engine = Engine(self.feature_size, lshashes=[lshash], vector_filters=[nearest], storage=redis_storage, distance=CosineDistance()) # Do some stuff like indexing or querying with the engine... # Finally store hash configuration in redis for later use redis_storage.store_hash_configuration(lshash)
def get_hash_config(redis_storage, name): config = redis_storage.load_hash_configuration(name) if config is not None: # Config is existing, create hash with None parameters lshash = RandomBinaryProjections(None, None, rand_seed=123) # Apply configuration loaded from redis lshash.apply_config(config) else: raise RuntimeError("Hash Config not found") return lshash
class RBP_hasher(object): def __init__(self, dimension, n_bit, alpha): self.n_bit = n_bit self.dim = dimension self.alpha = alpha self.sample_space = 2**n_bit self.rbp = RandomBinaryProjections('rbp', self.n_bit) self.engine = Engine(dimension, lshashes=[self.rbp]) @property def params(self): return self.rbp.get_config() def load(self, config): self.rbp.apply_config(config) def _string2int(self, s): return int(s, 2) def __call__(self, v): ''' Convert the returned string into a integer. Return a dict based off the weights. ''' s = self.rbp.hash_vector(v)[0] weights = { self._string2int(s): 1.0, } if not self.alpha: return weights # If alpha is non-zero, deposit weight into nearby bins slist = map(bool, map(int, list(s))) for n in range(len(s)): s2list = slist[:] s2list[n] = not slist[n] s2list = map(str, map(int, s2list)) s2 = ''.join(s2list) idx = self._string2int(s2) weights[idx] = self.alpha return weights
def test_hash_memory_storage_rbp(self): hash1 = RandomBinaryProjections('testRBPHash', 10) hash1.reset(100) self.memory.store_hash_configuration(hash1) hash2 = RandomBinaryProjections(None, None) hash2.apply_config(self.memory.load_hash_configuration('testRBPHash')) self.assertEqual(hash1.dim, hash2.dim) self.assertEqual(hash1.hash_name, hash2.hash_name) self.assertEqual(hash1.projection_count, hash2.projection_count) for i in range(hash1.normals.shape[0]): for j in range(hash1.normals.shape[1]): self.assertEqual(hash1.normals[i, j], hash2.normals[i, j])
def test_hash_memory_storage_rbp(self): hash1 = RandomBinaryProjections('testRBPHash', 10) hash1.reset(100) self.memory.store_hash_configuration(hash1) hash2 = RandomBinaryProjections(None, None) hash2.apply_config(self.memory.load_hash_configuration('testRBPHash')) self.assertEqual(hash1.dim, hash2.dim) self.assertEqual(hash1.hash_name, hash2.hash_name) self.assertEqual(hash1.projection_count, hash2.projection_count) for i in range(hash1.normals.shape[0]): for j in range(hash1.normals.shape[1]): self.assertEqual(hash1.normals[i, j], hash2.normals[i, j])
class GraphStateQueryIndex: def __init__(self): redis_object = redis.Redis(host='localhost', port=6379, db=0) redis_storage = RedisStorage(redis_object) # Get hash config from redis config = redis_storage.load_hash_configuration('MyHash') if config is None: # Config is not existing, create hash from scratch, with 5 projections self.lshash = RandomBinaryProjections('MyHash', 5) else: # Config is existing, create hash with None parameters self.lshash = RandomBinaryProjections(None, None) # Apply configuration loaded from redis self.lshash.apply_config(config) # print("HERE") # Create engine for feature space of 100 dimensions and use our hash. # This will set the dimension of the lshash only the first time, not when # using the configuration loaded from redis. Use redis storage to store # buckets. self.engine = Engine(4, lshashes=[self.lshash], storage=redis_storage) redis_storage.store_hash_configuration(self.lshash) def findMatch(self, v): matches = self.engine.neighbours(v) return matches def addVector(self, v, trainingText): self.engine.store_vector(v, trainingText) def clearIndex(self): self.engine.clean_all_buckets() def clearHashInstance(self, name): self.engine.clean_buckets(name)
host='redis', port=6379, # charset='utf-8', # decode_responses=True, ) redis_storage = RedisStorage(r) # Get hash config from redis config = redis_storage.load_hash_configuration('MyHash') if config is None: # Config is not existing, create hash from scratch, with 10 projections lshash = RandomBinaryProjections('MyHash', 50) else: # Config is existing, create hash with None parameters lshash = RandomBinaryProjections(None, None) # Apply configuration loaded from redis lshash.apply_config(config) # Create engine for feature space of 100 dimensions and use our hash. # This will set the dimension of the lshash only the first time, not when # using the configuration loaded from redis. Use redis storage to store # buckets. engine = Engine(dimension, lshashes=[lshash], storage=redis_storage) redis_storage.store_hash_configuration(lshash) app = Flask(__name__) @app.route('/') def index(): return "Hello, World!"