lssvmbaybackward.m

The goal of SPID is to provide the user with tools capable to simulate, preprocess, process and clas

function [backList, ptrnNew, vpredNew, nDel]=lssvmBayBackward(ptrnInit, ttrn, vpredInit, L3Init, sigInit, gamInit, nstep)
% function [backList, ptrnNew, vpredNew, nDel]=lssvmBayBackward(ptrnInit, ttrn, vpredInit, L3Init, sigInit, gamInit, nstep)

if nargin < 3,
   disp('No enough inputs'), help lssvmBayBackward, 
   return,
end

if nargin < 4, L3Init = inf; end,
if nargin < 5, sigInit=3; end,
if nargin < 6, gamInit = 1; end,

nv=size(ptrnInit,2);
if nargin < 7, nstep = nv; end,
nstep = min(nstep, nv);

disp('------------------------------------------------'),
disp('--- Lssvm Bayesian Input Selection: backward ---'),
disp('------------------------------------------------'),

L3star=L3Init; 
backList=struct('type','-','name', 'null', 'L3', L3Init, 'sigOpt', sigInit, 'gamOpt', gamInit, 'neffPar', 0); idxRmvd=[]; N_inputs=nv; nDel=0;
for step=1:nstep,
    if step ==1,
      index = [1:nv];
      gam_optD=gamInit;
    else
	  [mx, iRmvd]=min(L3D);
	  gam_optD=gammaD(iRmvd);
      index = setdiff([1:nv], [idxRmvd, iRmvd]);
  	end,
  
	Xtrain = ptrnInit(:,index); Ytrain = ttrn;
	N_inputs = size(Xtrain, 2);
	disp(['#inputs : ', num2str(N_inputs), ' x ', num2str(length(ttrn))]),
    
    if (step>1)|(L3Init==inf),
      %Sigma = sqrt(N_inputs/8)*[0.5 1 1.5 2 3 4 5 6 8 10];
      Sigma = sqrt(N_inputs/8)*[1 2 3 4 5 6];
  	  L3=[]; BPlikeli2r=[];
	  for i = 1:length(Sigma),
   	   %disp(['Sigma ', num2str(i), ': ', num2str(Sigma(i))]),
	   if i == 1,
      	startgamma = gam_optD;
       else 
      	startgamma = gamma(i-1);
	   end
	   [Bmu(i), Bzeta(i), Bnumeffpar(i), BPlikeli3(i), BPlikeli2(i), Bsloga(i), Bslogb(i)] ...
   	    = optim_gammaBayLSSVMardr(startgamma, Sigma(i), Xtrain, Ytrain, 1);
       L3(i)= 1/2*BPlikeli2(i)-log(Bsloga(i))-log(Bslogb(i));
       gamma(i) = abs(Bzeta(i)/Bmu(i));
    
	  end,
   
       % To check if to remove the variable or not!
       if min(L3) < L3star,
         L3star=min(L3);
         [m, iopt] = min(L3);
         sig_opt = Sigma(iopt);
         gam_opt = gamma(iopt);
         neffPar = Bnumeffpar(iopt);

          if step == 1,
            vr='null';
          else,
            vr=vpredInit{iRmvd};
            nDel=nDel+1;
            idxRmvd=[idxRmvd, iRmvd];
          end,
          backList(step).type = '-';
          backList(step).name = vr;
          backList(step).L3=L3star;
          backList(step).sigOpt=sig_opt;
          backList(step).gamOpt=gam_opt; 
          backList(step).neffPar=neffPar;

          disp(['For ', num2str(N_inputs), ' inputs:']),
          disp(['  Optimal Sigma : ', num2str(sig_opt), ' ; Optimal gamma : ', num2str(gam_opt)]),
          disp(['  current L3    : ', num2str(L3star), ' ; #effect Param : ', num2str(neffPar)]),
          disp(['  ======= ', num2str(nDel), '. variable removed: ', vr]),
      
        else
          disp('No more variable can be removed!'),
          break,
    	 end,

    	%figure(step*2-1), hold on, plot(L3, 'b'), plot(0.5*BPlikeli2, 'r'), hold off,
        
    else
       sig_opt=sigInit; gam_opt=gamInit; 
    end,

    if N_inputs < 2,
       break,
    end,
	L3D=[]; BPl2D=[];
	for i = 1:N_inputs,
	   idx = setdiff(index, index(i));

	   [BmuD(i), BzetaD(i), BnumeffparD(i), BPl3D(i), BPl2D(i), BsaD(i), BsbD(i)] ...
   	    = optim_gammaBayLSSVMardr(gam_opt, sig_opt, ptrnInit(:, idx), Ytrain, 1);
	   L3D(i)= 1/2*BPl2D(i)-log(BsaD(i))-log(BsbD(i));

	   gammaD(i) = abs(BzetaD(i)/BmuD(i));
	end

%	figure(2*step), hold on, plot(L3D, 'b'), plot(0.5*BPl2D, 'r'), hold off,

end, % For step 


disp('Backward elimation summary: '),

for bi=1:length(backList),
   disp([num2str(bi), '. ', backList(bi).name, ' : ', num2str(backList(bi).L3)]),
end,

if nDel>0,
    idxNew=setdiff([1:nv], idxRmvd);
    ptrnNew=ptrnInit(:,idxNew);

    vpredNew={};
    for i=1:nv-nDel,
        vpredNew{i}=vpredInit{idxNew(i)};
    end,
else
    vpredNew=vpredInit;
    ptrnNew=ptrnInit;
end,

return,