main.cpp

00001 #include <math.h>
00002 #include <mbed.h>
00003 Serial pc(USBTX, USBRX);
00004 const int PatternCount = 10;
00005 const int InputNodes = 7;
00006 const int HiddenNodes = 8;
00007 const int OutputNodes = 4;
00008 const float LearningRate = 0.3;
00009 const float Momentum = 0.9;
00010 const float InitialWeightMax = 0.5;
00011 const float Success = 0.0004;
00012 
00013 const byte Input[PatternCount][InputNodes] = {
00014   { 1, 1, 1, 1, 1, 1, 0 },  // 0
00015   { 0, 1, 1, 0, 0, 0, 0 },  // 1
00016   { 1, 1, 0, 1, 1, 0, 1 },  // 2
00017   { 1, 1, 1, 1, 0, 0, 1 },  // 3
00018   { 0, 1, 1, 0, 0, 1, 1 },  // 4
00019   { 1, 0, 1, 1, 0, 1, 1 },  // 5
00020   { 0, 0, 1, 1, 1, 1, 1 },  // 6
00021   { 1, 1, 1, 0, 0, 0, 0 },  // 7 
00022   { 1, 1, 1, 1, 1, 1, 1 },  // 8
00023   { 1, 1, 1, 0, 0, 1, 1 }   // 9
00024 }; 
00025 
00026 const byte Target[PatternCount][OutputNodes] = {
00027   { 0, 0, 0, 0 },  
00028   { 0, 0, 0, 1 }, 
00029   { 0, 0, 1, 0 }, 
00030   { 0, 0, 1, 1 }, 
00031   { 0, 1, 0, 0 }, 
00032   { 0, 1, 0, 1 }, 
00033   { 0, 1, 1, 0 }, 
00034   { 0, 1, 1, 1 }, 
00035   { 1, 0, 0, 0 }, 
00036   { 1, 0, 0, 1 } 
00037 };
00038 
00039 int i, j, p, q, r;
00040 int ReportEvery1000;
00041 int RandomizedIndex[PatternCount];
00042 long  TrainingCycle;
00043 float Rando;
00044 float Error;
00045 float Accum;
00046 
00047 
00048 float Hidden[HiddenNodes];
00049 float Output[OutputNodes];
00050 float HiddenWeights[InputNodes+1][HiddenNodes];
00051 float OutputWeights[HiddenNodes+1][OutputNodes];
00052 float HiddenDelta[HiddenNodes];
00053 float OutputDelta[OutputNodes];
00054 float ChangeHiddenWeights[InputNodes+1][HiddenNodes];
00055 float ChangeOutputWeights[HiddenNodes+1][OutputNodes];
00056 
00057 int main()
00058 {
00059   pc.baud(9600);
00060   randomSeed(analogRead(3));
00061   ReportEvery1000 = 1;
00062   for( p = 0 ; p < PatternCount ; p++ ) 
00063   {    
00064     RandomizedIndex[p] = p ;
00065   }
00066   
00067   void loop ()
00068   {
00069 
00070 
00071 
00072     for( i = 0 ; i < HiddenNodes ; i++ ) 
00073     {    
00074         for( j = 0 ; j <= InputNodes ; j++ ) 
00075         { 
00076             ChangeHiddenWeights[j][i] = 0.0 ;
00077             Rando = float(random(100))/100;
00078             HiddenWeights[j][i] = 2.0 * ( Rando - 0.5 ) * InitialWeightMax ;
00079         }
00080     }
00081 
00082     for( i = 0 ; i < OutputNodes ; i ++ ) 
00083     {    
00084         for( j = 0 ; j <= HiddenNodes ; j++ ) 
00085         {
00086             ChangeOutputWeights[j][i] = 0.0 ;  
00087             Rando = float(random(100))/100;        
00088             OutputWeights[j][i] = 2.0 * ( Rando - 0.5 ) * InitialWeightMax ;
00089         }
00090     }
00091     pc.printf("Initial/Untrained Outputs: \n");
00092     toTerminal();
00093 
00094     for( TrainingCycle = 1 ; TrainingCycle < 2147483647 ; TrainingCycle++) 
00095     {    
00096 
00097         for( p = 0 ; p < PatternCount ; p++) 
00098         {
00099             q = random(PatternCount);
00100             r = RandomizedIndex[p] ; 
00101             RandomizedIndex[p] = RandomizedIndex[q] ; 
00102             RandomizedIndex[q] = r ;
00103         }
00104         Error = 0.0 ;
00105 
00106         for( q = 0 ; q < PatternCount ; q++ ) 
00107         {    
00108             p = RandomizedIndex[q];
00109 
00110             for( i = 0 ; i < HiddenNodes ; i++ ) 
00111             {    
00112                 Accum = HiddenWeights[InputNodes][i] ;
00113                 for( j = 0 ; j < InputNodes ; j++ ) 
00114                 {
00115                     Accum += Input[p][j] * HiddenWeights[j][i] ;
00116                 }
00117                 Hidden[i] = 1.0/(1.0 + exp(-Accum)) ;
00118             }
00119 
00120 
00121             for( i = 0 ; i < OutputNodes ; i++ ) 
00122             {    
00123                 Accum = OutputWeights[HiddenNodes][i] ;
00124                 for( j = 0 ; j < HiddenNodes ; j++ ) 
00125                 {
00126                     Accum += Hidden[j] * OutputWeights[j][i] ;
00127                 }
00128                 Output[i] = 1.0/(1.0 + exp(-Accum)) ;   
00129                 OutputDelta[i] = (Target[p][i] - Output[i]) * Output[i] * (1.0 - Output[i]) ;   
00130                 Error += 0.5 * (Target[p][i] - Output[i]) * (Target[p][i] - Output[i]) ;
00131             }
00132 
00133 
00134             for( i = 0 ; i < HiddenNodes ; i++ ) 
00135             {    
00136                 Accum = 0.0 ;
00137                 for( j = 0 ; j < OutputNodes ; j++ ) 
00138                 {
00139                     Accum += OutputWeights[i][j] * OutputDelta[j] ;
00140                 }
00141                 HiddenDelta[i] = Accum * Hidden[i] * (1.0 - Hidden[i]) ;
00142             }
00143 
00144 
00145 
00146 
00147             for( i = 0 ; i < HiddenNodes ; i++ ) 
00148             {     
00149                 ChangeHiddenWeights[InputNodes][i] = LearningRate * HiddenDelta[i] + Momentum * ChangeHiddenWeights[InputNodes][i] ;
00150                 HiddenWeights[InputNodes][i] += ChangeHiddenWeights[InputNodes][i] ;
00151                 for( j = 0 ; j < InputNodes ; j++ ) 
00152                 { 
00153                     ChangeHiddenWeights[j][i] = LearningRate * Input[p][j] * HiddenDelta[i] + Momentum * ChangeHiddenWeights[j][i];
00154                     HiddenWeights[j][i] += ChangeHiddenWeights[j][i] ;
00155                 }
00156             }
00157 
00158 
00159             for( i = 0 ; i < OutputNodes ; i ++ ) 
00160             {    
00161                 ChangeOutputWeights[HiddenNodes][i] = LearningRate * OutputDelta[i] + Momentum * ChangeOutputWeights[HiddenNodes][i] ;
00162                 OutputWeights[HiddenNodes][i] += ChangeOutputWeights[HiddenNodes][i] ;
00163                 for( j = 0 ; j < HiddenNodes ; j++ ) 
00164                 {
00165                     ChangeOutputWeights[j][i] = LearningRate * Hidden[j] * OutputDelta[i] + Momentum * ChangeOutputWeights[j][i] ;
00166                     OutputWeights[j][i] += ChangeOutputWeights[j][i] ;
00167                 }
00168             }
00169      }
00170 
00171 
00172     ReportEvery1000 = ReportEvery1000 - 1;
00173     if (ReportEvery1000 == 0)
00174     { 
00175       pc.printf ("TrainingCycle: ");
00176       pc.printf ("%i",(int16_t)TrainingCycle);
00177       pc.printf ("  Error = ");
00178       pc.printf ("%i\n",(int16_t)Error, 5);
00179 
00180       toTerminal();
00181 
00182       if (TrainingCycle==1)
00183       {
00184         ReportEvery1000 = 999;
00185       }
00186         else
00187       {
00188         ReportEvery1000 = 1000;
00189       }
00190     }    
00191 
00192     if( Error < Success ) break ;  
00193   } 
00194     pc.printf ("TrainingCycle: ");
00195     pc.printf ("%i",(int16_t)TrainingCycle);
00196     pc.printf ("  Error = ");
00197     pc.printf ("%i\n",(int16_t)Error, 5);
00198 
00199     toTerminal();
00200 
00201     pc.printf ("Training Set Solved!\n");
00202     pc.printf ("--------\n");   
00203     ReportEvery1000 = 1;
00204     }
00205 }  
00206 
00207 void toTerminal()
00208 {
00209 
00210   for( p = 0 ; p < PatternCount ; p++ ) { 
00211     pc.printf ("  Training Pattern: ");
00212     pc.printf ("%i\n",(int16_t)p);      
00213     pc.printf ("  Input ");
00214     for( i = 0 ; i < InputNodes ; i++ ) {
00215       pc.printf ("%i,%i",(int16_t)Input[p][i],(int16_t)DEC);
00216       pc.printft (" ");
00217     }
00218     pc.printf ("  Target ");
00219     for( i = 0 ; i < OutputNodes ; i++ ) {
00220       pc.printf ("%i,%i",(int16_t)Input[p][i],(int16_t)DEC);
00221       Serial.print (" ");
00222     }
00223 /******************************************************************
00224 * Compute hidden layer activations
00225 ******************************************************************/
00226 
00227     for( i = 0 ; i < HiddenNodes ; i++ ) {    
00228       Accum = HiddenWeights[InputNodes][i] ;
00229       for( j = 0 ; j < InputNodes ; j++ ) {
00230         Accum += Input[p][j] * HiddenWeights[j][i] ;
00231       }
00232       Hidden[i] = 1.0/(1.0 + exp(-Accum)) ;
00233     }
00234 
00235 /******************************************************************
00236 * Compute output layer activations and calculate errors
00237 ******************************************************************/
00238 
00239     for( i = 0 ; i < OutputNodes ; i++ ) {    
00240       Accum = OutputWeights[HiddenNodes][i] ;
00241       for( j = 0 ; j < HiddenNodes ; j++ ) {
00242         Accum += Hidden[j] * OutputWeights[j][i] ;
00243       }
00244       Output[i] = 1.0/(1.0 + exp(-Accum)) ; 
00245     }
00246     pc.printf ("  Output ");
00247     for( i = 0 ; i < OutputNodes ; i++ ) {       
00248       pc.printf ("%i",Output[i], 5);
00249       pc.printf (" ");
00250     }
00251   }
00252 
00253 
00254 }
00255