Added random generator to Elkan, Hamerly & Lloyd

Author: PyDataBlog

src/elkan.jl

@@ -23,7 +23,7 @@ function kmeans!(alg::Elkan, containers, X, k, weights=nothing, metric=Euclidean
                 n_threads = Threads.nthreads(),
                 k_init = "k-means++", max_iters = 300,
                 tol = eltype(X)(1e-6), verbose = false,
-                init = nothing, rng = Random.GLOBAL_RNG, metric=Euclidean())
+                init = nothing, rng = Random.GLOBAL_RNG)
 
     nrow, ncol = size(X)
     centroids = init == nothing ? smart_init(X, k, n_threads, weights, rng, init=k_init).centroids : deepcopy(init)

src/hamerly.jl

@@ -22,7 +22,7 @@ function kmeans!(alg::Hamerly, containers, X, k, weights=nothing, metric=Euclide
                 n_threads = Threads.nthreads(),
                 k_init = "k-means++", max_iters = 300,
                 tol = eltype(X)(1e-6), verbose = false,
-                init = nothing, rng = Random.GLOBAL_RNG, metric=Euclidean())
+                init = nothing, rng = Random.GLOBAL_RNG)
 
     nrow, ncol = size(X)
     centroids = init == nothing ? smart_init(X, k, n_threads, weights, rng, init=k_init).centroids : deepcopy(init)

src/kmeans.jl

@@ -168,36 +168,20 @@ alternatively one can use `rand` to choose random points for init.
 
 A `KmeansResult` structure representing labels, centroids, and sum_squares is returned.
 """
-<<<<<<< HEAD
-function kmeans(alg::AbstractKMeansAlg, design_matrix, k;
-                weights = nothing,
+function kmeans(alg::AbstractKMeansAlg, design_matrix, k; weights = nothing,
                 n_threads = Threads.nthreads(),
                 k_init = "k-means++", max_iters = 300,
                 tol = eltype(design_matrix)(1e-6), verbose = false,
                 init = nothing, rng = Random.GLOBAL_RNG, metric = Euclidean())
 
-=======
-function kmeans(alg::AbstractKMeansAlg, design_matrix, k, weights = nothing;
-                n_threads = Threads.nthreads(), k_init = "k-means++", max_iters = 300,
-                tol = eltype(design_matrix)(1e-6), verbose = false, init = nothing, metric=Euclidean())
-
-    # Get dimensions of the input data
->>>>>>> Moved metric internally as a positional arg
     nrow, ncol = size(design_matrix)
 
     # Create containers based on the dimensions and specifications
     containers = create_containers(alg, design_matrix, k, nrow, ncol, n_threads)
 
-<<<<<<< HEAD
-    return kmeans!(alg, containers, design_matrix, k, weights, n_threads = n_threads,
-                    k_init = k_init, max_iters = max_iters, tol = tol,
-                    verbose = verbose, init = init, rng = rng, metric = metric)
-=======
-    # Dispatch based on the specified algorithm
     return kmeans!(alg, containers, design_matrix, k, weights, metric;
                    n_threads = n_threads, k_init = k_init, max_iters = max_iters,
-                   tol = tol, verbose = verbose, init = init)
->>>>>>> Moved metric internally as a positional arg
+                   tol = tol, verbose = verbose, init = init, rng = rng)
 
 end
 

src/lloyd.jl

@@ -18,7 +18,7 @@ function kmeans!(alg::Lloyd, containers, X, k, weights=nothing, metric=Euclidean
                 n_threads = Threads.nthreads(),
                 k_init = "k-means++", max_iters = 300,
                 tol = eltype(design_matrix)(1e-6), verbose = false,
-                init = nothing, rng = Random.GLOBAL_RNG, metric=Euclidean())
+                init = nothing, rng = Random.GLOBAL_RNG)
 
     # Get dimensions of the input data
     nrow, ncol = size(X)
@@ -69,8 +69,9 @@ kmeans(design_matrix, k;
     n_threads = Threads.nthreads(),
     k_init = "k-means++", max_iters = 300, tol = 1e-6,
     verbose = false, init = nothing, rng = Random.GLOBAL_RNG, metric = Euclidean()) =
-        kmeans(Lloyd(), design_matrix, k; weights = weights, n_threads = n_threads, k_init = k_init, max_iters = max_iters, tol = tol,
-            verbose = verbose, init = init, rng = rng, metric = metric)
+        kmeans(Lloyd(), design_matrix, k; weights = weights,
+               n_threads = n_threads, k_init = k_init, max_iters = max_iters, tol = tol,
+               verbose = verbose, init = init, rng = rng, metric = metric)
 
 
 """

