lsh 0.1.2 → 0.1.3

data/lib/lsh/index.rb

@@ -47,31 +47,35 @@ module LSH
     end
 
     def query(vector, multiprobe_radius = 0)
-      results = []
-      hashes(vector).each_with_index do |hash, i|
-        hash_i = array_to_hash(hash)
-        bucket = storage.find_bucket(i)
-        # Multiprobe LSH
-        # Take query hash, move it around at radius r, hash it and use the result as a query
-        # TODO: only works for binary LSH atm
-        bucket_results = storage.query_bucket(bucket, hash_i)
-        results += bucket_results if bucket_results
-        if multiprobe_radius > 0
-          (1..multiprobe_radius).to_a.each do |radius|
-            (0..(storage.parameters[:number_of_random_vectors] - 1)).to_a.combination(radius).each do |flips|
-              probe = hash.clone
-              flips.each { |d| probe[d] = (probe[d] == 1) ? 0 : 1  }
-              probe_hash = array_to_hash(probe)
-              probe_bucket_results = storage.query_bucket(bucket, probe_hash)
-              results += probe_bucket_results if probe_bucket_results
-            end
-          end
+      hash_arrays = hashes(vector)
+      hashes = hash_arrays.map { |a| array_to_hash(a) }
+      results = storage.query_buckets(hashes)
+      # Multiprobe LSH
+      # Take query hashes, move them around at radius r, and use them to do another query
+      # TODO: only works for binary LSH atm
+      if multiprobe_radius > 0
+        mp_arrays = multiprobe_hashes_arrays(hash_arrays, multiprobe_radius)
+        mp_arrays.each do |probes_arrays|
+          probes_hashes = probes_arrays.map { |a| array_to_hash(a) }
+          results += storage.query_buckets(probes_hashes)
         end
       end
       results = MathUtil.uniq(results)
       order_vectors_by_similarity(vector, results)
     end
 
+    def multiprobe_hashes_arrays(hash_arrays, multiprobe_radius)
+      mp_arrays = []
+      (1..multiprobe_radius).to_a.each do |radius|
+        (0..(storage.parameters[:number_of_random_vectors] - 1)).to_a.combination(radius).each do |flips|
+          probes = Marshal.load(Marshal.dump(hash_arrays))
+          probes.each { |probe| flips.each { |d| probe[d] = (probe[d] == 1) ? 0 : 1 } }
+          mp_arrays << probes
+        end
+      end
+      mp_arrays
+    end
+
     def order_vectors_by_similarity(vector, vectors)
       vectors.map { |v| [ v, similarity(vector, v) ] } .sort_by { |v, sim| sim } .reverse .map { |vs| vs[0] }
     end

data/lib/lsh/storage/memory.rb

@@ -49,8 +49,14 @@ module LSH
         @buckets[i]
       end
 
-      def query_bucket(bucket, hash)
-        bucket[hash]
+      def query_buckets(hashes)
+        results = []
+        hashes.each_with_index do |hash, i|
+          bucket = find_bucket(i)
+          in_bucket = bucket[hash]
+          results += in_bucket if in_bucket
+        end
+        results
       end
 
     end

data/lib/lsh/storage/redis_backend.rb

@@ -111,9 +111,15 @@ module LSH
         "bucket:#{i}" if @redis.get("buckets").to_i > i
       end
 
-      def query_bucket(bucket, hash)
+      def query_buckets(hashes)
+        vector_hashes = []
+        hashes.each_with_index do |hash, i|
+          bucket = find_bucket(i)
+          vector_hashes += @redis.smembers("#{bucket}:#{hash}")
+        end
+        vector_hashes.uniq!
         results = []
-        @redis.smembers("#{bucket}:#{hash}").map do |vector_hash|
+        vector_hashes.each do |vector_hash|
           vector = MathUtil.zeros(parameters[:dim])
           vector.load(File.join(@data_dir, vector_hash+'.dat'))
           results << vector

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lsh
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors: