/home/rex/ebltrunk/core/libeblearn/include/ebl_cost.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_COST_H_
#define EBL_COST_H_

#include "libidx.h"
#include "ebl_arch.h"

namespace ebl {

  template<typename T1, typename T2, class Tstate1 = bbstate_idx<T1>,
    class Tstate2 = bbstate_idx<T2> >
    class cost_module : public ebm_2<Tstate1, Tstate2, Tstate1> {
  public:
    idx<T1>             &targets;
    Tstate1              in2;
    idx<T1>              energies;

    cost_module(idx<T1> &targets_);
    virtual ~cost_module();
  };

  template<typename T1, typename T2, class Tstate1 = bbstate_idx<T1>,
    class Tstate2 = bbstate_idx<T2> >
    class euclidean_module : public cost_module<T1, T2, Tstate1, Tstate2> {
  public:
    euclidean_module(idx<T1> &targets_);

    virtual ~euclidean_module();

    virtual void fprop(Tstate1 &in1, Tstate2 &in2, Tstate1 &energy);

    virtual void bprop(Tstate1 &in1, Tstate2 &in2, Tstate1 &energy);

    virtual void bbprop(Tstate1 &in1, Tstate2 &in2, Tstate1 &energy);

    virtual void forget(forget_param_linear &fp) {}

    virtual double infer2(Tstate1 &i1, Tstate2 &i2, infer_param &ip, 
                          Tstate2 *label = NULL, Tstate1 *energy = NULL);
    
  protected:
    using cost_module<T1, T2, Tstate1, Tstate2>::targets;
    using cost_module<T1, T2, Tstate1, Tstate2>::in2;
    using cost_module<T1, T2, Tstate1, Tstate2>::energies;
  };

  template<class T>
    class logadd_layer { //: public module_1_1<fstate_idx, fstate_idx> { // TODO
  public:
    idx<T> expdist;
    idx<T> sumexp;

    logadd_layer(intg thick, intg si, intg sj);
    virtual ~logadd_layer() {
    }
    void fprop(fstate_idx<T> *in, fstate_idx<T> *out);
    void bprop(fstate_idx<T> *in, fstate_idx<T> *out);

    void bbprop(fstate_idx<T> *in, fstate_idx<T> *out);
  };

  template<class T> class distance_l2 : public ebm_2<T> {
  private:
    idx<T> tmp;
    
  public:
    distance_l2();
    virtual ~distance_l2();

    virtual void fprop(fstate_idx<T> &in1, fstate_idx<T> &in2,
                       fstate_idx<T> &energy);
    virtual void bprop(fstate_idx<T> &in1, fstate_idx<T> &in2,
                       fstate_idx<T> &energy);
    virtual void bbprop(fstate_idx<T> &in1, fstate_idx<T> &in2,
                        fstate_idx<T> &energy);
    virtual void forget(forget_param_linear &fp);
    virtual void infer2_copy(fstate_idx<T> &i1, fstate_idx<T> &i2,
                             fstate_idx<T> &energy);
  };

  template<class T> class penalty_l1 : public ebm_1<T> {
  private:
    double threshold;

  public:
    penalty_l1(T threshold_);
    virtual ~penalty_l1();

    virtual void fprop(fstate_idx<T> &in, fstate_idx<T> &energy);
    virtual void bprop(fstate_idx<T> &in, fstate_idx<T> &energy);
    virtual void bbprop(fstate_idx<T> &in, fstate_idx<T> &energy);
    virtual void forget(forget_param_linear &fp);
  };

} // namespace ebl {

#include "ebl_cost.hpp"

#endif /* EBLCOST_H_ */