---

gnn_mse.c

Go to the documentation of this file.

/***************************************************************************
 *  @file gnn_mse.h
 *  @brief Mean Square Error Criterion.
 *
 *  @date   : 25-08-03 20:17
 *  @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 Error function.
 * @defgroup gnn_mse_doc gnn_mse : Mean-Square-Error Criterion.
 * @ingroup gnn_criterion_doc
 *
 * This datatype implements the MSE criterion, given by
 * \f[ E(y,t) = \frac{1}{m} \sum_i^m (y_i - t_i)^2 \f]
 * Although widely used, this cost-function is not always the best suited
 * criterion. Since the errors are squared up and summed togheter, those
 * components with large errors can greatly influence the learning process
 * during training. It has been shown that for a class of problems, the MSE
 * criterion can lead to trappings in local minima, failing to find a solution
 * although there is at least one.
 */



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

#include "gnn_mse.h"



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

typedef gnn_criterion gnn_mse;

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

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



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

/**
 * @brief The evaluation function.
 * @ingroup gnn_mse_doc
 *
 * This function corresponds to the evaluation of the MSE criterion.
 *
 * @param  crit A pointer to a \ref gnn_mse 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_mse_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);
    }
    E /= y->size;

    return E;
}

/**
 * @brief The gradient evaluation function.
 * @ingroup gnn_mse_doc
 *
 * This function implements the \ref gnn_mse criterion's gradient evaluation
 * function given by
 *
 * \f[ \frac{\partial E}{\partial y_i} = \frac{2}{m} (y_i - t_i) \f]
 *
 * @param  crit A pointer to a \ref gnn_mse 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_mse_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;

        gsl_vector_set (dy, i, dyi);
    }

    return 0;
}


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

/**
 * @brief Creates a new \ref gnn_mse criterion.
 * @ingroup gnn_mse_doc
 *
 * This function creates a new \ref gnn_mse 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_mse or NULL if failed.
 */
gnn_criterion *
gnn_mse_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_mse", GSL_ENOMEM, NULL);

    /* initialize */
    status = gnn_criterion_init  (crit, "gnn_mse", size,
                                  gnn_mse_e, gnn_mse_dy, NULL);
    if (status)
    {
        gnn_criterion_destroy (crit);
        GSL_ERROR_VAL ("couldn't initialize gnn_mse", GSL_EFAILED, NULL);
    }
    
    return crit;
}

---