mse.h

这是linux下的进化计算的源代码。 === === === === === === === === === === === ===== check latest news at http:

//-----------------------------------------------------------------------------
// mse.h
//-----------------------------------------------------------------------------

#ifndef mse_h
#define mse_h

//-----------------------------------------------------------------------------

#include <qp.h>  // neuron layer net set

//-----------------------------------------------------------------------------

namespace mse
{
  //---------------------------------------------------------------------------
  // useful typedefs
  //---------------------------------------------------------------------------

  using qp::real;
  using qp::vector;
  using qp::max_real;
  using qp::min_real;
  using qp::set;
  using qp::neuron;
  using qp::layer;

  //---------------------------------------------------------------------------
  // error
  //---------------------------------------------------------------------------
  
  real error(const mlp::net& net, const set& ts)
  {
    real error_ = 0.0;

    for (set::const_iterator s = ts.begin(); s != ts.end(); ++s)
      {
	vector out = net(s->input);
	
	for (unsigned i = 0; i < out.size(); ++i)
	  {
	    real diff = s->output[i] - out[i];
	    error_ += diff * diff;
	  }
      }

    return error_ / ts.size();
  }
  //-------------------------------------------------------------------------
  // mse
  //-------------------------------------------------------------------------
  
  class net: public qp::net
  {
  public:
    net(mlp::net& n): qp::net(n) {}
    
    real error(const set& ts)
    {
      real error_ = 0;
      
      for (set::const_iterator s = ts.begin(); s != ts.end(); ++s)
	{
	  forward(s->input);
	  error_ += backward(s->input, s->output);
	}
      error_ /= ts.size();
	
      return error_;
    }
      
  private:
    real backward(const vector& input, const vector& output)
    {
      reverse_iterator current_layer = rbegin();
      reverse_iterator backward_layer = current_layer + 1;
      real error_ = 0;

      // output layer
      for (unsigned j = 0; j < current_layer->size(); ++j)
	{
	  neuron& n = (*current_layer)[j];

	  real diff = output[j] - n.out;
	  n.ndelta += n.delta = diff * n.out * (1.0 - n.out);

	  if (size() == 1)                                        // monolayer
	    n.dxo += n.delta * input;
	  else                                                    // multilayer
	    for (unsigned k = 0; k < n.dxo.size(); ++k)
	      n.dxo[k] += n.delta * (*backward_layer)[k].out;
	  
	  error_ += diff * diff;
	}
      
      // hidden layers
      while (++current_layer != rend())
	{
	  reverse_iterator forward_layer  = current_layer - 1;
	  reverse_iterator backward_layer = current_layer + 1;
	  
	  for (unsigned j = 0; j < current_layer->size(); ++j)
	    {
	      
	      neuron& n = (*current_layer)[j];
	      real sum = 0;
	      
	      for (unsigned k = 0; k < forward_layer->size(); ++k)
		{
		  neuron& nf = (*forward_layer)[k];
		  sum += nf.delta * (nf.n->weight[j] + nf.dweight1[j]);
		}

	      n.delta = n.out * (1.0 - n.out) * sum;
	      n.ndelta += n.delta;
	      
	      
	      if (backward_layer == rend())              // first hidden layer
		n.dxo += n.delta * input;
	      else                                     // rest of hidden layers
		for (unsigned k = 0; k < n.dxo.size(); ++k)
		  n.dxo[k] += n.delta * (*backward_layer)[k].out;
	    }
	}
    
      return error_;
    }
  };

  //---------------------------------------------------------------------------
  
} // namespace mse

//-----------------------------------------------------------------------------

#endif // mse_h

// Local Variables: 
// mode:C++ 
// End: