ScalarEpsSVR.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 ScalarEpsSVR
  :public general.regression.BaseQPSVR {
    public: /* ( setObservable ) */

        Eps = 0.05;
    public: /* ( setObservable ) */

        ScalarEpsSVR() {
            this = this@general.regression.BaseQPSVR;
            this.registerProps(" eps ");
        }
        function [ai , sf ] = regress(fxi,ainit) {
            m = size(this.K,1);
            T = [diag(ones(1,m)) -diag(ones(1,m))];

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

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

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

            /*  Call solver */
            p = this.solve(Q,c,lb,ub,[],[],[],ainit);

            /*  Convert results */
            ai = T*p;

            sf = StopFlag.SUCCESS;
        }
#if 0 //mtoc++: 'set.Eps'
function  Eps(value) {
            if ~isposrealscalar(value)
                error(" Value must be a positive real scalar ");
            end
            this.Eps= value;
        }

#endif

    
    public: /* ( Sealed ) */ /* ( setObservable ) */

        function copy = clone() {
            copy = general.regression.ScalarEpsSVR;
            /*  Call superclass clone */
            copy = clone@general.regression.BaseQPSVR(this, copy);
            /*  Copy local props */
            copy.Eps= this.Eps;
        }
    public: /* ( Static ) */ /* ( setObservable ) */

        static function res = test_ScalarEpsSVR() {

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

            svr = general.regression.ScalarEpsSVR;
            /* svr.eps = 0.073648; */
            svr.Eps= .1;
            svr.Lambda= 1/20;
            /* svr.MaxIterations = 1000; */

            /* kernel = kernels.PolyKernel(2);
             *kernel = kernels.LinearKernel; */
            kernel = kernels.GaussKernel(.5);
            svr.K= kernel.evaluate(x,x);

            figure;
            plot(x,fx," r ",x,[fx-svr.Eps; fx+svr.Eps]," r-- ");

            [ai, svidx] = svr.computeKernelCoefficients(fx, []);
            sv = x(:,svidx);
            svfun = @(x)ai" *(kernel.evaluate(x,sv) ");

            fsvr = svfun(x);

            fdiff = abs(fsvr(svidx)-fx(svidx));
            errors = find(fdiff  < .999*svr.Eps);
            res = isempty(errors);

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

            if ~res
                plot(x(svidx(errors)),fx(svidx(errors))," blackx "," LineWidth ",4);
            end

            tit = sprintf(" #SV=%d, eps=%f ",length(svidx),svr.Eps);
            title(tit);
            disp(tit);
            hold off;
        }
        static function  test2_CustomSVR() {

            x = [0    0.3000    0.6000    0.9000;
                0.8321    1.0756    1.3557    1.6539];
            fx = [0.7393    0.8799    0.9769    0.9966];

            svr = general.regression.ScalarEpsSVR;
            svr.Eps= 0.5;
            svr.C= 10;
            kernel = kernels.GaussKernel(1);
            svr.K= kernel.evaluate(x,x);

            figure(1);
            xp = x(1,:);
            plot(xp,fx," r ",xp,[fx-svr.Eps; fx+svr.Eps]," r-- ");

            [ai,svidx] = svr.regress(fx);
            sv = x(:,svidx);
            svfun = @(x)ai^t*kernel.evaluate(sv,x);

            fsvr = svfun(x);
            hold on;

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

            hold off;
        }
};
}
}