processing_units.cpp

预测神经网络

// Processing_units.cpp: implementation of the Processing_units class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Processing_units.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Processing_units::Processing_units()
{
  bias = 0.0;
  output_signal = 0.0;
  error_information_term = 0.0;
  bias_correction_term = 0.0;
  sum_of_weighted_inputs = 0.0;
}

Processing_units::~Processing_units()
{
  delete [] processing_unit_input;
  delete [] weight_of_inputs;
  delete [] weight_correction_term;
}

// Define base class member functions

void Processing_units::establish_array_of_processing_unit_inputs(void)
{//输入向量
  processing_unit_input = new float[number_of_input_units];
  //权重向量
  weight_of_inputs = new float[number_of_input_units];
  //偏置向量
  weight_correction_term = new float[number_of_input_units];
}

void Processing_units::establish_weight_vector_for_processing_units(void)
{
  for(int i = 0; i < number_of_input_units; i++)
  {
    // weights range from 1 to -1
    weight_of_inputs[i] =float( 1.0 - (2.0 * bedlam((long)(gaset))));
  }
}

void Processing_units::calculate_output_signal(int activation_function)
{
  sum_of_weighted_inputs = 0.0;

  for(int i = 0; i < number_of_input_units; i++)
  {
   if(i == number_of_input_units - 1)
   {sum_of_weighted_inputs += (processing_unit_input[i] * weight_of_inputs[i]) + bias;}
   else
   {sum_of_weighted_inputs += processing_unit_input[i] * weight_of_inputs[i];}
  }

  switch(activation_function)
  {
    case 1: // binary sigmoid function
    output_signal =float( 1.0 / (1.0 + exp(-1.0 * sum_of_weighted_inputs)));
    break;

    case 2: // bipolar sigmoid function
    output_signal = float((2.0 / (1.0 + exp(-1.0 * sum_of_weighted_inputs))) - 1);
    break;
  }

}
//激发函数求导后代入output_signal的值 
float Processing_units::calculate_output_signal_derivative(int afun)
{
  float derivative;
  switch(afun) // derivative used based on activation function seleted
  {
    case 1: // binary sigmoid function
    derivative = float(output_signal * (1.0 - output_signal));
    break;

    case 2:  // bipolar sigmoid function
    derivative = float(0.5 * (1.0 + output_signal) * (1.0 - output_signal));
    break;
  }
   return derivative;
}
//计算修正项并修改权值
void Processing_units::calculate_weight_and_bias_correction_terms(float learning_rate)
{
  for(int i = 0; i < number_of_input_units; i++)
  {weight_correction_term[i] = learning_rate * error_information_term * processing_unit_input[i];}
  bias_correction_term = learning_rate * error_information_term;
  error_information_term = 0.0;
  update_weights_and_biases();
}
//更新权值和偏置值
void Processing_units::update_weights_and_biases(void)
{
  for(int i = 0; i < number_of_input_units; i++)
  {weight_of_inputs[i] = weight_of_inputs[i] + weight_correction_term[i];}
  bias = bias + bias_correction_term;
}