gurls::ConfBoltzmanGap< T > Class Template Reference

ConfBoltzmanGap is the sub-class of Confidence that computes a confidence estimation for the predicted class (i.e. More...

#include <boltzmangap.h>

Inheritance diagram for gurls::ConfBoltzmanGap< T >:

Collaboration diagram for gurls::ConfBoltzmanGap< 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::ConfBoltzmanGap< T >

highest scoring class).

Definition at line 58 of file boltzmangap.h.

---

Member Function Documentation

template<typename T >

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

highest scoring class). The scores are converted in probabilities using the Boltzman distribution and 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 77 of file boltzmangap.h.

{
//   [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 = exp(out.confidence);
//    out.confidence = out.confidence./(sum(out.confidence,2)*ones(1,k));
//    out.confidence = sort(out.confidence,2,'descend');
//    out.confidence = out.confidence(:,1) - out.confidence(:,2);

    const T* expscores = pred.getData();

    T sum;
    T* rowT = new T[t];

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

    //TODO optmize search of two maxes
    for(unsigned long i=0; i<n; ++i)
    {
        getRow(expscores, n, t, i, rowT);
        exp(rowT, t);

        sum = sumv(rowT, t);
        scal(t, (T)(1.0/sum), rowT, 1);

        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:

• boltzmangap.h