/home/rex/ebltrunk/core/libeblearn/include/ebl_layers.h

/***************************************************************************
 *   Copyright (C) 2008 by Yann LeCun and Pierre Sermanet *
 *   yann@cs.nyu.edu, pierre.sermanet@gmail.com *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef EBL_LAYERS_H_
#define EBL_LAYERS_H_

#include "ebl_defines.h"
#include "libidx.h"
#include "ebl_states.h"
#include "ebl_basic.h"
#include "ebl_pooling.h"
#include "ebl_arch.h"
#include "ebl_nonlinearity.h"
#include "ebl_normalization.h"

namespace ebl {

  template <typename T, class Tstate = bbstate_idx<T> >
    class full_layer : public module_1_1<T,Tstate> {
  public: 
    full_layer(parameter<T,Tstate> *p, intg indim0, intg noutputs,
               bool tanh = true, const char *name = "full_layer");
    virtual ~full_layer();
    void fprop(Tstate &in, Tstate &out);
    void bprop(Tstate &in, Tstate &out);
    void bbprop(Tstate &in, Tstate &out);
    void forget(forget_param_linear &fp);
    virtual fidxdim fprop_size(fidxdim &i_size);
    virtual idxdim bprop_size(const idxdim &o_size);
    virtual full_layer<T,Tstate>* copy();
    virtual std::string describe();

    // members ////////////////////////////////////////////////////////
  private:
    bool                                 btanh; 
  public:
     /* linear_module_replicable<T,Tstate>       linear;//!< linear module for weight */
    linear_module<T,Tstate>              linear;
    addc_module<T,Tstate>                adder; 
    module_1_1<T,Tstate>                *sigmoid;
    Tstate                              *sum;   
  };

  template <typename T, class Tstate = bbstate_idx<T> >
    class convolution_layer : public module_1_1<T,Tstate> {
  public:
    convolution_layer(parameter<T,Tstate> *p, idxdim &ker, idxdim &stride,
                      idx<intg> &tbl, bool tanh = true,
                      const char *name = "convolution_layer");
    virtual ~convolution_layer();
    void fprop(Tstate &in, Tstate &out);
    void bprop(Tstate &in, Tstate &out);
    void bbprop(Tstate &in, Tstate &out);
    void forget(forget_param_linear &fp);
    virtual fidxdim fprop_size(fidxdim &i_size);
    virtual fidxdim bprop_size(const fidxdim &o_size);
    virtual convolution_layer<T,Tstate>* copy();

    // members ////////////////////////////////////////////////////////
  private:
    bool                                         btanh; 
  public:
  //    convolution_module_replicable<T,Tstate>  convol;//!< convolution module
    convolution_module<T,Tstate>         convol;
    addc_module<T,Tstate>                        adder; 
    module_1_1<T,Tstate>                        *sigmoid;
    Tstate                                      *sum;   
  };

  template <typename T, class Tstate = bbstate_idx<T> >
    class convabsnorm_layer : public module_1_1<T,Tstate> {
  public:

    convabsnorm_layer(parameter<T,Tstate> *p, intg kerneli, intg kernelj, 
                      intg stridei, intg stridej, idx<intg> &tbl,
                      bool mirror = false, bool tanh = true,
                      const char *name = "convabsnorm_layer");
    virtual ~convabsnorm_layer();
    void fprop(Tstate &in, Tstate &out);
    void bprop(Tstate &in, Tstate &out);
    void bbprop(Tstate &in, Tstate &out);
    void forget(forget_param_linear &fp);
    virtual fidxdim fprop_size(fidxdim &i_size);
    virtual fidxdim bprop_size(const fidxdim &o_size);
    virtual convabsnorm_layer<T,Tstate>* copy();

    // members ////////////////////////////////////////////////////////
  private:
    bool                                 btanh; 
  public:
    convolution_layer<T,Tstate>          lconv; 
    abs_module<T,Tstate>                 abs;   
    contrast_norm_module<T,Tstate>       norm;  
    Tstate                              *tmp;   
    Tstate                              *tmp2;  
  };

  template <typename T, class Tstate = bbstate_idx<T> >
    class subsampling_layer : public module_1_1<T,Tstate> {
  public:
    subsampling_layer(parameter<T,Tstate> *p, uint thickness,
                      idxdim &kernel, idxdim &stride,
                      bool tanh = true, const char *name = "subsampling_layer");
    virtual ~subsampling_layer();
    void fprop(Tstate &in, Tstate &out);
    void bprop(Tstate &in, Tstate &out);
    void bbprop(Tstate &in, Tstate &out);
    void forget(forget_param_linear &fp);
    virtual fidxdim fprop_size(fidxdim &i_size);
    virtual fidxdim bprop_size(const fidxdim &o_size);
    virtual subsampling_layer<T,Tstate>* copy();
    virtual std::string describe();

    // members ////////////////////////////////////////////////////////
  private:
    bool                                         btanh; 
  public:
    subsampling_module_replicable<T,Tstate>      subsampler;
    addc_module<T,Tstate>                        adder; 
    module_1_1<T,Tstate>                        *sigmoid;
    Tstate                                      *sum;   
   };

} // namespace ebl {

#include "ebl_layers.hpp"

#endif /* EBL_LAYERS_H_ */