Variable.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 1998 Pascal Vincent
// Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. 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.
// 
//  3. The name 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 BY THE AUTHORS ``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.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org


 

/* *******************************************************      
   * $Id: Variable.h,v 1.17 2004/07/26 21:04:14 chrish42 Exp $
   * This file is part of the PLearn library.
   ******************************************************* */

#ifndef Variable_INC
#define Variable_INC

#include <plearn/math/TMat.h>
#include <plearn/base/Object.h>

namespace PLearn {
using namespace std;

class Variable;
class VarArray;
class RandomVariable;
class RandomVar;

class Var: public PP<Variable>
{
  friend class RandomVariable;
  friend class RandomVar;

public:
  Var();
  Var(Variable* v);
  Var(Variable* v, const char* name);
  Var(const Var& other);
  Var(const Var& other, const char* name);
  explicit Var(int the_length, int width_=1);
  Var(int the_length, int the_width, const char* name);
  Var(int the_length, const char* name);
  explicit Var(const Vec& vec, bool vertival=true);
  explicit Var(const Mat& mat);

  int length() const;
  int width() const;

  Var subVec(int start, int len, bool transpose=false) const;
  Var subMat(int i, int j, int sublength, int subwidth, bool transpose=false) const;
  Var row(int i, bool transpose=false) const;
  Var column(int j, bool transpose=false) const;
  Var operator()(int i) const;
  Var operator()(int i, int j) const;

  Var operator[](int i) const;
  Var operator[](Var i) const;
  
  Var operator()(Var index) const;

  Var operator()(Var i, Var j) const;

  void operator=(real f);
  void operator=(const Vec& v);
  void operator=(const Mat& m);
};

class Variable: public Object
{
public:
  typedef Object inherited;

protected:
  Variable() : varnum(++nvars), marked(false), varname(), allows_partial_update(false),
               gradient_status(0), valuedata(0), gradientdata(0), min_value(-FLT_MAX),
               max_value(FLT_MAX), dont_bprop_here(false) {}

  static void declareOptions(OptionList & ol);
  
  friend class Var;
  friend class RandomVariable;
  friend class ProductRandomVariable;
  friend class Function;

  friend class UnaryVariable;
  friend class BinaryVariable;
  friend class NaryVariable;

public:
  static int nvars; 
  int varnum; 

protected:
  bool marked; 
  string varname; 

protected:
  bool allows_partial_update; 
  int gradient_status; 
  TVec<int> rows_to_update; 

public:
  Vec value;
  Vec gradient;
  Mat matValue;
  Mat matGradient;
  Vec rValue;
  Mat matRValue;
  Mat matDiagHessian; 

  real* valuedata; 
  real* gradientdata; 
  real min_value, max_value; 
  Var g; 
  Vec diaghessian; 
  real* diaghessiandata; 
  real* rvaluedata;
  bool dont_bprop_here; 
  
public:
  Variable(int thelength, int thewidth);
  Variable(const Mat& m);  

  int length() const { return matValue.length(); }
  int width() const { return matValue.width(); }
  int size() const { return matValue.size(); } // length*width
  int nelems() const { return size(); }

  virtual void recomputeSize(int& l, int& w) const;

  void resize(int l, int w);
  
  void sizeprop();

  virtual void setParents(const VarArray& parents);

  Variable(const Variable& v);

private:
  void build_();
public:
  virtual void build();

  bool isScalar() const { return length()==1 && width()==1; }
  bool isVec() const { return length()==1 || width()==1; }
  bool isColumnVec() const { return width()==1; }
  bool isRowVec() const { return length()==1; }

  PLEARN_DECLARE_ABSTRACT_OBJECT(Variable);

  virtual void makeDeepCopyFromShallowCopy(map<const void*, void*>& copies);

  virtual void fprop() =0;

  inline void sizefprop()
  { sizeprop(); fprop(); }

  virtual void bprop() =0;
  virtual void bbprop();
  virtual void fbprop();
  virtual void fbbprop();
  virtual void symbolicBprop();

  virtual void rfprop();

  virtual void copyValueInto(Vec v) { v << value; }
  virtual void copyGradientInto(Vec g) { g << gradient; }

  virtual void print(ostream& out) const;

  string getName() const;
  void setName(const string& the_name); 
  bool nameIsSet() { return varname.size()>0; }

  Mat defineGradientLocation(const Mat& m);

  virtual void printInfo(bool print_gradient=false) = 0;
  virtual void printInfos(bool print_gradient=false);

