VarArray.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: VarArray.h,v 1.17 2004/07/21 16:30:54 chrish42 Exp $
   * This file is part of the PLearn library.
   ******************************************************* */


#ifndef VARARRAY_INC
#define VARARRAY_INC

#include <plearn/base/general.h>
#include <plearn/base/Array.h>
#include "Variable.h"

namespace PLearn {
using namespace std;

class VarArray: public Array<Var>
{
public:

  typedef Var* iterator;

  VarArray();
  explicit VarArray(int n,int n_extra=10);
  VarArray(int n,int initial_length, int n_extra);
  VarArray(int n,int initial_length, int initial_width, int n_extra);
  VarArray(const Array<Var>& va): Array<Var>(va) {}
  VarArray(Array<Var>& va): Array<Var>(va) {}
  VarArray(const VarArray& va): Array<Var>(va) {}
  VarArray(const Var& v);
  VarArray(const Var& v1, const Var& v2);
  VarArray(Variable* v);
  VarArray(Variable* v1, Variable* v2);

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

  operator Var()
  { 
    if(size()!=1)
      PLERROR("Cannot cast VarArray containing more than one variable to Var");
    return operator[](0);
  }

  VarArray& operator&=(const Var& v) { PLearn::operator&=(*this,v); return *this;}
  VarArray& operator&=(const VarArray& va) { PLearn::operator&=(*this,va); return *this; }
  VarArray operator&(const Var& v) const { return PLearn::operator&(*this,v); }
  VarArray operator&(const VarArray& va) const { return PLearn::operator&(*this,va); }

  int nelems() const;
  int sumOfLengths() const;
  int sumOfWidths() const;
  int maxWidth() const;
  int maxLength() const;

  VarArray nonNull() const;
  VarArray& subVarArray(int start,int len) const;
  void copyFrom(int start,int len,const VarArray& from);//copy Var of from in courant VarArray 
  void copyFrom(int start,const VarArray& from){copyFrom(start,from.size(),from);}
  void copyFrom(const Vec& datavec);
  void copyValuesFrom(const VarArray& from);
  void copyTo(const Vec& datavec) const;
  void accumulateTo(const Vec& datavec) const;
  void copyGradientFrom(const Vec& datavec);
  void copyGradientFrom(const Array<Vec>& datavec);
  void accumulateGradientFrom(const Vec& datavec);
  void copyGradientTo(const Vec& datavec);
  void copyGradientTo(const Array<Vec>& datavec);
  void accumulateGradientTo(const Vec& datavec);

  void copyTo(real* x, int n) const;
  void accumulateTo(real* x, int n) const;
  void copyFrom(const real* x, int n);
  void makeSharedValue(real* x, int n); 
  void makeSharedGradient(real* x, int n); 

  void makeSharedValue(PP<Storage<real> > storage, int offset_=0); 
  void makeSharedValue(Vec& v, int offset_=0);
  void makeSharedGradient(Vec& v, int offset_=0);
  void makeSharedGradient(PP<Storage<real> > storage, int offset_=0); 
  void copyGradientTo(real* x, int n);
  void copyGradientFrom(const real* x, int n);
  void accumulateGradientFrom(const real* x, int n);
  void accumulateGradientTo(real* x, int n);
  void copyMinValueTo(const Vec& minv);
  void copyMaxValueTo(const Vec& maxv);
  void copyMinValueTo(real* x, int n);
  void copyMaxValueTo(real* x, int n);

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

  void setMark() const;
  void clearMark() const;
  void markPath() const;
  void buildPath(VarArray& fpath) const;
  void setDontBpropHere(bool val);

  void fprop();
  void sizeprop();
  void sizefprop();
  void bprop();
  void bbprop();
  void rfprop();
  void fbprop();
  void fbbprop();

  void fillGradient(real value);
  void clearGradient();
  void clearDiagHessian();
  VarArray sources() const;
  VarArray ancestors() const;
  void unmarkAncestors() const;

  VarArray parents() const;

  void symbolicBprop(); 
  VarArray symbolicGradient(); 
  void clearSymbolicGradient(); 

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

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

  real maxUpdate(Vec direction);

  bool update(real step_size);

  inline void updateAndClear();

  bool update(Vec new_value);

  void read(istream& in);
  void write(ostream& out) const;
  void printNames()const;
  void printInfo(bool print_gradient=false)
  {
    iterator array = data();
    for (int i=0;i<size();i++)
      if (!array[i].isNull())
        array[i]->printInfo(print_gradient);
  }

  Var operator[](Var index);
  inline Var& operator[](int i) { return Array<Var>::operator[](i); }
  inline const Var& operator[](int i) const
    { return Array<Var>::operator[](i); }
};

inline void VarArray::updateAndClear()
{
  iterator array = data();
  for(int i=0; i<size(); i++)
    array[i]->updateAndClear();
}

template <>
inline void deepCopyField(VarArray& field, CopiesMap& copies)
{
  field.makeDeepCopyFromShallowCopy(copies);
}

inline void operator<<(VarArray& ar, const Vec& datavec)
{ ar.copyFrom(datavec); }

inline void operator>>(VarArray& ar, const Vec& datavec)
{ ar.copyTo(datavec); }

void operator<<(VarArray& ar, const Array<Vec>& values);
void operator>>(VarArray& ar, const Array<Vec>& values);

VarArray propagationPath(const VarArray& inputs, const VarArray& outputs);

//VarArray propagationPath(const VarArray& inputs, const VarArray& parameters_to_optimize,const VarArray& outputs);

VarArray propagationPath(const VarArray& outputs);

VarArray propagationPathToParentsOfPath(const VarArray& inputs, const VarArray& outputs);


VarArray nonInputParentsOfPath(VarArray inputs, VarArray outputs);

VarArray allSources(const VarArray& v);

 VarArray operator-(const VarArray& a, const VarArray& b);

VarArray nonInputSources(const VarArray& inputs, const VarArray& outputs);

void printInfo(VarArray inputs, const Var& output, bool show_gradients=true);

void printInfo(VarArray& a);

inline VarArray operator&(Var v1, Var v2)
{ return VarArray(v1,v2); }

 DECLARE_TYPE_TRAITS(VarArray);

 inline PStream &operator>>(PStream &in, VarArray &o)
   { in >> static_cast<Array<Var> &>(o); return in; }
 
 inline PStream &operator<<(PStream &out, const VarArray &o)
   { out << static_cast<const Array<Var> &>(o); return out; }


} // end of namespace PLearn

#endif

---