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

/***************************************************************************
 *   Copyright (C) 2008 by Yann LeCun and Pierre Sermanet *
 *   yann@cs.nyu.edu, pierre.sermanet@gmail.com *
 *   All rights reserved.
 *
 * 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_STATES_H_
#define EBL_STATES_H_

#include "libidx.h"

namespace ebl {

  class infer_param {
  };

  class EXPORT gd_param: public infer_param {
  public:
    double eta;
    double n;
    double decay_l1;
    double decay_l2;
    intg decay_time;
    double inertia;
    double anneal_value;
    intg anneal_period;
    double gradient_threshold;
    int niter_done;

    gd_param();
    
    gd_param(double leta, double ln, double l1, double l2, intg dtime,
             double iner, double a_v, intg a_p, double g_t);
  };

  EXPORT std::ostream& operator<<(std::ostream &out, const gd_param &p);

  class forget_param {
  };

  class EXPORT forget_param_linear: public forget_param {
  public:
    forget_param_linear(double v, double e);

    // public member variables /////////////////////////////////////////////////
  public:
    double value;
    double exponent;
    random generator; 
  };

  class EXPORT state : public smart_pointer {
  public:
    state();
    virtual ~state();
    virtual void clear();
    virtual void clear_x();
    virtual void clear_dx();
    virtual void clear_ddx();
    virtual void update_gd(gd_param &arg);
    virtual state& operator=(const state& other);
  };

  template <typename T> class bbstate_idx;
  template <typename T, class Tstate = bbstate_idx<T> > class parameter;

  template <typename T> class fstate_idx: public state {
  public:
    virtual ~fstate_idx();


    fstate_idx();
    fstate_idx(intg s0);
    fstate_idx(intg s0, intg s1);
    fstate_idx(intg s0, intg s1, intg s2);
    fstate_idx(intg s0, intg s1, intg s2, intg s3, intg s4 = -1, intg s5 = -1,
              intg s6 = -1, intg s7 = -1);
    fstate_idx(const idxdim &d);
    fstate_idx(intg n, fstate_idx<T> &fs);


    fstate_idx(parameter<T,fstate_idx<T> > *st);
    fstate_idx(parameter<T,fstate_idx<T> > *st, intg s0);
    fstate_idx(parameter<T,fstate_idx<T> > *st, intg s0, intg s1);
    fstate_idx(parameter<T,fstate_idx<T> > *st, intg s0, intg s1, intg s2);
    fstate_idx(parameter<T,fstate_idx<T> > *st, intg s0, intg s1, intg s2,
               intg s3, intg s4 = -1, intg s5 = -1, intg s6 = -1, intg s7 = -1);
    fstate_idx(parameter<T,fstate_idx<T> > *st, const idxdim &d);


    fstate_idx(const idx<T> &x);


    virtual void clear();
    virtual void clear_x();


    virtual intg nelements();
    virtual intg footprint();
    virtual intg size();


    virtual void resize(intg s0 = -1, intg s1 = -1, intg s2 = -1, intg s3 = -1,
                        intg s4 = -1, intg s5 = -1, intg s6 = -1, intg s7 = -1);
    virtual void resize(const idxdim &d);
    virtual void resize1(intg dimn, intg size);   
    virtual void resize_as(fstate_idx& s);
    virtual void resize_as_but1(fstate_idx<T>& s, intg fixed_dim);

    //    virtual void resize(const intg* dimsBegin, const intg* dimsEnd);


    fstate_idx<T> select(int dimension, intg slice_index);    
    fstate_idx<T> narrow(int dimension, intg size, intg offset);
    
    
    fstate_idx<T> make_copy();
    virtual fstate_idx<T>& operator=(const fstate_idx<T>& other);
    virtual void copy(fstate_idx<T> &cpy);

    // info printing ///////////////////////////////////////////////////////////
    
    virtual void pretty();    
    virtual void print();
    
  public:
    idx<T> x;
    idx<T> dx;
    idx<T> ddx;
  };

  
  template <typename T> class bstate_idx: public fstate_idx<T> {
  public:
    virtual ~bstate_idx();


    bstate_idx();
    bstate_idx(intg s0);
    bstate_idx(intg s0, intg s1);
    bstate_idx(intg s0, intg s1, intg s2);
    bstate_idx(intg s0, intg s1, intg s2, intg s3, intg s4 = -1, intg s5 = -1,
              intg s6 = -1, intg s7 = -1);
    bstate_idx(const idxdim &d);
    bstate_idx(intg n, bstate_idx<T> &fs);


    bstate_idx(parameter<T,bstate_idx<T> > *st);
    bstate_idx(parameter<T,bstate_idx<T> > *st, intg s0);
    bstate_idx(parameter<T,bstate_idx<T> > *st, intg s0, intg s1);
    bstate_idx(parameter<T,bstate_idx<T> > *st, intg s0, intg s1, intg s2);
    bstate_idx(parameter<T,bstate_idx<T> > *st, intg s0, intg s1, intg s2,
               intg s3, intg s4 = -1, intg s5 = -1, intg s6 = -1, intg s7 = -1);
    bstate_idx(parameter<T,bstate_idx<T> > *st, const idxdim &d);


    bstate_idx(const idx<T> &x, const idx<T> &dx);


    virtual void clear();
    virtual void clear_dx();
    virtual void update_gd(gd_param &arg);
      

    using fstate_idx<T>::nelements;
    using fstate_idx<T>::footprint;
    using fstate_idx<T>::size;
    

    virtual void resize(intg s0 = -1, intg s1 = -1, intg s2 = -1, intg s3 = -1,
                        intg s4 = -1, intg s5 = -1, intg s6 = -1, intg s7 = -1);
    virtual void resize(const idxdim &d);
    virtual void resize1(intg dimn, intg size);    
    virtual void resize_as(bstate_idx& s);
    virtual void resize_as_but1(bstate_idx<T>& s, intg fixed_dim);

    //    virtual void resize(const intg* dimsBegin, const intg* dimsEnd);


    bstate_idx<T> select(int dimension, intg slice_index);     
    bstate_idx<T> narrow(int dimension, intg size, intg offset);
    
    
    bstate_idx<T> make_copy();
    virtual bstate_idx<T>& operator=(const bstate_idx<T>& other);
    virtual void copy(bstate_idx<T> &cpy);
    
    // info printing ///////////////////////////////////////////////////////////
    
    virtual void pretty();    
    virtual void print();
    
  public:
    using fstate_idx<T>::x;
    using fstate_idx<T>::dx;
    using fstate_idx<T>::ddx;
  };
  
  template <typename T> class bbstate_idx: public bstate_idx<T> {
  public:
    virtual ~bbstate_idx();


    bbstate_idx();
    bbstate_idx(intg s0);
    bbstate_idx(intg s0, intg s1);
    bbstate_idx(intg s0, intg s1, intg s2);
    bbstate_idx(intg s0, intg s1, intg s2, intg s3, intg s4 = -1, intg s5 = -1,
              intg s6 = -1, intg s7 = -1);
    bbstate_idx(const idxdim &d);
    bbstate_idx(intg n, bbstate_idx<T> &fs);


    bbstate_idx(parameter<T,bbstate_idx<T> > *st);
    bbstate_idx(parameter<T,bbstate_idx<T> > *st, intg s0);
    bbstate_idx(parameter<T,bbstate_idx<T> > *st, intg s0, intg s1);
    bbstate_idx(parameter<T,bbstate_idx<T> > *st, intg s0, intg s1, intg s2);
    bbstate_idx(parameter<T,bbstate_idx<T> > *st, intg s0, intg s1, intg s2,
                intg s3, intg s4 = -1, intg s5 = -1, intg s6 = -1, intg s7 =-1);
    bbstate_idx(parameter<T,bbstate_idx<T> > *st, const idxdim &d);


    // TODO: this causes bug in mnist part of tester
    /* //! Constructs a bbstate_idx from an idx to be used as x. dx and ddx */
    /* //! will be allocated with the same size as x. */
    /*//! Note: the data pointed to by x is not copied, we only create new idx*/
    /* //!   pointing to the same data. */
    /* bbstate_idx(const idx<T> &x); */

    bbstate_idx(const idx<T> &x, const idx<T> &dx, const idx<T> &ddx);


    virtual void clear();
    virtual void clear_ddx();
    using bstate_idx<T>::update_gd;
      

    using fstate_idx<T>::nelements;
    using fstate_idx<T>::footprint;
    using fstate_idx<T>::size;
    

    virtual void resize(intg s0 = -1, intg s1 = -1, intg s2 = -1, intg s3 = -1,
                        intg s4 = -1, intg s5 = -1, intg s6 = -1, intg s7 = -1);
    virtual void resize(const idxdim &d);
    virtual void resize1(intg dimn, intg size);    
    virtual void resize_as(bbstate_idx& s);
    virtual void resize_as_but1(bbstate_idx<T>& s, intg fixed_dim);

    //    virtual void resize(const intg* dimsBegin, const intg* dimsEnd);


    bbstate_idx<T> select(int dimension, intg slice_index);     
    bbstate_idx<T> narrow(int dimension, intg size, intg offset);
    
    
    bbstate_idx<T> make_copy();
    virtual bbstate_idx<T>& operator=(const bbstate_idx<T>& other);
    virtual void copy(bbstate_idx<T> &cpy);
    
    // info printing ///////////////////////////////////////////////////////////
    
    virtual void pretty();    
    virtual void print();
    
  public:
    using fstate_idx<T>::x;
    using fstate_idx<T>::dx;
    using fstate_idx<T>::ddx;
  };

  template <typename T>
    class parameter<T, fstate_idx<T> > : public fstate_idx<T> {
  public:
    parameter(intg initial_size = 100);
    parameter(const char *param_filename);
    virtual ~parameter();
    virtual void resize(intg s0);

    // I/O methods
    
    bool load_x(std::vector<string> &files);
    bool load_x(const char *param_filename);
    bool load_x(idx<T> &m);
    bool save_x(const char *param_filename);


    using fstate_idx<T>::nelements;
    using fstate_idx<T>::footprint;
    using fstate_idx<T>::size;
    
  public:
    using fstate_idx<T>::x;
  };


  template <typename T>
    class parameter<T, bstate_idx<T> >
    : public bstate_idx<T>, public parameter<T,fstate_idx<T> > {
  public:
    parameter(intg initial_size = 100);
    parameter(const char *param_filename);
    virtual ~parameter();
    virtual void resize(intg s0);
    virtual void update(gd_param &arg);
    void clear_deltax();    
    void set_epsilon(T m);

    // I/O methods
    
    bool load_x(const char *param_filename);
    bool save_x(const char *param_filename);


    using fstate_idx<T>::nelements;
    using fstate_idx<T>::footprint;
    using fstate_idx<T>::size;
    
    // protected methods

  protected:

    void update_gd(gd_param &arg);
    void update_deltax(T knew, T kold);
    
  public:
    using fstate_idx<T>::x;
    using bstate_idx<T>::dx;

    //    idx<T> gradient;
    idx<T> deltax;   
    idx<T> epsilons; 
  };


  template <typename T>
    class parameter<T, bbstate_idx<T> > : public bbstate_idx<T> {
  public:
    parameter(intg initial_size = 100);
    parameter(const char *param_filename);
    virtual ~parameter();
    virtual void resize(intg s0);
    virtual void update(gd_param &arg);
    void clear_deltax();
    void clear_ddeltax();
    void set_epsilon(T m);
    void compute_epsilons(T mu);
    void update_ddeltax(T knew, T kold);
    
    // I/O methods
    
    bool load_x(std::vector<string> &files);
    bool load_x(const char *param_filename);
    bool load_x(idx<T> &m);
    bool save_x(const char *param_filename);


    using fstate_idx<T>::nelements;
    using fstate_idx<T>::footprint;
    using fstate_idx<T>::size;
    
    // protected methods
  protected:
    
    void update_gd(gd_param &arg);    
    void update_deltax(T knew, T kold);
    
  public:
    using fstate_idx<T>::x;
    using fstate_idx<T>::dx;
    using fstate_idx<T>::ddx;

    //idx<T> gradient;    
    idx<T> deltax;   
    idx<T> epsilons; 
    idx<T> ddeltax;  
  };

  // state_idxloopers

  template <typename Tstate> class state_idxlooper;
  
  template <typename T>
    class state_idxlooper<fstate_idx<T> > : public fstate_idx<T> {
  public:
    using fstate_idx<T>::x;

    idxlooper<T> lx;

    state_idxlooper(fstate_idx<T> &s, int ld);
    virtual ~state_idxlooper();
    bool notdone();
    void next();
  };

  template <typename T>
    class state_idxlooper<bstate_idx<T> > : public bstate_idx<T> {
  public:
    using bstate_idx<T>::x;
    using bstate_idx<T>::dx;

    idxlooper<T> lx;
    idxlooper<T> ldx;

    state_idxlooper(bstate_idx<T> &s, int ld);
    virtual ~state_idxlooper();
    bool notdone();
    void next();
  };

  template <typename T>
    class state_idxlooper<bbstate_idx<T> > : public bbstate_idx<T> {
  public:
    using bbstate_idx<T>::x;
    using bbstate_idx<T>::dx;
    using bbstate_idx<T>::ddx;

    idxlooper<T> lx;
    idxlooper<T> ldx;
    idxlooper<T> lddx;

    state_idxlooper(bbstate_idx<T> &s, int ld);
    virtual ~state_idxlooper();
    bool notdone();
    void next();
  };