  Var subVec(int start, int len, bool transpose=false);
  Var subMat(int i, int j, int sublength, int subwidth, bool transpose=false);
  Var row(int i, bool transpose=false) { return subMat(i,0,1,width(),transpose); }
  Var column(int j, bool transpose=false) { return subMat(0,j,length(),1,transpose); }

  void setDontBpropHere(bool val) { dont_bprop_here = val; }
  void setKeepPositive() { min_value = 0; }
  void setMinValue(real minv=-FLT_MAX) { min_value = minv; }
  void setMaxValue(real maxv=FLT_MAX) { max_value = maxv; }
  void setBoxConstraint(real minv, real maxv) { min_value = minv; max_value = maxv; }

  void setMark() { marked = true; }
  void clearMark() { marked = false; }
  bool isMarked() { return marked; }

  void fillGradient(real value) { gradient.fill(value); }
  void clearGradient() 
    { 
      if(!allows_partial_update) 
        gradient.clear(); 
      else
      {
        for (int r=0;r<rows_to_update.length();r++)
          {
            int row = rows_to_update[r];
            matGradient.row(row).clear();
          }
          rows_to_update.resize(0);
          gradient_status=0;
      }
    }
  void clearDiagHessian(); 
  void clearSymbolicGradient() { g = Var(); }

  bool update(real step_size, Vec direction_vec, real coeff = 1.0, real b = 0.0);

  bool update(Vec step_sizes, Vec direction_vec, real coeff = 1.0, real b = 0.0);

  inline void updateAndClear();

  bool update(real step_size);

  void allowPartialUpdates()
  {
    allows_partial_update=true; 
    rows_to_update.resize(length()); // make sure that there are always enough elements
    rows_to_update.resize(0);
    gradient_status=0;
  }

  void disallowPartialUpdates()
  {
    allows_partial_update = false;
    gradient_status=2;
  }

  void updateRow(int row)
  {
    if (gradient_status!=2 && allows_partial_update && !rows_to_update.contains(row))
    {
      rows_to_update.append(row);
      if (gradient_status==0) gradient_status=1;
    }
  }


  bool update(Vec new_value);

  real maxUpdate(Vec direction);

  virtual bool markPath() =0;

  virtual void buildPath(VarArray& proppath) =0;

  virtual void oldread(istream& in);
  virtual void write(ostream& out) const;

  
  

  void copyFrom(const Vec& v)    { value << v; }
  void copyTo(Vec& v)    { v << value; }
  void copyGradientFrom(const Vec& v)    { gradient << v; }
  void copyGradientTo(Vec& v) { v << gradient; }
  void makeSharedValue(real* x, int n); 
  void makeSharedGradient(real* x, int n); 

  void makeSharedValue(PP<Storage<real> > storage, int offset_=0); 
  void makeSharedGradient(PP<Storage<real> > storage, int offset_=0); 
  void makeSharedValue(Vec& v, int offset_=0);
  void makeSharedGradient(Vec& v, int offset_=0);

  void copyRValueFrom(const Vec& v) { resizeRValue(); rValue << v; }
  void copyRValueTo(Vec& v) { resizeRValue(); v << rValue; }
  void makeSharedRValue(real* x, int n); 
  void makeSharedRValue(PP<Storage<real> > storage, int offset_=0);
  void makeSharedRValue(Vec& v, int offset_=0);

  virtual bool isConstant() { return false; }

  virtual void fprop_from_all_sources();

  virtual VarArray sources() = 0;

  virtual VarArray random_sources() = 0;

  virtual VarArray ancestors() = 0;
  virtual void unmarkAncestors() = 0;

  virtual VarArray parents() = 0;

  virtual void accg(Var v);

  virtual void verifyGradient(real step=0.001);

  virtual void resizeDiagHessian();

  virtual void resizeRValue();
};

DECLARE_OBJECT_PTR(Variable);
DECLARE_OBJECT_PP(Var, Variable);

// set value += gradient and clears the gradient
inline void Variable::updateAndClear()
{
  for(int i=0; i<nelems(); i++)
    valuedata[i] += gradientdata[i];
  gradient.clear();
}

void varDeepCopyField(Var& field, CopiesMap& copies);


inline Var Var::row(int i, bool transpose) const
{
  return subMat(i, 0, 1, width(), transpose);
}
    
inline Var Var::column(int j, bool transpose) const
{
  return subMat(0, j, length(), 1, transpose);
}

inline Var Var::operator()(int i) const
{
  return row(i, false);
}

inline Var Var::operator()(int i, int j) const
{
  return subMat(i, j, 1, 1);
}
    
} // end of namespace PLearn

#endif

---