Wie entwickelt man eine profitable Trading-Strategie

Einführung

Der Prozess der Entwicklung der erfolgreichen Handelsstrategien bei der Verwendung der technischen Analyse kann in mehreren Stufen geteilt werden:

1. Das Hinzufügen  der mehreren technischen Indikatoren zum  Preis-Chart eines Finanzinstruments und die Suche nach Gesetzmäßigkeiten in der Form von Marktkorrelationen und Indikatorssignalen;
2. Formulierung der Daten, die aus dem vorherigen Korrelationsschritt erhalten wurden;
3. Konvertierung der Strategie auf eine relevante Programmiersprache, um dadurch ein mechanisches Handelssystem zu bekommen;
4. Verwendung das Handelssystem durch einen Simulator, der auf Basis der History-Daten ist, und versuchen, seine Eingabeparameter auszusuchen (zu optimisiern);
5. Wenn der vorherige Schritt keinen Gewinn gebracht hat, gehen Sie zum Schritt №1;
6. Verwenden Sie das erhaltende System im Demo-Konto, um das System  zu überprüfen;
7. Wenn der vorherige Schritt keinen  Gewinn im Demo-Konto gebracht hat, gehen Sie zum Schritt. №1;
8. Verwendung des Systems im realen Handeln, deren Eingabeparameter wegen der vorläufigen Marktbedigungen ab und zu eingestellt werden sollen.

Das ist im Prinzip alles. Auf dieser Weise kann man das erhaltende System sowie für die Autotrading, auch als Expert Advisor bei dem manuellen Handeln verwendet werden, der die wichtigen Signalen von den technischen Indikatoren geben wird.
      
Und was ist, wenn dieser ganze Prozess auf den Computer geschoben wird? 

Dieser Artikel betrachtet die Verwendung eines einfachen einlagigen neuronalen Netzes, welches die zukünftigen Preisbewegungen auf Basis von den Messwerten des Oszillators Acceleration/Deceleration (AC) identifiziert wird.
      

Neuronales Netz

Was ist ein neuronales Netz oder Perceptron? Das ist ein Algorithmus, der eine lineare Ungleichung verwendet (des linearen Filters), um ein Objekt zu einer Klasse zu bestimmten oder, im Gegenteil, aus einer Objektklasse auszuschließen. Die Ungleichung selber sieht so aus:
      

      w1 * a1 + w2 * a2 + ... wn * an > d,

      
Wo:
      
      wi - Gewichtungskoeffizienten mit dem Index i,

      ai - der Zahlenwert eines Kennzeichens mit dem Index i vom forschenden Objekt,

      d - der Schwellenwert, der oft gleich 0 ist.

      
Wenn die linke Seite der Ungleichung höher als der Schwellenwert ist, dann gehört das Objekt zu einer bestimmten Klasse, wenn sie niedriger ist, dann gehört sie dazu nicht. Im Fall, wenn die Objektsklassifikation eine Sortierung in zwei Klassen vermutet, dann ist ein einlagiges neuronales Netz durchaus ausreichend.
      
Es scheint, dass die verwendete Ungleichung im neuronalen Netz irgendwie ähnlich mit einem magischen Zauberspruch in Bezug auf die Gewichtungskoeffizienten steht. Aber es ist in der Tat nicht so. Das Verwendungsprinzip der neuronalen Netzen hat eine geometrische Bedeutung.

Die Sache ist die, dass die geometrische Ebene von der linearen Gleichung beschrieben wird. Zum Beispiel sieht die Ebenengleichung in einem dreidimensionalen Raum in Bezug auf die Koordinaten X, Y und Z so aus:
      

A * X + B * Y + C * Z + D = 0

Die Koordinaten aller Punkte, die auf einer Seite der Ebene in diesem angeordnet Raum sind, erfüllen die Ungleichung:
      

A * X + B * Y + C * Z + D > 0

Und die Koordinaten aller Punkte, die auf der anderen Seite der Ebene sind, erfüllen die Ungleichung:
      

A * X + B * Y + C * Z + D < 0

