propclass/neuralnet.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2007 by Jorrit Tyberghein

    Neural Network Property Class
    Copyright (C) 2007 by Mat Sutcliffe

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#ifndef __CEL_PF_NEURALNET__
#define __CEL_PF_NEURALNET__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/refcount.h"
#include "csutil/array.h"
#include "csgeom/math.h"

#include "physicallayer/datatype.h"

class celNNActivationFunc;

struct iCelNNWeights : public virtual iBase
{ 
  SCF_INTERFACE(iCelNNWeights, 0, 0, 1);

  virtual csArray< csArray< csArray<float> > >& Data() = 0;

  virtual const csArray< csArray< csArray<float> > >& Data() const = 0;

  virtual csPtr<iCelNNWeights> Clone() const = 0;
};

struct iPcNeuralNet : public virtual iBase
{
  SCF_INTERFACE(iPcNeuralNet, 0, 0, 1);

  virtual void SetSize(size_t inputs, size_t outputs, size_t layers) = 0;

  virtual void SetComplexity(const char *name) = 0;

  virtual void SetLayerSizes(const csArray<size_t> &sizes) = 0;

  virtual void SetActivationFunc(celNNActivationFunc *) = 0;

  virtual bool Validate() = 0;

  virtual void SetInput(size_t index, const celData &value) = 0;

  virtual const celData& GetOutput(size_t index) const = 0;

  virtual void SetInputs(const csArray<celData> &values) = 0;

  virtual const csArray<celData>& GetOutputs() const = 0;

  virtual void Process() = 0;

  virtual csPtr<iCelNNWeights> CreateEmptyWeights() const = 0;

  virtual void GetWeights(iCelNNWeights *out) const = 0;

  virtual bool SetWeights(const iCelNNWeights *in) = 0;

  virtual bool CacheWeights(const char *scope, uint32 id) const = 0;

  virtual bool LoadCachedWeights(const char *scope, uint32 id) = 0;
};

class celNNActivationFunc : public virtual csRefCount
{
public:
  virtual void Function(celData &data) = 0;

  virtual celDataType GetDataType() = 0;

  virtual ~celNNActivationFunc() {}

protected:
  template <typename T>
  static const T& GetFrom(const celData &input);

  template <typename T>
  static celDataType DataType();
};

template<>
inline const float& celNNActivationFunc::GetFrom<float>(const celData &input)
{
  return input.value.f;
}
template<>
inline const int8& celNNActivationFunc::GetFrom<int8>(const celData &input)
{
  return input.value.b;
}
template<>
inline const uint8& celNNActivationFunc::GetFrom<uint8>(const celData &input)
{
  return input.value.ub;
}
template<>
inline const int16& celNNActivationFunc::GetFrom<int16>(const celData &input)
{
  return input.value.w;
}
template<>
inline const uint16& celNNActivationFunc::GetFrom<uint16>(const celData &input)
{
  return input.value.uw;
}
template<>
inline const int32& celNNActivationFunc::GetFrom<int32>(const celData &input)
{
  return input.value.l;
}
template<>
inline const uint32& celNNActivationFunc::GetFrom<uint32>(const celData &input)
{
  return input.value.ul;
}

template<>
inline celDataType celNNActivationFunc::DataType<int8>()
{
  return CEL_DATA_BYTE;
}
template<>
inline celDataType celNNActivationFunc::DataType<uint8>()
{
  return CEL_DATA_UBYTE;
}
template<>
inline celDataType celNNActivationFunc::DataType<int16>()
{
  return CEL_DATA_WORD;
}
template<>
inline celDataType celNNActivationFunc::DataType<uint16>()
{
  return CEL_DATA_UWORD;
}
template<>
inline celDataType celNNActivationFunc::DataType<int32>()
{
  return CEL_DATA_LONG;
}
template<>
inline celDataType celNNActivationFunc::DataType<uint32>()
{
  return CEL_DATA_ULONG;
}
template<>
inline celDataType celNNActivationFunc::DataType<float>()
{
  return CEL_DATA_FLOAT;
}

template <typename T>
class celNopActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data) {}
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celNopActivationFunc() {}
};

template <typename T>
class celStepActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set(T (val > 1 ? 1 : 0));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celStepActivationFunc() {}
};

template <typename T>
class celLogActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    double e_v = log(fabs((double) val)); // log may return not-a-number
    data.Set((T) (csNormal(e_v) ? e_v : 0.0));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celLogActivationFunc() {}
};

template <typename T>
class celAtanActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set((T) atan((double) val));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celAtanActivationFunc() {}
};

template <typename T>
class celTanhActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set((T) tanh((double) val));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celTanhActivationFunc() {}
};

template <typename T>
class celExpActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    double e_v = exp((double) val); // exp may return infinite
    data.Set((T) (csNormal(e_v) ? e_v : 0.0));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celExpActivationFunc() {}
};

class celInvActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const float &val = GetFrom<float>(data);
    data.Set(1.0f / val);
  }
  virtual celDataType GetDataType() { return CEL_DATA_FLOAT; }
  virtual ~celInvActivationFunc() {}
};

template <typename T>
class celSqrActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set(val * val);
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celSqrActivationFunc() {}
};

template <typename T>
class celGaussActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set((T) exp((double) -(val * val)));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celGaussActivationFunc() {}
};

template <typename T>
class celSinActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set((T) sin((double) val));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celSinActivationFunc() {}
};

template <typename T>
class celCosActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set((T) cos((double) val));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celCosActivationFunc() {}
};

template <typename T>
class celElliottActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set(val / (1 + (T)fabs((double) val)));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celElliottActivationFunc() {}
};

template <typename T>
class celSigActivationFunc : public celNNActivationFunc
{
public:
  virtual void Function(celData &data)
  {
    const T &val = GetFrom<T>(data);
    data.Set(T(1) / (T)(1 + exp((double) -val)));
  }
  virtual celDataType GetDataType() { return DataType<T>(); }
  virtual ~celSigActivationFunc() {}
};

#endif // __CEL_PF_NEURALNET__