clear all;
close all;

run   G:/tools1/vlfeat/toolbox/vl_setup
addpath  G:/tools1/vlfeat/toolbox
addpath  G:/tools1/vlfeat/toolbox/misc
%addpath C:/Users/mrog173/Desktop/deep-fbanks/matconvnet/examples/
%addpath C:/Users/mrog173/Desktop/deep-fbanks/matlab-helpers
addpath  G:/tools1/vlfeat/toolbox/mex
%addpath  G:/tools1/vlfeat/toolbox/mex/mexa64
addpath  G:/tools1/vlfeat/toolbox/mex/mexw64
info.classes =2;
multiLabel=false;
C = 1 ;
w = {} ;
b = {} ;
 opts.kernel= 'hell'; %'linear', 'hell','chi2'
%% training
%PCA to learn projection matrix, then learning GMM for  dictionary
%features_path='G:\MyResearch\Textures\latex_work\PeerJ computer sciences\convolutionalI featuresGNET \1fold\train\';
for foldnum=1:1:10
    sizelist=[];
    featurematrix_train=[];
    featurematrix_train=zeros(7424,1536);%3712
    featurematrix_test=zeros(32000,1536);%64 *500 fro two labels
    
    i=1;
    for classnum=1:2
        %features_path=['G:\MyResearch\Textures\latex_work\PeerJ computer sciences\convolutional featuresIGNET\'  num2str(foldnum) 'fold\train\'];
        features_path=['G:\MyResearch\Textures\latex_work\PeerJ computer sciences\convolutional features\InceptionResV2\'  num2str(foldnum) 'fold\train\'];
        
        features_path=[features_path   num2str(classnum-1) '\'];
        img_list = dir(features_path);
        img_list=img_list(3:end);
        for subloop=1:15:length(img_list)
            %
            subloop
            datafile=img_list(subloop).name;
            allpathtestfile=[ features_path  img_list(subloop).name  ];
            data =   load(allpathtestfile) ;
            data1=data.f;
            
            for  j=1:1:8
                for k=1:1:8
                    featurematrix_train(i,:)=data1(1,j,k,:);
                    i=i+1;
                end
            end
            
        end
    end
    
    descrs=featurematrix_train';
    opts.numWords=64;
    opts.numPcaDimensions =512%128;% 512 ;%+inf
    opts.whitening = false ;
    opts.whiteningRegul = 0 ;
    opts.renormalize = false ;
    encoder.projection = 1 ;
    encoder.projectionCenter = 0 ;
    
    % Step 1 (optional): learn PCA projection
    if opts.numPcaDimensions < inf || opts.whitening
        fprintf('%s: learni ng PCA rotation/projection\n', mfilename) ;
        encoder.projectionCenter = mean(descrs,2) ;
        x = bsxfun(@minus, descrs, encoder.projectionCenter) ;
        X = x*x' / size(x,2) ;
        [V,D] = eig(X) ;
        d = diag(D) ;
        [d,perm] = sort(d,'descend') ;
        d = d + opts.whiteningRegul * max(d) ;
        m = min(opts.numPcaDimensions, size(descrs,1)) ;
        V = V(:,perm) ;
        if opts.whitening
            encoder.projection = diag(1./sqrt(d(1:m))) * V(:,1:m)' ;
        else
            encoder.projection = V(:,1:m)' ;
        end
        clear X V D d ;
    else
        encoder.projection = 1 ;
        encoder.projectionCenter = 0 ;
    end
    descrs = encoder.projection * bsxfun(@minus, descrs, encoder.projectionCenter) ;
    % if encoder.renormalize
    %   descrs = bsxfun(@times, descrs, 1./max(1e-12, sqrt(sum(descrs.^2)))) ;
    % end
    
    % Step 2 : GMM
    v = var(descrs')' ;
    [encoder.means, encoder.covariances, encoder.priors] = ...
        vl_gmm(descrs, opts.numWords, 'verbose', ...
        'Initialization', 'kmeans', ...
        'CovarianceBound', double(max(v)*0.0001), ...
        'NumRepetitions', 1);
    
    %% Step 3 : train_test,  fisher vector for descriptors of each image, and SVM training and test
    %read all training images, PCA, vl_fisher for each images,and for  SVM training
    %y_train=[ zeros(1,860)  ones(1,860)];
    train_descrs=zeros(opts.numPcaDimensions*opts.numWords*2,1720);%860X2 =1720
    t=1;
    for classnum=1:2
        %features_path=['G:\MyResearch\Textures\latex_work\PeerJ computer sciences\convolutional featuresIGNET\'  num2str(foldnum)  'fold\train\'];
        features_path=['G:\MyResearch\Textures\latex_work\PeerJ computer sciences\convolutional features\InceptionResV2\'  num2str(foldnum) 'fold\train\'];
        
        features_path=[features_path   num2str(classnum-1) '\'];
        img_list = dir(features_path);
        img_list=img_list(3:end);
        for subloop=1:1:length(img_list)
            %
            subloop
            datafile=img_list(subloop).name;
            allpathtestfile=[ features_path  img_list(subloop).name  ];
            data =   load(allpathtestfile) ;
            data1=data.f;
            i=1;
            featurematrix_train=zeros(64,1536);
            for  j=1:1:8
                for k=1:1:8
                    featurematrix_train(i,:)=data1(1,j,k,:);%feature matric for each image
                    i=i+1;
                end
            end
            %PCA projection
            descrs=featurematrix_train';
            descrs = encoder.projection * bsxfun(@minus, descrs, encoder.projectionCenter) ;
            %fisher vector
            z = vl_fisher(descrs, ...
                encoder.means, ...
                encoder.covariances, ...
                encoder.priors, ...
                'Improved') ;
            train_descrs(:,t)=z';
            t=t+1;
        end
    end
    
    % read test images
    %y_test=[ zeros(1,250)  ones(1,250)];
    test_descrs=zeros(opts.numPcaDimensions*opts.numWords*2,500);%860X2 =1720
    t=1;
    for classnum=1:2
        %features_path=['G:\MyResearch\Textures\latex_work\PeerJ computer sciences\convolutional featuresIGNET\'  num2str(foldnum)  'fold\test\'];
        features_path=['G:\MyResearch\Textures\latex_work\PeerJ computer sciences\convolutional features\InceptionResV2\'  num2str(foldnum) 'fold\test\'];
        
        features_path=[features_path   num2str(classnum-1) '\'];
        img_list = dir(features_path);
        img_list=img_list(3:end);
        for subloop=1:1:length(img_list)
            %
            subloop
            datafile=img_list(subloop).name;
            allpathtestfile=[ features_path  img_list(subloop).name  ];
            data =   load(allpathtestfile) ;
            data1=data.f;
            i=1;
            featurematrix_train=zeros(64,1536);
            for  j=1:1:8
                for k=1:1:8
                    featurematrix_train(i,:)=data1(1,j,k,:);%feature matric for each image
                    i=i+1;
                end
            end
            %PCA projection
            descrs=featurematrix_train';
            descrs = encoder.projection * bsxfun(@minus, descrs, encoder.projectionCenter) ;
            %fisher vector
            z = vl_fisher(descrs, ...
                encoder.means, ...
                encoder.covariances, ...
                encoder.priors, ...
                'Improved') ;
            test_descrs(:,t)=z';
            t=t+1;
        end
    end
   
    %SVM training
    switch opts.kernel
        case 'linear'
        case 'hell'
            train_descrs = sign(train_descrs) .* sqrt(abs(train_descrs)) ;
            test_descrs = sign(test_descrs) .* sqrt(abs(test_descrs)) ;
        case 'chi2'  
            hom.kernel = 'KChi2';
            hom.order = 2;
% create the dataset structure
           %  train_descrs = vl_svmdataset(train_descrs, 'homkermap', hom);
          %   test_descrs = vl_svmdataset(test_descrs, 'homkermap', hom);
           train_descrs = vl_homkermap(train_descrs,1,'kchi2') ;
           test_descrs = vl_homkermap(test_descrs,1,'kchi2') ;
        otherwise
            assert(false) ;
    end
    
    
    labels=[ ones(1,860)   zeros(1,860);  zeros(1,860)  ones(1,860)];
    % labels should be two lines, make special labels for class 0 and 1.
    %first line: 860  1, and 860 0
    %sec ond line: 860 0, 860 1
    train_index=[1:1:860];
    test_index=[1:1:250];
    for c=1:2
        
        y_train = labels(c,:) ;
        y_train=y_train.*2-1;
        np = sum(y_train > 0) ;
        nn = sum(y_train < 0) ;
        n = np + nn ;
        
        % addpath('C:\Users\mrog173\Desktop\deep-fbanks\vlfeat\toolbox\mex\mexw64\');
        addpath('G:\tools\vlfeat\toolbox\mex\mexw64\');
       % [w{c},b{c}] = vl_svmtrain(train_descrs, y_train, 1/(n* C), 'epsilon', 0.001, 'verbose', 'biasMultiplier', 1, 'maxNumIterations', n * 200) ;
        
        
        par = {'Solver', 'sdca', 'Verbose', ...
       'BiasMultiplier', 1, ...
       'Epsilon', 0.001, ...
       'MaxNumIterations', n * 200} ;
   
       lambda=1/(n* C);
      maxIter=n * 200;
     % [w{c},b{c}] = vl_svmtrain(train_descrs, y_train, lambda, 'MaxNumIterations', maxIter);
      [w{c},b{c}] = vl_svmtrain(train_descrs, y_train, lambda, par{:}) ;
      
        pred_train = w{c}'*train_descrs + b{c} ;
        pred_test = w{c}'*test_descrs + b{c} ;
        
        % try cheap calibration
        if(c==1)
            mp = median(pred_train(1,1:860)) ;%mp = median(pred(train & y > 0)) ;
            mn = median(pred_train(1,861:end)) ; % mn = median(pred(train & y < 0)) ;
        else
            mp = median(pred_train(1,861:end)) ;%mp = median(pred(train & y > 0)) ;
            mn = median(pred_train(1,1:860)) ; % mn = median(pred(train & y < 0)) ;
        end
        b{c} = (b{c} - mn) / (mp - mn) ;
        w{c} = w{c} / (mp - mn) ;
        pred_train = w{c}'*train_descrs + b{c} ;
        pred_test = w{c}'*test_descrs + b{c} ;
        
        scores{c} = pred_test ;
        
        % [~,~,i]= vl_pr(y(train), pred(train)) ; ap(c) = i.ap ; ap11(c) = i.ap_interp_11 ; auc(c) = i.auc ;
        % [~,~,i]= vl_pr(y(test), pred(test)) ; tap(c) = i.ap ; tap11(c) = i.ap_interp_11 ; tauc(c) = i.auc ;
        % [~,~,i]= vl_pr(y(train), pred(train), 'normalizeprior', 0.01) ; nap(c) = i.ap ;
        % [~,~,i]= vl_pr(y(test), pred(test), 'normalizeprior', 0.01) ; tnap(c) = i.ap ;
    end
    info.w = cat(2,w{:}) ;
    info.b = cat(2,b{:}) ;
    info.scores = cat(1, scores{:}) ;
    
    
    
    [~,preds] = max(info.scores,[],1) ;
    pred_irregular=preds(1:250);
    pred_regular=preds(251:end);
    [aa bb]=find(pred_irregular==2);
    [cc dd]=find(pred_regular==1);
    accuracy(foldnum)=1-(length(aa)+length(cc))./(500);
    % plot corectly  the images
    
end
mean(accuracy)
std(accuracy)
ii=0;