C/C++ Neural Network Source Code

C# MLP Backprop Code

using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Data; 
using System.Drawing; 
using System.Text; 
using System.Windows.Forms;

namespace WindowsApplication1

//////////////////////////////////////////////////////////////////////////// 
   //MLP neural network in C#
   //Original source code by Dr Phil Brierley 
   //www.philbrierley.com 
   //Translated to C++ - dspink Sep 2005 
   //Translated to C# by Dr Eddie O'Brien - March 2006 
   //For the C# GUI, just needs a button (name = Go) and 
   // a textBox (name = cout) - set MulitLine property to True 
   // and set Scroll property to Vertical. 
   //This code may be freely used and modified at will 
   //C# compiled using free Microsoft Visual C# 2005 Express (.NET Framework 2.0) 
////////////////////////////////////////////////////////////////////////////

{ 
   public partial class Form1 : Form 
   { 
      public Form1() { 
         InitializeComponent(); 
      } 
      //// Data dependent settings //// 
      const int numInputs = 3; 
      const int numPatterns = 4;

//// User defineable settings //// 
      const int numHidden = 4; 
      const int numEpochs = 500; 
      const double LR_IH = 0.7; 
      const double LR_HO = 0.07;

private void Go_Click(object sender, EventArgs e) { 
         // initiate the weights 
         initWeights();

// load in the data 
         initData();

// train the network 
         for(int j = 0; j <= numEpochs; j++) { 
            for(int i = 0; i<numPatterns; i++) { 
               //select a pattern at random 
               patNum = randNum.Next(4);

//calculate the current network output and error for this pattern 
               calcNet();

//change network weights 
               WeightChangesHO(); 
               WeightChangesIH(); 
            } 
            //display the overall network error after each epoch 
            calcOverallError(); 
            //printf("epoch = %d RMS Error = %f\n",j,RMSerror); 
            cout.AppendText("\r\nepoch = " + j.ToString() + " RMS error = " + RMSerror.ToString()); 
         }

//training has finished //display the results 
         displayResults(); 
      }

//// variables //// 
      int patNum = 0; 
      double errThisPat = 0.0; 
      double outPred = 0.0; 
      double RMSerror = 0.0;

// the outputs of the hidden neurons 
      double [] hiddenVal = new double[numHidden];

// the weights 
      double [,] weightsIH = new double[numInputs, numHidden]; 
      double [] weightsHO = new double[numHidden];

// the data 
      int [,] trainInputs = new int[numPatterns, numInputs]; 
      int [] trainOutput = new int[numPatterns]; 
      Random randNum = new Random();

//============================================================== 
      //************** function definitions ************************** 
      //==============================================================

//*********************************** 
      // calculates the network output 
      private void calcNet() { 
         //calculate the outputs of the hidden neurons 
         //the hidden neurons are tanh 
         int i = 0; 
         for(i = 0; i < numHidden; i++) { 
            hiddenVal[i] = 0.0; 
            for(int j = 0; j < numInputs; j++) { 
               hiddenVal[i] = hiddenVal[i] + (trainInputs[patNum, j] * weightsIH[j, i]); 
            } 
            hiddenVal[i] = Math.Tanh(hiddenVal[i]); 
            //  hiddenVal[i] = logistic(hiddenVal[i]); 
         }

//calculate the output of the network 
         //the output neuron is linear 
         outPred = 0.0;

for(i = 0; i < numHidden; i++) { 
            outPred = outPred + hiddenVal[i] * weightsHO[i]; 
         } 
         //calculate the error 
         errThisPat = outPred - trainOutput[patNum]; 
      }

//************************************ 
      //adjust the weights hidden-output 
      private void WeightChangesHO() { 
         for(int k = 0; k<numHidden; k++) { 
            double weightChange = LR_HO * errThisPat * hiddenVal[k]; 
            weightsHO[k] = weightsHO[k] - weightChange; 
            //regularisation on the output weights 
            if (weightsHO[k] < -5) { 
               weightsHO[k] = -5; 
            } 
            else if (weightsHO[k] > 5) { 
               weightsHO[k] = 5; 
            } 
         } 
      }

//************************************ 
      // adjust the weights input-hidden 
      void WeightChangesIH() { 
         for(int i = 0; i<numHidden; i++) { 
            for(int k = 0; k<numInputs; k++) { 
               double x = 1 - (hiddenVal[i] * hiddenVal[i]); 
               x = x * weightsHO[i] * errThisPat * LR_IH; 
               x = x * trainInputs[patNum, k]; 
               double weightChange = x; 
               weightsIH[k, i] = weightsIH[k, i] - weightChange; 
            } 
         } 
      }

//************************************ 
      // set weights to random numbers 
      void initWeights() { 
         for(int j = 0;j<numHidden;j++) { 
            weightsHO[j] = (randNum.NextDouble() - 0.5)/2; 
            for(int i = 0; i<numInputs; i++) { 
               weightsIH[i, j] = (randNum.NextDouble() - 0.5)/5; 
               //printf("Weight = %f\n", weightsIH[i, j]); 
               cout.AppendText("\r\nWeight = " + weightsIH[i, j].ToString()); 
            } 
         } 
      }

//************************************ 
      // read in the data 
      void initData() { 
         //printf("initialising data\n"); 
         cout.AppendText("\r\ninitialising data"); 
         // the data here is the XOR data 
         // it has been rescaled to the range [-1, 1] 
         // an extra input valued 1 is also added to act as the bias 
         // the output must lie in the range -1 to 1

trainInputs[0, 0]  = 1; 
         trainInputs[0, 1]  = -1; 
         trainInputs[0, 2]  = 1;       //bias 
         trainOutput[0] = 1;

trainInputs[1, 0]  = -1; 
         trainInputs[1, 1]  = 1; 
         trainInputs[1, 2]  = 1;       //bias 
         trainOutput[1] = 1;

trainInputs[2, 0]  = 1; 
         trainInputs[2, 1]  = 1; 
         trainInputs[2, 2]  = 1;       //bias 
         trainOutput[2] = -1;

trainInputs[3, 0]  = -1; 
         trainInputs[3, 1]  = -1; 
         trainInputs[3, 2]  = 1;       //bias 
         trainOutput[3] = -1; 
      }

//************************************ 
      // display results 
      void displayResults() { 
         for(int i = 0; i < numPatterns; i++) { 
            patNum = i; 
            calcNet(); 
            //printf("pat = %d actual = %d neural model = %f\n",patNum+1,trainOutput[patNum],outPred); 
            cout.AppendText("\r\npat = " + (patNum + 1) + " actual = " + trainOutput[patNum].ToString() + " neural model = " + outPred.ToString()); 
         } 
      }

//************************************ 
      // calculate the overall error 
      void calcOverallError() { 
         RMSerror = 0.0; 
         for(int i = 0; i<numPatterns; i++) { 
            patNum = i; 
            calcNet(); 
            RMSerror = RMSerror + (errThisPat * errThisPat); 
         } 
         RMSerror = RMSerror/numPatterns; 
         RMSerror = Math.Sqrt(RMSerror); 
      } 
   } 
}