Arduino mit neuronalem Netz überlastet?

[name123 (Gast)]

Hallo,

ich habe ein Neuronales Netz in Matlab gebaut und daraus C++ Code 
generiert für meinen Arduino Yun. Testweise hab ich erstmal alle 
Funktionen in die Arduino IDE so eingebunden, wie es in der 
Beispieldatei vom Matlab Coder zu finden war, dazu hab ich noch ein paar 
Nachrichten eingebaut, die über die serielle Schnittstelle verschickt 
werden, damit ich sehen kann was der Arduino gerade macht.
Und da ist das Problem, es werden mir die Zahlen bis 3 angezeigt, die 4 
fehlt, außerdem leuchtet die Tx LED auf dem Arduino die ganze zeit (die 
Rx LED blinkt konstant). Ist der Atmega32u4 mit dem neuronalen Netz 
überlastet oder warum kommt er nicht aus der Funtkion in die main 
zurück?

Macht es Sinn den Watchdog mal zu aktivieren? Ich hab gelesen, dass es 
dann evtl. zu Problemen mit dem bootloader kommen kann??

Ich hab jetzt erstmal nur die main und die NeuralNetwork Funktionen 
angehangen, da der Coder jede Menge Funktionen generiert hat, wenn noch 
was fehlt würde ich das dann bei Bedarf noch hochladen.

void setup() {
  // put your setup code here, to run once:
  Serial.begin(19200);

  //while (!SerialUSB); // wait for Serial port to connect.
  while (!Serial) ;
  Serial.println("Start:\n");

  NeuralNetwork_initialize();
  Serial.println("1");
}

void loop() {
  emxArray_real32_T *data;
  float activity_data[2];     
  int activity_size[1];
  float percent;

  int i;
  Serial.println("2");

  while(1){
  // Initialize function 'NeuralNetwork' input arguments.
  // Initialize function input argument 'data'.
  data = argInit_d7351x5_real32_T();
  Serial.println("3");

   // Call the entry-point 'NeuralNetwork'.
  NeuralNetwork(data, activity_data, activity_size, &percent);
  Serial.println("4");
  emxDestroyArray_real32_T(data);
  Serial.println("5");
  delay(20000);
  }
}


