Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  back propogation
Language: C/C++
Code:
#include<stdio.h>
#include<conio.h>
#include<math.h>
//********************************************DECLARATION***********************************************
int i,j;
double inwt[3][2],h1wt[2][2],h2wt[2][2];
double in[3],inh1[2],inh2[2];
double neth[2][2],neto[2],erro[2],errh[2][2];
double fneth[2][2],fneto[2];
double t0,t1,lc;
int iter=0;
float e=0.05;
void nethidden1();
void fnethidden1();
void nethidden2();
void fnethidden2();
void netoutput();
void fnetoutput();
void erroroutput();
void errorhidden2();
void errohidden1();
void update_wto();
void update_wth2();
void update_wth1();
void printupdatedweights();
int main()
{
//********************************************INPUT***********************************************

printf("****************Weights for Input Layer to Hidden Layer 1**************n");
printf("nn");
for(i=0;i<3;i++)
{
     printf("weights for input node %dn",i+1);
     for(j=0;j<2;j++)
     {
          printf("between input layer node %d and hidden layer node %d::",i+1,j+1);
          scanf("%lf",&inwt[i][j]);
          
     }
     printf("n");
}


printf("**********Weights for Hidden Layer 1 to Hidden Layer 2*******************n");
printf("nn");
for(i=0;i<2;i++)
{
     printf("weights for Hidden Layer1 node %dn",i+1);
     for(j=0;j<2;j++)
     {
          printf("between Hidden Layer1 node %d and Hidden layer2 node %d::",i+1,j+1);
          scanf("%lf",&h1wt[i][j]);
          
     }
     printf("n");
}

printf("***********Weights for Hidden Layer 2 to Output Layer********************n");
printf("nn");
for(i=0;i<2;i++)
{
     printf("Enter the weights for Hidden Layer2 node %dn",i+1);
     for(j=0;j<2;j++)
     {
          printf("between Hidden Layer2 node %d and Output Layer node %d::",i+1,j+1);
          scanf("%lf",&h2wt[i][j]);
          
     }
     printf("n");
}

printf("******************************TARGETS*******************************n");
printf("nn");
printf("Enter the target for ouput layer node 1::");
scanf("%lf",&t0);
printf("Enter the target for ouput layer node 2::");
scanf("%lf",&t1);

printf("Enter the Input given to Network");
printf("n");
for(i=0;i<3;i++)
{
     printf("Node%d::",i+1);
     scanf("%lf",&in[i]);
}
printf("Learning Constant::");
scanf("%lf",&lc);

//***********************************Process Starts****************************************************//
check:                                                                                          

printf("*******************Iteration :%d*****************nn",++iter);
nethidden1(); /* net weight calculation at hidden layer1 */
fnethidden1(); /* f net calculation using unipolar sigmoidal function at hidden layer 1 */
nethidden2();  /* net weight calculation at hidden layer2 */
fnethidden2();  /* f net calculation using unipolar sigmoidal function at hidden layer 2 */

netoutput();
fnetoutput();
if((fneto[0]<=(t0-e)||fneto[0]>=(t0+e)) && (fneto[1]<=(t1-e)||fneto[1]>=(t1+e)))                    //Stopping Condition
{
printf("n***********Errors*********************n");
erroroutput(); /* function for error calculation  at the output layer */
errorhidden2(); /* function to calculate error at hidden layer 1*/
errohidden1();  /* function to calculate error at hidden layer 2*/

printf("n************Updated Weights*************n");
update_wto(); /* function for updating weights at output layer */
update_wth2(); /* function for updating weights at hidden layer 2 */
update_wth1(); /* function for updating weights at hidden layer 1 */
goto check;                                                                                     //Iteration initiation

}
else
{
    printupdatedweights();
}

getch();
return 0;
}

void nethidden1()
{
     for(i=0;i<2;i++)
     {
          for(j=0;j<3;j++)
          {
               neth[0][i]+=in[j]*inwt[j][i];
          }
          printf("Net for Hiddenlayer1 node %d:: %lf n",i+1,neth[0][i]);
     }
}


void fnethidden1()
{
     fneth[0][0]=1.0/(1.0+exp(-(neth[0][0])));
     fneth[0][1]=1.0/(1.0+exp(-(neth[0][1])));
     printf("fnet for HiddenLayer1 node 1 :: %lfn",fneth[0][0]);
     printf("fnet for HiddenLayer1 node 2 :: %lfn",fneth[0][1]);
}

void nethidden2()
{
     printf("n");
     neth[1][0]=fneth[0][0]*h1wt[0][0]+fneth[0][1]*h1wt[1][0];
     neth[1][1]=fneth[0][0]*h1wt[0][1]+fneth[0][1]*h1wt[0][1];
     printf("Net for Hiddenlayer2 node :: %lf n",neth[1][0]);
     printf("Net for Hiddenlayer2 node :: %lf n",neth[1][1]);
     
}

