View unanswered posts | View active topics It is currently Mon Nov 24, 2014 8:25 am






Reply to topic  [ 1 post ] 
1.40: program switches to system menu after a while & crash 
Author Message
Guru
User avatar

Joined: Sat Mar 01, 2008 12:52 pm
Posts: 1030
Post 1.40: program switches to system menu after a while & crash
hi, another problem:
(this is really hard for me to explain in English, cause it's quite complex and "multi-layered"):

in my program (artificial neuronal network) I have lots of calculations, and a couple of menus to interrupt, load, and restart the program.
Now, after some (10-20) minutes of calculation (auto learning) a strange thing is happening:

- the nxt screen is kind of flickering, and the system menu seems to appear (in a sort of "see-through" or "over-laid" way), which even overlaps my own menus;

- among all the figures of my numbers or my menus you can recognize fragments of the system menu with the check button (hook) and the abort button (X), which appear and again disappear;

- independent of what button you are actually pressing, the program doesn't react to my own menus (getkey/readkey functions), but the program reacts to the built-in menu function (check or abort)

- after you have pressed any button, an other system menu is overlaid to my screen, now you can recognize fragments of the nxt system file menu (3 symbols: left: the "TRY_ME"/Lego head, middle: "MY_FILES"/disk symbols, right: "NXT_PROGRAM"/sqare symbols with arrow)

- if you press any button again, you may see that my program was still running in the background, and maybe you can also watch it terminating (my self-programmed "END" screen appearing).

try to train the net with a more complex patterns, such as:
in---out
000--11
100--10
010--01
110--00
001--10
101--11
011--01
111--00
(this includes some hard to calculate XOR conditions so it will run for a longer time).

train it 1x manually.
when the last input (111) has been trained, finally there is a long low tone.
then choose "autom" (press right nxt button),
so now there will be up to 2000 cycles of automized 8-pattern-training.

if you start the program in debug mode (USB) with remote screen , you may watch

1st, the remote screen to freeze
2nd, the nxt screen to flicker like reported above
3rd, maybe even the nxt program to crash and the nxt to switch off by himself :

Code:
// Lernfaehiges 2-schichtiges Neuronales Netz
// Backpropagation Netz mit 3 Sensor-Eingaengen (Touch an S1, S2, S3)
// an 3 verdeckten Neurons
// dann 2 Ausgabe-Neurons mit 2 Outputs (Anzeige auf dem Display)
// (c) H. W. 2008
// neu: automatisches Training nach Datei
   string Version="0.480";


#define printXY nxtDisplayStringAt
#define println nxtDisplayTextLine


//**********************************************************************
// Basisdeklarationen fuer Neuronale Netze
//**********************************************************************


const int L0 =  3;    // max. Neurons in Schicht (Layer) 0 (Schicht fuer Inputs)
const int L1 =  2;    // max. Neurons in Schicht (Layer) 1 (Ausgabe Schicht bei 2-schichtigen)
const int L2 =  1;    // max. Neurons in Schicht (Layer) 2
const int L3 =  1;    // max. Neurons in Schicht (Layer) 3

const int ni = 3;      // max. Dendriten-Eingaenge (Zaehler ab 0)



//**********************************************************************
// Neuron-Struktur
//**********************************************************************

float lf     = 0.7;                  // Lern-Faktor
int CalcTime = (L0+L1+L2+L3+1)*10;     // Network CalcTime

float sollOut;

typedef struct{
   float in[ni];    // Einzel-Inputs (Dendriten)
   float w[ni];     // Einzel-Wichtungen (jedes Dendriten)
   float net;       // totaler Input
   float th;        // Schwellenwert (threshold)
   float d;         // delta=Fehlersignal
   float out;       // Output (Axon): z.B. 0 oder 1
} tNeuron;

//**********************************************************************

tNeuron Neuron0[L0];  // Neurons-Schicht 0  (Schicht fuer Inputs)
tNeuron Neuron1[L1];  // Neurons-Schicht 1  (Ausgabe Schicht bei 2-schichtigen)
tNeuron Neuron2[L2];  // Neurons-Schicht 2
tNeuron Neuron3[L3];  // Neurons-Schicht 3


//**********************************************************************
//  mathematische Hilfsfunktionen
//**********************************************************************


float tanh(float x)  // Tangens hyperbolicus
{
   float e2x;
   e2x=exp(2*x);
   return((e2x-1)/(e2x+1));
}

//**********************************************************************
// Ein-/ Ausgabefunktionen (Tatstatur, Display)
//**********************************************************************

int key;               // gedrueckte NXT-Taste
int buttonPressed(){

  TButtons nBtn;
  nNxtExitClicks=100; // gegen versehentliches Druecken

  nBtn = nNxtButtonPressed; // check for button press
   switch (nBtn)     {
      case kLeftButton: {
           return 1;   break;     }

        case kEnterButton: {
             return 2;   break;     }

        case kRightButton: {
             return 3;   break;     }

        case kExitButton: {
             return 4;   break;     }

        default: {
             return 0;   break;     }
   }
   return 0;
}

//*****************************************

int getkey() {
   int k, buf;

   k=buttonPressed();
   buf=buttonPressed();
  while (buf!=0)
  { buf=buttonPressed();
    wait1Msec(20);}
  return k;
}

void pause() {

   int k=0;

   do {k=getkey();}
   while (k==0);

}



//**********************************************************************
string MenuText="";    // Menue-Steuerung

task DisplayValues(){
  int i;  // input number  = Sensoren an verdeckter Schicht
  int j;  // neuron number = Outputs an Ausgabe-Schicht

   while(true) {

    printXY(00,    63, "%4.1f", Neuron0[0].w[0]);  // Neuron L0 [0]
      printXY(26,    63, "%4.1f", Neuron0[0].w[1]);  // Eingabe-Schicht
      printXY(52,    63, "%4.1f", Neuron0[0].w[2]);
    printXY(78,    63, "%4.1f", Neuron0[0].th);

    printXY(00,    55, "%4.1f", Neuron0[1].w[0]);  // Neuron L0 [1]
      printXY(26,    55, "%4.1f", Neuron0[1].w[1]);  // Eingabe-Schicht
      printXY(52,    55, "%4.1f", Neuron0[1].w[2]);
    printXY(78,    55, "%4.1f", Neuron0[1].th);

    printXY(00,    47, "%4.1f", Neuron0[2].w[0]);  // Neuron L0 [2]
      printXY(26,    47, "%4.1f", Neuron0[2].w[1]);  // Eingabe-Schicht
      printXY(52,    47, "%4.1f", Neuron0[2].w[2]);
    printXY(78,    47, "%4.1f", Neuron0[2].th);

    printXY(00,    39, "%4.1f", Neuron1[0].w[0]);  // Neuron L1 [0]
      printXY(26,    39, "%4.1f", Neuron1[0].w[1]);  // Ausgabe-Schicht
      printXY(52,    39, "%4.1f", Neuron1[0].w[2]);
    printXY(78,    39, "%4.1f", Neuron1[0].th);

    printXY(00,    31, "%4.1f", Neuron1[1].w[0]);  // Neuron L1 [1]
      printXY(26,    31, "%4.1f", Neuron1[1].w[1]);  // Ausgabe-Schicht
      printXY(52,    31, "%4.1f", Neuron1[1].w[2]);
    printXY(78,    31, "%4.1f", Neuron1[1].th);

    printXY(00,    23, "%2.0f", Neuron0[0].in[0]); // inputs (3)
    printXY(16,    23, "%2.0f", Neuron0[0].in[1]);
    printXY(32,    23, "%2.0f", Neuron0[0].in[2]);

    printXY(50,    23, "%4.1f", Neuron1[0].out);   // outputs (2)
    printXY(76,    23, "%4.1f", Neuron1[1].out);


    println(7, "%s", MenuText);                    //  Menue-Zeile fuer Tastatur-Steuerung

  }
  return;
}

//**********************************************************************



//**********************************************************************
// File I/O
//**********************************************************************
const string sFileName = "Memory.dat";

TFileIOResult nIoResult;
TFileHandle   fHandle;

int   nFileSize     = (L0 + L1 + L2 + L3 +1)*100;


void SaveMemory()
{
   int i, j;

   CloseAllHandles(nIoResult);
   println(6,"%s","Save Memory...");
   wait1Msec(500);
   PlaySound(soundBeepBeep);
   wait1Msec(11);

   Delete(sFileName, nIoResult);

  OpenWrite(fHandle, nIoResult, sFileName, nFileSize);
  if (nIoResult==0) {
    eraseDisplay();

    for (j=0;j<L0;j++)   {
      for (i=0; i<ni;i++)
      {   WriteFloat (fHandle, nIoResult, Neuron0[j].w[i]); }
        WriteFloat (fHandle, nIoResult, Neuron0[j].th);     }

    for (j=0;j<L1;j++)   {
      for (i=0; i<ni;i++)
      {   WriteFloat (fHandle, nIoResult, Neuron1[j].w[i]); }
        WriteFloat (fHandle, nIoResult, Neuron1[j].th);     }


    Close(fHandle, nIoResult);
    if (nIoResult==0) {
       PlaySound(soundUpwardTones);
       println(6,"%s","Save Memory: OK"); }
    else {
       PlaySound(soundException);
       println(6,"%s","Save Memory: ERROR"); }
  }
  else PlaySound(soundDownwardTones);

}

//*****************************************

void RecallMemory()
{
  int i, j;
   println(6,"%s","Recall Memory");
  CloseAllHandles(nIoResult);
   wait1Msec(500);
   PlaySound(soundBeepBeep);
   wait1Msec(11);

   OpenRead(fHandle, nIoResult, sFileName, nFileSize);
  if (nIoResult==0) {

  for (j=0;j<L0;j++) {
     for (i=0; i<ni;i++)
     { ReadFloat (fHandle, nIoResult, Neuron0[j].w[i]); }
       ReadFloat (fHandle, nIoResult, Neuron0[j].th);     }

  for (j=0;j<L1;j++) {
     for (i=0; i<ni;i++)
     { ReadFloat (fHandle, nIoResult, Neuron1[j].w[i]); }
       ReadFloat (fHandle, nIoResult, Neuron1[j].th);     }


    Close(fHandle, nIoResult);
    if (nIoResult==0) PlaySound(soundUpwardTones);
    else {
       PlaySound(soundException);
       println(6,"%s","Recall: ERROR"); }
  }
  else PlaySound(soundDownwardTones);
  eraseDisplay();

}


//**********************************************************************
// Funktionen des neuronalen Netzes
//**********************************************************************

//**********************************************************************
// Inputs
//**********************************************************************

task RefreshInputLayer(){  // Inputs aus Sensorwerten
int i, j;
  while(true){
  for (j=0; j<L0; j++) {   // alle Inputs an alle Eingangs-Neuronen
    for (i=0; i<ni; i++)   {
      Neuron0[j].in[i]=(float)SensorValue(i);
      }
    }
  }
  return;
}

//*****************************************



void SetInputPattern(int i) // Inputs virtuell generiert
{
   int j, n;

   printXY(80, 63, "%d", i);
   for (j=0; j<L0;j++)
  {

     for (n = 0; n <=ni-1; n++)
    {
      Neuron0[j].in[n]= i & 1;
      i >>= 1;
    }
  }
}





//**********************************************************************
// Propagierungsfunktionen: Eingaenge gewichtet aufsummieren (in -> net)
//**********************************************************************

void netPropag(tNeuron &neur){      // Propagierungsfunktion 1
  int i=0;                          // kalkuliert den Gesamt-Input (net)
  float s=0;

  for(i=0;i<ni;i++){
     s+= (neur.in[i]*neur.w[i]);     // gewichtete Summe
  }
  neur.net=s;
}

void netPropagThr(tNeuron &neur){   // Propagierungsfunktion 2
  int i=0;                          // kalkuliert den Gesamt-Input (net)
  float s=0;                        // und beruecksichtigt Schwellwert

  for(i=0;i<ni;i++){
     s+= (neur.in[i]*neur.w[i]);     // gewichtete Summe
  }
  neur.net=s-neur.th;               // abzueglich Schwellwert
}

//**********************************************************************
// Aktivierungsfunktionen inkl. Ausgabe (net -> act -> out)
//**********************************************************************


void act_01(tNeuron &neur){         // Aktivierungsfunktion 1 T1: x -> [0; +1]
   if (neur.net>=0)                  // 0-1-Schwellwertfunktion
      {neur.out=1;}                  // Fkt.-Wert: 0 oder 1
   else {neur.out=0;}
}

void actIdent(tNeuron &neur){       // Aktivierungsfunktion 2 T2: x -> x
   neur.out=neur.net;                // Identitaets-Funktion
}                                   // Fkt-Wert: Identitaet


void actFermi(tNeuron &neur){       // Aktivierungsfunktion 3 T3: x -> [0; +1]
  float val;                        // Fermi-Fkt. (Logistisch, differenzierbar)
  float c=3.0;                      // c= Steilheit, bei c=1: flach,
                                    // c=10: Sprung zwischen x E [-0.1; +0.1]

  val= (1/(1+(exp(-c*neur.net))));
  neur.out=val;
}

void actTanH(tNeuron &neur){        // Aktivierungsfunktion 4 T4: x -> [-1; +1]
   float val;                       // Tangens Hyperbolicus, differenzierbar
   float c=2.0;                     // c= Steilheit, bei c=1: flach
  val= tanh(c*neur.net);            // c=3: Sprung zwischen x E [-0.1; +0.1]
  neur.out=val;
}



//**********************************************************************
// Reset / Init
//**********************************************************************

void ResetNeuron(tNeuron &neur, int rand){ // alles auf Null bzw. randomisiert
   int i;



   for (i=0; i<ni; i++) {
      neur.in[i]=0;                   // Einzel-Input (Dendrit)
     if (rand==0) {neur.w[i]=0;}     // Einzel-Wichtung (Dendrit)=0
      else
      neur.w[i]=-1.0+random(10)*0.2;  // Einzel-Wichtung (Dendrit) randomomisiert

   }
   neur.net=0;                       // totaler Input
   if (rand==0) {neur.th=0;}         // Schwellenwert (threshold)=0
   else
   neur.th=-1.0 + random(10)*0.2;    // Schwellenwert (threshold) randomisiert
   neur.out=0;                       // errechneter Aktivierungswert=Output
   }

//*****************************************

void InitAllNeurons(){             // alle Netz-Neurons resetten
   int j;                           // (0 oder randomisiert)


   for (j=0; j<L0; j++) {           // Neuron-Schicht 0
        ResetNeuron(Neuron0[j],1);}

  for (j=0; j<L1; j++) {           // Neuron-Schicht 1
        ResetNeuron(Neuron1[j],1);}

  for (j=0; j<L2; j++) {           // Neuron-Schicht 2
        ResetNeuron(Neuron2[j],0);}

  for (j=0; j<L3; j++) {           // Neuron-Schicht 3
        ResetNeuron(Neuron3[j],0);}
}

//*****************************************

void PrepThisNeuralNet()  // for testing
{
   ; // defaults
}


//**********************************************************************
// einzelne Neurons schichtenweise durchrechnen
//**********************************************************************

task RefreshLayers(){
  int j, k, CycleTime;


  while(true)
  {
    //CycleTime=nSysTime;          // fuer Test: max 50 mSec (5 Neurons)

     for (j=0;j<L0;j++) {
       netPropagThr(Neuron0[j]);    // net-Input Layer 0
      actFermi(Neuron0[j]);        // Aktivierung T: Fermi-Funktion -> out
      for (k=0;k<L1;k++) {
        Neuron1[k].in[j] = Neuron0[j].out; } // Synapse Neuron0->Neuron1
    }

    for (j=0;j<L1;j++) {
      netPropagThr(Neuron1[j]);    // net-Input Layer 1
      actFermi(Neuron1[j]);        // Aktivierung T: Fermi-Funktion -> out
    }

    //CycleTime=nSysTime-CycleTime;
    //println(6,"%d",CycleTime);
  }
  return;
}

//**********************************************************************
// Lernverfahren
//**********************************************************************



//**********************************************************************
void LearnPerceptronRule() {         // Perceptron-Lern-Modus
  int ErrorCount;
  int in;        // Sensor-Kombinationen
  int i;         // Anzahl Inputs
  int j;         // Anzahl Ausgabe-Neurons

 do
 {
  ErrorCount=0;
  PlaySound(soundBeepBeep);
  MenuText="-- <<  ok  >> ++";


   SetInputPattern(in);           // virtuelles Muster praesentieren
   wait1Msec(CalcTime);

   for (j=0;j<2;j++)  // 1 bis Anzahl Ausgabe-Neuron
   {

       sollOut=0;
       MenuText="-- <<  ok  >> ++";
       printXY(0,15, "soll:");
       printXY(48+(j*25),15,"%2.0f", sollOut);
      do                        // erzeugten Output berichtigen
      {
         key=getkey();

         if (key==1) {   if (sollOut>0) sollOut-=1;  }
         else
         if (key==3) { if (sollOut< 1) sollOut+=1;  }
        printXY(0,15, "soll:");
         printXY(48+(j*25),15,"%2.0f", sollOut);
        wait1Msec(100);
      } while ((key!=2)&&(key!=4));

      println(5, " ");

      //...................................................
      if (key==4) {                     // Lern-Modus ENDE
         PlaySound(soundException);
         key=0;
         return;
      }
      //....................................................

                                        // Lern-Modus START
      //....................................................
      if (sollOut==Neuron0[j].out    )  // teachOut korrekt
        {
            PlaySound(soundBlip);
         PlaySound(soundBlip);
         wait1Msec(100);
      }
        //....................................................
      if (sollOut!=Neuron0[j].out)      // teachOut falsch
        {
           PlaySound(soundException);
           wait1Msec(100);
        ErrorCount+=1;
           //...................................................
                                        // LERNEN

        for (i=0; i<=L0; i++)           // fuer alle i (Inputs)
           {                               // Wichtungen anpassen (Delta-Regel)
              Neuron0[j].w[i] = Neuron0[j].w[i]+ (lf *Neuron0[j].in[i]*(sollOut-Neuron0[j].out));
           }

           if (sollOut!=Neuron0[j].out)    // Schwelle anpassen (Delta-Regel, erweitert)
           {
              Neuron0[j].th = Neuron0[j].th + (lf *(sollOut-Neuron0[j].out));
           }
        //...................................................
      } // if (sollOut!=Neuron0[j].out)

   } // for j


 } while (ErrorCount>0);

PlaySound(soundUpwardTones);
PlaySound(soundUpwardTones);
}

//**********************************************************************
//**********************************************************************

int IOpattern[(1<<ni)][L1];      // fix 471-002 [2<<(ni-1)] -> [(1<<ni)]
//**********************************************************************


void LearnBackpropagation() {    // Backpropagation-Lern-Modus
                                 // 1 verdeckte/Eingabe-Schicht(L0) +  1 Ausgabe-Schicht(L1)
  int idummy;

  int count;
  int maxCount=2000;

  int in;         // angelegtes Sensor/Input-Muster(Pattern)
  int i;          // Zaehler Inputs
  int j, k;       // Index fuer Ausgabe-Neurons L1
  int m;          // Index fuer Eingabe-Neurons L0


  float f;        // Fehler (sollout-out )
  float f_sig1;   // Fehler-Signal Schicht 1 zum Lernen v. Wichtung und Schwelle
  float f_sig0;   // Fehler-Signal Schicht 0 zum Lernen v. Wichtung und Schwelle

  float f_sum=0;  // Fehler verdeckte Schicht (Summe (Wichtung*Fehlersignal))
  float out;      // Neuron-out, Dummy;
  float fehler=0; // Summe der Fehlersignale
  float epsilon;  // max. zulssiger Netz-Fehler

  float delta_w0,  delta_w1;  // Aenderungswert der Wichtung
  float delta_th0, delta_th1; // Aenderungswert des Schwellwerts

  bool LearnModeAuto=false; // automat. Lernen oder manuell per Taste


  count=maxCount;
  epsilon=(float)(ni*L1)*0.1; // max. 10% Fehler

  do {
   fehler=0;
   count-=1;

   if (!LearnModeAuto)  PlaySound(soundBeepBeep);
    else PlaySound(soundBlip);

    for (in=0; in < (1<<ni); in++)    // in = 1. bis letztes Eingabe-Neuron
   {
     SetInputPattern(in);        // Eingabe-Muster anlegen

     wait1Msec(CalcTime);        // durch alle Schichten durchrechnen

     for (j=0;j<L1;j++)          // j = 1. bis letztes Ausgabe-Neuron
     {
//=====================================================================================

        if (!LearnModeAuto)                   // einlesen per Tastatur
       {

         sollOut=0;
         MenuText="-- <<  ok  >> ++";
         printXY(0,15, "soll:");
         printXY(48+(j*25),15,"%2.0f", sollOut);
         do
         {
           key=getkey();
           if (key==4) {                     // Lern-Schritt ueberspringen
             IOpattern[in][j]=-99;
             key=0;
             printXY(48+(j*25),15,"   ");
             goto _NEXT;
           }  // if key

           if (key==1) {   if (sollOut==1) sollOut=0;  }
           else
           if (key==3) { if (sollOut==0) sollOut=1;  }

           IOpattern[in][j]=sollOut;        // IO-Muster in IO-array schreiben

           printXY(0,15, "soll:");
           printXY(48+(j*25),15,"%2.0f", sollOut);
           wait1Msec(100);
        } while ((key!=2));
      }
//=====================================================================================
      else                                  // autom. einlesen per IO-array
      {
          PlaySound(soundBlip);
         if (IOpattern[in][j]!=-99)
         {  sollOut=IOpattern[in][j];}
         else
         break;

         printXY(48+(j*25),15,"%2.0f", sollOut);
      }
//=====================================================================================

      PlaySound(soundBlip);
      wait1Msec(CalcTime);
      println(6, " ");

    // 1. Schritt: Fehlersignal Ausgabeschicht bestimmen
    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

      out=Neuron1[j].out;
      f= (sollOut-out);
      if ((abs(f))>=0.009)
        { out*=0.9;  sollOut*=0.9;}
      f_sig1=out*(1-out)* f;         // Fehler-Signal (j) fuer Ausgabeschicht

      Neuron1[j].d=f_sig1;                      // im Neuron1[j] speichern

      fehler=fehler + abs(sollOut-out);         // Gesamtfehler aller Ausgabeneuronen

   _NEXT:

    } // for j= 1. bis letztes Ausgabe-Neuron



     // 2. Schritt: Fehlersignale verdeckte/Eingabe-Schicht bestimmen
     // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

   for (k=0;k<L1;k++)    // k = 1. bis letztes Neuron in der Eingabe-Schicht

   {
         if (IOpattern[in][k]==-99) continue;

         f_sig1=Neuron1[k].d;                          // Fehlersignal des Nachfolger-(Ausgabe)-Neurons (k)

         f_sum=0;
         for (m=0; m<L0; m++)
        {  f_sum=f_sum + (Neuron1[k].w[m] * f_sig1);  }    // Summe ueber alle (Wichtungen(L1)*FSignale(L1)

        out=Neuron1[k].out;
        f_sig0 = out * (1-out) * f_sum;                    // Fehlersignal Eingabe/verdeckte Schicht L0

        for (m=0; m<L0; m++)
        {
           Neuron0[m].d    = f_sig0;                        // Fehlersignal im Neuron0 speichern
        }

     // 3. Schritt: neue Wichtungen und Schwellenwerte fuer Ausgabeschicht L1 berechnen
     // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

         for (m=0; m<L0; m++)
        {

          out=Neuron0[m].out;                              // Vorgaenger-out
          if (abs(f_sig1)<0.000001) {delta_w1=0;}                         // fix 474.002
          else
          delta_w1  = lf  * out * f_sig1;                  // Aenderungswert fuer Wichtungen Ausgabe-Schicht

          Neuron1[k].w[m] = Neuron1[k].w[m] + delta_w1;    // neue Wichtungen fuer Ausgabe-Schicht L1
          if ((abs(Neuron1[k].w[m])>20)&& (fehler>(10*epsilon)))
            ResetNeuron(Neuron1[k],1);                    // fix 0479.001
        }

        delta_th1 = lf  * f_sig1;                          // Aenderungswert delta_th

        Neuron1[k].th  = Neuron1[k].th - delta_th1;        // neue Schwellenw. fuer Ausgabe-Schicht L1
        if ((abs(Neuron1[k].th)>20)&& (fehler>(10*epsilon)))
          ResetNeuron(Neuron1[k],1);                       // fix 0479.001


     // 4. Schritt: neue Wichtungen und Schwellenwerte fuer Eingabeschicht L0 berechnen
     // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^


        for (m=0; m<L0; m++)
        {
           f_sig0 = Neuron0[m].d;

          for (i=0; i<ni; i++)
          {
             out=Neuron0[m].in[i];                           // Vorgaenger-out = Sensor-out = eigener Input
             delta_w0  = lf  * out * f_sig0;                 // Aenderungswert fuer Wichtungen Eingabe-Schicht

             Neuron0[m].w[i] = Neuron0[m].w[i] + delta_w0;   // neue Wichtungen fuer Eingabe-Schicht L0
             if ((abs(Neuron0[m].w[i])>20)&& (fehler>(10*epsilon)))
               ResetNeuron(Neuron0[m],1);                    // fix 0479.001
          }

          delta_th0 = lf  * f_sig0;                         // Aenderungswert fuer Schellenw. Eingabe-Schicht
          Neuron0[m].th  = Neuron0[m].th - delta_th0;       // neue Schwellenw. fuer Eingabe-Schicht L0
          if ((abs(Neuron0[m].th)>20)&& (fehler>(10*epsilon)))
            ResetNeuron(Neuron1[m],1);                      // fix 0479.001
        }

    } // for k = 1. bis letztes Neuron in der Ausgabe-Schicht

  } // for in=1... (Eingabe-Muster)

  //...................................................
  if (!LearnModeAuto)
  {
     MenuText="Menu manual. auto";
    PlaySound(soundLowBuzzShort);
    do {
      key=getkey();
      if (key==1)    {  return;   }
      if (key==2)    {  LearnModeAuto=false;  }
      if (key==3)    {  LearnModeAuto=true;   }
      if (key==4)    {  return; }
    }
    while (key==0);
    key=0;
  }
  //...................................................
  else
  {
     PlaySound(soundBlip);
     key=getkey();
     if (key!=0)
     {
        goto _ENDE;  // Abbruch durch beliebige Taste
     }
  }
  //...................................................

  if (fehler>4) lf=0.8;      // Lernfaktor anpassen
  else
  if (fehler<1.5) lf=0.4;
  else
  lf=fehler/5;

  //...................................................

  eraseDisplay();
  idummy=(int)(lf*10);
  MenuText=(string)count+" lf=."+(string)idummy;
  MenuText=MenuText+" f="+(string)fehler;

  //...................................................
  if ((count<=(3*maxCount/4))&&(fehler>=(30*epsilon) )) // 300% fehler
  { InitAllNeurons(); PlaySound(soundDownwardTones); count=maxCount;}
  //...................................................

 } while ((fehler>epsilon)&&(count>=0));

//...................................................
_ENDE:
if (fehler>epsilon) PlaySound(soundDownwardTones);
else
{ PlaySound(soundUpwardTones); PlaySound(soundUpwardTones);}
println(6, "Weiter: <Taste>");
pause();
println(6, "");
}
//**********************************************************************
//**********************************************************************




//**********************************************************************
// Programmablauf-Steuerung, Menues
//**********************************************************************

int Menu_Recall() {
  eraseDisplay();
  MenuText="<Recall    Clear>";
  println(7, "%s", MenuText);
  println(0, "%s", " Hal "+ Version);
  println(1, "%s", "----------------");
  println(2, "%s", "Reload my brain -");
  println(4, "%s", " Total Recall ?");
  do
  {
     key=getkey();
     if (key==1)    {  return 1;       }
     if (key==2)    {  PlaySound(soundException);  }
     if (key==3)    {  return 3;       }
     if (key==4)    {  PlaySound(soundException);  }

     wait1Msec(100);
  }
  while ((key==0)||(key==2)||(key==4));
}

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

int Menu_Quit() {
  eraseDisplay();
  MenuText="<Quit Sav Resume>";
  println(7, "%s", MenuText);

  do
  {
     key=getkey();
     if (key==1)    {  return 1;       }
     if (key==2)    {  SaveMemory();   }
     if (key==3)    {  return 3;       }
     if (key==4)    {  PlaySound(soundException); }

     wait1Msec(100);
  }
  while ((key==0)||(key==2)||(key==4));
}

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

int Menu_LearnSaveRun() {
  eraseDisplay();
  MenuText="<Learn  Sav  Run>";
  do
  {
     key=getkey();
     if (key==1)    {  return 1;   }
     if (key==2)    {  SaveMemory(); }
     if (key==3)    {  return 3;   }
     if (key==4)    {  PlaySound(soundException);
                      return 4;}

     wait1Msec(100);
  }
  while ((key==0)||(key==2));
}

//**********************************************************************
// Hauptprogramm
//**********************************************************************
int choice;


task main(){
  SensorType(S1)=sensorTouch;
  SensorType(S2)=sensorTouch;
  SensorType(S3)=sensorTouch;

  nVolume=2;


  _START_NEW_:
  choice=Menu_Recall();
  if (choice==1)  { RecallMemory(); } // altes Gedaechtnis laden
  else
  if (choice==3)  { InitAllNeurons();
                    PrepThisNeuralNet();} //  neu initialisieren


  StartTask (DisplayValues);
  StartTask (RefreshLayers);

//============================================================================================

  while(true)
  {
     choice=Menu_LearnSaveRun();        // Haupt-Menue
//============================================================================================
    if (choice==1)
    {
       StopTask(RefreshInputLayer);
       LearnBackpropagation();          // Lern-Modus Backpropagation
    }

//============================================================================================
    if (choice==4)                     // ENDE ?
    {
       StopTask(DisplayValues);
       eraseDisplay();

       MenuText="<Quit    Resume>";
      println(7, "%s", MenuText);

      choice=0;
      choice=Menu_Quit();

       if (choice==1) {  println(4, "      E N D");
                         wait1Msec(500);
                         StopAllTasks();
                         goto _END_; }

       if (choice==3) {  StartTask(DisplayValues);
                         goto _START_NEW_;

    }
    while ((choice==0));
   }
//============================================================================================

    MenuText="Menue: [ESC]";           // Run-Modus
    PlaySound(soundFastUpwardTones);
    StartTask (RefreshInputLayer);
    do
    {
       key=getkey();
      wait1Msec(100);
    } while (key!=4);
  }
//============================================================================================

  _END_:

}


_________________
regards,
HaWe aka Ford
#define S sqrt(t+2*i*i)<2
#define F(a,b) for(a=0;a<b;++a)
float x,y,r,i,s,j,t,n;task main(){F(y,64){F(x,99){r=i=t=0;s=x/33-2;j=y/32-1;F(n,50&S){t=r*r-i*i;i=2*r*i+j;r=t+s;}if(S){PutPixel(x,y);}}}while(1)}


Sat Aug 09, 2008 5:52 am
Profile
Display posts from previous:  Sort by  
Reply to topic   [ 1 post ] 

Who is online

Users browsing this forum: No registered users and 2 guests


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  



Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group.
Designed by ST Software for PTF.