//
// MYNEURALNETWORKFUNCTION neural network simulation function.
//
//  Generated by Neural Network Toolbox function genFunction, 31-May-2016 11:28:21.
//
//  [y1] = myNeuralNetworkFunction(x1) takes these arguments:
//    x = 3xQ matrix, input #1
//  and returns:
//    y = 3xQ matrix, output #1
//  where Q is the number of samples.
// Arguments    : const emxArray_real32_T *x1
//                emxArray_real32_T *b_y1
// Return Type  : void
//
static void myNeuralNetworkFunction(const emxArray_real32_T *x1,
  emxArray_real32_T *b_y1)
{
  emxArray_real32_T *xp1;
  emxArray_real32_T *a1;
  emxArray_real32_T *c;
  int unnamed_idx_1;
  int br;
  int cr;
  emxArray_real32_T *b_a1;
  int ic;
  int ar;
  int ib;
  emxArray_real32_T *b_c;
  int ia;
  static const float fv0[60] = { -0.935882866F, 4.46991396F, 2.53056645F,
    3.92316675F, -0.0743107051F, -0.205709472F, 9.03690338F, -1.70399106F,
    0.926421523F, -2.28623581F, 3.10071659F, -1.26935542F, -2.23631501F,
    -9.84459591F, 0.993087471F, 2.04302645F, 4.20321703F, -2.27149796F,
    3.58496547F, 2.44178247F, 3.40729475F, -0.469613314F, 1.78666961F,
    2.29417801F, -3.18740916F, 2.17195415F, -4.67395782F, 7.34630871F,
    -3.47461224F, 3.20834136F, -1.70746982F, -5.48665953F, -4.09667301F,
    0.739171386F, 1.74923265F, -0.311410457F, -4.78127909F, -1.39544213F,
    0.524882078F, 1.18182981F, -0.696411669F, -5.19608736F, 3.62969112F,
    2.3355298F, 1.22786868F, -2.47384286F, -3.22555089F, 2.6435349F, 3.88966441F,
    5.3713007F, 3.07616806F, 1.22356141F, -1.26548851F, 2.36210823F, 2.64689827F,
    3.01882696F, -4.02463341F, -2.71989417F, -0.96769774F, -2.5208497F };

  emxArray_real32_T *b_xp1;
  static const float fv1[60] = { 1.67931402F, 0.225867584F, -0.620378792F,
    3.7200551F, -4.08313942F, -1.29023838F, -2.4495995F, 0.483594865F,
    0.21202448F, -1.67420352F, 2.72048736F, 0.35660097F, -1.29303122F,
    -0.261822969F, 0.836389482F, -0.926075F, 1.18991697F, 0.630103171F,
    5.31526899F, 1.27763438F, -5.82296467F, 3.09937382F, 0.774506807F,
    -4.02001476F, -1.25317657F, 3.04016709F, -1.59480321F, -1.30187023F,
    4.28900337F, -1.87965155F, -1.41545141F, 2.92732859F, -0.156499282F,
    3.42386079F, -0.692593813F, -1.06308234F, 1.32546556F, 0.971363962F,
    -1.49928606F, 4.62583208F, -0.401979417F, -4.44609356F, 2.21129417F,
    -0.263876438F, -1.07116032F, 0.954135299F, -1.38533843F, -1.27242231F,
    -3.90341139F, 1.66190958F, 1.72585738F, -1.24888289F, 1.22324169F,
    0.0705933943F, 2.23840976F, 0.210101902F, -0.130835086F, 1.03181279F,
    -0.514154136F, -1.49132049F };

  emxInit_real32_T(&xp1, 2);
  emxInit_real32_T(&a1, 2);
  emxInit_real32_T(&c, 2);

  //  ===== NEURAL NETWORK CONSTANTS =====
  //  Input 1
  //  Layer 1
  //  Layer 2
  //  ===== SIMULATION ========
  //  Dimensions
  //  samples
  //  Input 1
  mapminmax_apply(x1, xp1);

  //  Layer 1
  repmat((float)x1->size[1], a1);
  unnamed_idx_1 = xp1->size[1];
  br = c->size[0] * c->size[1];
  c->size[0] = 20;
  c->size[1] = unnamed_idx_1;
  c->size[0L] = 20;
  emxEnsureCapacity((emxArray__common *)c, br, (int)sizeof(float));
  unnamed_idx_1 = c->size[1];
  for (br = 0; br < unnamed_idx_1; br++) {
    for (cr = 0; cr < 20; cr++) {
      c->data[cr + c->size[0] * br] = 0.0F;
    }
  }

  if (xp1->size[1] == 0) {
  } else {
    unnamed_idx_1 = 20 * (xp1->size[1] - 1);
    for (cr = 0; cr <= unnamed_idx_1; cr += 20) {
      for (ic = cr + 1; ic <= cr + 20; ic++) {
        c->data[ic - 1] = 0.0F;
      }
    }

    br = 0;
    for (cr = 0; cr <= unnamed_idx_1; cr += 20) {
      ar = -1;
      for (ib = br; ib + 1 <= br + 3; ib++) {
        if (xp1->data[ib] != 0.0F) {
          ia = ar;
          for (ic = cr; ic + 1 <= cr + 20; ic++) {
            ia++;
            c->data[ic] += xp1->data[ib] * fv0[ia];
          }
        }

        ar += 20;
      }

      br += 3;
    }
  }

  emxInit_real32_T(&b_a1, 2);
  br = b_a1->size[0] * b_a1->size[1];
  b_a1->size[0] = 20;
  b_a1->size[1] = a1->size[1];
  emxEnsureCapacity((emxArray__common *)b_a1, br, (int)sizeof(float));
  unnamed_idx_1 = a1->size[0] * a1->size[1];
  for (br = 0; br < unnamed_idx_1; br++) {
    b_a1->data[br] = a1->data[br] + c->data[br];
  }

  emxFree_real32_T(&c);
  emxInit_real32_T(&b_c, 2);
  tansig_apply(b_a1, a1);

  //  Layer 2
  b_repmat((float)x1->size[1], xp1);
  unnamed_idx_1 = a1->size[1];
  br = b_c->size[0] * b_c->size[1];
  b_c->size[0] = 3;
  b_c->size[1] = unnamed_idx_1;
  b_c->size[0L] = 3;
  emxEnsureCapacity((emxArray__common *)b_c, br, (int)sizeof(float));
  unnamed_idx_1 = b_c->size[1];
  emxFree_real32_T(&b_a1);
  for (br = 0; br < unnamed_idx_1; br++) {
    for (cr = 0; cr < 3; cr++) {
      b_c->data[cr + b_c->size[0] * br] = 0.0F;
    }
  }

  if (a1->size[1] == 0) {
  } else {
    unnamed_idx_1 = 3 * (a1->size[1] - 1);
    for (cr = 0; cr <= unnamed_idx_1; cr += 3) {
      for (ic = cr + 1; ic <= cr + 3; ic++) {
        b_c->data[ic - 1] = 0.0F;
      }
    }

    br = 0;
    for (cr = 0; cr <= unnamed_idx_1; cr += 3) {
      ar = -1;
      for (ib = br; ib + 1 <= br + 20; ib++) {
        if (a1->data[ib] != 0.0F) {
          ia = ar;
          for (ic = cr; ic + 1 <= cr + 3; ic++) {
            ia++;
            b_c->data[ic] += a1->data[ib] * fv1[ia];
          }
        }

        ar += 3;
      }

      br += 20;
    }
  }

  emxFree_real32_T(&a1);
  emxInit_real32_T(&b_xp1, 2);
  br = b_xp1->size[0] * b_xp1->size[1];
  b_xp1->size[0] = 3;
  b_xp1->size[1] = xp1->size[1];
  emxEnsureCapacity((emxArray__common *)b_xp1, br, (int)sizeof(float));
  unnamed_idx_1 = xp1->size[0] * xp1->size[1];
  for (br = 0; br < unnamed_idx_1; br++) {
    b_xp1->data[br] = xp1->data[br] + b_c->data[br];
  }

  emxFree_real32_T(&b_c);
  emxFree_real32_T(&xp1);
  softmax_apply(b_xp1, b_y1);

  //  Output 1
  emxFree_real32_T(&b_xp1);
}

