gurls::ParamSelHoGPRegr< T > Class Template Reference

ParamSelHoGPRegr is the sub-class of ParamSelection that implements.

#include <hogpregr.h>

Inheritance diagram for gurls::ParamSelHoGPRegr< T >:

Collaboration diagram for gurls::ParamSelHoGPRegr< T >:

List of all members.

Public Member Functions
GurlsOptionsList *	execute (const gMat2D< T > &X, const gMat2D< T > &Y, const GurlsOptionsList &opt)
	Performs parameter selection for Gaussian Process regression.
Static Public Member Functions
static ParamSelection< T > *	factory (const std::string &id) throw (BadParamSelectionCreation)
	Factory function returning a pointer to the newly created object.

---

Detailed Description

template<typename T>
class gurls::ParamSelHoGPRegr< T >

Definition at line 68 of file hogpregr.h.

---

Member Function Documentation

template<typename T >

GurlsOptionsList * gurls::ParamSelHoGPRegr< T >::execute	(	const gMat2D< T > &	X,
		const gMat2D< T > &	Y,
		const GurlsOptionsList &	opt
	)		[virtual]

The hold-out approach is used.

Parameters:

X	input data matrix
Y	labels matrix
opt	options with the following: nlambda (default) hoperf (default) split (settable with the class Split and its subclasses) kernel (settable with the class Kernel and its subclasses)

Returns:

paramsel, a GurlsOptionList with the following fields:

• lambdas = array of values of the regularization parameter lambda minimizing the validation error for each class
• guesses = array of guesses for the regularization parameter lambda
• forho = matrix of validation accuracies for each lambda guess and for each class

Implements gurls::ParamSelection< T >.

Definition at line 91 of file hogpregr.h.

