made randomized tests more robust

Author: SebastianAment

src/basispursuit.jl

@@ -144,9 +144,10 @@ shrinkage(x::Real, α::Real) = sign(x) * max(abs(x)-α, zero(x))
 
 # TODO fast iterative shrinkage and hard-thresholding algorithm
 # for weighted l1-norm minimization
-function fista(A::AbstractMatrix, b::AbstractVector, λ::Real, x::AbstractVector = spzeros(size(A, 2)))
+function fista(A::AbstractMatrix, b::AbstractVector, λ::Real,
+    x::AbstractVector = spzeros(size(A, 2)); maxiter::Int = 1024, stepsize::Real = 1e-2)
     w = fill(λ, size(x))
-    fista(A, b, w, x)
+    fista(A, b, w, x, maxiter = maxiter, stepsize = stepsize)
 end
 
 function l1(x::AbstractVector, w::AbstractVector)
@@ -159,20 +160,20 @@ function l1(x::AbstractVector, w::AbstractVector)
 end
 
 # TODO: stepsize selection
-function ista(A, b, λ::Real, x = spzeros(size(A, 2)); maxiter::Int = 128)
-    ista(A, b, fill(λ, size(x)), x, maxiter = maxiter)
+function ista(A, b, λ::Real, x = spzeros(size(A, 2)); maxiter::Int = 1024, stepsize::Real = 1e-2)
+    ista(A, b, fill(λ, size(x)), x, maxiter = maxiter, stepsize = stepsize)
 end
 
 function ista(A::AbstractMatrix, b::AbstractVector, w::AbstractVector,
                                         x::AbstractVector = spzeros(size(A, 2));
-                                        maxiter::Int = 128)
+                                        maxiter::Int = 1024, stepsize::Real = 1e-2)
     x = sparse(x)
     r(x) = b-A*x # residual
     f(x) = sum(abs2, r(x)) + l1(x, w)
     g(x) = A'r(x) # negative gradient
-    α = .01 # step-size
+    α = stepsize
     fx = f(x)
-    for i in 1:1024
+    for i in 1:maxiter
         ∇ = g(x)
         @. x = shrinkage(x + 2α*∇, w*α)
         dropzeros!(x) # optimize sparse representation
@@ -183,14 +184,14 @@ end
 
 function fista(A::AbstractMatrix, b::AbstractVector, w::AbstractVector,
                                         x::AbstractVector = spzeros(size(A, 2));
-                                        maxiter::Int = 128)
+                                        maxiter::Int = 1024, stepsize::Real = 1e-2)
     x = sparse(x)
     r(x) = b-A*x # residual
     f(x) = sum(abs2, r(x)) + l1(x, w)
     g(x) = A'r(x) # negative gradient
-    α = .1 # step-size
+    α = stepsize
     tk = 1
-    for i in 1:16
+    for i in 1:maxiter
         ∇ = g(x)
         tkn = (1 + sqrt(1 + 4tk^2)) / 2
         y = xkn + (tk - 1) / tkn * (xkn - xk)

test/backward.jl

@@ -7,7 +7,7 @@ using LinearAlgebra
 using SparseArrays
 
 # set up data
-n, k = 64, 16
+n, k = 32, 3
 A, x, b = gaussian_data(n = n, m = n, k = k)
 δ = 1e-2
 y = perturb(b, δ/2)

test/basispursuit.jl

@@ -4,7 +4,7 @@ using LinearAlgebra
 using SparseArrays
 using CompressedSensing: bp, bp_candes, bp_ard, bpd, bpd_candes, bpd_ard, sparse_data, perturb
 
-n, m = 32, 64
+n, m = 32, 48
 k = 3
 A, x, b = sparse_data(n = n, m = m, k = k, rescaled = true)
 δ = 1e-2
@@ -39,7 +39,7 @@ end
 using CompressedSensing: ista, fista
 @testset "ISTA" begin
     λ = δ/10
-    xista = ista(A, y, λ, maxiter = 1024)
+    xista = ista(A, y, λ, maxiter = 1024, stepsize = 1e-1)
     # droptol!(xista, δ)
     # @test xista.nzind == x.nzind
     # @test xista.nzind ⊆ x.nzind

test/forward.jl

@@ -4,7 +4,7 @@ using CompressedSensing: sparse_data, fr, foba, perturb, FR
 
 using Test
 using LinearAlgebra
-n, m, k = 32, 64, 3
+n, m, k = 32, 48, 3
 A, x, b = sparse_data(n = n, m = m, k = k) # needs to be determined
 δ = 1e-2
 y = perturb(b, δ)

test/matchingpursuit.jl

@@ -7,7 +7,7 @@ using SparseArrays
 # NOTE: these tests may rarely fail, because the randomly generated data is "hard"
 # a small failure probability is theoretically expected
 @testset "Matching Pursuits" begin
-    n, m, k = 32, 64, 3
+    n, m, k = 32, 48, 3
     A, x, b = sparse_data(n = n, m = m, k = k)
     δ = 1e-2 # slightly noisy
     y = perturb(b, δ/2)
@@ -30,10 +30,10 @@ using SparseArrays
     end
 
     @testset "Generalized Orthogonal Matching Pursuit" begin
-        n, m, k = 64, 96, 7
+        n, m, k = 32, 48, 3
         A, x, b = sparse_data(n = n, m = m, k = k)
         y = perturb(b, δ/2)
-        l = 3 # identify three atoms at a time
+        l = 2 # identify two atoms at a time
         # noiseless
         xgomp = gomp(A, b, l, k)
         @test xgomp.nzind == x.nzind

test/sbl.jl

@@ -4,7 +4,7 @@ using LinearAlgebra
 using CompressedSensing: sparse_data, sbl, SBL, fsbl, rmps, update!, rmp, foba, perturb
 using SparseArrays
 
-n, m, k = 64, 128, 6
+n, m, k = 32, 48, 3
 A, x, b = sparse_data(n = n, m = m, k = k)
 σ = 1e-2
 y = perturb(b, σ/2)