[Jim M. (turboj)]

Wieso willst das auf dem arschlahmen Atmel rechnen und nicht auf dem 
Linux Prozessor? RAM wird da auch knapp.

Der AR9331 ist wenigstens eine Größenordnung schneller...

[Noch einer (Gast)]

float Variablen auf einem Atmega? Auf den 8bit Mikrocontrollen machen 
wir alle Arten vor unsauberen Tricks, bevor wir Gleitkommazahlen 
benutzen.

Die haben keine Hardware für Gleitkomma. Jede Berechnung braucht 
hunderte von Maschinenbefehlen.

[Bernd K. (prof7bit)]

Jim M. schrieb:
> Wieso willst das auf dem arschlahmen Atmel rechnen

Du weißt doch gar nicht wie schnell es sein soll? Vielleicht reichen ihm 
ja ein paar hundert Ergebnisse pro Sekunde vollkommen aus?

> und nicht auf
> dem
> Linux Prozessor?

Kanonen -> Spatzen?

> RAM wird da auch knapp.

Wie das? Wo soll ein fertig trainiertes NN mit ein paar dutzend 
Koeffizienten im Flash irgendwelches nennenswerte RAM verbrauchen?

[Kabolt (Gast)]

Wieviel Flash / RAM belegst du laut Ausgabe des Makes?

Diese Funktion solltest du noch posten: NeuralNetwork.

[name123 (Gast)]

Bernd K. schrieb:
> Jim M. schrieb:
>> Wieso willst das auf dem arschlahmen Atmel rechnen
>
> Du weißt doch gar nicht wie schnell es sein soll? Vielleicht reichen ihm
> ja ein paar hundert Ergebnisse pro Sekunde vollkommen aus?


Die Funktion soll ca. 20 mal pro sekunde aufgerufen werden, ist das 
machbar für dem Atmega oder lohnt es sich wirklich den linux prozessor 
zu verwenden?

Kabolt schrieb:
> Wieviel Flash / RAM belegst du laut Ausgabe des Makes?