void fnethidden2()
{
     fneth[1][0]=1.0/(1.0+exp(-(neth[1][0])));
     fneth[1][1]=1.0/(1.0+exp(-(neth[1][1])));
     printf("fnet for HiddenLayer2 node 1 :: %lfn",fneth[1][0]);
     printf("fnet for HiddenLayer2 node 2 :: %lfn",fneth[1][1]);
}

void netoutput()
{
     printf("n");
     neto[0]=fneth[1][0]*h2wt[0][0]+fneth[1][1]*h2wt[1][0];
     neto[1]=fneth[1][0]*h2wt[0][1]+fneth[1][1]*h2wt[0][1];
     printf("Net for output layer node1 :: %lf n",neto[0]);
     printf("Net for output layer node2 :: %lf n",neto[1]);

}
void fnetoutput()
{
     for(i=0;i<2;i++)
     {
          fneto[i]=1.0/(1.0+exp(-(neto[i])));
          printf("fNet for Output Layer node1:: %lfn",fneto[i]);
     }
}

void erroroutput()
{
     printf("n");
     erro[0]=fneto[0]*(1-fneto[0])*(t0-fneto[0]);
     erro[1]=fneto[1]*(1-fneto[1])*(t1-fneto[1]);
     printf("Error at outputlayer node 1 :: %lfn",erro[0]);
     printf("Error at outputlayer node 2 :: %lfn",erro[1]);
}

void errorhidden2()
{
     errh[1][0]=fneth[1][0]*(1-fneth[1][0])*(erro[0]*h2wt[0][0]+erro[1]*h2wt[0][1]);
     errh[1][1]=fneth[1][1]*(1-fneth[1][1])*(erro[0]*h2wt[1][0]+erro[1]*h2wt[1][1]);
     printf("Error at Hidden Layer 2 node 1 ::%lf n",errh[1][0]);
     printf("Error at Hidden Layer 2 node 2 ::%lf n",errh[1][1]);
}

void errohidden1()
{
     errh[0][0]=fneth[0][0]*(1-fneth[0][0])*(errh[1][0]*h1wt[0][0]+errh[1][1]*h1wt[0][1]);
     errh[0][1]=fneth[0][1]*(1-fneth[0][1])*(errh[1][0]*h1wt[1][0]+errh[1][1]*h1wt[1][1]);
     printf("Error at Hidden Layer 1 node 1 ::%lf n",errh[0][0]);
     printf("Error at Hidden Layer 1 node 2 ::%lf n",errh[0][1]);
}

void update_wto()
{
     for(i=0;i<2;i++)
     {
          for(j=0;j<2;j++)
          {
               h2wt[i][j]+=lc*erro[j]*fneth[1][i];
               printf("Weight between hiddenlayer2 node %d and output layer node %d:: %lfn",i+1,j+1,h2wt[i][j]);
          }
     }
}
void update_wth2()
{
     printf("nn");
     for(i=0;i<2;i++)
     {
          for(j=0;j<2;j++)
          {
               h1wt[i][j]+=lc*errh[1][j]*fneth[0][i];
               printf("Weight between hiddenlayer1 node %d and hiddenlayer2 node %d:: %lfn",i+1,j+1,h1wt[i][j]);
          }
     }
     
}
void update_wth1()
{
     printf("nn");
     for(i=0;i<3;i++)
     {
          for(j=0;j<2;j++)
          {
               inwt[i][j]+=lc*errh[0][j]*in[i];
               printf("Weight between inputlayer node %d and hiddenlayer1 node %d:: %lfn",i+1,j+1,inwt[i][j]);
          }
     }
}
void printupdatedweights()
{
     printf("nn");
     printf("********************FINAL Upadetd Weights************");
     for(i=0;i<3;i++)
     {
          for(j=0;j<2;j++)
          {
          
               printf("Weight between inputlayer node %d and hiddenlayer1 node %d:: %lfn",i+1,j+1,inwt[i][j]);
          }
     }
     for(i=0;i<2;i++)
     {
          for(j=0;j<2;j++)
          {
          
               printf("Weight between hiddenlayer1 node %d and hiddenlayer2 node %d:: %lfn",i+1,j+1,h1wt[i][j]);
          }
     }
     for(i=0;i<2;i++)
     {
          for(j=0;j<2;j++)
          {
               
               printf("Weight between hiddenlayer2 node %d and output layer node %d:: %lfn",i+1,j+1,h2wt[i][j]);
          }
     }
}
     
     

          
          
Comments: