ModelSelectionParameters.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) 2011-2012 Heiko Strathmann
 * Copyright (C) 2011 Berlin Institute of Technology and Max-Planck-Society
 */

#ifndef __MODELSELECTIONPARAMETERS_H_
#define __MODELSELECTIONPARAMETERS_H_

#include <shogun/base/SGObject.h>
#include <shogun/lib/DynamicObjectArray.h>

namespace shogun
{

class CParameterCombination;

enum ERangeType
{
    R_LINEAR, R_EXP, R_LOG
};

enum EMSParamType
{
    MSPT_NONE=0,

    /* float64_t */
    MSPT_FLOAT64,

    /* int32_t */
    MSPT_INT32,

    MSPT_FLOAT64_VECTOR,

    MSPT_INT32_VECTOR,

    MSPT_FLOAT64_SGVECTOR,

    MSPT_INT32_SGVECTOR,
};

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

    CModelSelectionParameters(const char* node_name);

    CModelSelectionParameters(const char* node_name, CSGObject* sgobject);

    ~CModelSelectionParameters();

    void append_child(CModelSelectionParameters* child);

    template <class T>
    void set_values(const SGVector<T>& values, EMSParamType value_type);

    void print_tree(int prefix_num=0);

    CDynamicObjectArray* get_combinations(index_t prefix_num=1);

    CParameterCombination* get_single_combination(bool rand = true);

    void build_values(float64_t min, float64_t max, ERangeType type,
            float64_t step=1.0, float64_t type_base=2.0);

    void build_values_vector(float64_t min, float64_t max, ERangeType type,
            void* vector, index_t* size, float64_t step=1.0,
            float64_t type_base=2.0);

    void build_values_sgvector(float64_t min, float64_t max, ERangeType type,
            void* vector, float64_t step=1.0, float64_t type_base=2.0);

    void build_values(int32_t min, int32_t max, ERangeType type, int32_t step=1,
            int32_t type_base=2);

    void build_values_vector(int32_t min, int32_t max, ERangeType type,
            void* vector, index_t* size, int32_t step=1,
            int32_t type_base=2);

    void build_values_sgvector(int32_t min, int32_t max, ERangeType type, void* vector,
            int32_t step=1, int32_t type_base=2);

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

    virtual bool save_serializable(CSerializableFile* file,
            const char* prefix="", int32_t param_version=VERSION_PARAMETER)
    {
        SG_ERROR("Serialization is not allowed for %s!\n", get_name());
        return false;
    }

    virtual bool load_serializable(CSerializableFile* file,
        const char* prefix="", int32_t param_version=VERSION_PARAMETER)
    {
        SG_ERROR("Serialization is not allowed for %s!\n", get_name());
        return false;
    }

private:
    void init();

    void delete_values();

    void build_values(EMSParamType param_type, void* min, void* max,
            ERangeType type, void* step, void* type_base);

protected:
    bool has_children() const
    {
        return m_child_nodes->get_num_elements()>0;
    }

private:
    CSGObject* m_sgobject;
    const char* m_node_name;
    void* m_values;
    index_t m_values_length;
    index_t* m_vector_length;
    CDynamicObjectArray* m_child_nodes;
    EMSParamType m_value_type;
    void*   m_vector;
};

template <class T> SGVector<T> create_range_array(T min, T max,
        ERangeType type, T step, T type_base)
{
    if (max<min)
        SG_SERROR("unable build values: max=%f < min=%f\n", max, min);

    /* create value vector, no ref-counting */
    index_t num_values=CMath::round((max-min)/step)+1;
    SGVector<T> result(num_values, false);

    /* fill array */
    for (index_t i=0; i<num_values; ++i)
    {
        T current=min+i*step;

        switch (type)
        {
        case R_LINEAR:
            result.vector[i]=current;
            break;
        case R_EXP:
            result.vector[i]=CMath::pow((float64_t)type_base, current);
            break;
        case R_LOG:
            if (current<=0)
                SG_SERROR("log(x) with x=%f\n", current);

            /* custom base b: log_b(i*step)=log_2(i*step)/log_2(b) */
            result.vector[i]=CMath::log2(current)/CMath::log2(type_base);
            break;
        default:
            SG_SERROR("unknown range type!\n");
            break;
        }
    }

    return result;
}

}
#endif /* __MODELSELECTIONPARAMETERS_H_ */