Wenn uns also eine Ebenengleichung  und alle Punkte-Koordinaten bekannt sind, können wir  eine Menge aller Punkte  des Raums in zwei  Mengen der Punkte teilen, die mit dieser Ebene getrennt werden.
      
Dann sind die Gewichtungskoeffizienten in der Ungleichung eines neuronalen Netzes - die Konstanten, die eine bestimmte Ebenengleichung in dem mehrdimensionalen Raum von Objektszeichens definieren. Und mit Hilfe dieser Ungleichung können wir genau definieren, ob diese Objekte auf einer oder der anderen Seite der festgelegten Ebene liegen. Es ist nur genug,  die genauen Koordinaten von Objekten zu finden, und sie nachdem in der Gleichung der Ebene zu substituieren, dadurch wird es mit Null verglichen.

Darstellung des Problems

Wenn wir Objekte in zwei Klassen teilen: wie zum Beispiel offene Long-Positionen und Short-Positionen, und als Kennzeichens nehmen wir den Indikatoren-Wert oder Oszillatoren-Wert der technischen Analyse an, dann müssen wir bloß nur eine Ebenengleichung herausfinden und mit ihr die Identifikation durchführen. Die Problemstellung ist klar. 
      
Allerdings gibt es ein Problem, welches für neuronalen Netze typisch ist. Lassen Sie uns zum Beispiel einen zweidimensionalen Raum der Kennzeichens nehmen, der von Koordinaten X und Y beschrieben wird. Setzen wir in diesem Raum Objekte, die genauen Koordinaten haben. 
      

     

            
Das Bild oben zeigt, dass beide Menge von Punkten mit einer Linie getrennt werden kann (eine Linie wird eine Trennlinie in einem zweidimensionalen Raum, aber in drei oder mehren dimensionalen Raum wird sie schon eine Ebene), wenn eine Menge von Punkten (in der roten Farbe) nicht mit einer Menge von Koordinatenpunkten (in der blauen Farbe) kreuzt. Daraufhin können die Gleichungen dieser Trennlinien unterschiedlich sein. Und nun ein anderes Beispiel:
      

     

      
Wir können jetzt sehen, dass  die Menge von Punkten im Raum gekreuzt werden, und es ist nicht möglich, eine sichtbare Trennlinie zwischen ihnen zu ziehen. Die einzige passende Lösung wäre, eine Linie zu zeichnen, die beiden Menge von Punkten so trennen würde, so dass die Mehrheit der roten Objekte auf einer Seite bleiben könnten, und die blauen Objekte - auf der anderen Seite. Dieses Mal haben wir mit einer Optimierungsaufgabe zu tun, das heißt, es wird nach einer Gleichung gesucht, die eine Ebene oder Linie trennen könnte, sie muss auch eine maximale Trennung zwischen zwei Objektenklassen machen können, aber mit Wahrscheinlichkeit, dass einige Punkte mit Zugehörigkeit zu einer Klasse, werden fälschlicherweise als die Punkte mit Zugehörigkeit zu einer anderen Klasse identifiziert. 
      
Es gibt auch andere Wege, neuronale Netze zu realisieren, und zwar über nichtlineare Filter und mehrschichtige Netze. Nichtlinear Filter ermöglichen als eine Trenngrenze zwischen Objekten aus verschiedenen Klassen eine Trennebene der höhen Reihe zu verwenden. Mehrschichtige Netze bedeuten die Verwendung der mehreren Filter (Trennebenen oder -flächen) für die Objektenidentifizierung, die zu drei oder mehren Klassen gehören.
      
Lassen Sie uns versuchen, eine Aufgabe zu definieren, die wir lösen möchten. Natürlich ist das, was ein Händler für ein profitables Trading wissen soll, - sind die Richtungen der Preisbewegungen. Das heißt, wenn ein Preis nach oben geht, soll eine Long-Positiion eröffnet werden. Wenn es nach unten geht, soll eine Short-Position eröffnet werden. Deshalb haben wir bereits zwei Klassen von Objekten, nämlich die Richtungen der Preisbewegungen. Um eine Entscheidung nach der technischen Analyse zu treffen, benutzen Händler die Forschungen der so genannten technischen Indikatoren oder Oszillatoren. Wir analysieren auch den Oszillator namens AC. 
      
