GradientResult.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) 2013 Roman Votyakov
 * Copyright (C) 2012 Jacob Walker
 */

#ifndef CGRADIENTRESULT_H_
#define CGRADIENTRESULT_H_

#include <shogun/lib/config.h>

#include <shogun/evaluation/EvaluationResult.h>
#include <shogun/lib/Map.h>

namespace shogun
{

class CGradientResult : public CEvaluationResult
{
public:
    CGradientResult() : CEvaluationResult()
    {
        m_total_variables=0;
        m_gradient=NULL;
        m_parameter_dictionary=NULL;
    }

    virtual ~CGradientResult()
    {
        SG_UNREF(m_gradient);
        SG_UNREF(m_parameter_dictionary);
    }

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

    static CGradientResult* obtain_from_generic(CEvaluationResult* eval_result)
    {
        ASSERT(eval_result);

        REQUIRE(eval_result->get_result_type()==GRADIENTEVALUATION_RESULT,
                "Provided evaluation result is not of type CGradientResult!\n")

        SG_REF(eval_result);
        return (CGradientResult*) eval_result;
    }

    virtual EEvaluationResultType get_result_type() const
    {
        return GRADIENTEVALUATION_RESULT;
    }

    virtual void print_result()
    {
        REQUIRE(m_gradient, "Gradient map should not be NULL\n")
        REQUIRE(m_parameter_dictionary, "Parameter dictionary should not be "
                "NULL\n")

        // print value of the function
        SG_SPRINT("Value: [")

        for (index_t i=0; i<m_value.vlen-1; i++)
            SG_SPRINT("%f, ", m_value[i])

        if (m_value.vlen>0)
            SG_SPRINT("%f", m_value[m_value.vlen-1])

        SG_SPRINT("] ")

        // print gradient wrt parameters
        SG_SPRINT("Gradient: [")

        for (index_t i=0; i<m_gradient->get_num_elements(); i++)
        {
            CMapNode<TParameter*, SGVector<float64_t> >* param_node=
                m_gradient->get_node_ptr(i);

            // get parameter name
            const char* param_name=param_node->key->m_name;

            // get object name
            const char* object_name=
                m_parameter_dictionary->get_element(param_node->key)->get_name();

            // get gradient wrt parameter
            SGVector<float64_t> param_gradient=param_node->data;

            SG_PRINT("%s.%s: ", object_name, param_name)

            for (index_t j=0; j<param_gradient.vlen-1; j++)
                SG_SPRINT("%f, ", param_gradient[j])

            if (i==m_gradient->get_num_elements()-1)
            {
                if (param_gradient.vlen>0)
                    SG_PRINT("%f", param_gradient[param_gradient.vlen-1])
            }
            else
            {
                if (param_gradient.vlen>0)
                    SG_PRINT("%f; ", param_gradient[param_gradient.vlen-1])
            }
        }

        SG_SPRINT("] Total Variables: %u\n", m_total_variables)
    }

    virtual uint32_t get_total_variables()
    {
        return m_total_variables;
    }

    virtual void set_value(SGVector<float64_t> value)
    {
        m_value=SGVector<float64_t>(value);
    }

    virtual SGVector<float64_t> get_value()
    {
        return SGVector<float64_t>(m_value);
    }

    virtual void set_gradient(CMap<TParameter*, SGVector<float64_t> >* gradient)
    {
        REQUIRE(gradient, "Gradient map should not be NULL\n")

        SG_REF(gradient);
        SG_UNREF(m_gradient);
        m_gradient=gradient;

        m_total_variables=0;

        for (index_t i=0; i<gradient->get_num_elements(); i++)
        {
            CMapNode<TParameter*, SGVector<float64_t> >* node=
                m_gradient->get_node_ptr(i);
            m_total_variables+=node->data.vlen;
        }
    }

    virtual CMap<TParameter*, SGVector<float64_t> >* get_gradient()
    {
        SG_REF(m_gradient);
        return m_gradient;
    }

    virtual void set_paramter_dictionary(
            CMap<TParameter*, CSGObject*>* parameter_dictionary)
    {
        SG_REF(parameter_dictionary);
        SG_UNREF(m_parameter_dictionary);
        m_parameter_dictionary=parameter_dictionary;
    }

    virtual CMap<TParameter*, CSGObject*>* get_paramter_dictionary()
    {
        SG_REF(m_parameter_dictionary);
        return m_parameter_dictionary;
    }

private:
    SGVector<float64_t> m_value;

    CMap<TParameter*, SGVector<float64_t> >* m_gradient;

    CMap<TParameter*, CSGObject*>*  m_parameter_dictionary;

    uint32_t m_total_variables;
};
}
#endif /* CGRADIENTRESULT_H_ */