#define state_idx_eloop1(dst0,src0,type0)                               \
  state_idxlooper<type0> dst0(src0, (src0).x.order() - 1);              \
  for ( ; dst0.notdone(); dst0.next())

#define state_idx_eloop2(dst0,src0,type0,dst1,src1,type1)               \
  if ((src0).x.dim((src0).x.order() - 1)                                \
  != (src1).x.dim((src1).x.order() - 1))                                \
  eblerror("incompatible state_idx for eloop\n");                       \
  state_idxlooper<type0> dst0(src0,(src0).x.order()-1);                 \
  state_idxlooper<type1> dst1(src1,(src1).x.order()-1);                 \
  for ( ; dst0.notdone(); dst0.next(), dst1.next())

#define state_idx_eloop3(src0,type0,dst1,src1,type1,dst2,src2,type2)    \
  if (((src0).x.dim((src0).x.order() - 1)                               \
       != (src1).x.dim((src1).x.order() - 1))                           \
      || ((src0).x.dim((src0).x.order() - 1)                            \
          != (src2).x.dim((src2).x.order() - 1)))                       \
    eblerror("incompatible idxs for eloop\n");                          \
  state_idxlooper<type0> dst0(src0,(src0).x.order()-1);                 \
  state_idxlooper<type1> dst1(src1,(src1).x.order()-1);                 \
  state_idxlooper<type2> dst2(src2,(src2).x.order()-1);                 \
  for ( ; dst0.notdone(); dst0.next(), dst1.next(), dst2.next())

  template <class Tstate> class mstate : public svector<Tstate> {
  public:
    mstate();
    mstate(const mstate<Tstate> &other, intg dims, intg nstates = -1);
    mstate(const mstate<Tstate> &other);
    virtual ~mstate();


    virtual void clear_x();
    virtual void clear_dx();
    virtual void clear_ddx();
    
    virtual void copy(mstate<Tstate> &cpy);
    template <typename T> void copy(midx<T> &cpy);
    template <typename T> midx<T> copy();
    
    virtual mstate<Tstate> narrow(intg size, intg offset);
    virtual mstate<Tstate> narrow(int dimension, intg size, intg offset);
    virtual mstate<Tstate> narrow(midxdim &regions);
    virtual mstate<Tstate> narrow_max(mfidxdim &regions);
    
    template <class T> void get_midx(mfidxdim &regions, midx<T> &all);
    template <class T> void get_max_midx(mfidxdim &regions, midx<T> &all);
    template <class T> void get_padded_midx(mfidxdim &regions, midx<T> &all);
    
    virtual void resize(mstate<Tstate> &s2, uint nmax = 0);
    template <class Tstate2> void resize(mstate<Tstate2> &other);
    virtual idxdim& get_idxdim0();
    
    // member variables ////////////////////////////////////////////////////////
  protected:
    typename svector<Tstate>::iterator it;
  };

  

  // stream operators

  template <typename T>
  EXPORT std::ostream& operator<<(std::ostream &out, const fstate_idx<T> &p);
  template <typename T>
  EXPORT std::ostream& operator<<(std::ostream &out, const bstate_idx<T> &p);
  template <typename T>
  EXPORT std::ostream& operator<<(std::ostream &out, const bbstate_idx<T> &p);  
  template <class Tstate>
  EXPORT std::ostream& operator<<(std::ostream &out, const mstate<Tstate> &p);

} // namespace ebl {

#include "ebl_states.hpp"

#endif /* EBL_STATES_H_ */