{
    //    [n,T]  = size(y);
    const unsigned long n = Y.rows();
    const unsigned long t = Y.cols();

    const unsigned long d = X.cols();

//    tot = opt.nlambda;
    int tot = static_cast<int>(opt.getOptAsNumber("nlambda"));


//    K = opt.kernel.K;
    const gMat2D<T> &K = opt.getOptValue<OptMatrix<gMat2D<T> > >("kernel.K");

    const GurlsOptionsList* split = opt.getOptAs<GurlsOptionsList>("split");

    const gMat2D< unsigned long > &indices_mat = split->getOptValue<OptMatrix<gMat2D< unsigned long > > >("indices");
    const gMat2D< unsigned long > &lasts_mat = split->getOptValue<OptMatrix<gMat2D< unsigned long > > >("lasts");

    const unsigned long *lasts = lasts_mat.getData();
    const unsigned long *indices = indices_mat.getData();


    unsigned long *tr = new unsigned long[indices_mat.cols()];
    unsigned long *va;


    T lmin;
    T lmax;

    if(opt.hasOpt("lambdamin"))
        lmin = opt.getOptAsNumber("lambdamin");
    else
        lmin = 0.001;

    if(opt.hasOpt("lambdamax"))
        lmax = opt.getOptAsNumber("lambdamax");
    else
        lmax = 10;



//    guesses = lmin.*(lmax/lmin).^linspace(0,1,tot);
    T* guesses = new T[tot];

    T* linspc = new T[tot];
    linspace((T)0.0, (T)1.0, tot, linspc);
    const T coeff = lmax/lmin;

    for(int i=0; i< tot; ++i)
        guesses[i] = lmin* std::pow(coeff, linspc[i]);

    delete[] linspc;

    GurlsOptionsList* nestedOpt = new GurlsOptionsList("nested");
    nestedOpt->copyOpt("singlelambda", opt);


    GurlsOptionsList* tmpPredKernel = new GurlsOptionsList("predkernel");
    GurlsOptionsList* tmpKernel = new GurlsOptionsList("kernel");
    GurlsOptionsList* tmpParamSel = new GurlsOptionsList("paramsel");

    nestedOpt->addOpt("kernel", tmpKernel);
    nestedOpt->addOpt("predkernel", tmpPredKernel);
    nestedOpt->addOpt("paramsel", tmpParamSel);

    gMat2D<T> subXtr;
    gMat2D<T> subYtr;
    gMat2D<T> subXva;
    gMat2D<T> subYva;

    gMat2D<T>* subK = new gMat2D<T>();
    gMat2D<T>* subPredK = new gMat2D<T>();
    gMat2D<T>* subPredKTest = new gMat2D<T>();

    tmpKernel->addOpt("K", new OptMatrix<gMat2D<T> > (*subK));
    tmpPredKernel->addOpt("K", new OptMatrix<gMat2D<T> > (*subPredK));
    tmpPredKernel->addOpt("Ktest", new OptMatrix<gMat2D<T> > (*subPredKTest));


    RLSGPRegr<T> rlsgp;
    PredGPRegr<T> predgp;
    Performance<T>* perfClass = Performance<T>::factory(opt.getOptAsString("hoperf"));

    const int nholdouts = static_cast<int>(opt.getOptAsNumber("nholdouts"));
    const unsigned long indices_cols = indices_mat.cols();

    T *perf = new T[tot*t];

    gMat2D<T>* lambdas_round_mat = new gMat2D<T>(nholdouts, t);
    T *lambdas_round = lambdas_round_mat->getData();

    gMat2D<T> *perf_mat = new gMat2D<T>(nholdouts, tot*t);

    gMat2D<T>* guesses_mat = new gMat2D<T>(nholdouts, tot);
    T *ret_guesses = guesses_mat->getData();

    gMat2D<T> * lambda = new gMat2D<T>(1,1);
    tmpParamSel->addOpt("lambdas", new OptMatrix<gMat2D<T> >(*lambda));

//    for nh = 1:opt.nholdouts
    for(int nh = 0; nh < nholdouts; ++nh)
    {

//        if strcmp(class(opt.split),'cell')
//            tr = opt.split{nh}.tr;
//            va = opt.split{nh}.va;
//        else
//            tr = opt.split.tr;
//            va = opt.split.va;
//        end
        unsigned long last = lasts[nh];
        copy(tr, indices+nh, indices_cols, 1, indices_mat.rows());
        va = tr+last;
        const unsigned long va_size = indices_cols-last;

//        [n,T]  = size(y(tr,:));

        // here n is last

//        opt.kernel.K = K(tr,tr);
        subK->resize(last, last);
        copy_submatrix(subK->getData(), K.getData(), K.rows(), last, last, tr, tr);


//        opt.predkernel.K = K(va,tr);
        subPredK->resize(va_size, last);
        copy_submatrix(subPredK->getData(), K.getData(), K.rows(), va_size, last, va, tr);

//        opt.predkernel.Ktest = diag(K(va,va));
        T* tmpMat = new T[va_size*va_size];
        subPredKTest->resize(va_size, 1);

        copy_submatrix(tmpMat, K.getData(), K.rows(), va_size, va_size, va, va);
        copy(subPredKTest->getData(), tmpMat, va_size, 1, va_size+1);

        delete[] tmpMat;

        subXtr.resize(last, d);
        subMatrixFromRows(X.getData(), n, d, tr, last, subXtr.getData());

        subYtr.resize(last, t);
        subMatrixFromRows(Y.getData(), n, t, tr, last, subYtr.getData());

        subXva.resize(va_size, d);
        subMatrixFromRows(X.getData(), n, d, va, va_size, subXva.getData());

        subYva.resize(va_size, t);
        subMatrixFromRows(Y.getData(), n, t, va, va_size, subYva.getData());


//        for i = 1:tot
        for(int i=0; i< tot; ++i)
        {
//            opt.paramsel.noises = guesses(i);
            lambda->getData()[0] = guesses[i];

//            opt.rls = rls_gpregr(X(tr,:),y(tr,:),opt);
            GurlsOptionsList* ret_rlsgp = rlsgp.execute(subXtr, subYtr, *nestedOpt);

            nestedOpt->removeOpt("optimizer");
            nestedOpt->addOpt("optimizer", ret_rlsgp);

//            tmp = pred_gpregr(X(va,:),y(va,:),opt);
            GurlsOptionsList * pred_list = predgp.execute(subXva, subYva, *nestedOpt);

//            opt.pred = tmp.means;
            nestedOpt->removeOpt("pred");
            nestedOpt->addOpt("pred", pred_list->getOpt("means"));

            pred_list->removeOpt("means", false);

            delete pred_list;


//            opt.perf = opt.hoperf([],y(va,:),opt);
            GurlsOptionsList * perf_list = perfClass->execute(subXva, subYva, *nestedOpt);
            gMat2D<T>& forho = perf_list->getOptValue<OptMatrix<gMat2D<T> > >("forho");

//            for t = 1:T
//                perf(i,t) = opt.perf.forho(t);
            copy(perf+i, forho.getData(), t, tot, 1);

            delete perf_list;
        }

//        [dummy,idx] = max(perf,[],1);
        T* work = NULL;
        unsigned long* idx = new unsigned long[t];
        indicesOfMax(perf, tot, t, idx, work, 1);

//        vout.lambdas_round{nh} = guesses(idx);
        T* lambdas_nh = new T[t];
        copyLocations(idx, guesses, t, tot, lambdas_nh);
        copy(lambdas_round + nh, lambdas_nh, t, nholdouts, 1);
        delete [] lambdas_nh;

//        vout.perf{nh} = perf;
        copy(perf_mat->getData()+nh, perf, tot*t, nholdouts, 1);

//        vout.guesses{nh} = guesses;
        copy(ret_guesses+nh, guesses, tot, nholdouts, 1);

    }

    delete nestedOpt;

    delete[] guesses;
    delete perfClass;
    delete[] perf;


    GurlsOptionsList* paramsel;

    if(opt.hasOpt("paramsel"))
    {
        GurlsOptionsList* tmp_opt = new GurlsOptionsList("tmp");
        tmp_opt->copyOpt("paramsel", opt);

        paramsel = GurlsOptionsList::dynacast(tmp_opt->getOpt("paramsel"));
        tmp_opt->removeOpt("paramsel", false);
        delete tmp_opt;

        paramsel->removeOpt("lambdas_round");
        paramsel->removeOpt("guesses");
        paramsel->removeOpt("perf");
        paramsel->removeOpt("lambdas");
    }
    else
        paramsel = new GurlsOptionsList("paramsel");


    paramsel->addOpt("lambdas_round", new OptMatrix<gMat2D<T> >(*lambdas_round_mat));
    paramsel->addOpt("perf", new OptMatrix<gMat2D<T> >(*perf_mat));
    paramsel->addOpt("guesses", new OptMatrix<gMat2D<T> >(*guesses_mat));


    gMat2D<T> *l = new gMat2D<T>(1, t);

//    if numel(vout.lambdas_round) > 1
    if(nholdouts>1)
    {
        T *lambdas = new T[t];
//        lambdas = cell2mat(vout.lambdas_round');
//        vout.lambdas = mean(lambdas);
        mean(lambdas_round, lambdas, nholdouts, t, t);

        copy(l->getData(), lambdas, t);

        delete [] lambdas;
    }
    else
    {
//        vout.lambdas = vout.lambdas_round{1};
        copy(l->getData(), lambdas_round, t);
    }

    paramsel->addOpt("lambdas", new OptMatrix<gMat2D<T> >(*l));

    return paramsel;
}