Da technische Oszillatoren Histogrammen sind, deren Werte von einer horizontalen Linie abweichen, brachen wir auch ein neuronales Netz mit einem linearen Filter. Wir werden als Kennzeichens eines Objekts Muster verwenden, das heißt die Werte des Oszillators  an vier Punkten, die mit Schritt in  sieben Zeiträumen zurück in der History genommen werden, ab dem momentanen Zeitpunkt.     

           
Der Wert des Oszillators ist im obigen Bild mit einem Kreis in der Figur markiert. Wir identifizieren sie als a1, a2, a3 und a4 und substituieren sie in der Gleichung der Trennebene, danach werden wir den erhaltenen Wert mit Null vergleichen, um davon zu erfahren, auf welcher Seite das Muster sein wird.
      
Wir müssen jetzt nur noch die Ebenengleichung finden, die die Muster der vorhergehenden Aufwärtskursbewegung von den Mustern der vorhergehenden Abwärtspreisbewegung trennen wird.
      
Zu diesem Zweck werden wir den in MetaTrader4 eingebauten genetischen Algorithmus verwenden, der für die Beschleunigung der Optimierungsprozesse vorgesehen ist. Mit anderen Worten, werden wir die Werte der Gewichtungskoeffizientenn vom linearen Filter in einer solchen Weise auswählen, damit wir schließlich die Trennlinie-Gleichung für die maximale Balance der Optimierungsstrategien auf Basis von Historydaten verwenden könnten.
      
Zu diesem Zweck brauchen wir zumindest eine Formulierung einer Handelsstrategie, mit der wir einen Algorithmus realisieren könnten und den im Expert Advisor-Code für MetaTrader 4 konvertieren.
      
In der Theorie sollte ein Handelssystem sowohl Signale für den Markteintritt, auch für den Ausgang des Marktes geben können. Jedoch sind die Ausgangssignale nicht nötig und können unter den folgenden Bedingungen vermieden werden:

1. Die Setzung der Stop Loss-Orders - takeprofit und stoploss;
2. Die Wende in die entgegengesetzte Richtung wegen einem Signalsempfang über eine Richtungsänderung in dem Markttrend.

Um zu vermeiden, das Handelssystem zu komplizierte zu machen, werden wir die Ausgaben für die Schutzstops verwenden - Verlust und Umkehrsignale zu stoppen. In diesem Fall wird das neuronale Netz nur zwei Ausgangssignale nach Vorzeichenwerten für Objekte geben, und nämlich:       

• Die Preise dürften nach oben bewegen;
• Die Preise dürften nach unten bewegen.

Das vereinfacht die Aufgabe, die Objekte für neuronale Netze zu identifizieren, indem sie alle in zwei Klassen geteilt werden. Der Optimierungsprozess des Handelssystems können auch durch das Ausschließen  der Kontrolle von Gewinnmitnahmen Orders (Take Profit)  vereinfacht werden, das heißt, vermeiden noch einen anderen Eingabeparameter auszuwählen. In diesem Fall ist es ausreichend, Trailing-Stops zu verwenden, das heißt Stop-Loss auf die profitable Seite nach und nach zu setzen, bis das neuronale Netz ein entgegengesetztes Signal sendet oder einen Fehler macht. Jeder Fehler des neuronalen Netzes wird den Schutzstop auslösen. Darüber hinaus wird das Auftragsmanagementsystem komplizierter. Schnelle Positionswende in eine entgegengesetzte Richtung wird am besten durch einen entgegneten Order mit einer doppelten Menge der Lots durchgeführt und einem nachfolgenden Schließen einer gegenüberliegen Position. Dieses Manöver ermöglicht allen Operationen sofort nach der Wende zu erledigen, sobald ein Signal vom neuronalen Netz empfängt wird.

Um die Anzahl der falschen neuronalen Netzsignalen zu reduzieren, werden wir ihre Registrierung und ihre Aufführung basierend nur auf bereits gebildeten Bars und Erröfnungspreise der gleichen Bars durchführen.

Aufgabelösung