Der Sketch verwendet 17.168 Bytes (59%) des Programmspeicherplatzes. Das 
Maximum sind 28.672 Bytes.
Globale Variablen verwenden 819 Bytes (31%) des dynamischen Speichers, 
1.741 Bytes für lokale Variablen verbleiben. Das Maximum sind 2.560 
Bytes.

Kabolt schrieb:
> Diese Funktion solltest du noch posten: NeuralNetwork.

// daten enthält die x,y,z Beschleudnigung und die richtig aktivität die
// erkannt werden soll, zurückgegeben wird die erkannte aktivität und die
// relative Genauigkeit des NN
//    data: 1.Spalte -> Zeitstempel; 2.-4. Spalte -> x,y,z-Beschleunigung; 5.
//    Spalte -> Aktivität
// Arguments    : const emxArray_real32_T *data
//                float activity_data[]
//                int activity_size[1]
//                float *percent
// Return Type  : void
//
void NeuralNetwork(const emxArray_real32_T *data, float activity_data[], int
                   activity_size[1], float *percent)
{
  emxArray_real32_T *b_data;
  int ix;
  int k;
  emxArray_real32_T *NNfit;
  int ixstart;
  emxArray_real32_T *r0;
  int n;
  int i;
  float mtmp;
  boolean_T s_data[7351];
  boolean_T exitg1;
  emxInit_real32_T(&b_data, 2);
  ix = data->size[0];
  k = b_data->size[0] * b_data->size[1];
  b_data->size[0L] = 3;
  b_data->size[1L] = ix;
  emxEnsureCapacity((emxArray__common *)b_data, k, (int)sizeof(float));
  for (k = 0; k < ix; k++) {
    for (ixstart = 0; ixstart < 3; ixstart++) {
      b_data->data[ixstart + b_data->size[0] * k] = data->data[k + data->size[0]
        * (1 + ixstart)];
    }
  }

  emxInit_real32_T(&NNfit, 2);
  emxInit_real32_T(&r0, 2);
  myNeuralNetworkFunction(b_data, r0);
  k = NNfit->size[0] * NNfit->size[1];
  NNfit->size[0L] = r0->size[1L];
  NNfit->size[1L] = 3;
  emxEnsureCapacity((emxArray__common *)NNfit, k, (int)sizeof(float));
  emxFree_real32_T(&b_data);
  for (k = 0; k < 3; k++) {
    ix = r0->size[1L];
    for (ixstart = 0; ixstart < ix; ixstart++) {
      NNfit->data[ixstart + NNfit->size[0] * k] = r0->data[k + r0->size[0] *
        ixstart];
    }
  }

  emxFree_real32_T(&r0);
  ixstart = NNfit->size[0];
  if (ixstart >= 3) {
  } else {
    ixstart = 3;
  }

  if (NNfit->size[0] == 0) {
    n = 0;
  } else {
    n = ixstart;
  }

  activity_size[0L] = n;
  for (k = 0; k < n; k++) {
    activity_data[k] = 0.0F;
  }

  for (i = 0; i < n; i++) {
    ixstart = 1;
    mtmp = NNfit->data[i];
    k = 1;
    if (rtIsNaNF(NNfit->data[i])) {
      ix = 2;
      exitg1 = false;
      while ((!exitg1) && (ix < 4)) {
        ixstart = ix;
        if (!rtIsNaNF(NNfit->data[i + NNfit->size[0] * (ix - 1)])) {
          mtmp = NNfit->data[i + NNfit->size[0] * (ix - 1)];
          k = ix;
          exitg1 = true;
        } else {
          ix++;
        }
      }
    }

    if (ixstart < 3) {
      while (ixstart + 1 < 4) {
        if (NNfit->data[i + NNfit->size[0] * ixstart] > mtmp) {
          mtmp = NNfit->data[i + NNfit->size[0] * ixstart];
          k = ixstart + 1;
        }

        ixstart++;
      }
    }

    activity_data[i] = k;
  }

  emxFree_real32_T(&NNfit);
  ix = data->size[0];
  for (k = 0; k < ix; k++) {
    s_data[k] = (data->data[k + (data->size[0] << 2)] == activity_data[k]);
  }

  ixstart = 0;
  for (k = 0; k < ix; k++) {
    if (s_data[k]) {
      ixstart++;
    }
  }

  *percent = (float)ixstart / (float)n * 100.0F;
}