test/test03_lloyd.jl

@@ -104,21 +104,22 @@ end
 end
 
 @testset "Lloyd metric support" begin
-    Random.seed!(2020)
+    rng = StableRNG(2020)
     X = [1. 2. 4.;]
 
-    res = kmeans(Lloyd(), X, 2; tol = 1e-16, metric=Cityblock())
+    res = kmeans(Lloyd(), X, 2; tol = 1e-16, metric=Cityblock(), rng = rng)
 
-    @test res.assignments == [1, 1, 2]
-    @test res.centers == [1.5 4.0]
+    @test res.assignments == [2, 2, 1]
+    @test res.centers == [4.0 1.5]
     @test res.totalcost == 1.0
     @test res.converged
 
-    Random.seed!(2020)
-    X = rand(3, 100)
+    rng = StableRNG(2020)
+    X = rand(rng, 3, 100)
 
-    res = kmeans(X, 2, tol = 1e-16, metric=Cityblock())
-    @test res.totalcost ≈ 62.04045252895372
+    res = kmeans(X, 2; tol = 1e-16, metric = Cityblock(), rng = rng)
+    @test res.totalcost ≈ 60.893492629945044
+    @test res.iterations == 6
     @test res.converged
 end
 

test/test04_elkan.jl

@@ -92,21 +92,21 @@ end
 
 
 @testset "Elkan metric support" begin
-    Random.seed!(2020)
+    rng = StableRNG(2020)
     X = [1. 2. 4.;]
 
-    res = kmeans(Elkan(), X, 2; tol = 1e-16, metric=Cityblock())
+    res = kmeans(Lloyd(), X, 2; tol = 1e-16, metric=Cityblock(), rng = rng)
 
-    @test res.assignments == [1, 1, 2]
-    @test res.centers == [1.5 4.0]
+    @test res.assignments == [2, 2, 1]
+    @test res.centers == [4.0 1.5]
     @test res.totalcost == 1.0
     @test res.converged
 
-    Random.seed!(2020)
-    X = rand(3, 100)
+    rng = StableRNG(2020)
+    X = rand(rng, 3, 100)
 
-    res = kmeans(Elkan(), X, 2, tol = 1e-16, metric=Cityblock())
-    @test res.totalcost ≈ 62.04045252895372
+    res = kmeans(Elkan(), X, 2; tol = 1e-16, metric = Cityblock(), rng = rng)
+    @test res.totalcost ≈ 60.893492629945044
     @test res.converged
 end
 

test/test05_hamerly.jl

@@ -105,25 +105,25 @@ end
 
 
 @testset "Hamerly metric support" begin
-    Random.seed!(2020)
+    rng = StableRNG(2020)
     X = [1. 2. 4.;]
 
-    res = kmeans(Hamerly(), X, 2; tol = 1e-16, metric=Cityblock())
+    res = kmeans(Hamerly(), X, 2; tol = 1e-16, metric=Cityblock(), rng = rng)
 
-    @test res.assignments == [1, 1, 2]
-    @test res.centers == [1.5 4.0]
+    @test res.assignments == [2, 2, 1]
+    @test res.centers == [4.0 1.5]
     @test res.totalcost == 1.0
     @test res.converged
 
-    Random.seed!(2020)
+    rng = StableRNG(2020)
     X = rand(3, 100)
+    rng_orig = deepcopy(rng)
 
-    baseline = kmeans(Lloyd(), X, 2, tol = 1e-16, metric=Cityblock())
+    baseline = kmeans(Lloyd(), X, 2, tol = 1e-16, metric=Cityblock(), rng = rng)
 
-    Random.seed!(2020)
-    X = rand(3, 100)
+    rng = deepcopy(rng_orig)
+    res = kmeans(Hamerly(), X, 2; tol = 1e-16, metric=Cityblock(), rng = rng)
 
-    res = kmeans(Hamerly(), X, 2; tol = 1e-16, metric=Cityblock())
     @test res.totalcost ≈ baseline.totalcost
     @test res.converged == baseline.converged
     @test res.iterations == baseline.iterations