gurls::ConfGap< T > Class Template Reference

ConfGap is the sub-class of Confidence that computes a confidence estimation for the predicted class.

#include <gap.h>

Inheritance diagram for gurls::ConfGap< T >:

Collaboration diagram for gurls::ConfGap< T >:

List of all members.

Public Member Functions
GurlsOptionsList *	execute (const gMat2D< T > &X, const gMat2D< T > &Y, const GurlsOptionsList &opt) throw (gException)
	Computes a confidence estimation for the predicted class (i.e.
Static Public Member Functions
static Confidence< T > *	factory (const std::string &id) throw (BadConfidenceCreation)
	Factory function returning a pointer to the newly created object.

---

Detailed Description

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

Definition at line 58 of file gap.h.

---

Member Function Documentation

template<typename T >

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

highest scoring class). The difference between the highest scoring class and the second highest scoring class is used as an estimate.

Parameters:

X	not used
Y	not used
opt	options with the following: pred (settable with the class Prediction and its subclasses)

Returns:

ret, a GurlsOptionList with the following fields:

• confidence = array containing the confidence score for each row of the field pred of opt.
• labels = array containing predicted class for each row of the field pred of opt.

Implements gurls::Confidence< T >.

Definition at line 76 of file gap.h.

{
    //   out = struct;
    //   [n,k] = size(opt.pred);
    const gMat2D<T> &pred = opt.getOptValue<OptMatrix<gMat2D<T> > >("pred");

    const unsigned long n = pred.rows();
    const unsigned long t = pred.cols();


//      out.confidence = opt.pred;
//      out.confidence = sort(out.confidence,2,'descend');
//      out.confidence = out.confidence(:,1) - out.confidence(:,2);

    const T* expscores = pred.getData();

    gMat2D<T> *conf = new gMat2D<T>(n,1);
    T* confidence = conf->getData();

    T* rowT = new T[t];

    for(unsigned long i=0; i<n; ++i)
    {
        getRow(expscores, n, t, i, rowT);
        std::sort(rowT,rowT+t);

        confidence[i] = rowT[t-1]-rowT[t-2];
    }

    delete [] rowT;

    GurlsOptionsList* ret = new GurlsOptionsList("confidence");
    ret->addOpt("confidence", new OptMatrix<gMat2D<T> >(*conf));

    return ret;
}

template<typename T>

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

(

const std::string &

id

)

throw (BadConfidenceCreation) [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 105 of file confidence.h.

    {
        if(id == "boltzman")
            return new ConfBoltzman<T>;
        if(id == "boltzmangap")
            return new ConfBoltzmanGap<T>;
        if(id == "gap")
                return new ConfGap<T>;
        if(id == "maxscore")
            return new ConfMaxScore<T>;
        throw BadConfidenceCreation(id);
    }

---

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

• gap.h