Optimierungs-Algo für Multi-Class-Classifier Neuronales Netz?

Einloggen oder registrieren, um einen Kommentar zu schreiben
Bayne
745
Bayne  

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.

Chris70
122
Chris70  

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

Bayne
745
Bayne  
Chris70:

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 :)

Chris70
122
Chris70  

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

Otto Pauser
1537
Otto Pauser  

@Bayne

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.

Bayne
745
Bayne  
Chris70:

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
0xA0B1 FX5
107
0xA0B1 FX5  
Es ist viel einfacher ein LSTM netz per DLL einzubinden. MLP sind für lange Zeitreihen nicht geeignet.
Bayne
745
Bayne  
0xA0B1 FX5:
Es ist viel einfacher ein LSTM netz per DLL einzubinden. MLP sind für lange Zeitreihen nicht geeignet.
Funktioniert das Teil das auch im Strategietester (habe keine vernünftigen Ansätze wie man einen realistischen Tester in Python selber baut
Chris70
122
Chris70  

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).

0xA0B1 FX5
107
0xA0B1 FX5  
KI trading geht mit FX wunderbar, allerdings muss man sehr gut programmieren können und KI ebenfalls im Detail verstehen. Mal eben schnell machen und Wunder erwarten gibts nicht. Neueinsteiger brauchen mindestens 2-3 Jahre um das Thema zu beherrschen. Und neu ist das auch nicht, LSTM gibts schon seit 20+ Jahren und MLPs seit ca. 50 Jahren.
Einloggen oder registrieren, um einen Kommentar zu schreiben