ScalarNuSVR.m

Go to the documentation of this file.

namespace general{
namespace regression{


/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class ScalarNuSVR
  :public general.regression.BaseQPSVR {
    public: /* ( setObservable ) */

        nu = .4;
    public: /* ( Transient ) */

        LastEpsilon;

        
    public: /* ( Transient ) */


        ScalarNuSVR() {
            this = this@general.regression.BaseQPSVR;
            this.registerProps(" nu ");
        }


        function [ai , sf ] = regress(fxi,ainit) {

            /* % Compile quadratic program */

            /*  Total number of samples */
            m = size(this.K,1);

            /*  Storage: alpha(1..m) = alpha_i, alpha(m+1..2m) = alpha_i*
             * T performs alpha_i* - alpha_i each */
            T = [diag(ones(1,m)) -diag(ones(1,m))];

            Q = T^t*this.K*T;
            Q = (Q+Q^t)/2;
            c = -(fxi*T)^t;
            A = ones(1,2*m);

            /*  Starting point */
            if nargin < 3 || isempty(ainit)
                ainit = ones(m,1)*this.C/m;
                /* ainit = []; */
            end

            /*  Bounds */
            lbA = 0;
            ubA = this.C * this.nu;
            lb = zeros(2*m,1);
            ub = ones(2*m,1)*(this.C/m);

            /* % Call solver */
            [p,d,info] = this.solve(Q,c,lb,ub,A,lbA,ubA,T^t*ainit);

            /* % Convert results */
            ai = T*p;
            this.LastEpsilon= d(end);

            sf = StopFlag.SUCCESS;
        }
#if 0 //mtoc++: 'set.nu'
function  nu(value) {
            if ~isposrealscalar(value)
                error(" nu must be a positive scalar ");
            elseif value >= 1
                error(" nu must be lower than one ");
            end
            this.nu= value;
        }

#endif

    
    public: /* ( Sealed ) */ /* ( Transient ) */

        function copy = clone() {
            copy = general.regression.ScalarNuSVR;
            /*  Call superclass clone */
            copy = clone@general.regression.BaseScalarSVR(this, copy);
            /*  Copy local props */
            copy.nu= this.nu;
        }
    public: /* ( Static ) */ /* ( Transient ) */


        static function res = test_ScalarNuSVR() {

            x = -5:.1:5;
            fx = sinc(x);
            /* x = 1:10;
             *fx = ones(size(x))*5; */

            svr = general.regression.ScalarNuSVR;
            svr.nu= .1;
            svr.Lambda= 1/100;
            /* kernel = kernels.PolyKernel(2);
             *kernel = kernels.LinearKernel; */
            kernel = kernels.GaussKernel(1);
            svr.K= kernel.evaluate(x,x);

            figure(2);
            [ai, svidx] = svr.computeKernelCoefficients(fx, []);
            epsi = svr.LastEpsilon;
            plot(x,fx," r ",x,[fx-epsi; fx+epsi]," r-- ");

            sv = x(:,svidx);
            svfun = @(x)ai^t*kernel.evaluate(sv,x);

            fsvr = svfun(x);

            /*  Plot approximated function */
            hold on;
            plot(x,fsvr," b ",x,[fsvr-epsi; fsvr+epsi]," b-- ");
            skipped = setdiff(1:length(x),svidx);
            plot(sv,fx(svidx)," .r ",x(skipped),fx(skipped)," xr ");

            fdiff = abs(fsvr(svidx)-fx(svidx));
            errors = find(fdiff  < .999*epsi);
            res = isempty(errors);
            if ~res
                plot(x(svidx(errors)),fx(svidx(errors))," blackx "," LineWidth ",4);
            end

            tit = sprintf(" nu = %f, epsilon = %f, #SV=%d ",svr.nu,epsi,length(svidx));
            title(tit);
            disp(tit);
            hold off;
        }
        static function res = test_ScalarNuSVR_to_EpsSVR() {

            x = -5:.1:5;

            r = rand(1,length(x));
            fx = sinc(x);
            fx(r<.2) = fx(r<.2)-.5;
            fx(r>.8) = fx(r>.8)+.5;

            /* fx = sinc(x) + (rand(1,length(x))-.5)*.3; */

            svr = general.regression.ScalarNuSVR;
            svr.nu= 0.3;
            svr.Lambda= 1/20;
            kernel = kernels.GaussKernel(1);
            svr.K= kernel.evaluate(x,x);
            [ai,svidx] = svr.computeKernelCoefficients(fx,[]);
            epsi = svr.LastEpsilon;
            sv = x(:,svidx);
            svfun = @(x)ai^t*kernel.evaluate(sv,x);

            /*  Create eps-SVR and feed with computed epsilon */
            esvr = general.regression.ScalarEpsSVR;
            esvr.Eps= epsi;
            esvr.K= svr.K;
            esvr.Lambda= svr.Lambda;
            [eai,esvidx] = esvr.computeKernelCoefficients(fx,[]);
            esv = x(:,esvidx);
            esvfun = @(x)eai^t*kernel.evaluate(esv,x);

            figure(1);
            xp = x(1,:);
            subplot(1,2,1);
            plot(xp,fx," r ");/* ,xp,[fx-eps; fx+eps],'r--'); */

            fsvr = svfun(x);
            hold on;

            /*  Plot approximated function */
            plot(xp,fsvr," b ",xp,[fsvr-epsi; fsvr+epsi]," b-- ");
            skipped = setdiff(1:length(x),svidx);
            plot(sv(1,:),fx(svidx)," .r ",xp(skipped),fx(skipped)," xr ");
            title(sprintf(" nu = %f, epsilon = %f, #SV = %d, C = %d ",svr.nu,epsi,length(svidx),svr.C));
            hold off;
            subplot(1,2,2);
            plot(xp,fx," r ");/* ,xp,[fx-eps; fx+eps],'r--'); */

            efsvr = esvfun(x);
            hold on;

            /*  Plot approximated function */
            plot(xp,efsvr," b ",xp,[efsvr-epsi; efsvr+epsi]," b-- ");
            skipped = setdiff(1:length(x),esvidx);
            plot(esv(1,:),fx(esvidx)," .r ",xp(skipped),fx(skipped)," xr ");
            title(sprintf(" epsilon = %f, #SV = %d, C = %d ",epsi,length(esvidx),esvr.C));
            hold off;

            res = norm(fsvr-efsvr) < sqrt(eps);
        }
};
}
}