Labels.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
 * Written (W) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _LABELS__H__
#define _LABELS__H__

#include "lib/common.h"
#include "lib/io.h"
#include "lib/File.h"
#include "base/SGObject.h"

namespace shogun
{

    class CFile;

class CLabels : public CSGObject
{
    public:
        CLabels();

        CLabels(int32_t num_labels);

        CLabels(float64_t* src, int32_t len);

        CLabels(float64_t* in_confidences, int32_t in_num_labels, int32_t in_num_classes);

        CLabels(CFile* loader);
        virtual ~CLabels();

        virtual void load(CFile* loader);

        virtual void save(CFile* writer);

        inline bool set_label(int32_t idx, float64_t label)
        { 
            if (labels && idx<num_labels)
            {
                labels[idx]=label;
                return true;
            }
            else 
                return false;
        }

        inline bool set_int_label(int32_t idx, int32_t label)
        { 
            if (labels && idx<num_labels)
            {
                labels[idx]= (float64_t) label;
                return true;
            }
            else 
                return false;
        }

        inline float64_t get_label(int32_t idx)
        {
            if (labels && idx<num_labels)
                return labels[idx];
            else
                return -1;
        }

        inline int32_t get_int_label(int32_t idx)
        {
            if (labels && idx<num_labels)
            {
                ASSERT(labels[idx]== ((float64_t) ((int32_t) labels[idx])));
                return ((int32_t) labels[idx]);
            }
            else
                return -1;
        }

        bool is_two_class_labeling();

        int32_t get_num_classes();

        float64_t* get_labels(int32_t &len);
        
        void get_labels(float64_t** dst, int32_t* len);

        void set_labels(float64_t* src, int32_t len);

        void set_confidences(float64_t* in_confidences, int32_t in_num_labels, int32_t in_num_classes);

        float64_t* get_confidences(int32_t& out_num_labels, int32_t& out_num_classes);

        void get_confidences(float64_t** dst, int32_t* out_num_labels, int32_t* out_num_classes);

        float64_t* get_sample_confidences(const int32_t& in_sample_index, int32_t& out_num_classes);

        int32_t* get_int_labels(int32_t &len);

        void set_int_labels(int32_t *labels, int32_t len) ;

        inline int32_t get_num_labels() { return num_labels; }

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

    protected:
        void find_labels();

#ifdef HAVE_BOOST_SERIALIZATION
    private:

        // serialization needs to split up in save/load because 
        // the serialization of pointers to natives (int* & friends) 
        // requires a workaround 
        friend class ::boost::serialization::access;
        template<class Archive>
            void save(Archive & ar, const unsigned int archive_version) const
            {

                SG_DEBUG("archiving Labels\n");

                ar & ::boost::serialization::base_object<CSGObject>(*this);

                ar & num_labels;
                for (int32_t i=0; i < num_labels; ++i) 
                {
                    ar & labels[i];
                }

                SG_DEBUG("done with Labels\n");

            }

        template<class Archive>
            void load(Archive & ar, const unsigned int archive_version)
            {

                SG_DEBUG("archiving Labels\n");

                ar & ::boost::serialization::base_object<CSGObject>(*this);

                ar & num_labels;

                SG_DEBUG("num_labels: %i\n", num_labels);

                if (num_labels > 0)
                {

                    labels = new float64_t[num_labels];
                    for (int32_t i=0; i< num_labels; ++i) 
                    {
                        ar & labels[i];
                    }

                }

                SG_DEBUG("done with Labels\n");

            }

        GLOBAL_BOOST_SERIALIZATION_SPLIT_MEMBER();


    public:

        virtual std::string toString() const
        {
            std::ostringstream s;

            ::boost::archive::text_oarchive oa(s);

            oa << *this;

            return s.str();
        }


        virtual void fromString(std::string str)
        {

            std::istringstream is(str);

            ::boost::archive::text_iarchive ia(is);

            ia >> *this;

        }
#endif //HAVE_BOOST_SERIALIZATION

    protected:
        int32_t num_labels;
        float64_t* labels;

        int16_t m_num_classes;

        float64_t* m_confidences;

};
}
#endif