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
}