Mercurial > hg > absrec
changeset 13:a2d881253324
In working, not debugged yet
| author | Nic Cleju <nikcleju@gmail.com> |
|---|---|
| date | Mon, 12 Mar 2012 17:04:00 +0200 |
| parents | 86e1204b9e69 |
| children | f2eb027ed101 |
| files | ABSexact.py ABSlambda.py ABSmixed.py algos.py stdparams.py stdparams_approx.py test_approx.py |
| diffstat | 7 files changed, 647 insertions(+), 403 deletions(-) [+] |
line wrap: on
line diff
--- a/ABSexact.py Fri Mar 09 16:35:06 2012 +0200 +++ b/ABSexact.py Mon Mar 12 17:04:00 2012 +0200 @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 09 14:06:13 2012 + +@author: ncleju +""" + +import numpy +import pyCSalgos.BP.l1eq_pd +import pyCSalgos.OMP.omp_QR +import pyCSalgos.SL0.SL0 +import pyCSalgos.TST.RecommendedTST + +def bp(y,M,Omega,x0, lbtol=1e-3, mu=10, cgtol=1e-8, cgmaxiter=200, verbose=False): + + N,n = Omega.shape + D = numpy.linalg.pinv(Omega) + U,S,Vt = numpy.linalg.svd(D) + Aextra = Vt[-(N-n):,:] + + # Create aggregate problem + Atilde = numpy.vstack((numpy.dot(M,D), Aextra)) + ytilde = numpy.concatenate((y,numpy.zeros(N-n))) + + return numpy.dot(D , pyCSalgos.BP.l1eq_pd.l1eq_pd(x0,Atilde,Atilde.T,ytilde, lbtol, mu, cgtol, cgmaxiter, verbose)) + +def ompeps(y,M,Omega,epsilon): + + N,n = Omega.shape + D = numpy.linalg.pinv(Omega) + U,S,Vt = numpy.linalg.svd(D) + Aextra = Vt[-(N-n):,:] + + # Create aggregate problem + Atilde = numpy.vstack((numpy.dot(M,D), Aextra)) + ytilde = numpy.concatenate((y,numpy.zeros(N-n))) + + opts = dict() + opts['stopCrit'] = 'mse' + opts['stopTol'] = epsilon + return numpy.dot(D , pyCSalgos.OMP.omp_QR.greed_omp_qr(aggy,aggD,aggD.shape[1],opts)[0]) + +def ompk(y,M,Omega,k): + + N,n = Omega.shape + D = numpy.linalg.pinv(Omega) + U,S,Vt = numpy.linalg.svd(D) + Aextra = Vt[-(N-n):,:] + + # Create aggregate problem + Atilde = numpy.vstack((numpy.dot(M,D), Aextra)) + ytilde = numpy.concatenate((y,numpy.zeros(N-n))) + + opts = dict() + opts['stopTol'] = k + return numpy.dot(D , pyCSalgos.OMP.omp_QR.greed_omp_qr(aggy,aggD,aggD.shape[1],opts)[0]) + +def sl0(y,M,Omega, sigma_min, sigma_decrease_factor=0.5, mu_0=2, L=3, true_s=None): + + N,n = Omega.shape + D = numpy.linalg.pinv(Omega) + U,S,Vt = numpy.linalg.svd(D) + Aextra = Vt[-(N-n):,:] + + # Create aggregate problem + Atilde = numpy.vstack((numpy.dot(M,D), Aextra)) + ytilde = numpy.concatenate((y,numpy.zeros(N-n))) + + return numpy.dot(D, pyCSalgos.SL0.SL0.SL0(Atilde,ytilde,sigma_min,sigma_decrease_factor,mu_0,L,true_s)) + +def tst_recom(y,M,Omega, nsweep=300, tol=0.00001, xinitial=None, ro=None): + + N,n = Omega.shape + D = numpy.linalg.pinv(Omega) + U,S,Vt = numpy.linalg.svd(D) + Aextra = Vt[-(N-n):,:] + + # Create aggregate problem + Atilde = numpy.vstack((numpy.dot(M,D), Aextra)) + ytilde = numpy.concatenate((y,numpy.zeros(N-n))) + + return numpy.dot(D, pyCSalgos.RecomTST.RecommendedTST.RecommendedTST(Atilde, ytilde, nsweep, tol, xinitial, ro)) + \ No newline at end of file
--- a/ABSlambda.py Fri Mar 09 16:35:06 2012 +0200 +++ b/ABSlambda.py Mon Mar 12 17:04:00 2012 +0200 @@ -7,7 +7,7 @@ import numpy import pyCSalgos.BP.l1qc -import pyCSalgos.SL0.SL0_qc +import pyCSalgos.SL0.SL0_approx import pyCSalgos.OMP.omp_QR import pyCSalgos.TST.RecommendedTST @@ -18,19 +18,19 @@ U,S,Vt = numpy.linalg.svd(D) aggDupper = numpy.dot(M,D) aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) + aggD = numpy.vstack((aggDupper, lbd * aggDlower)) aggy = numpy.concatenate((y, numpy.zeros(N-n))) - return pyCSalgos.SL0.SL0_approx.SL0_approx(aggD,aggy,epsilon,sigmamin,sigma_decrease_factor,mu_0,L,A_pinv,true_s) + return pyCSalgos.SL0.SL0_approx.SL0_approx(aggD,aggy,epsilon,sigma_min,sigma_decrease_factor,mu_0,L,A_pinv,true_s) -def l1qc(y,M,Omega,epsilon,lbd, lbtol=1e-3, mu=10, cgtol=1e-8, cgmaxiter=200, verbose=False): +def bp(y,M,Omega,epsilon,lbd, x0, lbtol=1e-3, mu=10, cgtol=1e-8, cgmaxiter=200, verbose=False): N,n = Omega.shape D = numpy.linalg.pinv(Omega) U,S,Vt = numpy.linalg.svd(D) aggDupper = numpy.dot(M,D) aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) + aggD = numpy.vstack((aggDupper, lbd * aggDlower)) aggy = numpy.concatenate((y, numpy.zeros(N-n))) return pyCSalgos.BP.l1qc.l1qc_logbarrier(x0,aggD,aggD.T,aggy,epsilon, lbtol, mu, cgtol, cgmaxiter, verbose) @@ -42,7 +42,7 @@ U,S,Vt = numpy.linalg.svd(D) aggDupper = numpy.dot(M,D) aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) + aggD = numpy.hstack((aggDupper, lbd * aggDlower)) aggy = numpy.concatenate((y, numpy.zeros(N-n))) opts = dict() @@ -57,10 +57,9 @@ U,S,Vt = numpy.linalg.svd(D) aggDupper = numpy.dot(M,D) aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) + aggD = numpy.vstack((aggDupper, lbd * aggDlower)) aggy = numpy.concatenate((y, numpy.zeros(N-n))) - nsweep = 300 tol = epsilon / numpy.linalg.norm(aggy) return pyCSalgos.RecomTST.RecommendedTST.RecommendedTST(aggD, aggy, nsweep, tol, xinitial, ro) \ No newline at end of file
--- a/ABSmixed.py Fri Mar 09 16:35:06 2012 +0200 +++ b/ABSmixed.py Mon Mar 12 17:04:00 2012 +0200 @@ -27,5 +27,5 @@ Aeps = numpy.dot(M,D) Aexact = Vt[-(N-n):,:] - return numpy.dot(D, pyCSalgos.SL0.SL0_approx.SL0_approx_analysis(Aeps,Aexact,y,epsilon,sigmamin,sigma_decrease_factor,mu_0,L,Aeps_pinv,Aexact_pinv,true_s)) + return numpy.dot(D, pyCSalgos.SL0.SL0_approx.SL0_approx_analysis(Aeps,Aexact,y,epsilon,sigma_min,sigma_decrease_factor,mu_0,L,Aeps_pinv,Aexact_pinv,true_s)) \ No newline at end of file
--- a/algos.py Fri Mar 09 16:35:06 2012 +0200 +++ b/algos.py Mon Mar 12 17:04:00 2012 +0200 @@ -1,5 +1,7 @@ # -*- coding: utf-8 -*- """ +Define simple wrappers for algorithms + Created on Wed Dec 07 14:06:13 2011 @author: ncleju @@ -8,17 +10,76 @@ import numpy import pyCSalgos import pyCSalgos.GAP.GAP -import pyCSalgos.BP.l1qc -import pyCSalgos.BP.l1qec -import pyCSalgos.SL0.SL0_approx -import pyCSalgos.OMP.omp_QR -import pyCSalgos.RecomTST.RecommendedTST -import pyCSalgos.NESTA.NESTA +import ABSexact +import ABSmixed +import ABSlambda +#import pyCSalgos.BP.l1qc +#import pyCSalgos.BP.l1qec +#import pyCSalgos.SL0.SL0_approx +#import pyCSalgos.OMP.omp_QR +#import pyCSalgos.RecomTST.RecommendedTST +#import pyCSalgos.NESTA.NESTA -#========================== -# Algorithm functions -#========================== +###--------------------------------- +### Exact reconstruction algorithms +###--------------------------------- +def run_exact_gap(y,M,Omega): + """ + Wrapper for GAP algorithm for exact analysis recovery + """ + gapparams = {"num_iteration" : 1000,\ + "greedy_level" : 0.9,\ + "stopping_coefficient_size" : 1e-4,\ + "l2solver" : 'pseudoinverse',\ + "noise_level": 1e-10} + return pyCSalgos.GAP.GAP.GAP(y,M,M.T,Omega,Omega.T,gapparams,numpy.zeros(Omega.shape[1]))[0] + +def run_exact_bp(y,M,Omega): + """ + Wrapper for BP algorithm for exact analysis recovery + Algorithm implementation is l1eq_pd() from l1-magic toolbox + """ + return ABSexact.bp(y,M,Omega,numpy.zeros(Omega.shape[0])) + +def run_exact_ompeps(y,M,Omega): + """ + Wrapper for OMP algorithm for exact analysis recovery, with stopping criterion = epsilon + """ + return ABSexact.ompeps(y,M,Omega,1e-9) + +#def run_exact_ompk(y,M,Omega) +# """ +# Wrapper for OMP algorithm for exact analysis recovery, with stopping criterion = fixed no. of atoms +# """ + +def run_exact_sl0(y,M,Omega): + """ + Wrapper for SL0 algorithm for exact analysis recovery + """ + sigma_min = 1e-12 + sigma_decrease_factor = 0.5 + mu_0 = 2 + L = 20 + return ABSexact.sl0(y,M,Omega, sigma_min, sigma_decrease_factor, mu_0, L) + +def run_exact_tst(y,M,Omega): + """ + Wrapper for TST algorithm (with default optimized params) for exact analysis recovery + """ + nsweep = 300 + tol = 1e-5 + return ABSexact.tst_recom(y,M,Omega, nsweep, tol) + + +###--------------------------------------- +### Approximate reconstruction algorithms +###--------------------------------------- +# 1. Native + def run_gap(y,M,Omega,epsilon): + """ + Wrapper for GAP algorithm for approximate analysis recovery + """ gapparams = {"num_iteration" : 1000,\ "greedy_level" : 0.9,\ "stopping_coefficient_size" : 1e-4,\ @@ -26,35 +87,10 @@ "noise_level": epsilon} return pyCSalgos.GAP.GAP.GAP(y,M,M.T,Omega,Omega.T,gapparams,numpy.zeros(Omega.shape[1]))[0] -def run_bp_analysis(y,M,Omega,epsilon): - - N,n = Omega.shape - D = numpy.linalg.pinv(Omega) - U,S,Vt = numpy.linalg.svd(D) - Aeps = numpy.dot(M,D) - Aexact = Vt[-(N-n):,:] - # We don't ned any aggregate matrices anymore - - x0 = numpy.zeros(N) - return numpy.dot(D , pyCSalgos.BP.l1qec.l1qec_logbarrier(x0,Aeps,Aeps.T,y,epsilon,Aexact,Aexact.T,numpy.zeros(N-n))) - -def run_sl0_analysis(y,M,Omega,epsilon): - - N,n = Omega.shape - D = numpy.linalg.pinv(Omega) - U,S,Vt = numpy.linalg.svd(D) - Aeps = numpy.dot(M,D) - Aexact = Vt[-(N-n):,:] - # We don't ned any aggregate matrices anymore - - sigmamin = 0.001 - sigma_decrease_factor = 0.5 - mu_0 = 2 - L = 10 - return numpy.dot(D , pyCSalgos.SL0.SL0_approx.SL0_approx_analysis(Aeps,Aexact,y,epsilon,sigmamin,sigma_decrease_factor,mu_0,L)) - def run_nesta(y,M,Omega,epsilon): - + """ + Wrapper for NESTA algorithm for approximate analysis recovery + """ U,S,V = numpy.linalg.svd(M, full_matrices = True) V = V.T # Make like Matlab m,n = M.shape # Make like Matlab @@ -65,74 +101,195 @@ opts = {'U':Omega, 'Ut':Omega.T.copy(), 'USV':optsUSV, 'TolVar':1e-5, 'Verbose':0} return pyCSalgos.NESTA.NESTA.NESTA(M, None, y, opt_muf, epsilon, opts)[0] +# 2. ABS-mixed -def run_sl0(y,M,Omega,D,U,S,Vt,epsilon,lbd): - - N,n = Omega.shape - #D = numpy.linalg.pinv(Omega) - #U,S,Vt = numpy.linalg.svd(D) - aggDupper = numpy.dot(M,D) - aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) - aggy = numpy.concatenate((y, numpy.zeros(N-n))) - - sigmamin = 0.001 +def run_mixed_sl0(y,M,Omega,epsilon): + """ + Wrapper for SL0-mixed algorithm for approximate analysis recovery + """ + sigma_min = 0.001 sigma_decrease_factor = 0.5 mu_0 = 2 L = 10 - return pyCSalgos.SL0.SL0_approx.SL0_approx(aggD,aggy,epsilon,sigmamin,sigma_decrease_factor,mu_0,L) + return ABSmixed.sl0(y,M,Omega,epsilon,sigma_min, sigma_decrease_factor, mu_0, L) + +def run_mixed_bp(y,M,Omega,epsilon): + """ + Wrapper for BP-mixed algorithm for approximate analysis recovery + """ + return ABSmixed.bp(y,M,Omega,epsilon, numpy.zeros(Omega.shape[0])) + +# 3. ABS-lambda + +def run_lambda_sl0(y,M,Omega,epsilon,lbd): + """ + Wrapper for SL0 algorithm within ABS-lambda approach for approximate analysis recovery + """ + sigma_min = 0.001 + sigma_decrease_factor = 0.5 + mu_0 = 2 + L = 10 + return ABSlambda.sl0(y,M,Omega,epsilon, lbd, sigma_min, sigma_decrease_factor, mu_0, L) + +def run_lambda_bp(y,M,Omega,epsilon,lbd): + """ + Wrapper for BP algorithm within ABS-lambda approach for approximate analysis recovery + """ + return ABSlambda.bp(y,M,Omega,epsilon,lbd,numpy.zeros(Omega.shape[0])) + +def run_lambda_ompeps(y,M,Omega,epsilon,lbd): + """ + Wrapper for OMP algorithm, with stopping criterion = epsilon, + for approximate analysis recovery within ABS-lambda approach + """ + return ABSlambda.ompeps(y,M,Omega,epsilon,lbd) + +def run_lambda_tst(y,M,Omega,epsilon,lbd): + """ + Wrapper for TST algorithm (with default optimized params) + for approximate analysis recovery within ABS-lambda approach + """ + nsweep = 300 + return ABSlambda.tst_recom(y,M,Omega,epsilon,lbd, nsweep) -def run_bp(y,M,Omega,D,U,S,Vt,epsilon,lbd): - N,n = Omega.shape - #D = numpy.linalg.pinv(Omega) - #U,S,Vt = numpy.linalg.svd(D) - aggDupper = numpy.dot(M,D) - aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) - aggy = numpy.concatenate((y, numpy.zeros(N-n))) +### Algorithm tuples +## Exact recovery +exact_gap = (run_exact_gap, 'GAP') +exact_bp = (run_exact_bp, 'ABS-exact: BP') +exact_ompeps = (run_exact_ompeps, 'ABS-exact: OMP-eps') +exact_sl0 = (run_exact_sl0, 'ABS-exact: SL0') +exact_tst = (run_exact_tst, 'ABS-exact: TST') +## Approximate recovery +# Native +gap = (run_gap, 'GAP') +nesta = (run_nesta, 'NESTA') +# ABS-mixed +mixed_sl0 = (run_mixed_sl0, 'ABS-mixed: SL0') +mixed_bp = (run_mixed_bp, 'ABS-mixed: BP') +# ABS-lambda +lambda_sl0 = (run_lambda_sl0, 'ABS-lambda: SL0') +lambda_bp = (run_lambda_bp, 'ABS-lambda: BP') +lambda_ompeps = (run_lambda_ompeps, 'ABS-lambda: OMP-eps') +lambda_tst = (run_lambda_tst, 'ABS-lambda: TST') - x0 = numpy.zeros(N) - return pyCSalgos.BP.l1qc.l1qc_logbarrier(x0,aggD,aggD.T,aggy,epsilon) - -def run_ompeps(y,M,Omega,D,U,S,Vt,epsilon,lbd): - - N,n = Omega.shape - #D = numpy.linalg.pinv(Omega) - #U,S,Vt = numpy.linalg.svd(D) - aggDupper = numpy.dot(M,D) - aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) - aggy = numpy.concatenate((y, numpy.zeros(N-n))) - - opts = dict() - opts['stopCrit'] = 'mse' - opts['stopTol'] = epsilon**2 / aggy.size - return pyCSalgos.OMP.omp_QR.greed_omp_qr(aggy,aggD,aggD.shape[1],opts)[0] - -def run_tst(y,M,Omega,D,U,S,Vt,epsilon,lbd): - - N,n = Omega.shape - #D = numpy.linalg.pinv(Omega) - #U,S,Vt = numpy.linalg.svd(D) - aggDupper = numpy.dot(M,D) - aggDlower = Vt[-(N-n):,:] - aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) - aggy = numpy.concatenate((y, numpy.zeros(N-n))) - - nsweep = 300 - tol = epsilon / numpy.linalg.norm(aggy) - return pyCSalgos.RecomTST.RecommendedTST.RecommendedTST(aggD, aggy, nsweep=nsweep, tol=tol) - - -#========================== -# Define tuples (algorithm function, name) -#========================== -gap = (run_gap, 'GAP') -sl0 = (run_sl0, 'SL0a') -sl0analysis = (run_sl0_analysis, 'SL0a2') -bpanalysis = (run_bp_analysis, 'BPa2') -nesta = (run_nesta, 'NESTA') -bp = (run_bp, 'BP') -ompeps = (run_ompeps, 'OMPeps') -tst = (run_tst, 'TST') \ No newline at end of file +##========================== +## Algorithm functions +##========================== +#def run_gap(y,M,Omega,epsilon): +# gapparams = {"num_iteration" : 1000,\ +# "greedy_level" : 0.9,\ +# "stopping_coefficient_size" : 1e-4,\ +# "l2solver" : 'pseudoinverse',\ +# "noise_level": epsilon} +# return pyCSalgos.GAP.GAP.GAP(y,M,M.T,Omega,Omega.T,gapparams,numpy.zeros(Omega.shape[1]))[0] +# +#def run_bp_analysis(y,M,Omega,epsilon): +# +# N,n = Omega.shape +# D = numpy.linalg.pinv(Omega) +# U,S,Vt = numpy.linalg.svd(D) +# Aeps = numpy.dot(M,D) +# Aexact = Vt[-(N-n):,:] +# # We don't ned any aggregate matrices anymore +# +# x0 = numpy.zeros(N) +# return numpy.dot(D , pyCSalgos.BP.l1qec.l1qec_logbarrier(x0,Aeps,Aeps.T,y,epsilon,Aexact,Aexact.T,numpy.zeros(N-n))) +# +#def run_sl0_analysis(y,M,Omega,epsilon): +# +# N,n = Omega.shape +# D = numpy.linalg.pinv(Omega) +# U,S,Vt = numpy.linalg.svd(D) +# Aeps = numpy.dot(M,D) +# Aexact = Vt[-(N-n):,:] +# # We don't ned any aggregate matrices anymore +# +# sigmamin = 0.001 +# sigma_decrease_factor = 0.5 +# mu_0 = 2 +# L = 10 +# return numpy.dot(D , pyCSalgos.SL0.SL0_approx.SL0_approx_analysis(Aeps,Aexact,y,epsilon,sigmamin,sigma_decrease_factor,mu_0,L)) +# +#def run_nesta(y,M,Omega,epsilon): +# +# U,S,V = numpy.linalg.svd(M, full_matrices = True) +# V = V.T # Make like Matlab +# m,n = M.shape # Make like Matlab +# S = numpy.hstack((numpy.diag(S), numpy.zeros((m,n-m)))) +# +# opt_muf = 1e-3 +# optsUSV = {'U':U, 'S':S, 'V':V} +# opts = {'U':Omega, 'Ut':Omega.T.copy(), 'USV':optsUSV, 'TolVar':1e-5, 'Verbose':0} +# return pyCSalgos.NESTA.NESTA.NESTA(M, None, y, opt_muf, epsilon, opts)[0] +# +# +#def run_sl0(y,M,Omega,D,U,S,Vt,epsilon,lbd): +# +# N,n = Omega.shape +# #D = numpy.linalg.pinv(Omega) +# #U,S,Vt = numpy.linalg.svd(D) +# aggDupper = numpy.dot(M,D) +# aggDlower = Vt[-(N-n):,:] +# aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) +# aggy = numpy.concatenate((y, numpy.zeros(N-n))) +# +# sigmamin = 0.001 +# sigma_decrease_factor = 0.5 +# mu_0 = 2 +# L = 10 +# return pyCSalgos.SL0.SL0_approx.SL0_approx(aggD,aggy,epsilon,sigmamin,sigma_decrease_factor,mu_0,L) +# +#def run_bp(y,M,Omega,D,U,S,Vt,epsilon,lbd): +# +# N,n = Omega.shape +# #D = numpy.linalg.pinv(Omega) +# #U,S,Vt = numpy.linalg.svd(D) +# aggDupper = numpy.dot(M,D) +# aggDlower = Vt[-(N-n):,:] +# aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) +# aggy = numpy.concatenate((y, numpy.zeros(N-n))) +# +# x0 = numpy.zeros(N) +# return pyCSalgos.BP.l1qc.l1qc_logbarrier(x0,aggD,aggD.T,aggy,epsilon) +# +#def run_ompeps(y,M,Omega,D,U,S,Vt,epsilon,lbd): +# +# N,n = Omega.shape +# #D = numpy.linalg.pinv(Omega) +# #U,S,Vt = numpy.linalg.svd(D) +# aggDupper = numpy.dot(M,D) +# aggDlower = Vt[-(N-n):,:] +# aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) +# aggy = numpy.concatenate((y, numpy.zeros(N-n))) +# +# opts = dict() +# opts['stopCrit'] = 'mse' +# opts['stopTol'] = epsilon**2 / aggy.size +# return pyCSalgos.OMP.omp_QR.greed_omp_qr(aggy,aggD,aggD.shape[1],opts)[0] +# +#def run_tst(y,M,Omega,D,U,S,Vt,epsilon,lbd): +# +# N,n = Omega.shape +# #D = numpy.linalg.pinv(Omega) +# #U,S,Vt = numpy.linalg.svd(D) +# aggDupper = numpy.dot(M,D) +# aggDlower = Vt[-(N-n):,:] +# aggD = numpy.concatenate((aggDupper, lbd * aggDlower)) +# aggy = numpy.concatenate((y, numpy.zeros(N-n))) +# +# nsweep = 300 +# tol = epsilon / numpy.linalg.norm(aggy) +# return pyCSalgos.RecomTST.RecommendedTST.RecommendedTST(aggD, aggy, nsweep=nsweep, tol=tol) +# +##========================== +## Define tuples (algorithm function, name) +##========================== +#gap = (run_gap, 'GAP') +#sl0 = (run_sl0, 'SL0a') +#sl0analysis = (run_sl0_analysis, 'SL0a2') +#bpanalysis = (run_bp_analysis, 'BPa2') +#nesta = (run_nesta, 'NESTA') +#bp = (run_bp, 'BP') +#ompeps = (run_ompeps, 'OMPeps') +#tst = (run_tst, 'TST') \ No newline at end of file
--- a/stdparams.py Fri Mar 09 16:35:06 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,287 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Wed Dec 07 14:04:40 2011 - -@author: ncleju -""" - -import numpy -from algos import * - -#========================== -# Standard parameters -#========================== -# Standard parameters for quick testing -# Algorithms: GAP, SL0 and BP -# d=50, sigma = 2, delta and rho only 3 x 3, lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -# Useful for short testing -def stdtest(): - # Define which algorithms to run - algosN = nesta, # tuple of algorithms not depending on lambda - #algosL = sl0,bp # tuple of algorithms depending on lambda (our ABS approach) - algosL = sl0, - - d = 50.0 - sigma = 2.0 - deltas = numpy.array([0.05, 0.45, 0.95]) - rhos = numpy.array([0.05, 0.45, 0.95]) - #deltas = numpy.array([0.95]) - #deltas = numpy.arange(0.05,1.,0.05) - #rhos = numpy.array([0.05]) - numvects = 10; # Number of vectors to generate - SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_stdtest.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_stdtest_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - - -# Standard parameters 1 -# All algorithms, 100 vectors -# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -def std1(): - # Define which algorithms to run - algosN = gap,sl0analysis,bpanalysis,nesta # tuple of algorithms not depending on lambda - algosL = sl0,bp,ompeps,tst # tuple of algorithms depending on lambda (our ABS approach) - - d = 50.0; - sigma = 2.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std1.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std1_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - - -# Standard parameters 2 -# All algorithms, 100 vectors -# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -def std2(): - # Define which algorithms to run - algosN = gap,sl0analysis,bpanalysis,nesta # tuple of algorithms not depending on lambda - algosL = sl0,bp,ompeps,tst # tuple of algorithms depending on lambda (our ABS approach) - - d = 20.0 - sigma = 10.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std2.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std2_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - - - # Standard parameters 3 -# All algorithms, 100 vectors -# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -# IDENTICAL with 1 but with 10dB SNR noise -def std3(): - # Define which algorithms to run - algosN = gap,sl0analysis,bpanalysis,nesta # tuple of algorithms not depending on lambda - algosL = sl0,bp,ompeps,tst # tuple of algorithms depending on lambda (our ABS approach) - - d = 50.0; - sigma = 2.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std3.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std3_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - -# Standard parameters 4 -# All algorithms, 100 vectors -# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -# Identical to 2 but with 10dB SNR noise -def std4(): - # Define which algorithms to run - algosN = gap,sl0analysis,bpanalysis,nesta # tuple of algorithms not depending on lambda - algosL = sl0,bp,ompeps,tst # tuple of algorithms depending on lambda (our ABS approach) - - d = 20.0 - sigma = 10.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std4.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std4_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - -# Standard parameters 1nesta -# Only NESTA, 100 vectors -# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -# Identical to std1 but with only NESTA -def std1nesta(): - # Define which algorithms to run - algosN = nesta, # tuple of algorithms not depending on lambda - algosL = () # tuple of algorithms depending on lambda (our ABS approach) - - d = 50.0; - sigma = 2.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std1nesta.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std1nesta_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - -# Standard parameters 2nesta -# Only NESTA, 100 vectors -# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -# Identical with std2, but with only NESTA -def std2nesta(): - # Define which algorithms to run - algosN = nesta, # tuple of algorithms not depending on lambda - algosL = () # tuple of algorithms depending on lambda (our ABS approach) - - d = 20.0 - sigma = 10.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std2nesta.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std2nesta_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - - # Standard parameters 3nesta -# Only NESTA, 100 vectors -# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -# IDENTICAL with 3 but with only NESTA -def std3nesta(): - # Define which algorithms to run - algosN = nesta, # tuple of algorithms not depending on lambda - algosL = () # tuple of algorithms depending on lambda (our ABS approach) - - d = 50.0; - sigma = 2.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std3nesta.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std3nesta_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts - -# Standard parameters 4nesta -# Only NESTA, 100 vectors -# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 -# Do save data, do save plots, don't show plots -# Identical to 4 but with only NESTA -def std4nesta(): - # Define which algorithms to run - algosN = nesta, # tuple of algorithms not depending on lambda - algosL = () # tuple of algorithms depending on lambda (our ABS approach) - - d = 20.0 - sigma = 10.0 - deltas = numpy.arange(0.05,1.,0.05) - rhos = numpy.arange(0.05,1.,0.05) - numvects = 100; # Number of vectors to generate - SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy - # Values for lambda - #lambdas = [0 10.^linspace(-5, 4, 10)]; - lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) - - dosavedata = True - savedataname = 'approx_pt_std4nesta.mat' - doshowplot = False - dosaveplot = True - saveplotbase = 'approx_pt_std4nesta_' - saveplotexts = ('png','pdf','eps') - - return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ - doshowplot,dosaveplot,saveplotbase,saveplotexts \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stdparams_approx.py Mon Mar 12 17:04:00 2012 +0200 @@ -0,0 +1,287 @@ +# -*- coding: utf-8 -*- +""" +Created on Wed Dec 07 14:04:40 2011 + +@author: ncleju +""" + +import numpy +from algos import * + +#========================== +# Standard parameters +#========================== +# Standard parameters for quick testing +# Algorithms: GAP, SL0 and BP +# d=50, sigma = 2, delta and rho only 3 x 3, lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +# Useful for short testing +def stdtest(): + # Define which algorithms to run + algosN = nesta, # tuple of algorithms not depending on lambda + #algosL = sl0,bp # tuple of algorithms depending on lambda (our ABS approach) + algosL = lambda_sl0, + + d = 50.0 + sigma = 2.0 + deltas = numpy.array([0.05, 0.45, 0.95]) + rhos = numpy.array([0.05, 0.45, 0.95]) + #deltas = numpy.array([0.95]) + #deltas = numpy.arange(0.05,1.,0.05) + #rhos = numpy.array([0.05]) + numvects = 10; # Number of vectors to generate + SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_stdtest.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_stdtest_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + + +# Standard parameters 1 +# All algorithms, 100 vectors +# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +def std1(): + # Define which algorithms to run + algosN = gap,mixed_sl0,mixed_bp,nesta # tuple of algorithms not depending on lambda + algosL = lambda_sl0,lambda_bp,lambda_ompeps,lambda_tst # tuple of algorithms depending on lambda (our ABS approach) + + d = 50.0; + sigma = 2.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std1.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std1_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + + +# Standard parameters 2 +# All algorithms, 100 vectors +# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +def std2(): + # Define which algorithms to run + algosN = gap,mixed_sl0,mixed_bp,nesta # tuple of algorithms not depending on lambda + algosL = lambda_sl0,lambda_bp,lambda_ompeps,lambda_tst # tuple of algorithms depending on lambda (our ABS approach) + + d = 20.0 + sigma = 10.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std2.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std2_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + + + # Standard parameters 3 +# All algorithms, 100 vectors +# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +# IDENTICAL with 1 but with 10dB SNR noise +def std3(): + # Define which algorithms to run + algosN = gap,mixed_sl0,mixed_bp,nesta # tuple of algorithms not depending on lambda + algosL = lambda_sl0,lambda_bp,lambda_ompeps,lambda_tst # tuple of algorithms depending on lambda (our ABS approach) + + d = 50.0; + sigma = 2.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std3.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std3_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + +# Standard parameters 4 +# All algorithms, 100 vectors +# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +# Identical to 2 but with 10dB SNR noise +def std4(): + # Define which algorithms to run + algosN = gap,mixed_sl0,mixed_bp,nesta # tuple of algorithms not depending on lambda + algosL = lambda_sl0,lambda_bp,lambda_ompeps,lambda_tst # tuple of algorithms depending on lambda (our ABS approach) + + d = 20.0 + sigma = 10.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std4.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std4_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + +# Standard parameters 1nesta +# Only NESTA, 100 vectors +# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +# Identical to std1 but with only NESTA +def std1nesta(): + # Define which algorithms to run + algosN = nesta, # tuple of algorithms not depending on lambda + algosL = () # tuple of algorithms depending on lambda (our ABS approach) + + d = 50.0; + sigma = 2.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std1nesta.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std1nesta_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + +# Standard parameters 2nesta +# Only NESTA, 100 vectors +# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +# Identical with std2, but with only NESTA +def std2nesta(): + # Define which algorithms to run + algosN = nesta, # tuple of algorithms not depending on lambda + algosL = () # tuple of algorithms depending on lambda (our ABS approach) + + d = 20.0 + sigma = 10.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 20.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std2nesta.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std2nesta_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + + # Standard parameters 3nesta +# Only NESTA, 100 vectors +# d=50, sigma = 2, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +# IDENTICAL with 3 but with only NESTA +def std3nesta(): + # Define which algorithms to run + algosN = nesta, # tuple of algorithms not depending on lambda + algosL = () # tuple of algorithms depending on lambda (our ABS approach) + + d = 50.0; + sigma = 2.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std3nesta.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std3nesta_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts + +# Standard parameters 4nesta +# Only NESTA, 100 vectors +# d=20, sigma = 10, delta and rho full resolution (0.05 step), lambdas = 0, 1e-4, 1e-2, 1, 100, 10000 +# Do save data, do save plots, don't show plots +# Identical to 4 but with only NESTA +def std4nesta(): + # Define which algorithms to run + algosN = nesta, # tuple of algorithms not depending on lambda + algosL = () # tuple of algorithms depending on lambda (our ABS approach) + + d = 20.0 + sigma = 10.0 + deltas = numpy.arange(0.05,1.,0.05) + rhos = numpy.arange(0.05,1.,0.05) + numvects = 100; # Number of vectors to generate + SNRdb = 10.; # This is norm(signal)/norm(noise), so power, not energy + # Values for lambda + #lambdas = [0 10.^linspace(-5, 4, 10)]; + lambdas = numpy.array([0., 0.0001, 0.01, 1, 100, 10000]) + + dosavedata = True + savedataname = 'approx_pt_std4nesta.mat' + doshowplot = False + dosaveplot = True + saveplotbase = 'approx_pt_std4nesta_' + saveplotexts = ('png','pdf','eps') + + return algosN,algosL,d,sigma,deltas,rhos,lambdas,numvects,SNRdb,dosavedata,savedataname,\ + doshowplot,dosaveplot,saveplotbase,saveplotexts \ No newline at end of file
--- a/test_approx.py Fri Mar 09 16:35:06 2012 +0200 +++ b/test_approx.py Mon Mar 12 17:04:00 2012 +0200 @@ -11,9 +11,13 @@ import os import time -import stdparams -import pyCSalgos.Analysis +import stdparams_approx +import AnalysisGenerate +# For exceptions +import pyCSalgos.BP.l1qec +import pyCSalgos.BP.l1qc +import pyCSalgos.NESTA.NESTA #========================== # Pool initializer function (multiprocessing) # Needed to pass the shared variable to the worker processes @@ -259,12 +263,13 @@ for ilbd,lbd in zip(np.arange(lambdas.size),lambdas): for iy in np.arange(y.shape[1]): D = np.linalg.pinv(Omega) - U,S,Vt = np.linalg.svd(D) + #U,S,Vt = np.linalg.svd(D) for algofunc,strname in algosL: epsilon = 1.1 * np.linalg.norm(realnoise[:,iy]) try: timestart = time.time() - gamma = algofunc(y[:,iy],M,Omega,D,U,S,Vt,epsilon,lbd) + #gamma = algofunc(y[:,iy],M,Omega,D,U,S,Vt,epsilon,lbd) + gamma = algofunc(y[:,iy],M,Omega,epsilon,lbd) elapsed[strname][ilbd] = elapsed[strname][ilbd] + (time.time() - timestart) except pyCSalgos.BP.l1qc.l1qcInputValueError as e: print "Caught exception when running algorithm",strname," :",e.message @@ -296,7 +301,7 @@ l = round(d - rho*m); # Generate Omega and data based on parameters - Omega = pyCSalgos.Analysis.Generate_Analysis_Operator(d, p); + Omega = AnalysisGenerate.Generate_Analysis_Operator(d, p); # Optionally make Omega more coherent U,S,Vt = np.linalg.svd(Omega); Sdnew = S * (1+np.arange(S.size)) # Make D coherent, not Omega! @@ -304,7 +309,7 @@ Omega = np.dot(U , np.dot(Snew,Vt)) # Generate data - x0,y,M,Lambda,realnoise = pyCSalgos.Analysis.Generate_Data_Known_Omega(Omega, d,p,m,l,noiselevel, numvects,'l0'); + x0,y,M,Lambda,realnoise = AnalysisGenerate.Generate_Data_Known_Omega(Omega, d,p,m,l,noiselevel, numvects,'l0'); return Omega,x0,y,M,realnoise