comparison DL/two-step DL/SMALL_two_step_DL.m @ 224:fd0b5d36f6ad danieleb

Updated the contents of this branch with the contents of the default branch.

 function DL=SMALL_two_step_DL(Problem, DL)
+    
+    %%  DL=SMALL_two_step_DL(Problem, DL) learn a dictionary using two_step_DL
+    %   The specific parameters of the DL structure are:
+    %   -name: can be either 'ols', 'opt', 'MOD', KSVD' or 'LGD'.
+    %   -param.learningRate: a step size used by 'ols' and 'opt'. Default: 0.1
+    %   for 'ols', 1 for 'opt'.
+    %   -param.flow: can be either 'sequential' or 'parallel'. De fault:
+    %   'sequential'. Not used by MOD.
+    %   -param.coherence: a real number between 0 and 1. If present, then
+    %   a low-coherence constraint is added to the learning.
+    %
+    %   See dico_update.m for more details.
 
 % determine which solver is used for sparse representation %
 
 solver = DL.param.solver;
 
-% determine which type of udate to use ('KSVD', 'MOD','MOCOD','ols' or 'mailhe') %
+% determine which type of udate to use ('KSVD', 'MOD', 'ols', 'opt' or 'LGD') %
 
 typeUpdate = DL.name;
 
 sig = Problem.b;
 

 end
 
 
 % initialize the dictionary %
 
-if (isfield(DL.param,'initdict')) && ~isempty(DL.param.initdict);
+if (isfield(DL.param,'initdict'))
   if (any(size(DL.param.initdict)==1) && all(iswhole(DL.param.initdict(:))))
     dico = sig(:,DL.param.initdict(1:dictsize));
   else
     if (size(DL.param.initdict,1)~=size(sig,1) || size(DL.param.initdict,2)<dictsize)
       error('Invalid initial dictionary');

 else
     flow = 'sequential';
 end
 
 % learningRate. If the type is 'ols', it is the descent step of
-% the gradient (typical choice: 0.1). If the type is 'mailhe', the 
-% descent step is the optimal step*rho (typical choice: 1, although 2
-% or 3 seems to work better). Not used for MOD and KSVD.
+% the gradient (default: 0.1). If the type is 'mailhe', the 
+% descent step is the optimal step*rho (default: 1, although 2 works
+% better). Not used for MOD and KSVD.
 
 if isfield(DL.param,'learningRate')
     learningRate = DL.param.learningRate;
 else
-    learningRate = 0.1;
+    switch typeUpdate
+        case 'ols'
+            learningRate = 0.1;
+        otherwise
+            learningRate = 1;
+    end
 end
 
 % number of iterations (default is 40) %
 
 if isfield(DL.param,'iternum')

 else
     iternum = 40;
 end
 % determine if we should do decorrelation in every iteration  %
 
-if isfield(DL.param,'coherence') && isscalar(DL.param.coherence)
+if isfield(DL.param,'coherence')
     decorrelate = 1;
     mu = DL.param.coherence;
 else
     decorrelate = 0;
 end
-
-if ~isfield(DL.param,'decFcn'), DL.param.decFcn = 'none'; end
 
 % show dictonary every specified number of iterations
 
 if isfield(DL.param,'show_dict')
     show_dictionary=1;

 solver.profile = 0;
 
 % main loop %
 
 for i = 1:iternum
-    %disp([num2str(i) '/' num2str(iternum)]);
-    %SPARSE CODING STEP
-	Problem.A = dico;
+    Problem.A = dico;
     solver = SMALL_solve(Problem, solver);
-	%DICTIONARY UPDATE STEP
-	if strcmpi(typeUpdate,'mocod')			%if update is MOCOD create parameters structure
-		mocodParams = struct('zeta',DL.param.zeta,...	%coherence regularization factor
-							 'eta',DL.param.eta,...		%atoms norm regularization factor
-							 'Dprev',dico);				%previous dictionary
-		dico = dico_update(dico,sig,solver.solution,typeUpdate,flow,learningRate,mocodParams);
-	else
-		[dico, solver.solution] = dico_update(dico, sig, solver.solution, ...
-			typeUpdate, flow, learningRate);
-		dico = normcols(dico);
-	end
-    
-        switch lower(DL.param.decFcn)
-            case 'ink-svd'
-                dico = dico_decorr_symetric(dico,mu,solver.solution);
-            case 'grassmannian'
-                [n m] = size(dico);
-                dico = grassmannian(n,m,[],0.9,0.99,dico);
-			case 'shrinkgram'
-				dico = shrinkgram(dico,mu);
-			case 'iterproj'
-				dico = iterativeprojections(dico,mu,Problem.b1,solver.solution);
-            otherwise
-        end
+    [dico, solver.solution] = dico_update(dico, sig, solver.solution, ...
+        typeUpdate, flow, learningRate);
+    if (decorrelate)
+        dico = dico_decorr_symetric(dico, mu, solver.solution);
+    end
     
    if ((show_dictionary)&&(mod(i,show_iter)==0))
        dictimg = SMALL_showdict(dico,[8 8],...
             round(sqrt(size(dico,2))),round(sqrt(size(dico,2))),'lines','highcontrast');  
        figure(2); imagesc(dictimg);colormap(gray);axis off; axis image;