Hier finden Sie den  Quellcode des Expert Advisors, der diese Handelsstrategie realisiert:

//+------------------------------------------------------------------+
//|                                       ArtificialIntelligence.mq4 |
//|                               Copyright й 2006, Yury V. Reshetov |
//|                                         http://reshetov.xnet.uz/ |
//+------------------------------------------------------------------+
#property copyright "Copyright й 2006, Yury V. Reshetov ICQ:282715499  http://reshetov.xnet.uz/"
#property link      "http://reshetov.xnet.uz/"
//---- input parameters
extern int    x1 = 120;
extern int    x2 = 172;
extern int    x3 = 39;
extern int    x4 = 172;
// StopLoss level
extern double sl = 50;
extern double lots = 0.1;
extern int    MagicNumber = 888;
static int prevtime = 0;
static int spread = 3;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   if(Time[0] == prevtime) 
       return(0);
   prevtime = Time[0];
//----
   if(IsTradeAllowed()) 
     {
       spread = MarketInfo(Symbol(), MODE_SPREAD);
     } 
   else 
     {
       prevtime = Time[1];
       return(0);
     }
   int ticket = -1;
   // check for opened position
   int total = OrdersTotal();   
   for(int i = 0; i < total; i++) 
     {
       OrderSelect(i, SELECT_BY_POS, MODE_TRADES); 
       // check for symbol & magic number
       if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) 
         {
           int prevticket = OrderTicket();
           // long position is opened
           if(OrderType() == OP_BUY) 
             {
               // check profit 
               if(Bid > (OrderStopLoss() + (sl * 2  + spread) * Point)) 
                 {               
                   if(perceptron() < 0) 
                     { 
                       // reverse
                       ticket = OrderSend(Symbol(), OP_SELL, lots * 2, Bid, 3, 
                                          Ask + sl * Point, 0, "AI", MagicNumber, 
                                          0, Red); 
                       Sleep(30000);
                       if(ticket < 0) 
                         {
                           prevtime = Time[1];
                         } 
                       else 
                         {
                           OrderCloseBy(ticket, prevticket, Blue);   
                         }
                     } 
                   else 
                     { 
                       // trailing stop
                       if(!OrderModify(OrderTicket(), OrderOpenPrice(), 
                          Bid - sl * Point, 0, 0, Blue)) 
                         {
                           Sleep(30000);
                           prevtime = Time[1];
                         }
                     }
                 }  
               // short position is opened
             } 
           else 
             {
               // check profit 
               if(Ask < (OrderStopLoss() - (sl * 2 + spread) * Point)) 
                 {
                   if(perceptron() > 0) 
                     { 
                       // reverse
                       ticket = OrderSend(Symbol(), OP_BUY, lots * 2, Ask, 3, 
                                          Bid - sl * Point, 0, "AI", MagicNumber,
                                          0, Blue); 
                       Sleep(30000);
                       if(ticket < 0) 
                         {
                           prevtime = Time[1];
                         } 
                       else 
                         {
                           OrderCloseBy(ticket, prevticket, Blue);   
                         }
                     } 
                   else 
                     { 
                       // trailing stop
                       if(!OrderModify(OrderTicket(), OrderOpenPrice(), 
                          Ask + sl * Point, 0, 0, Blue)) 
                         {
                           Sleep(30000);
                           prevtime = Time[1];
                         }  
                     }
                 }  
             }
           // exit
           return(0);
         }
     }
   // check for long or short position possibility
   if(perceptron() > 0) 
     { 
       //long
       ticket = OrderSend(Symbol(), OP_BUY, lots, Ask, 3, Bid - sl * Point, 0, 
                      "AI", MagicNumber, 0, Blue); 
       if(ticket < 0) 
         {
           Sleep(30000);
           prevtime = Time[1];
         }
     } 
   else 
     { 
       // short
       ticket = OrderSend(Symbol(), OP_SELL, lots, Bid, 3, Ask + sl * Point, 0, 
                      "AI", MagicNumber, 0, Red); 
       if(ticket < 0) 
         {
           Sleep(30000);
           prevtime = Time[1];
         }
     }
//--- exit
   return(0);
  }
