|| || || || || || || ||

---

LogisticRegression.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_LogisticRegression_h
#define Impala_Core_Training_LogisticRegression_h

#include "Core/Training/Classifier.h"

namespace Impala
{
namespace Core
{
namespace Training
{

class LogisticRegression : public Classifier
{
public:
    LogisticRegression()
    {
    }

    virtual void SetTrainSet(const ConceptFeatureTableType* trainset)
    {
    }

    virtual Model* Train(PropertySet* properties)
    {
        /*
        %LOGLC Logistic Linear Classifier
        % 
        %   W = LOGLC(A)
        % 
        % INPUT
        %   A   Dataset
        %
        % OUTPUT
        %   W   Logistic linear classifier 
        %
        % DESCRIPTION  
        % Computation of the linear classifier for the dataset A by maximizing the
        % likelihood criterion using the logistic (sigmoid) function.
        % 
        % REFERENCES
        % A. Webb, Statistical Pattern Recognition, John Wiley & Sons, New York, 2002.
        %
        %  SEE ALSO 
        %  MAPPINGS, DATASETS, LDC, FISHERC

        % Copyright: R.P.W. Duin, duin@ph.tn.tudelft.nl
        % Faculty of Applied Physics, Delft University of Technology
        % P.O. Box 5046, 2600 GA Delft, The Netherlands

        % $Id: loglc.m,v 1.9 2003/11/22 23:20:39 bob Exp $
        */
               // [m,k,c] = getsize(a); aantal objecten, aantal features (dimensies), classes
        int sampleCount = mTrainSet->Size();
        int vectorLength = mTrainset->GetColumn3()->GetVectorLength(0);
        // nlab = getnlab(a); vraag labels per object [-1,+1] -> vector
        std::vector<double> labels = GetDistinct(mTrainSet->GetColumn2());
        if(labels.size() != 2)
            std::cerr << "[LogisticRegression::Train] multiclass not supported (yet)" << std::endl;
        int class1 = CountSelect(mTrainSet->GetColumn2(), labels[0]);
            // prior = getprior(a); de a priori kansen per classe -> [p(+1), p(-1)]
        double prior[2] = {(double)class1 / (double)sampleCount, (double)(sampleCount-class1) / (double)sampleCount};
                // v = scalem(a,'variance'); schalen op variantie (per feature)
                // a = a*v; <-(hier wordt de schaling pas toegepast)
        ScaleMeanAndVariance(mTrainSet->GetColumn3());
        
                // x = [+a,ones(m,1)]; matrix met de features en een 1 erachter (de + haalt de data uit de dataset)
        VectorSet* x = new VectorSet(true, vectorLength+1, sampleCount);
        SetVal(x->GetStorage(), x->GetStorage(), 1);
        PatSet(x->GetStorage(), mTrainSet->GetColumn3()->GetStorage(), 0, 0, 0, vectorLength, 0, 0);
                
        // % A standard trick to set the labels to +1 for the first class
                // % (NLAB=1) and to -1 for the second one (NLAB=2). Then, each 
                // % object vector is multiplied by its new label +/-1.
                // x(find(nlab==2),:) = -x(find(nlab==2),:); inverteer de features van een van de classes
        int i;
        for(i=0 ; i<sampleCount ; i++)
            if(mTrainSet->Get2(i) == -1)
                mTrainSet->Get3(i) = -mTrainSet->Get3(i);

                // alf = sum(nlab==2)/sum(nlab==1); ratio van de labels
        double alf = (double)class1 / (double)(sampleCount-class1);
                // weights = zeros(1,k+1); model gewichten, length = feature lengte + 1
        double weights[vectorLength+1] = {0};
                // % Maximize the likelihood L to find WEIGHTS
                // L = -inf; Lnew = -realmax;
        double L = -1e100; 
        double Lnew = 1e100; 
                // accuracy = 0.0001;
                // while (abs(Lnew - L) > accuracy)
        while(abs(Lnew - L) > 0.001)
        {
                        // pax = ones(m,1) ./ (1 + exp(-x*weights'));   % Estimate of P(class +1|x).
            //   ' = transpose
            //   pax -> m rijen 1 colom ->
            //   prob = x*transpose(weights);
            Vector prob = MatMul(x, weights);
            //   pax[i] = 1/1+exp(-prob[i]);
            double pax[sampleCount];
            for(i=0 ; i<sampleCount ; ++i)
                pax[i] = 1. / 1.+exp(-weights2[i]);
                        // pbx = 1 - pax;                                       % Estimate of P(class -1|x).
            double pbx[sampleCount];
            for(i=0 ; i<sampleCount ; ++i)
                pbx[i] = 1. - pax[i];
                        // L = Lnew; Lnew = sum(log(pax+realmin));     % Update likelihood.     
            L = Lnew;
            Lnew = 0;
            for(i=0 ; i<sampleCount ; ++i)
                Lnew += log(pax[i] + 1e-100); 
                        // p2x = sqrt(pax.*pbx); p2x colom vector -> p2x[i] = sqrt(pax[i]*pbx[i])
            double p2x[sampleCount];
            for(i=0 ; i<sampleCount ; ++i)
                p2x[i] = sqrt(pax[i]*pbx[i]);
                        // y = x .* p2x(:,ones(1,k+1)); -> deze constructie maakt een repeterende matrix -> puntsgewijs met matrix x vermenigvuldigen
            Matrix y = x;
            for(i=0 ; i<sampleCount ; ++i)
                y.GetColumn(i) *= p2x[i];
                        // weights = pbx' * x * pinv(y'*y) + weights;
            Matrtix weightupdate = MatMul(MatTranspose(pbx),MatMul(x,MatPseudoInverse(MatMul(MatTranspose(y), y)));
            for(i=0 ; i<vectorLength+1 ; ++i)
                weights[i] += weightupdate.Value(0, i);
        }
                // end
                // % Define LOGLC by an affine (linear) mapping based 
                // % on the [K x 1] matrix R and the offset w0.
                // w0 = weights(k+1) + log(alf*prior(1)/prior(2));
        double w0 = weights.Value(vectorLength) + log(alf*prior[0]/prior[1]);
                // R  = weights(1:k)';
                // W  = v*affine(R,w0,a,getlablist(a)); 
                // W  = setout_conv(W,1);
    }

    virtual void SetTestSet(const ConceptFeatureTableType* testset)
    {
    }

    virtual double Predict(const Impala::Core::Vector::VectorTem<double>* feature, const Model* model)
    {
    }

    virtual RankingTableType* Rank(const Model* model)
    {
    }
};

}//namespace Core
}//namespace Training
}//namespace Impala

#endif

---