esn.hpp

一个人工神经网络的程序。 文档等说明参见http://aureservoir.sourceforge.net/

      break;

    case SIM_LI:
      if(sim_) delete sim_;
      sim_ = new SimLI<T>(this);
      net_info_[SIMULATE_ALG] = SIM_LI;
      break;

    case SIM_BP:
      if(sim_) delete sim_;
      sim_ = new SimBP<T>(this);
      net_info_[SIMULATE_ALG] = SIM_BP;
      break;

    case SIM_FILTER:
      if(sim_) delete sim_;
      sim_ = new SimFilter<T>(this);
      net_info_[SIMULATE_ALG] = SIM_FILTER;
      break;

    case SIM_FILTER2:
      if(sim_) delete sim_;
      sim_ = new SimFilter2<T>(this);
      net_info_[SIMULATE_ALG] = SIM_FILTER2;
      break;

    case SIM_FILTER_DS:
      if(sim_) delete sim_;
      sim_ = new SimFilterDS<T>(this);
      net_info_[SIMULATE_ALG] = SIM_FILTER_DS;
      break;

    default:
      throw AUExcept("ESN::setSimAlgorithm: no valid Algorithm!");
  }
}

template <typename T>
void ESN<T>::setSize(int neurons)
  throw(AUExcept)
{
  if(neurons<1)
    throw AUExcept("ESN::setReservoirSize: there must be at least one neuron!");

  neurons_=neurons;
}

template <typename T>
void ESN<T>::setInputs(int inputs)
  throw(AUExcept)
{
  if(inputs<1)
    throw AUExcept("ESN::setInputs: there must be at least one input!");

  inputs_=inputs;
}

template <typename T>
void ESN<T>::setOutputs(int outputs)
  throw(AUExcept)
{
  if(outputs<1)
    throw AUExcept("ESN::setOutputs: there must be at least one output!");

  outputs_=outputs;
}

template <typename T>
void ESN<T>::setNoise(double noise)
  throw(AUExcept)
{
  if(noise<0)
    throw AUExcept("ESN::setNoise: Noise level must be a positive number!");

  noise_=noise;
}

template <typename T>
void ESN<T>::setInitParam(InitParameter key, T value)
{
  init_params_[key] = value;
}

template <typename T>
void ESN<T>::setReservoirAct(ActivationFunction f)
  throw(AUExcept)
{
  switch(f)
  {
    case ACT_LINEAR:
      reservoirAct_= act_linear;
      net_info_[RESERVOIR_ACT] = ACT_LINEAR;
      break;

    case ACT_TANH:
      reservoirAct_= act_tanh;
      net_info_[RESERVOIR_ACT] = ACT_TANH;
      break;

    case ACT_TANH2:
      reservoirAct_= act_tanh2;
      net_info_[RESERVOIR_ACT] = ACT_TANH2;
      break;

    case ACT_SIGMOID:
      reservoirAct_= act_sigmoid;
      net_info_[RESERVOIR_ACT] = ACT_SIGMOID;
      break;

    default:
      throw AUExcept("ESN::setReservoirAct: wrong reservoir activation function!");
  }
}

template <typename T>
void ESN<T>::setOutputAct(ActivationFunction f)
  throw(AUExcept)
{
  switch(f)
  {
    case ACT_LINEAR:
      outputAct_    = act_linear;
      outputInvAct_ = act_invlinear;
      net_info_[OUTPUT_ACT] = ACT_LINEAR;
      break;

    case ACT_TANH:
      outputAct_    = act_tanh;
      outputInvAct_ = act_invtanh;
      net_info_[OUTPUT_ACT] = ACT_TANH;
      break;

    case ACT_SIGMOID:
      outputAct_    = act_sigmoid;
      outputInvAct_ = act_invsigmoid;
      net_info_[OUTPUT_ACT] = ACT_SIGMOID;
      break;

    default:
      throw AUExcept("ESN::setOutputAct: wrong output activation function!");
  }
}

template <typename T>
void ESN<T>::setWin(const DEMatrix &Win) throw(AUExcept)
{
  if( Win.numRows() != neurons_ )
      throw AUExcept("ESN::setWin: wrong row size!");
  if( Win.numCols() != inputs_ )
      throw AUExcept("ESN::setWin: wrong column size!");

  Win_ = Win;
}

template <typename T>
void ESN<T>::setW(const DEMatrix &W) throw(AUExcept)
{
  if( W.numRows() != neurons_ )
      throw AUExcept("ESN::setW: wrong row size!");
  if( W.numCols() != neurons_ )
      throw AUExcept("ESN::setW: wrong column size!");

//   W_.initWith(W, 1E-9);
  W_ = W;
}