//+------------------------------------------------------------------+
//|  The PERCEPRRON - a perceiving and recognizing function          |
//+------------------------------------------------------------------+
double perceptron() 
  {
   double w1 = x1 - 100.0;
   double w2 = x2 - 100.0;
   double w3 = x3 - 100.0;
   double w4 = x4 - 100.0;
   double a1 = iAC(Symbol(), 0, 0);
   double a2 = iAC(Symbol(), 0, 7);
   double a3 = iAC(Symbol(), 0, 14);
   double a4 = iAC(Symbol(), 0, 21);
   return (w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4);
  }
//+------------------------------------------------------------------+

 
Jetzt müssen wir nur die Gewichtungskoeffizienten der linearen Gleichung von der Trennebene für ein neuronales Netz auswählen. Lassen Sie uns den Strategie-Tester durch die Kombination Ctrl + R starten:
            

Im Titel Settings wählen wir ein Marktmodell der Emulation mit einer schnellen Methode nur durch die Eröffnungspreise aus (denn die Signale in unserem EA werden nur auf den gebildeten Bars registriert). Setzen wir das Hacken in Recalculate und Optimization. Und klicken danach auf Expert properties.
      
Der Titel Testing:
      

     
Wir stellen als das Anfangsdeposit mit höher $ 3.000, die Optimierung und den Test werden wir über langen und kurzen Positionen durchführen. Als Hauptkennzeichen der Optimierung nehmen wir den maximalen Wert der Balance während der Testzeit. Auch sollte ein genetischer Algorithmus angemacht werden, um den Optimierungsprozess zu beschleunigen.

Der Titel Inputs:
      

      
Setzen wir auch die Hacken auf den Eingabeparameter, die vom genetischen Algorithmus ausgewählt werden: x1, x2, x3 und x4 für Gewichtungskoeffizienten des neuronalen Netzes, auch müssen wir den akzeptablen Wert sl auswählen - die Ebene stoploss. Die Anzahl der Lots lassen wir in 1, und die magische Zahl wird standardmäßig eingestellt.

Der Titel Optimization:
      

      
Um den Optimierungsprozess zu beschleunigen, wird der maximale Drawdown auf dem Niveau von 35% aufgebaut. Zur Präzisierung der akzeptablen Niveaus eines Maximum Drawdowns ist es zuerst notwendig, den Optimierungsprozess ohne Einschränkungen zu starten. Erst nachdem, wie die ersten Optimierungsergebnisse erhalten werden, muss einen Wert genommen werden, aufgerundet, und nach dem Stopp des Prozesses müssen Einschränkungen eingegeben werden. Die erneut gestartete Optimierung wird wesentlich schneller laufen.
      
Klicken Sie auf OK, um die Experteneinstellungen zu schließen. Jetzt können wir den Optimierungsprozess durch Drücken auf die Start-Taste starten. Es ist auch besser, die Ausgabe der nutzlosen Ergebnisse zu deaktivieren:
      

      
Wenn der Computer schwach ist und hat einen kleinen RAM, dann ist es besser, während des Optimierungsprozesses Informationen im Journal gelegentlich zu löschen.
      

      
Auf Pentium III fordert den gesamte Optimierungsprozess etwa über eine Stunde. Die Zeit hängt von dem Finanzinstrument ab.
     

      
Man soll nun nur mit der rechten Taste auf die oberen Zeile klicken und den Test über History-Daten  starten lassen, welcher durch die Auswahl des  Set Input Parameters aus dem Popup-Menü aktiviert wird.
      
Es besteht kein Zweifel, dass die Testergebnisse Daten mit Ergebnissen gleich werden, die der Optimierer gegeben hat. 
      
Wir möchten diese Ergebnisse hier veröffentlichen. Aber jeder kann äußern, dass die Informationen einfach auf die History-Daten angepasst werden könnten. Und wie wird die erhaltene Strategie bei der Marktveränderung verhalten? Wie aktuell sind die Muster in der Zukunft, die von den letzten Perioden erhalten wurden? Nehmen wir zum Beispiel die Teilnahme an der Autotrading-Meisterschaft, denn Regeln verbieten ja, die Eingabeparameter zu ändern oder mir etwas hinzuzufügen, solange die Meisterschaft nicht vergeht.
      