[The D. (thedaz)]

Hast du diese Code-Wüste selbst geschrieben oder generieren lassen? Im 
Ernst: sowas kann man nicht inhaltlich bewerten. Deswegen alternativ: 
kompiliere das mal auf dem PC und starte es im Debugger.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

name123 schrieb:
> Macht es Sinn den Watchdog mal zu aktivieren?
Sicher nicht, denn wenn du ihn nicht zurücksetzt, dann setzt er 
deinen uC dauernd zurück...

> Globale Variablen verwenden 819 Bytes (31%) des dynamischen Speichers,
Du meinst vermutlich das oridinäre RAM.
> 1.741 Bytes für lokale Variablen verbleiben.
Ich weiß nicht so recht...
Allein das hier:
> boolean_T s_data[7351];
7351 Bits sind allein schon 918 Bytes. Und wehe, der Compiler verwendet 
für ein Boolean ein ganzes Byte...
Und dann kommt noch die wirkliche dynamische Speicherverwaltung über 
"emxEnsureCapacity()" dazu. Und das kann der Compiler tatsächlich nicht 
vorausberechnen, weil es erst zur Laufzeit passiert.

Wenn ich mir das so ansehe, dann fällt mir nur das linke Bild dazu ein.

[name123 (Gast)]

The D. schrieb:
> Hast du diese Code-Wüste selbst geschrieben oder generieren
> lassen? Im
> Ernst: sowas kann man nicht inhaltlich bewerten. Deswegen alternativ:
> kompiliere das mal auf dem PC und starte es im Debugger.

Der Code wurde aus Matlab Code generiert, deswegen ist es nicht ganze 
einfach diesen nachzuvollziehen. Da der Code aber generiert wurde, würde 
ich erstmal davon ausgehen, dass dieser korrekt funktioniert. Aber kann 
der Arduino so lange dafür brauchen, eine 2x5 Matrix aus float Werten im 
NN zu verarbeiten?

Die Arduino IDE hat leider keinen Debugger, wenn es wirklich sein kann, 
dass der Atmega das nicht schafft dann muss ich mal schauen ob ich die 
ganzen Librarys von Arduino finde und das ganze im Atmel-Studio laufen 
lassen.

Hat schonmal jemand versucht eigenen Code auf dem Linux Prozessor vom 
Yun laufen zu lassen, hab in der Arduino Doku nicht wirklich was dazu 
gefunden, nur das es theoertisch möglich ist?

[name123 (Gast)]

Lothar M. schrieb:
> name123 schrieb:
>> Macht es Sinn den Watchdog mal zu aktivieren?
> Sicher nicht, denn wenn du ihn nicht zurücksetzt, dann setzt er
> deinen uC dauernd zurück...

Ja wenn er resettet wird, weiß ich das es zu viel für den uC ist oder 
sehe ich das falsch?

Lothar M. schrieb:
>> Globale Variablen verwenden 819 Bytes (31%) des dynamischen Speichers,
> Du meinst vermutlich das oridinäre RAM.
>> 1.741 Bytes für lokale Variablen verbleiben.
> Ich weiß nicht so recht...
> Allein das hier:
>> boolean_T s_data[7351];
> 7351 Bits sind allein schon 918 Bytes. Und wehe, der Compiler verwendet
> für ein Boolean ein ganzes Byte...
> Und dann kommt noch die wirkliche dynamische Speicherverwaltung über
> "emxEnsureCapacity()" dazu. Und das kann der Compiler tatsächlich nicht
> vorausberechnen, weil es erst zur Laufzeit passiert

Das ist das was mir die Arduino IDE nach dem programmieren des uC 
anzeigt.
der Code soll theoretisch bis zu einer Datensatzlänge von 7351 
funktionieren, in static emxArray_real_T *argInit_d7351x5_real_T() wird 
diese zum Testen erstmal auf 2 gesetzt, warum in NeuralNetwork trotzdem 
jedes mal soviel Speicher blockiert wird. Insgesamt braucht der Sketch 
17.200 Bytes, liegen diese komplett im RAM? Laut Datenblatt hat dieser 
nur 16 KB!

