SGDQN.h

Go to the documentation of this file.

#ifndef _SGDQN_H___
#define _SGDQN_H___

/*
   SVM with Quasi-Newton stochastic gradient
   Copyright (C) 2009- Antoine Bordes

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

   Shogun adjustments (w) 2011 Siddharth Kherada
*/

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/machine/LinearMachine.h>
#include <shogun/features/DotFeatures.h>
#include <shogun/labels/Labels.h>
#include <shogun/loss/LossFunction.h>

namespace shogun
{
class CSGDQN : public CLinearMachine
{
    public:

        MACHINE_PROBLEM_TYPE(PT_BINARY);

        CSGDQN();

        CSGDQN(float64_t C);

        CSGDQN(
            float64_t C, CDotFeatures* traindat,
            CLabels* trainlab);

        virtual ~CSGDQN();

        virtual EMachineType get_classifier_type() { return CT_SGDQN; }

        virtual bool train(CFeatures* data=NULL);

        inline void set_C(float64_t c_neg, float64_t c_pos) { C1=c_neg; C2=c_pos; }

        inline float64_t get_C1() { return C1; }

        inline float64_t get_C2() { return C2; }

        inline void set_epochs(int32_t e) { epochs=e; }

        inline int32_t get_epochs() { return epochs; }

        void compute_ratio(float64_t* W,float64_t* W_1,float64_t* B,float64_t* dst,int32_t dim,float64_t regularizer_lambda,float64_t loss);

        void combine_and_clip(float64_t* Bc,float64_t* B,int32_t dim,float64_t c1,float64_t c2,float64_t v1,float64_t v2);

        void set_loss_function(CLossFunction* loss_func);

        inline CLossFunction* get_loss_function() { SG_REF(loss); return loss; }

        virtual const char* get_name() const { return "SGDQN"; }

    protected:
        void calibrate();

    private:
        void init();

    private:
        float64_t t;
        float64_t C1;
        float64_t C2;
        int32_t epochs;
        int32_t skip;
        int32_t count;

        CLossFunction* loss;
};
}
#endif