Diskussion zum Artikel "Backpropagation von Neuronalen Netze mit MQL5-Matrizen" - Seite 2

Neuer Kommentar
 
Lorentzos Roussos #:

Ja, aber die Aktivierungswerte werden an die Ableitungsfunktion übergeben, während diese die Voraktivierungswerte erwartet. Das ist es, was ich sagen will.

Ich glaube, du liegst falsch. Die Ableitung wird nach der Formel berechnet, die ich oben angegeben habe: y'(x) = y(x)*(1-y(x)), wobei x der Zustand des Neurons vor der Aktivierung und y(x) das Ergebnis der Anwendung der Aktivierungsfunktion ist. Sie verwenden nicht den Wert vor der Aktivierung, um die Ableitung zu berechnen, sondern das Ergebnis der Aktivierung (y). Hier ist ein vereinfachter Test:

double derivative(double output)
{
  return output * (1 - output);
}

void OnStart()
{
  vector x = {{0.68}};
  vector y;
  x.Activation(y, AF_SIGMOID);                            // erhält das Ergebnis der Aktivierung/Sigmoid als "y(x)" in y[0]
  vector d;
  x.Derivative(d, AF_SIGMOID);                            // Ableitung des Sigmoid nach x erhalten
  Print(derivative(x[0]), " ", derivative(y[0]), " ", d); // 0.2176 0.2231896389723258 [0.2231896389723258]
}
 
Stanislav Korotky #:

Ich glaube, Sie liegen falsch. Die Ableitung wird nach der Formel berechnet, die ich oben angegeben habe: y'(x) = y(x)*(1-y(x)), wobei x der Zustand des Neurons vor der Aktivierung und y(x) das Ergebnis der Anwendung der Aktivierungsfunktion ist. Sie verwenden nicht den Wert vor der Aktivierung, um die Ableitung zu berechnen, sondern das Ergebnis der Aktivierung (y). Hier ist ein vereinfachter Test:

Ja, das ist es, was ich meine, die korrekte Ableitung entspricht der Ableitung, die aus den x-Werten aufgerufen wird.

In der Backprop-Funktion rufen Sie das Äquivalent y.Derivative(d,AF_SIGMOID) auf.

Die Ausgabematrix ist y in der Backprop-Funktion. Ich glaube nicht, dass Sie das Äquivalent von x in einer Matrix speichern, um die Ableitung davon aufzurufen.

(noch einmal, gemäß der mq-Funktion)

--

selbst in deinem Beispiel rufst du die Ableitung von x auf, ich wette, du hast zuerst y eingegeben und dann "hoppla" gemacht

Sag es ihnen einfach im russischen Forum. Es wird vielen Leuten eine Menge Zeit ersparen, wenn sie es in die Dokumentation aufnehmen können.

Danke

 
Stanislav Korotky #:

Ich glaube, Sie liegen falsch. Die Ableitung wird nach der Formel berechnet, die ich oben angegeben habe: y'(x) = y(x)*(1-y(x)), wobei x der Zustand des Neurons vor der Aktivierung und y(x) das Ergebnis der Anwendung der Aktivierungsfunktion ist. Sie verwenden nicht den Wert vor der Aktivierung, um die Ableitung zu berechnen, sondern das Ergebnis der Aktivierung (y). Hier ist ein vereinfachter Test:

Lassen Sie mich dies vereinfachen.

Dies ist Ihr Beispiel

double derivative(double output)
{
  return output * (1 - output);
}

void OnStart()
{
  vector x = {{0.68}};
  vector y;
  x.Activation(y, AF_SIGMOID);                            // erhält das Ergebnis der Aktivierung/Sigmoid als "y(x)" in y[0]
  vector d;
  x.Derivative(d, AF_SIGMOID);                            // Ableitung des Sigmoid nach x erhalten
  Print(derivative(x[0]), " ", derivative(y[0]), " ", d); // 0.2176 0.2231896389723258 [0.2231896389723258]
}

In Ihrem Beispiel rufen Sie x.Derivative auf, um den Ableitungsvektor d zu füllen.

Sie rufen y.Derivative nicht auf, um die Ableitungen zu füllen, warum? Weil es die falschen Werte zurückgibt. (und Sie haben es wahrscheinlich gesehen, deshalb haben Sie x.Derivative verwendet).

Was ist y? die Aktivierungswerte von x.

Wenn Sie dies also tun :

x.Activation(y, AF_SIGMOID);  

Du füllst y mit den Aktivierungswerten von x, aber du rufst die Ableitung nach x und nicht nach y auf (was gemäß der mql5-Funktion korrekt ist).

In Ihrem Artikel ist in der Vorwärtskopplung x 

matrix temp = outputs[i].MatMul(weights[i]);

Und y wären die Aktivierungswerte von x. Welche Matrix ist das?

temp.Activation(outputs[i + 1], i < n - 1 ? af : of)

DieAusgänge. Im Artikel ist y ( von dem Sie die Ableitung im Beispiel nicht aufrufen) die Ausgangsmatrix .

