---

gnn_msre.c

Go to the documentation of this file.

/***************************************************************************
 *  @file gnn_msre.h
 *  @brief Mean Square Relative Error Criterion.
 *
 *  @date   : 27-09-03 21:08
 *  @author : Pedro Ortega C. <peortega@dcc.uchile.cl>
 *  Copyright  2003  Pedro Ortega C.
 ****************************************************************************/
/*
 *  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 2 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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/**
 * @brief Mean Square Relative Error function.
 * @defgroup gnn_msre_doc gnn_msre : Mean-Square-Relative-Error Criterion.
 * @ingroup gnn_criterion_doc
 *
 * This datatype implements the MSRE criterion, given by
 * \f[ E(y,t) = \frac{1}{m} \sum_i^m \frac{(y_i - t_i)^2}{t_i^2} \f]
 * This function resembles the MSE criterion, but measures the relative
 * error with respect to the target value. Minimizing this function is
 * equivalent to minimize
 *
 * \f[ E(y,t) = \frac{1}{m} \sum_i^m \left | \frac{y_i - t_i}{t_i} \right | \f]
 *
 * Please note that zero target values do undefine the function. This criterion
 * isn't appropiate for small target values.
 *
 * In a batch training mode, where all patterns are used to determine the
 * gradient \f$\frac{\partial E}{\partial w}\f$, then the training optimizes
 * the MAPE criterion.
 */



/******************************************/
/* Include Files                          */
/******************************************/

#include "gnn_msre.h"



/******************************************/
/* Static Declaration                     */
/******************************************/

typedef gnn_criterion gnn_msre;

double
gnn_msre_e (gnn_criterion *crit,
            const gsl_vector *y,
            const gsl_vector *t);

int
gnn_msre_dy (gnn_criterion *crit,
             const gsl_vector *y,
             const gsl_vector *t,
             gsl_vector * dy);



/******************************************/
/* Static Implementation                  */
/******************************************/

/**
 * @brief The evaluation function.
 * @ingroup gnn_msre_doc
 *
 * This function corresponds to the evaluation of the MSRE criterion.
 *
 * @param  crit A pointer to a \ref gnn_msre criterion.
 * @param  y    A pointer to an estimation vector \f$y\f$.
 * @param  t    A pointer to the desired target vector \f$t\f$.
 * @return A real number corresponding to the value of the criterion.
 */
double
gnn_msre_e (gnn_criterion *crit,
            const gsl_vector *y,
            const gsl_vector *t)
{
    int i;
    double E;

    assert (crit != NULL);
    assert (y != NULL);
    assert (t != NULL);

    /* check sizes */
    if (y->size != t->size)
        GSL_ERROR_VAL ("vector sizes should be the same", GSL_EINVAL, 0.0);

    /* compute error */
    E = 0.0;
    for (i=0; i<y->size; ++i)
    {
        double yi;
        double ti;

        yi = gsl_vector_get (y, i);
        ti = gsl_vector_get (t, i);

        E += (yi - ti) * (yi - ti) / (ti * ti);
    }
    E /= y->size;

    return E;
}

/**
 * @brief The gradient evaluation function.
 * @ingroup gnn_msre_doc
 *
 * This function implements the \ref gnn_msre criterion's gradient evaluation
 * function given by
 *
 * \f[ \frac{\partial E}{\partial y_i} = \frac{2}{m t_i^2} (y_i - t_i) \f]
 *
 * @param  crit A pointer to a \ref gnn_msre criterion.
 * @param  y    A pointer to an estimation vector \f$y\f$.
 * @param  t    A pointer to the desired target vector \f$t\f$.
 * @param  dy   A pointer to a buffer vector where the result should be placed.
 * @return Returns 0 if succeeded.
 */
int
gnn_msre_dy (gnn_criterion *crit,
             const gsl_vector *y,
             const gsl_vector *t,
             gsl_vector * dy)
{
    int i;

    assert (crit != NULL);
    assert (y != NULL);
    assert (t != NULL);
    assert (dy != NULL);

    /* check sizes */
    if (y->size != t->size || y->size != dy->size)
        GSL_ERROR ("vector sizes should be the same", GSL_EINVAL);

    /* compute dy */
    for (i=0; i<y->size; ++i)
    {
        double yi;
        double ti;
        double dyi;

        yi  = gsl_vector_get (y, i);
        ti  = gsl_vector_get (t, i);
        dyi = gsl_vector_get (dy, i);

        dyi += 2 * (yi - ti) / (y->size * ti * ti);

        gsl_vector_set (dy, i, dyi);
    }

    return 0;
}


/******************************************/
/* Public Interface                       */
/******************************************/

/**
 * @brief Creates a new \ref gnn_msre criterion.
 * @ingroup gnn_msre_doc
 *
 * This function creates a new \ref gnn_msre of the given size.
 *
 * @param  size    The size of the estimation and the target vector \f$y\f$
 *                 and \f$t\f$.
 * @return Returns a pointer to a new \ref gnn_msre or NULL if failed.
 */
gnn_criterion *
gnn_msre_new (size_t size)
{
    int status;
    gnn_criterion *crit;

    /* check size */
    if (size < 1)
        GSL_ERROR_VAL ("size should be strictly positive", GSL_EINVAL, NULL);

    /* alloc memory */
    crit = (gnn_criterion *) malloc (sizeof (*crit));
    if (crit == NULL)
        GSL_ERROR_VAL ("couldn't alloc memory for gnn_msre", GSL_ENOMEM, NULL);

    /* initialize */
    status = gnn_criterion_init  (crit, "gnn_msre", size,
                                  gnn_msre_e, gnn_msre_dy, NULL);
    if (status)
    {
        gnn_criterion_destroy (crit);
        GSL_ERROR_VAL ("couldn't initialize gnn_msre", GSL_EFAILED, NULL);
    }

    return crit;
}

---