---

gnn_divergence.c

Go to the documentation of this file.

/***************************************************************************
 *  @file gnn_divergence.c
 *  @brief gnn_divergence Implementation.
 *
 *  @date   : 28-09-03 13:14
 *  @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.
 */

/**
 * @defgroup gnn_divergence_doc gnn_divergence : Input Divergence.
 * @ingroup gnn_atomic_doc
 *
 * This node type implements the function given by:
 *
 * \f[ y = [x, x, x, x]^T \f]
 *
 * In other words, it replicates the input several times on the output vector.
 * If the output vector's size isn't a multiple of the input vector's size,
 * that is, if \f$m\f$ can't be written as \f$kn\f$, then only the first inputs
 * will be copied, e.g. if \f$x=[x_0, \ldots, x_3]^T\f$ and \f$y\f$ is of size
 * \f$6 \times 1\f$ then
 *
 * \f[ y = [x_0, x_1, x_2, x_3, x_0, x_1]^T \f]
 *
 * Schematically, this idea can be depicted as
 *
 * <img src="images/gnn_divergence1.png">
 *
 * The function's gradient is:
 * \f[ \frac{\partial E}{\partial x_i}
 *     = \sum_k \frac{\partial E}{\partial y_{kn+i}}
 * \f]
 */


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

#include "gnn_divergence.h"



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

static int
gnn_divergence_f (gnn_node *node,
                  const gsl_vector *x,
                  const gsl_vector *w,
                  gsl_vector *y);

static int
gnn_divergence_dx (gnn_node *node,
                   const gsl_vector *x,
                   const gsl_vector *w,
                   const gsl_vector *dy,
                   gsl_vector *dx);

static int
gnn_divergence_dw (gnn_node *node,
                   const gsl_vector *x,
                   const gsl_vector *w,
                   const gsl_vector *dy,
                   gsl_vector *dw);

static void
gnn_divergence_destroy (gnn_node *node);



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

/**
 * @brief Computes the output.
 * @ingroup gnn_divergence_doc
 *
 * @param   node A pointer to the \ref gnn_divergence node.
 * @param x The input vector \f$x\f$.
 * @param w The parameter vector \f$w\f$.
 * @param y The output buffer vector \f$y\f$.
 * @return Returns 0 on success.
 */
static int
gnn_divergence_f (gnn_node *node,
                  const gsl_vector *x,
                  const gsl_vector *w,
                  gsl_vector *y)
{
    size_t n;
    size_t m;
    size_t k;
    gnn_divergence *dnode;

    /* get views */
    dnode = (gnn_divergence *) node;

    /* get sizes */
    n = gnn_node_input_get_size (node);
    m = gnn_node_output_get_size (node);

    /* evaluate */
    for (k=0; k<m; ++k)
    {
        size_t i;
        double yk;

        i  = k % n;
        yk = gsl_vector_get (x, i);
        gsl_vector_set (y, k, yk);
    }

    return 0;
}

/**
 * @brief Computes \f$ \frac{\partial E}{\partial x} \f$.
 * @ingroup gnn_divergence_doc
 *
 * @param    node A pointer to the \ref gnn_divergence node.
 * @param x  The input vector \f$x\f$.
 * @param w  The parameter vector \f$w\f$.
 * @param dy The vector \f$\frac{\partial E}{\partial y}\f$.
 * @param dx The output buffer vector \f$\frac{\partial E}{\partial x}\f$.
 * @return Returns 0 on success.
 */
static int
gnn_divergence_dx (gnn_node *node,
                   const gsl_vector *x,
                   const gsl_vector *w,
                   const gsl_vector *dy,
                   gsl_vector *dx)
{
    size_t n;
    size_t m;
    size_t k;
    gnn_divergence *dnode;

    /* get views */
    dnode = (gnn_divergence *) node;

    /* get sizes */
    n = gnn_node_input_get_size (node);
    m = gnn_node_output_get_size (node);

    /* evaluate */
    gsl_vector_set_zero (dx);
    for (k=0; k<m; ++k)
    {
        size_t i;
        double dxi;

        i    = k % n;
        dxi  = gsl_vector_get (dx, i);
        dxi += gsl_vector_get (dy, k);
        gsl_vector_set (dx, i, dxi);
    }

    return 0;
}

/**
 * @brief Computes \f$ \frac{\partial E}{\partial w} \f$.
 * @ingroup gnn_divergence_doc
 *
 * @param    node A pointer to the \ref gnn_divergence node.
 * @param x  The input vector \f$x\f$.
 * @param w  The parameter vector \f$w\f$.
 * @param dy The vector \f$\frac{\partial E}{\partial y}\f$.
 * @param dx The output buffer vector \f$\frac{\partial E}{\partial w}\f$.
 * @return Returns 0 on success.
 */
static int
gnn_divergence_dw (gnn_node *node,
                   const gsl_vector *x,
                   const gsl_vector *w,
                   const gsl_vector *dy,
                   gsl_vector *dw)
{
    return 0;
}



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

/**
 * @brief Creates an input divergence node.
 * @ingroup gnn_divergence_doc
 *
 * This function creates a node of the \ref gnn_divergence type.
 *
 * @param input_size  The input size \f$n\f$.
 * @param output_size The output size \f$m\f$.
 * @return A pointer to a new \ref gnn_divergence node.
 */
gnn_node *
gnn_divergence_new (size_t input_size, size_t output_size)
{
    int status;
    size_t k;
    gnn_node *node;
    gnn_divergence *dnode;

    /* check sizes */
    if (input_size < 1)
    {
        GSL_ERROR_VAL ("input size should be strictly positive",
                       GSL_EINVAL, NULL);
    }
    if (input_size > output_size)
    {
        GSL_ERROR_VAL ("output size should be greater than the input size",
                       GSL_EINVAL, NULL);
    }

    /* allocate the node */
    dnode = (gnn_divergence *) malloc (sizeof (gnn_divergence));
    if (dnode == NULL)
    {
        GSL_ERROR_VAL ("could not allocate memory for gnn_divergence node",
                       GSL_ENOMEM, NULL);
    }

    /* get view as a gnn_node */
    node = (gnn_node *) dnode;

    /* Initialize the node */
    status = gnn_node_init (node,
                            "gnn_divergence",
                            gnn_divergence_f,
                            gnn_divergence_dx,
                            gnn_divergence_dw,
                            NULL);
    if (status)
    {
        GSL_ERROR_VAL ("could not initialize gnn_divergence node",
                       GSL_EFAILED, NULL);
    }

    status = gnn_node_set_sizes (node, input_size, output_size, 0);
    if (status)
    {
        GSL_ERROR_VAL ("could not set sizes for gnn_divergence node",
                       GSL_EFAILED, NULL);
    }

    /* compute amount of replications */
    dnode->rep =  output_size / input_size;
    dnode->rep += (output_size % input_size == 0)? 0 : 1;

    return node;
}

---