lssvmbaybackward0.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, displ)
% function [backList, ptrnNew, vpredNew, nDel]=lssvmBayBackward(ptrnInit, ttrn, vpredInit, L3Init, sigInit, gamInit, nstep, displ)

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-1; end,
nstep = min(nstep, nv-1);
initList=[1:nv];

if nargin < 8, displ=1; end,

global nlsig vFixed kernelType,
idxFixed=varIndex(vpredInit, vFixed); nFixed=length(idxFixed);

if kernelType=='rbf',
    knl=1; else knl=2;
end,

%nlsig=3; % total number of levels needed to refine the Sigmas.
numSteps=2; % # refined points added to the Sigmas to the left/right centered at a point.

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;

iniList=[1:nv]; nDel=0; idxRmvd=[];

for step=1:nstep,
   nst=length(initList); N_inputs=nst-1;

   %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];
%   Sigma0 = sqrt(N_inputs)*[0.1 1 2 3 5];
   iRmvd=0;
  
   L3=inf*ones(1,nst); gamma=zeros(1,nst); sig=zeros(1,nst);
   for st=1:nst,
       if displ, fprintf('.%g', st),
       elseif mod(st, 100)==0,
           fprintf('.%g', st),
       end,

       if isempty(find(idxFixed==initList(st))),       
           idx=setdiff(initList, initList(st));
           Xtrain = ptrnInit(:, idx); Ytrain = ttrn;
           switch kernelType,
           case 'rbf'
               Sigma0 = sqrt(N_inputs)*[0.1 1 2 3 5];
           case 'lin'
               Sigma0 = [1]; nlsig=[1];
           case 'pol'
               Sigma0 = [1:4]; nlsig=[1];
           end,
           
           [sig(st), gamma(st), L3(st), numEffPar(st)]=...
               optSigGamLssvmBay(Xtrain, Ytrain, Sigma0, nlsig, 0, knl); 
       else
           L3(st)=inf;
           gamma(st)=0;
       end, %if st (is fixed)
   end, %for st    
  
   fprintf('\n')    
   % To check if to remove a variable or not!
   if min(L3)<L3star,
      [L3star, iopt] = min(L3);
	  sig_opt = sig(iopt);
  	  gam_opt = gamma(iopt);
      neffPar = numEffPar(iopt);
      nDel = nDel + 1;
      iRmvd=initList(iopt);
      vr=vpredInit{iRmvd};
      
      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;
      idxRmvd=[idxRmvd, iRmvd];
      
     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,
    initList = setdiff(initList, iRmvd);

    if length(initList)==1,
        disp('Only one variable remains!'),
        break,
    end,

end, % For step 

disp('Backward selection summary: '),

for bi=1:size(backList,2),
   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,