Lassen Sie es uns versuchen, machen wir ein Experiment. Dafür wird das neuronale Netz auf den History-Daten trainiert werden, die als eine repräsentative Probe entnommen werden, aber wir schließen die Daten von den letzten drei Monaten aus. Zu diesem Zweck werden wir eine eingebaute Einschränkung im Tester nutzen, welche die Optimierungsphase und den Test von Terminen ordnet.

      
Starten wir den Optimierungsprozess. Wir werden die Ergebnisse für die Eingabeparameter erhalten: x1 = 146, x2 = 25, x3 = 154, x4 = 121, sl = 45.

     

Jetzt werden wir die erhaltene Strategie für diesen Zeitraum überprüfen, in dem es nicht optimiert wurde und konnte keine Annahmen haben, das heißt, drei Monate später nach der Optimierungsphase. Wir nehmen einfach das Hacken von "Use date" weg und schauen wir, wie die Strategie weiter handeln wird:

           

Das Ergebnis spricht für sich selbst. Die Strategie gab schließlich Gewinn. Klar ist der Gewinn weniger im Vergleich mit dem Gewinn, den man am Anfang der Meisterhaft hatte. Aber wir  sollten jedoch daran denken, dass die Kapital- und Risikomanagement im EA nicht angewendet werden, es sind nur Positionen mit einer festgelegten Menge von Lots vorgesehen.  Darüber hinaus sollten die Überoptimierung im realen Handeln viel öfter durchgeführt werden als einmal alle drei Monate. 

Schlussfolgerungen

Gut, aber wie soll man die Schlussfolgerungen bezüglich der neuronalen Netze begreifen, die von. D. Katz und D. McCormick. in ihrem Buch "The Encyclopedia of Trading Strategies" gezogen wurden?
      
Na erstens gibt es ein Prinzip: Vertrauen ist gut, Kontrolle ist besser. Die so genannten Aktivitäten von D. Katz und D.McCormick sind in Grunde so gebaut worden, um die Möglichkeit diesen Test zu vermeiden. Mit anderen Worten, das ist ein unwissenschaftliches Prinzip, die Fortpflanzung ausschließt. Es ist verständlich, wenn einige Leute Geschäfte mit Verlagshäusern machen, anstatt mit Trading. Ihre Aufgabe ist es, erfolgreich ihr Manuskript zu verkaufen, egal was in ihrem Inhalt steht. Den Sinn dabei zu verstehen, ist ziemlich einfach, sie wollten nur den Schrott, Papier in der Art "500 nutzlose Ratschläge" mit Zahlen schreiben. Versuchen wir es besser zu verstehen.

• Die Problemstellung von D.Katz und D.McCormick bestand darin, um einen mystischen Indikator zu erstellen, genauer gesagt, einen zeitumgekehrten  Stochastik mit langsamen % K, der in der Tat wie eine Zeitmaschine wirkt und nimmt Informationen für 10 Bars im Voraus und gibt dadurch seinen Messwert für 10 Bars zurück. Wenn ich diesen Indikator hätte, könnten Bill Gates und George Soros mit mir gar nicht konkurrieren;
• Der nächste Schritt war, einige Daten zu übernehmen und mit den telepathischen Fähigkeiten des Stochastiks Prognosen zu erhalten. Sie haben bereits die Annäherungsaufgabe gesetzt, das heißt,  die Werte der Funktion durch die Funktionsargumente zu bekommen. Annäherung ist in der Tat, die Anpassung (Nacharbeit), die Katz und McCormick so pointiert auf den Seiten ihres Manuskripts diskutiert hatten;
• Es ist nicht so sehr wichtig, wie die Approximation erhalten wurde, wichtiger ist es, dass neuronale Netze für dieses Ziel nicht geeignet sind. Es wäre viel einfacher, die gleiche Aufgabe beispielsweise durch eine Spektralanalyse zu lösen;
• Neuronale Netze wirken noch schlimmer mit Interpolations und Extrapolations Aufgaben, und wenn wir Daten aus einer repräsentativen Stichprobe nehmen, dann bekommt man die Extrapolation, anstatt eine Zugehörigkeit zu einer bestimmten Klasse;
• Nachdem es eine Art der telepathischen stochastischen Approximation bekommen wurde, deren Realisierung offensichtliche Fehler enthalten, Katz und McCormick gingen weiter und auf der Grundlage der Messungen dieses fehlerhaften Geräts haben sie eine "Trading-Strategie" erstellt, die auch diese Messwerte vom defekten Gerät interpretieren  musste, nämlich, wenn %K bestimmte Grenzen überschritten sollten, dann sollten wahrscheinlich Preise Maximal- oder Minimalwerte erreicht haben. Danach wurde alle dieser Wahnsinn in einem mechanischen Handelssystem eingesteckt, wo Statistiken und voreilige Schlüsse erhalten wurden, eben das haben die Autoren ihren Lesern zum Lesen vorgeschlagen.

