Optimierungs-Algo für Multi-Class-Classifier Neuronales Netz?
Backpropagation (copy/paste einer Notiz aus meinem eigenen Algorithmus):
// general delta rule: delta_w_ij = -lambda * error_j * output_i
// with error_j for output neurons: error_j = phi'(net_j) * (output_j- label_j)
// with error_j for hidden neurons: error_j = phi'(net_j) * SUM_k[err_k*w_jk]
// notes:
// - phi'(net_j) is the derivative of the activation function applied to the net input (=sum of weighted inputs)
// - SUM_k[err_k*w_jk] is the sum of all errors of the following layer multiplied by their weights
_________________________________
ob es ein Classifier ist hängt auch vom Label ab; komplizierter ist daran überhaupt nichts
softmax: geht, liefert Dir aber eine Scheingenauigkeit
tanh: geht genauso wie von Dir vorgeschlagen, wundere Dich dann aber nicht, wenn das Netz ständig Ergebnisse wie 0.00000001 ausspuckt und Du damit nur beweist, dass der Markt nicht vorhersehbar ist; testen ob Dein Netz "kaputt" ist oder ob Du einfach versuchst eine Gleichung zu lösen, die keine Lösung hat, kannst Du üben lassen, indem Du zum Spaß mit Daten trainierst wo die Lösung eindeutig ist. Sehr einfach umzusetzen: bau Dir eine simple Funktion, die aus Dezimalzahlen Binärzahlen rechnet, nimm dann die Binärzahl als Input und immer die ursprüngliche Dezimalzahl als Label - so kannst Du eine Trainings-Endlosschleife basteln. Wenn Du dann nach einigen Iterationen (sowas lernt ein NN in Sekundenbruchteilen), dass das Output richtig ist (lässt sich sowohl als Classifier als auch Regressor betreiben), weißt Du, dass das Netz funktioniert. Du wirst so eine Art Testdatensatz für's Debugging in jedem Fall brauchen.
.... und trotzdem verschwendest Du Deine Zeit
Backpropagation (copy/paste einer Notiz aus meinem eigenen Algorithmus):
// general delta rule: delta_w_ij = -lambda * error_j * output_i
// with error_j for output neurons: error_j = phi'(net_j) * (output_j- label_j)
// with error_j for hidden neurons: error_j = phi'(net_j) * SUM_k[err_k*w_jk]
// notes:
// - phi'(net_j) is the derivative of the activation function applied to the net input (=sum of weighted inputs)
// - SUM_k[err_k*w_jk] is the sum of all errors of the following layer multiplied by their weights
_________________________________
ob es ein Classifier ist hängt auch vom Label ab; komplizierter ist daran überhaupt nichts
softmax: geht, liefert Dir aber eine Scheingenauigkeit
tanh: geht genauso wie von Dir vorgeschlagen, wundere Dich dann aber nicht, wenn das Netz ständig Ergebnisse wie 0.00000001 ausspuckt und Du damit nur beweist, dass der Markt nicht vorhersehbar ist
.... und trotzdem verschwendest Du Deine Zeit
Danke dir, darf ich fragen worum es sich bei lambda handelt und was du mit Scheingenauigkeit meinst?
Btw Ich respektiere deinen Ratschlag und muss es einfach fertigbringen :)
grob gesagt:
- sigmoid oder tanh in Kombination mit squared error als cost function sind Standard für regressive Modelle; ReLu und LReLu in diesem Fall evtl. alternativ bei großen (rechenintensiven) Netzen
- softmax mit cross entropy sind Methode der Wahl für Classifier, insbesondere geeignet auch für nicht-binäre Classifier
Letzteres nützt Dir aber nichts, wenn das "wahre" Ergebnis gar keine Klasse angehört - wenn man also z.B. statt kaufen oder verkaufen auch würfeln könnte (der Würfel ist dann auch "scheingenau" - er zeigt z.B. genau eine vier, trotzdem ist diese nur Zufall); wenn Du hingegen ein
regressives Modell als Classifier "missbrauchst" (so herum geht das [denn wenn das Label diskontinuierliche Werte annimmt, sollte das Dein Output ebenso zeigen], anders herum nicht), fällt Dir das sofort auf
edit/Ergänzung: lambda/epsilon/alpha sind alles gängige griechische Buchstaben die gerne für die learning rate verwendet werden
Verschwende deine Zeit nicht mit NNs oder Perceptrons. Ich hab simple Perceptrons getestet. Das bringt nix.
Der Markt ist immer die Nasenspitze vorraus und du hechelst hinterher. Auch die Überoptimierungsfalle lauert!
Price-Action ist imho immer noch das profitabelste.
grob gesagt:
- sigmoid oder tanh in Kombination mit squared error als cost function sind Standard für regressive Modelle; ReLu und LReLu in diesem Fall evtl. alternativ bei großen (rechenintensiven) Netzen
- softmax mit cross entropy sind Methode der Wahl für Classifier, insbesondere geeignet auch für nicht-binäre Classifier
Letzteres nützt Dir aber nichts, wenn das "wahre" Ergebnis gar keine Klasse angehört - wenn man also z.B. statt kaufen oder verkaufen auch würfeln könnte (der Würfel ist dann auch "scheingenau" - er zeigt z.B. genau eine vier, trotzdem ist diese nur Zufall); wenn Du hingegen ein
regressives Modell als Classifier "missbrauchst" (so herum geht das [denn wenn das Label diskontinuierliche Werte annimmt, sollte das Dein Output ebenso zeigen], anders herum nicht), fällt Dir das sofort auf
edit/Ergänzung: lambda/epsilon/alpha sind alles gängige griechische Buchstaben die gerne für die learning rate verwendet werden
verstehe die backpropagation für die hiddenlayers nicht ganz: (kurz auskommentiert wie ich denke wie es gecodet werden soll):
for (int l = Layers; l>0;l--) // für Layer L .... (rückwärts) { int ThisNeurons = NeuronenArray[l]; // neuronen von diesem layer double errortemp =0; for (int j = 0; j<ThisNeurons;j++) //für Neuronen J in diesem Layer { if (l==Layers){ // Wenn wir beim Outputlayer sind Error[j][l] = phi'(NET[j][l]) * (NET[j][l]-Y[j][l]); //berechnen wir den Error des Neurons J delta_w[i][j][l] = -lambda * Error[j][l] * output[i] // Was ist i und :Delta ist der Gradient, also das Neue Gewicht oder um wiviel wir das alte Gewicht ändern müssen } // und was ist Output_i ? das gleiche wie NET[j][l] oder kommt da nochmal ne akrivierfunktion drauf? else { double SUM_k = 0; // => SUM_k[err_k*w_jk] is the sum of all errors of the following layer multiplied by their weights - //-> also die Summe aus den Errors der Neuronen (Error[alle j][l+1]) mulipliziert mit den gewichten aus dem die zum Layer davor verbinden (W[alle i][alle j][l]) ? // wieso? das ganze wurde doch schon damit multipliziert wieso nochmal? oder meinst du das anders? for (int jk = 0; jk<NeuronenArray[l];jk++) // für jedes Gewicht in dem jetzigen Layer (verbunden mit dem nächsten Layer) rictig? { for (int k = 0; k<NeuronenArray[l+1];k++) // für jedes Neuron aus dem nächsten layer {Sum_k += Error[k][l+1]*Weight[k][j][l+1];} // summieren wir den Error des Nächsten Neurons mit dem Gewicht welches den jetzigen mitdem nächsten Layer verbindet } } Error[j][l] = phi'(NET[j][l]) * SUM_k; //der Error dieses Neurons im jetzigen layer ergibt sich aus dem Produkt //aus der abgeleiteten aktivierungsfunktion & der obigen Summe Sum_k richtig? delta_w[i][j][l]= -lambda * Error[j][l] * output[i]; //wie gesagt was ist i und wofür brauchen wir Delta genauergesagt? } // und was ist Output_i ? }sobald ich den backpropagation algo einmal richtig sehe bin ich zu 90% fertig mit diesem Standard MLP und kann mich ( nach den restlichen 10 % ) an wirkungsvolleres wagen
Es ist viel einfacher ein LSTM netz per DLL einzubinden. MLP sind für lange Zeitreihen nicht geeignet.
Ich kann Dir wirklich nicht jedes einzelne Detail erklären. Wenn Du bisher noch nicht einmal über die Deltaregel gestolpert bist, hast Du Deine Hausaufgaben nicht gemacht. Erst Programmieren und danach die Grundlagen erarbeiten.. die Reihenfolge funktioniert nicht.
Wenn ich Dir den ganzen Code schreibe, hast Du nichts davon, denn Du willst ja offenbar etwas lernen.
Ich weiß, dass ich Dir die neuronalen Netze nicht ausreden kann.
- den Tipp mit den online-Lectures von Andrew Ng (Uni Stanford) habe ich Dir gegeben
- zieh Dir ein paar Youtube-Videos rein (z.B. den Kanal von Siraj Raval; ignoriere dort die Python-Beispiele; die allgemeinen Erklärungen sind sehr gut)
- google nach "backpropagation numerical example", dann findest Du konkrete Beispiele an Zahlen vorgerechnet wie's geht (sowas gibt's übrigens auch für LSTMs)
Das eigentliche Programm zu schreiben ist nicht die Kunst, das geht auch in ein paar Stunden, wenn Du vorher ein paar Stunden investiert hast, Dich einzulesen. Die Infos sind alle vorhanden, nur lesen musst Du sie selbst (oder halt als Video-Tutorials).
Nachdem hier im deutschen Forum in letzter Zeit neuronale Netze ein großes Thema waren (Hallo Bayne ;-) ...) möchte ich an dieser Stelle auf eine von mir geplante Artikel-Serie im englischen Forum verweisen, in der ich regelmäßige Updates geplant habe:
https://www.mql5.com/en/forum/319316
Wer kein Englisch spricht kann dort ja auf den "DE" Übersetzungs-Button drücken.
Ich weiß, dass ich mich hier mehrfach sehr skeptisch über das Potential von Zeitreihen-Vorhersage im Trading geäußert habe, weshalb ich mir mit dem Projekt etwas selbst widerspreche. Es kann allerdings auch gut sein, dass ich am Ende zu der Erkenntnis komme "funktioniert nicht".
Mit traditionellen LSTM-Netzwerken hatte ich ja schon früher Erfahrungen, mit der Quintessenz "funktioniert - aber nicht gut genug". Ich hatte allerdings einschichtige LSTMs verwendet. Das ist im Vergleich mit MLPs nicht ungewöhnlich, denn es kann sich trotzdem um "deep networks" handeln, denn die "tiefe" Komponente kann einerseits bedeuten "tief durch die Anzahl der Schichten" oder bei rekurrenten Netzen eben auch "tief in der Zeit". Ich habe inzwischen den Mql5-Code fertig auch für voll vernetzte LSTM-Netzwerke mit beliebig vielen Schichten. Darüber hinaus möchte ich für die Inputs einen Autoencoder (=bottleneck-MLP mit output-refeed) vorschalten, der quasi eine einfachere Representation komplexerer Daten einspeist und das Netzwerk so deutlich leistungsfähiger macht. Ich kann mir vorstellen, dass dieses Konzept dem einfachen LSTM überlegen ist (nicht meine Erfindung, in anderen Bereichen wurde das bereits gezeigt (z.B. sehr interessanter Artikel: Gensler et al., Deep Learning for Solar Power Forecasting - An Approach Using Autoencoder and LSTM Neural Networks, Uni Kassel), ich möchte das allerdings selbst im Trading überprüfen, bevor ich das Konzept verwerfe.
Falls sich jemand dafür interessiert: schaut einfach gelegentlich im englischen Forum vorbei.
Lg,
Chris.
- 2019.08.04
- www.mql5.com
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Hallo, habe das Konzept für Backpropagation weitestgehend verinnerlicht und ebenso das des GradientenAbstiegs (Fehler der Outputs berechnen, daraus fehler der vorherigen Schicht berechnen
(Backpropagation/Optimierung : OutputDelta = Produkt aus Error und partiell abgeleiteter Sgmoid funktion; -> Delta_HiddenLayerDavor = Summe aus (OutputNeuronError * AlleGewichteDesHiddenLayer)* partielle Ableitung der Simoid (wobei Sigmoid durch 1 ersetzt wird, da das Neuron schon aktiviert wurde) usw. -> und anschließend mittels gradient descent (Adjustierung = Gewicht + Produkt aus ErrorDesNeurons, Input & learning rate... (& das gleiche für den bias) )
Wenn ich einen Classifier Output haben möchte wird es jedoch komplizierter:
soweit ich verstehe nutzen wir die letzten 3 ( in diesem Beispiel 3 für buy, nothing oder sell) als Outputvektor (also array) und gleichen dieses mit einem Labelsubarray/vektor (Y) ab.(z.b. [1, 0, 0] oder [0, 1, 0] oder [0, 0, 1])
Da wir jedoch nicht "(ver)kaufen" und "nicht (ver)kaufen" zu gleich ausführen könne fehlt noch ein Schritt nach dem Output, der den höchsten Wert im Vektor = 1 setzt und den rest = 0.
Das ganze wäre sicherlich mit ArrayMax() machbar
A) oder meint ihr die softmax funktion wäre genau das richtige?
jedoch stellt sich die Frage:
B) wie hierdurch der (Output-)Error (pro OutputNeuron) berechnet werden kann. ( einfach vom Zielvektor bzw Labelvektor Y abziehen oder gibt es hierbei einen besseren weg?)
C) ob es nicht noch die Möglichkeit gäbe eine mir unbekannte Aktivierungsfunktion anzuwenden die das ganze auf einen Output (wie etwa 1 für "buy", 0 für "do nothing" und -1 für "sell" runterbricht) (Edit: weiß wer ob das mit der hyperbolic tangent funktion machbar sein könnte? (outputwert von -1 bis 1, dann evtl -0,5 bis 0,5 als 0 runden)
Eigene Ansätze sind selbstverständlich willkommen.