template <typename T>
void ESN<T>::setWback(const DEMatrix &Wback) throw(AUExcept)
{
  if( Wback.numRows() != neurons_ )
      throw AUExcept("ESN::setWback: wrong row size!");
  if( Wback.numCols() != outputs_ )
      throw AUExcept("ESN::setWback: wrong column size!");

  Wback_ = Wback;
}

template <typename T>
void ESN<T>::setWout(const DEMatrix &Wout) throw(AUExcept)
{
  if( Wout.numRows() != outputs_ )
      throw AUExcept("ESN::setWout: Wout must have output_ rows!");
  if( Wout.numCols() != inputs_+neurons_ && 
      Wout.numCols() != 2*(inputs_+neurons_) )
      throw AUExcept("ESN::setWout: wrong column size!");

  Wout_ = Wout;
}

template <typename T>
void ESN<T>::setX(const DEVector &x) throw(AUExcept)
{
  if( x.length() != neurons_ )
      throw AUExcept("ESN::setX: wrong size!");

  x_ = x;
}

template <typename T>
void ESN<T>::setLastOutput(const DEVector &last)
  throw(AUExcept)
{
  if( last.length() != outputs_ )
      throw AUExcept("setLastOutput: wrong size!");

  sim_->last_out_.resize(last.length(),1);
  sim_->last_out_(_,1) = last;
}

template <typename T>
void ESN<T>::setWin(T *inmtx, int inrows, int incols) throw(AUExcept)
{
  if( inrows != neurons_ )
      throw AUExcept("ESN::setWin: wrong row size!");
  if( incols != inputs_ )
      throw AUExcept("ESN::setWin: wrong column size!");

  Win_.resize(inrows,incols);

  for(int i=0; i<inrows; ++i) {
  for(int j=0; j<incols; ++j) {
    Win_(i+1,j+1) = inmtx[i*incols+j];
  } }
}

template <typename T>
void ESN<T>::setW(T *inmtx, int inrows, int incols) throw(AUExcept)
{
  if( inrows != neurons_ )
      throw AUExcept("ESN::setW: wrong row size!");
  if( incols != neurons_ )
      throw AUExcept("ESN::setW: wrong column size!");

  DEMatrix Wtmp(neurons_,neurons_);

  for(int i=0; i<inrows; ++i) {
  for(int j=0; j<incols; ++j) {
    Wtmp(i+1,j+1) = inmtx[i*incols+j];
  } }

//   W_.initWith(Wtmp, 1E-9);
  W_ = Wtmp;
}

template <typename T>
void ESN<T>::setWback(T *inmtx, int inrows, int incols) throw(AUExcept)
{
  if( inrows != neurons_ )
      throw AUExcept("ESN::setWback: wrong row size!");
  if( incols != outputs_ )
      throw AUExcept("ESN::setWback: wrong column size!");

  Wback_.resize(inrows,incols);

  for(int i=0; i<inrows; ++i) {
  for(int j=0; j<incols; ++j) {
    Wback_(i+1,j+1) = inmtx[i*incols+j];
  } }
}

template <typename T>
void ESN<T>::setWout(T *inmtx, int inrows, int incols) throw(AUExcept)
{
  if( inrows != outputs_ )
      throw AUExcept("ESN::setWout: Wout must have output_ rows!");
  if( incols != inputs_+neurons_ && 
      incols != 2*(inputs_+neurons_) )
      throw AUExcept("ESN::setWout: wrong column size!");

  Wout_.resize(inrows,incols);

  for(int i=0; i<inrows; ++i) {
  for(int j=0; j<incols; ++j) {
    Wout_(i+1,j+1) = inmtx[i*incols+j];
  } }
}

template <typename T>
void ESN<T>::setX(T *invec, int insize) throw(AUExcept)
{
  if( insize != neurons_ )
      throw AUExcept("ESN::setX: wrong size!");

  x_.resize(insize);
  for(int i=0; i<insize; ++i)
    x_(i+1) = invec[i];
}

template <typename T>
void ESN<T>::setLastOutput(T *last, int size)
  throw(AUExcept)
{
  if( size != outputs_ )
      throw AUExcept("setLastOutput: wrong size!");

  sim_->last_out_.resize(size,1);
  for(int i=0; i<size; ++i)
    sim_->last_out_(i+1,1) = last[i];
}

template <typename T>
string ESN<T>::getActString(int act)
{
  switch(act)
  {
    case ACT_LINEAR:
      return "ACT_LINEAR";

    case ACT_TANH:
      return "ACT_TANH";

    case ACT_TANH2:
      return "ACT_TANH2";


    case ACT_SIGMOID:
      return "ACT_SIGMOID";

    default:
      throw AUExcept("ESN::getActString: unknown activation function");
  }
}

template <typename T>
string ESN<T>::getInitString(int alg)
{
  switch(alg)
  {
    case INIT_STD:
      return "INIT_STD";

    default:
      throw AUExcept("ESN::getInitString: unknown init algorithm");
  }
}