(Was wir im obigen Code sehen, ist das Äquivalent x.Activation(y,AF) aus dem Beispiel, das y mit den Aktivierungswerten füllt)

In Ihrem Backprop-Code rufen Sie x.Derivative nicht auf, weil x(Matrix temp = outputs[i].MatMul(weights[i]);)

nirgendwo gespeichert ist und Sie es nicht aufrufen können. Sie rufen das Äquivalent von y.Derivative auf, das die falschen Werte liefert

outputs[n].Derivative(temp, of)
outputs[i].Derivative(temp, af)

weil y die Aktivierungswerte hat.

Wiederum gemäß der mql5-Funktion.

In Ihrem Beispiel verwenden Sie also den richtigen Aufruf und in Ihrem Artikel den falschen Aufruf.

Vielen Dank

 

Also, du willst das:

   bool backProp(const matrix &target)
   {
      if(!ready) return false;
   
      if(target.Rows() != outputs[n].Rows() ||
         target.Cols() != outputs[n].Cols())
         return false;
      
      // Ausgabeschicht
      matrix temp;
      //*if(!outputs[n].Derivative(temp, of))
      //* return false;
      if(!outputs[n - 1].MatMul(weights[n - 1]).Derivative(temp, of))
         return false;
      matrix loss = (outputs[n] - target) * temp; // Datensatz pro Zeile
     
      for(int i = n - 1; i >= 0; --i) // für jede Schicht außer Ausgabe
      {
         //*// remove unusable pseudo-errors for neurons, added as constant bias source
         //*// (in all layers except for the last (where it wasn't added))
         //*if(i < n - 1) loss.Resize(loss.Rows(), loss.Cols() - 1);
         #ifdef  BATCH_PROP
         matrix delta = speed[i] * outputs[i].Transpose().MatMul(loss);
         adjustSpeed(speed[i], delta * deltas[i]);
         deltas[i] = delta;
         #else
         matrix delta = speed * outputs[i].Transpose().MatMul(loss);
         #endif
         
         //*if(!outputs[i].Derivative(temp, af))
         //* return false;
         //*Verlust = loss.MatMul(gewichte[i].Transpose()) * temp;
         if(i > 0) // Backpropagation des Verlusts auf vorherige Schichten
         {
            if(!outputs[i - 1].MatMul(weights[i - 1]).Derivative(temp, af))
               return false;
            matrix mul = loss.MatMul(weights[i].Transpose());
            // Entfernen unbrauchbarer Pseudofehler für Neuronen, die als konstante Vorspannungsquelle hinzugefügt wurden
            mul.Resize(mul.Rows(), mul.Cols() - 1);
            loss = mul * temp;
         }
         
         weights[i] -= delta;
      }
      return true;
   }

Ich werde darüber nachdenken.

 
Stanislav Korotky #:

Sie wollen also das hier:

Ich werde darüber nachdenken.

Auf den ersten Blick sieht es gut aus, ja. Die Berechnung vor Ort ist schneller als die Speicherung nehme ich an .

👍

 
Lorentzos Roussos #:

Auf den ersten Blick sieht es gut aus, ja. Die Berechnung vor Ort ist schneller als die Speicherung, nehme ich an.

Ich glaube, ich kenne den Grund, warum es ursprünglich über die Ausgabe der Aktivierungsfunktion kodiert ist. In allen meinen früheren NN-Libs und einigen anderen Libs, die ich verwendet habe, werden die Ableitungen über die Ausgaben berechnet, weil es einfacher und effektiver ist (während der Anpassung an die Matrix-API habe ich nicht auf den Unterschied geachtet). Zum Beispiel:

sigmoid' = sigmoid * (1 - sigmoid)
tanh' = 1 - tanh^2
softsign' = (1 - |softsign|)^2

Auf diese Weise müssen wir keine Voraktivierungsargumente (Matrizen) aufbewahren oder sie während der Backpropagation-Phase neu berechnen (wie es in der Korrektur gemacht wird). Ich mag beide Ansätze nicht. Die Berechnung der "Selbstableitung" sieht sozusagen eleganter aus. Daher würde ich es vorziehen, einige Referenzen mit Formeln für Selbstableitungen aller (oder vieler) unterstützter Aktivierungsfunktionen zu finden, und zu meinem ursprünglichen Ansatz zurückzukehren.

Interessanterweise ist es nicht erforderlich, dass die Formel für die Selbstableitung streng von der Aktivierungsfunktion abgeleitet ist - jede Funktion mit gleichem Effekt ist ausreichend.
 
Stanislav Korotky #:

Ich glaube, ich kenne den Grund, warum es ursprünglich über die Ausgabe der Aktivierungsfunktion kodiert wurde. In allen meinen früheren NN-Libs und einigen anderen Libs, die ich verwendet habe, werden die Ableitungen über die Ausgaben berechnet, weil es einfacher und effektiver ist (während der Anpassung an die Matrix-API habe ich nicht auf den Unterschied geachtet). Zum Beispiel:

