OnlineLinearMachine.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 1999-2009 Soeren Sonnenburg
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _ONLINELINEARCLASSIFIER_H__
#define _ONLINELINEARCLASSIFIER_H__

#include <shogun/lib/common.h>
#include <shogun/labels/Labels.h>
#include <shogun/labels/RegressionLabels.h>
#include <shogun/features/streaming/StreamingDotFeatures.h>
#include <shogun/machine/Machine.h>

#include <stdio.h>

namespace shogun
{
class COnlineLinearMachine : public CMachine
{
    public:
        COnlineLinearMachine();
        virtual ~COnlineLinearMachine();

        virtual inline void get_w(float32_t*& dst_w, int32_t& dst_dims)
        {
            ASSERT(w && w_dim>0);
            dst_w=w;
            dst_dims=w_dim;
        }

        virtual void get_w(float64_t*& dst_w, int32_t& dst_dims)
        {
            ASSERT(w && w_dim>0);
            dst_w=SG_MALLOC(float64_t, w_dim);
            for (int32_t i=0; i<w_dim; i++)
                dst_w[i]=w[i];
            dst_dims=w_dim;
        }

        virtual inline SGVector<float32_t> get_w()
        {
            return SGVector<float32_t>(w, w_dim);
        }

        virtual inline void set_w(float32_t* src_w, int32_t src_w_dim)
        {
            SG_FREE(w);
            w=SG_MALLOC(float32_t, src_w_dim);
            memcpy(w, src_w, size_t(src_w_dim)*sizeof(float32_t));
            w_dim=src_w_dim;
        }

        virtual void set_w(float64_t* src_w, int32_t src_w_dim)
        {
            SG_FREE(w);
            w=SG_MALLOC(float32_t, src_w_dim);
            for (int32_t i=0; i<src_w_dim; i++)
                w[i] = src_w[i];
            w_dim=src_w_dim;
        }

        virtual inline void set_bias(float32_t b)
        {
            bias=b;
        }

        virtual inline float32_t get_bias()
        {
            return bias;
        }

        virtual inline void set_features(CStreamingDotFeatures* feat)
        {
            if (features)
                SG_UNREF(features);
            SG_REF(feat);
            features=feat;
        }

        virtual CRegressionLabels* apply_regression(CFeatures* data=NULL);
        
        virtual CBinaryLabels* apply_binary(CFeatures* data=NULL);

        virtual float64_t apply_one(int32_t vec_idx)
        {
            SG_NOTIMPLEMENTED;
            return CMath::INFTY;
        }

        virtual float32_t apply_one(float32_t* vec, int32_t len);

        virtual float32_t apply_to_current_example();

        virtual CStreamingDotFeatures* get_features() { SG_REF(features); return features; }

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

        virtual void start_train() { }

        virtual void stop_train() { }

        virtual void train_example(CStreamingDotFeatures *feature, float64_t label) { SG_NOTIMPLEMENTED; }

    protected:
        virtual bool train_machine(CFeatures* data=NULL);

        SGVector<float64_t> apply_get_outputs(CFeatures* data);

        virtual bool train_require_labels() const { return false; }

    protected:
        int32_t w_dim;
        float32_t* w;
        float32_t bias;
        CStreamingDotFeatures* features;
};
}
#endif