[Joachim B. (jar)]

name123 schrieb:
> Atmega32u4

name123 schrieb:
> Insgesamt braucht der Sketch
> 17.200 Bytes, liegen diese komplett im RAM? Laut Datenblatt hat dieser
> nur 16 KB!

komisch Atmel meint:

SRAM (kBytes): 2.5

http://www.atmel.com/devices/atmega32u4.aspx?tab=parameters

Lothar M. schrieb:
> 7351 Bits sind allein schon 918 Bytes. Und wehe, der Compiler verwendet
> für ein Boolean ein ganzes Byte...

[Michael B. (laberkopp)]

name123 schrieb:
> Ist der Atmega32u4 mit dem neuronalen Netz überlastet

Im Prinzip ja. Floating-Poinnt ist nichts für den. 3-fach geschachtelte 
Schleifen schon gar nicht. Schon der Stack-Speicher wird nicht reichen. 
Mit dem Programm wird das also nichts.

Es hat schon einen Grund, warum man für neuronale Netze gerne 
spezilisierte Prozessoren verwendet.

[Alexander S. (esko)]

Dieser Code ist Schrott, einfach mal den Code unten anschauen.

Man kann dann nur hoffen, dass der GCC-Optimierer einige 
Nachlässigkeiten des Matlab-Code-Generators ausbügelt.

name123 schrieb:
>     if (ixstart < 3) {
>       while (ixstart + 1 < 4) {
>         if (NNfit->data[i + NNfit->size[0] * ixstart] > mtmp) {
>           mtmp = NNfit->data[i + NNfit->size[0] * ixstart];
>           /* dieser Ausruck wird
>           k = ixstart + 1;
>         }
>         ixstart++;
>       }
>     }

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

> Arduino mit neuronalem Netz überlastet?
Probier doch mal im Kopf den Tangens der dritten Wurzel von 4883,0815 zu 
berechnen. Dann weißt Du, wie sich der Ardummino gerade fühlt.

[PittyJ (Gast)]

Anscheinend ist das neuronale Netz vor dem Rechner auch schon 
überlastet.

Es schint es noch was schnelleres dort zu geben, das fähig ist, einen 
Browser zu starten (ein PC?) .
Aber das neuronale Netz soll auf dem langsamsten verfügbaren Rechner 
laufen.


Gestern war so ein Troll da, der ARM Prozessoren suchte und innerhalb 
eines Tages ein Linux portiert hat.

[name123 (Gast)]

Michael B. schrieb:
> Im Prinzip ja. Floating-Poinnt ist nichts für den. 3-fach geschachtelte
> Schleifen schon gar nicht. Schon der Stack-Speicher wird nicht reichen.
> Mit dem Programm wird das also nichts.
>
> Es hat schon einen Grund, warum man für neuronale Netze gerne
> spezilisierte Prozessoren verwendet.


Danke für die Antwort, dann werde ich mich mal nach geeigneter Hardware 
umsehen.

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Da mußt Du mal Dr. Noonien Soong fragen, der hat davon Ahnung.

[Tim . (cpldcpu)]

Ist heute schon Freitag?

Würde vorschlagen für das Thema sowohl Matlab als auch Arduino hinter 
sich zu lassen. Die coolen Kids spielen gerade mit Tensorflow und 
GPU-Accelleration.

[Jim M. (turboj)]

name123 schrieb:
> Die Funktion soll ca. 20 mal pro sekunde aufgerufen werden, ist das
> machbar für dem Atmega oder lohnt es sich wirklich den linux prozessor
> zu verwenden?

Da sind tonnenweise Floats drin, das wird so nix auf dem Atmega - 
außerdem hat der vermutlich auch vielzuwenig RAM.

[... (Gast)]

Am einfachsten einen 8087 Numeric Coprocessor an den ATNega
anschliessen. Für den sind die paar Floats und Double nicht
mal ein Räuspern wert.

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

> ATNega
Wußte gar nicht, daß es den IC auch in weiß gibt... ;)