Auf diese Weise müssen wir keine Voraktivierungsargumente (Matrizen) aufbewahren oder sie während der Backpropagation-Phase neu berechnen (wie es in der Korrektur gemacht wird). Ich mag beide Ansätze nicht. Die Berechnung der "Selbstableitung" sieht sozusagen eleganter aus. Daher würde ich es vorziehen, einige Referenzen mit Formeln für Selbstableitungen aller (oder vieler) unterstützter Aktivierungsfunktionen zu finden, und zu meinem ursprünglichen Ansatz zurückzukehren.

Ja, aber mq hat sich dafür entschieden, es auf diese Weise zu machen, also gilt es für alle Aktivierungsfunktionen.

Mit einfachen Worten, anstatt dass sich die Ableitungsfunktion an die Aktivierungsfunktion "anpasst" (so wie die 3 von Ihnen erwähnten Funktionen die Ausgänge erhalten könnten), haben sie beschlossen, dass die Funktionen sowieso die Werte vor der Aktivierung erhalten. Das ist in Ordnung, das Problem ist, dass es nicht in der Dokumentation steht.

Jeder geht standardmäßig davon aus, dass es sich an den AF anpasst.

Das ist schlecht für jemanden, der neu ist (wie ich zum Beispiel), da er sie "in Angriff nimmt", bevor er überhaupt anfängt.Das, was mich gerettet hat, war, dass ich zuerst ein objektbasiertes Netz aufgebaut habe.

(der Vergleich von objektbasierten und matrixbasierten Netzen wäre auch ein sehr interessanter Artikel und würde vielen Programmierern helfen, die keine Mathekenntnisse haben)

Wie auch immer, ich habe ihn in den Thread eines Moderators gestellt, in dem man Dokumentationsprobleme melden kann.

(off topic : man kann dieses TanH benutzen, es ist schneller und korrekt, denke ich)

double customTanH(double of){
  double ex=MathExp(2*of);
  return((ex-1.0)/(ex+1.0));
}
Interessant ist, dass die Formel für die Selbstableitung nicht unbedingt von der Aktivierungsfunktion abgeleitet sein muss - jede Funktion mit gleichem Effekt ist ausreichend.

Sie meinen, wie ein "Ersatz"?

Zum Beispiel erhält ein Knoten einen Fehler an seinem Ausgang, und Sie kennen die "Fluktuation" des Ausgangs, so dass es funktioniert, wenn Sie ihn auf eine einfachere Aktivierung "verschieben" und ableiten?

Theoretisch wäre es also so, als würde man die Ausgabe "regularisieren", aber ohne dies zu tun und einfach mit der Ableitung der Regularisierung vor der Ableitung der Aktivierung multiplizieren?

Zum Beispiel:

tanh output -1 -> +1 
sigmoid output 0 -> +1 
tanh to sigmoid output = (tanh_out+1)/2.0
and you just multiply by the derivative of that which is 0.5 ? (without touching the tanh outputs at all)
mql5 documentation errors, defaults or inconsistencies.
mql5 documentation errors, defaults or inconsistencies.
  • 2023.04.07
  • www.mql5.com
Page : https://www.mql5.com/en/docs/globals/globalvariabletime This is inexact, GlobalVariableCheck() does NOT modify the last access time. 2023.04...
 
Fehlerbehebung.
Dateien:
MatrixNet.mqh  23 kb
 

Ein Administrator hat auf den Moderatoren-Thread zu diesem Thema geantwortet. Das könnte Sie interessieren

Forum zum Thema Handel, automatisierte Handelssysteme und Testen von Handelsstrategien

mql5 Dokumentation Fehler, Vorgaben oder Ungereimtheiten.

Rashid Umarov, 2023.04.18 11:36

Wird so bald wie möglich verbessert werden. Für eine Weile können Sie diese Include-Datei als Referenz verwenden.

@Stanislav Korotky
 
Stanislav Korotky # : Fehlerbehebung.

@Stanislav Korotky

Ihre Bemühungen, das Konzept des Neuronalen Netzwerks mit MQL zu verbinden, werden sehr geschätzt. Dies ist wirklich ein großartiges Stück Arbeit für Anfänger wie mich. Hut ab :)

Vielen Dank für die Aktualisierung der Datei mit behobenem Fehler. Ich würde jedoch vorschlagen, die Datei im Downloadbereich zu ersetzen.

Glücklicherweise bin ich die Diskussion zu diesem Thema durchgegangen und habe einen Fehler in der Datei gefunden. Und als ich dann nach der Lösung gesucht habe, habe ich diesen Link hier gefunden.

Ich hoffe es gibt nur diese Stellen für den Bugfix bei den Zeilennummern 490-493, 500, 515-527, die ich mit //* markieren konnte. Wenn irgendwo anders bitte Zeilennummern erwähnen oder //*BugFix markieren ...

Mit freundlichen Grüßen

123
Neuer Kommentar