template<typename T>

static ParamSelection<T>* gurls::ParamSelection< T >::factory

(

const std::string &

id

)

throw (BadParamSelectionCreation) [inline, static, inherited]

Warning:

The returned pointer is a plain, un-managed pointer. The calling function is responsible of deallocating the object.

Definition at line 146 of file paramsel.h.

    {
        if(id == "loocvprimal")
            return new ParamSelLoocvPrimal<T>;
        if(id == "loocvdual")
            return new ParamSelLoocvDual<T>;
        if(id == "fixlambda")
            return new ParamSelFixLambda<T>;
        if(id == "calibratesgd")
            return new ParamSelCalibrateSGD<T>;
        if(id == "siglam")
            return new ParamSelSiglam<T>;
        if(id == "siglamho")
            return new ParamSelSiglamHo<T>;
        if(id == "hodual")
            return new ParamSelHoDual<T>;
        if(id == "hodualr")
            return new ParamSelHoDualr<T>;
        if(id == "hoprimal")
            return new ParamSelHoPrimal<T>;
        if(id == "hoprimalr")
            return new ParamSelHoPrimalr<T>;
        if(id == "fixsiglam")
            return new ParamSelFixSigLam<T>;
        if(id == "loogpregr")
            return new ParamSelLooGPRegr<T>;
        if(id == "hogpregr")
            return new ParamSelHoGPRegr<T>;
        if(id == "siglamloogpregr")
            return new ParamSelSiglamLooGPRegr<T>;
        if(id == "siglamhogpregr")
            return new ParamSelSiglamHoGPRegr<T>;

        throw BadParamSelectionCreation(id);
    }

---

The documentation for this class was generated from the following file:

• hogpregr.h