Change the 'r' parameter of LpHash to 'scale'. Fix for issue #11.

Author: kernelmethod

src/hashes/lphash.jl

@@ -24,9 +24,10 @@ mutable struct LpHash{T <: Union{Float32,Float64}, D} <: SymmetricLSHFunction
     # Coefficient matrix with which we multiply the input to the hash function
     coeff :: Matrix{T}
 
-    # "Denominator" parameter r. Higher values of r lead to higher collision
-    # rates. This parameter is user-specified
-    r :: T
+    # "Denominator" parameter scale (called "r" in the reference paper). Higher
+    # values of r lead to higher collision rates. This parameter is
+    # user-specified.
+    scale :: T
 
     # "Shift" parameter (referred to as 'b' in the 'p-stable distributions' paper.
     # There's one shift parameter for every hash function; each parameter is
@@ -56,7 +57,7 @@ abstract type L2Hash <: SymmetricLSHFunction end
 ### External LpHash constructors
 
 function LpHash{T}(n_hashes::Integer = DEFAULT_N_HASHES;
-                   r::Real = T(1.0),
+                   scale::Real = T(1.0),
                    power::Integer = 2,
                    resize_pow2::Bool = DEFAULT_RESIZE_POW2) where {T <: Union{Float32,Float64}}
 
@@ -73,7 +74,7 @@ function LpHash{T}(n_hashes::Integer = DEFAULT_N_HASHES;
         end
     end
 
-    LpHash(coeff, T(r), shift, Int64(power), distr, resize_pow2)
+    LpHash(coeff, T(scale), shift, Int64(power), distr, resize_pow2)
 end
 
 L1Hash(args...; kws...) where {T} = LpHash(args...; power = 1, kws...)
@@ -186,9 +187,9 @@ hashtype(::LpHash) = Int32
 # See Section 3.2 of the reference paper
 function single_hash_collision_probability(hashfn::LpHash, sim::Real)
     ### Compute the collision probability for a single hash function
-    distr, r = hashfn.distr, hashfn.r
-    integral, err = quadgk(x -> pdf(distr, x/sim) * (1 - x/r),
-                           0, r, rtol=1e-5)
+    distr, scale = hashfn.distr, hashfn.scale
+    integral, err = quadgk(x -> pdf(distr, x/sim) * (1 - x/scale),
+                           0, scale, rtol=1e-5)
     integral = integral ./ sim
 
     # Note that from the reference for the L^p LSH family, we're supposed to
@@ -223,6 +224,6 @@ function (hashfn::LpHash{T})(x::AbstractArray{T}) where T
     end
 
     h = @views hashfn.coeff[1:end,1:n] * x
-    h = @. h / hashfn.r + hashfn.shift
+    h = @. h / hashfn.scale + hashfn.shift
     floor.(Int32, h)
 end

test/hashes/test_lphash.jl

@@ -10,17 +10,17 @@ Tests
 
     @testset "Can construct an ℓ^p distance hash function" begin
         # Construct a hash for L^1 distance
-        L1_hash = L1Hash(5; r = 2)
+        L1_hash = L1Hash(5; scale = 2)
         @test n_hashes(L1_hash) == 5
-        @test L1_hash.r == 2
+        @test L1_hash.scale == 2
         @test L1_hash.power == 1
         @test similarity(L1_hash) == ℓ1
         @test hashtype(L1_hash) == Int32
 
         # Construct a hash for L^2 distance
-        L2_hash = L2Hash(12; r = 3.4)
+        L2_hash = L2Hash(12; scale = 3.4)
         @test n_hashes(L2_hash) == 12
-        @test L2_hash.r == Float32(3.4)
+        @test L2_hash.scale == Float32(3.4)
         @test L2_hash.power == 2
         @test similarity(L2_hash) == ℓ2
 
@@ -31,22 +31,22 @@ Tests
 
     @testset "Hashes are correctly computed" begin
         n_hashes = 8
-        r = 2
+        scale = 2
 
-        hashfn = L2Hash(n_hashes; r = r)
+        hashfn = L2Hash(n_hashes; scale=scale)
 
         # Test on a single input
         x = randn(8)
         hashes = hashfn(x)
-        manual_hashes = floor.(Int32, hashfn.coeff * x ./ r .+ hashfn.shift)
+        manual_hashes = floor.(Int32, hashfn.coeff * x ./ scale .+ hashfn.shift)
 
         @test isa(hashes, Vector{Int32})
         @test hashes == manual_hashes
 
         # Test on many inputs, simultaneously
         x = randn(8, 128)
         hashes = hashfn(x)
-        manual_hashes = floor.(Int32, hashfn.coeff * x ./ r .+ hashfn.shift)
+        manual_hashes = floor.(Int32, hashfn.coeff * x ./ scale .+ hashfn.shift)
 
         @test isa(hashes, Matrix{Int32})
         @test hashes == manual_hashes
@@ -66,7 +66,7 @@ Tests
     end
 
     @testset "Nearby points experience more frequent collisions" begin
-        hashfn = L2Hash(1024; dtype=Float64, r=4)
+        hashfn = L2Hash(1024; dtype=Float64, scale=4)
 
         x1 = randn(128)
         x2 = x1 + 0.05 * randn(length(x1))
@@ -78,7 +78,7 @@ Tests
     end
 
     @testset "Hash collision frequency matches probability" begin
-        hashfn = L2Hash(1024; r = 4)
+        hashfn = L2Hash(1024; scale = 4)
 
         # Dry run
         @test test_collision_probability(hashfn, 0.05)

test/hashes/test_lshfunction.jl

@@ -62,12 +62,12 @@ end
     end
 
     @testset "Create L^p distance hash function" begin
-        hashfn = LSHFunction(ℓ1, 20; r = 4.0)
+        hashfn = LSHFunction(ℓ1, 20; scale = 4.0)
 
         @test similarity(hashfn) == ℓ1
         @test n_hashes(hashfn) == 20
         @test isa(hashfn, LSHFunctions.LpHash)
-        @test hashfn.r == 4.0
+        @test hashfn.scale == 4.0
     end
 
     @testset "Create Jaccard similarity hash function" begin