LLM.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLMath/src/ICLMath/LLM.h                              **
** Module : ICLMath                                                **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/CompatMacros.h>
#include <ICLUtils/Range.h>
#include <ICLUtils/Configurable.h>
#include <vector>

namespace icl{
  namespace math{

    class ICLMath_API LLM : public utils::Configurable{
      public:
      struct ICLMath_API Kernel{
        Kernel();
        Kernel(unsigned int inputDim, unsigned int outputDim);
        Kernel(const Kernel &k);
        ~Kernel();
        Kernel &operator=(const Kernel &k);

        float *w_in;

        float *w_out;

        float *A;

        float *dw_in;

        float *var;

        unsigned int inputDim;

        unsigned int outputDim;

        void show(unsigned int idx=0) const;


        void set(const float *w_in, const float *w_out, const float *A);
      };


      static const int TRAIN_CENTERS = 1; 
      static const int TRAIN_SIGMAS = 2;  
      static const int TRAIN_OUTPUTS = 4; 
      static const int TRAIN_MATRICES = 8;
      static const int TRAIN_ALL = TRAIN_CENTERS | TRAIN_SIGMAS | TRAIN_OUTPUTS | TRAIN_MATRICES; 
      private:
      void init_private(unsigned int inputDim,unsigned int outputDim);

      public:

      LLM(unsigned int inputDim, unsigned int outputDim);

      LLM(unsigned int inputDim, unsigned int outputDim, unsigned int numCenters,
          const std::vector<utils::Range<icl32f> > &ranges,
          const std::vector<float> &var=std::vector<float>(1,1));


      void init(unsigned int numCenters, const std::vector<utils::Range<icl32f> > &ranges,
                const std::vector<float> &var=std::vector<float>(1,1));


      void init(const std::vector<float*> &centers,
                const std::vector<float> &var=std::vector<float>(1,1));


      const float *apply(const float *x);


      void train(const float *x,const float *y, int trainflags = TRAIN_ALL);

      void trainCenters(const float *x);

      void trainSigmas(const float *x);

      void trainOutputs(const float *x,const float *y);

      void trainMatrices(const float *x,const float *y);

      private:

      const float *updateGs(const float *x);

      public:
      const float *getErrorVec(const float *x, const float *y);


      void setEpsilonIn(float val) { setPropertyValue("epsilon In",val); }

      void setEpsilonOut(float val) { setPropertyValue("epsilon Out",val); }

      void setEpsilonA(float val) { setPropertyValue("epsilon A",val); }


      void setEpsilonSigma(float val) { setPropertyValue("epsilon Sigma",val); }

      void showKernels() const;

      unsigned int numKernels() const { return m_kernels.size(); }

      const Kernel &operator[](unsigned int i) const { return m_kernels[i]; }


      Kernel &operator[](unsigned int i) { return m_kernels[i]; }

      bool isSoftMaxUsed() const { return const_cast<Configurable*>(static_cast<const Configurable*>(this))->getPropertyValue("soft max enabled").as<bool>(); }

      void setSoftMaxEnabled(bool enabled) { setPropertyValue("soft max enabled",enabled); }

      private:

      void trainCentersIntern(const float *x,const float *g);

      void trainSigmasIntern(const float *x,const float *g);

      void trainOutputsIntern(const float *x,const float *y,const float *g, const float *dy, bool useDeltaWin);

      void trainMatricesIntern(const float *x,const float *y,const float *g, const float *dy);

      const float *applyIntern(const float *x,const  float *g);

      const float *getErrorVecIntern(const float *y, const float *ynet);

      unsigned int m_inputDim;

      unsigned int m_outputDim;

  #if 0
      float m_epsilonIn;

      float m_epsilonOut;

      float m_epsilonA;

      float m_epsilonSigma;
  #endif
      std::vector<Kernel> m_kernels;

      std::vector<float> m_outBuf;

      std::vector<float> m_gBuf;

      std::vector<float> m_errorBuf;

  #if 0
      bool m_bUseSoftMax;
  #endif
    };

  } // namespace math
}