template <typename T>
string ESN<T>::getSimString(int alg)
{
  switch(alg)
  {
    case SIM_STD:
      return "SIM_STD";

    case SIM_SQUARE:
      return "SIM_SQUARE";

    case SIM_LI:
      return "SIM_LI";

    case SIM_BP:
      return "SIM_BP";

    case SIM_FILTER:
      return "SIM_FILTER";

    case SIM_FILTER2:
      return "SIM_FILTER2";

    case SIM_FILTER_DS:
      return "SIM_FILTER_DS";

    default:
      throw AUExcept("ESN::getSimString: unknown simulation algorithm");
  }
}

template <typename T>
string ESN<T>::getTrainString(int alg)
{
  switch(alg)
  {
    case TRAIN_PI:
      return "TRAIN_PI";

    case TRAIN_LS:
      return "TRAIN_LS";

    case TRAIN_RIDGEREG:
      return "TRAIN_RIDGEREG";

    case TRAIN_DS_PI:
      return "TRAIN_DS_PI";

    default:
      throw AUExcept("ESN::getTrainString: unknown training algorithm");
  }
}


// template <typename T>
// void ESN<T>::setParameter(string param, string value)
//   throw(AUExcept)
// {
//   // tests machen für diese funktion
// 
//   bool ok = false;
// 
//   // algorithms
// 
//   if( param == "simulation_alg" || param == "sim_alg" ||
//       param == "simulation_algorithm" || param == "sim_algorithm"  )
//   {
//     if( value == "sim_std" || value == "std" )
//     {
//       setSimAlgorithm( SIM_STD );
//       ok = true;
//     }
//   }
//   if( param == "training_alg" || param == "train_alg" ||
//       param == "training_algorithm" || param == "train_algorithm"  )
//   {
//     if( value == "train_leastsquare" || value == "leastsquare" )
//     {
//       setTrainAlgorithm( TRAIN_LS );
//       ok = true;
//     }
//   }
//   if( param == "initialization_alg" || param == "init_alg" ||
//       param == "initialization_algorithm" || param == "init_algorithm"  )
//   {
//     if( value == "init_std" || value == "std" )
//     {
//       setInitAlgorithm( INIT_STD );
//       ok = true;
//     }
//   }
// 
//   // general
// 
//   if( param == "size" || param == "reservoir_size" ||
//       param == "reservoir size" || param == "reservoir" )
//   {
//     setSize( stringToInt(value) );
//     ok = true;
//   }
//   if( param == "inputs" )
//   {
//     setInputs( stringToInt(value) );
//     ok = true;
//   }
//   if( param == "outputs" )
//   {
//     setOutputs( stringToInt(value) );
//     ok = true;
//   }
// 
//   // input parameter map
// 
//   if( param == "connectivity" || param == "conn" )
//   {
//     setInitParam( CONNECTIVITY, stringToDouble(value) );
//     ok = true;
//   }
//   if( param == "alpha" )
//   {
//     setInitParam( ALPHA, stringToDouble(value) );
//     ok = true;
//   }
//   if( param == "in_connectivity" || param == "in_conn" )
//   {
//     setInitParam( IN_CONNECTIVITY, stringToDouble(value) );
//     ok = true;
//   }
//   if( param == "in_scale" )
//   {
//     setInitParam( IN_SCALE, stringToDouble(value) );
//     ok = true;
//   }
//   if( param == "in_shift" )
//   {
//     setInitParam( IN_SHIFT, stringToDouble(value) );
//     ok = true;
//   }
//   if( param == "fb_connectivity" || param == "fb_conn" )
//   {
//     setInitParam( FB_CONNECTIVITY, stringToDouble(value) );
//     ok = true;
//   }
//   if( param == "fb_scale" )
//   {
//     setInitParam( FB_SCALE, stringToDouble(value) );
//     ok = true;
//   }
//   if( param == "fb_shift" )
//   {
//     setInitParam( FB_SHIFT, stringToDouble(value) );
//     ok = true;
//   }
// 
//   // activation functions
// 
//   if( param == "reservoir_act" || param == "res_act" )
//   {
//     if( value == "linear" || value == "lin" )
//     {
//       setReservoirAct( ACT_LINEAR );
//       ok = true;
//     }
//     if( value == "tanh" )
//     {
//       setReservoirAct( ACT_TANH );
//       ok = true;
//     }
//   }
//   if( param == "output_act" || param == "out_act" )
//   {
//     if( value == "linear" || value == "lin" )
//     {
//       setOutputAct( ACT_LINEAR );
//       ok = true;
//     }
//     if( value == "tanh" )
//     {
//       setOutputAct( ACT_TANH );
//       ok = true;
//     }
//   }
// 
//   if( !ok )
//     throw AUExcept("ESN::setParameter: parameter value not valid!");
// }

} // end of namespace aureservoir