Die Ergebnisse kamen sofort. In repräsentativen Proben gab es noch einen gewissen Fortschritt, jedoch außerhalb dieser Gruppe ist die Möglichkeit, Profit zu machen, war begrenzt und brachte nur Verluste.

Doch es war nicht nur Katz und McCormick, die Pech bei den Experimenten mit neuronalen Netzen bekommen haben. Das erste Projekt des neuronalen Netzes namens "Perceptron" brachte auch keine Ergebnisse, die von ihm erwartet wurden. Bei Frankenstein passierte es genauso, also aller Anfang ist schwer. Eine spätere objektive Analyse über die Fähigkeiten und Behinderungen eines neuronalen Netzes  wurde von M. Minsky und S. Papert [1] durchgeführt. Deswegen, bevor Sie anfangen, eine Aufgabe auf Basis von neuronalen Netzen zu lösen, geben Sie etwas Mühe, die gleichen Fehler nicht zu machen:

1. Die Problemstellung sollte nicht telepathische Zukunftsprognosen enthalten, um bloß eine präzise Antwort auf die Frage zu bekommen, wann und wie viel. Die Lösung sollte in Form einer Sortierung in wenigen exklusiven möglichen Situationen auf Basis der aktuellen Kennzeichens sein, so müssen sie identifiziert werden. Zum Beispiel, wenn Sie eine Aufgabe über das Wetter haben, dann versuchen Sie nicht herauszufinden, wann genau der Regnen beginnt, oder das, wie viele Niederschläge in Millimeter fallen soll. Machen Sie Ihre Prognose  möglichst von der Situation auf eine Änderung, also es kann sonnig oder  regnerisch sein;
2. Schneiden Sie alle unnötigen mit "Ockhams Rasiermesser".  Einige Experimentatoren glauben so, je mehr Schichten das neuronale Netz hat und je komplizierte seine Aktivierungsfunktionen sind, desto bessere Ergebnisse sind. Auf diese Weise können Sie sicher eine genauere Trennlinie zwischen den identifizierten Objekten nach ihren Kennzeichen ziehen. Niemand streitet darüber. Aber wieso? Schließlich ist ein solches Prinzip gleichwertig mit Sandburgen. Wenn die Grenze  eine definierte Form hätte, die in der Zeit konstant und unabhängig von anderen Umständen bliebe, dann hätte die Komplexität  zwecks einer maximieren Verfeinerung einen Sinn. Aber die meisten Probleme, die mit Hilfe von neuronalen Netzen gelöst werden, gehören zu dieser Kategorie nicht. Die Finanzinstrumente bleiben auch nicht immer stehen. Von daher kann ein einfaches neuronales Netz mit einer geringen Anzahl von Eingängen und einer einzigen Schicht akzeptabler sein als eine komplizierte Konstruktion mit einer Einmaligen-Effizienz.

Das ist eigentlich alles, was ich in diesem Artikel sagen wollte.

Referenzen

1. Minsky, M. and Papert, S. (1969) PERCEPTRON; an Introduction to Computational Geometry, MIT Press, Massachussetts (Übersetzungen: M. Minsky M., Papert. S. Persepteroni: Übersetzung. von Eng. - M.: Mir, 1971 - S. 261).