Diskussion zum Artikel "Neuronale Netzwerke: Von der Theorie zur Praxis" - Seite 6

Neuer Kommentar
 
fyords: Natürlich habe ich nichts dagegen, die Feinheiten neuronaler Netze in diesem Thread zu diskutieren, aber ursprünglich war der Artikel für Anfänger gedacht. Er lässt einige Details aus, weil gerade diese Details einen Neuling in Sachen neuronale Netze verwirren können. Natürlich geht der Artikel nicht auf die verschiedenen Methoden des Trainings (der Anpassung) neuronaler Netze ein, aber das ist in der Anfangsphase auch nicht nötig. Wenn Sie feststellen, dass neuronale Netze gar nicht so schwierig sind, ist das kein Grund, sich abzuwenden und zu sagen: "Das ist sehr schwierig und nichts für mich". Wenn Sie mehr wissen, ist das großartig, dann ist der Artikel wahrscheinlich nichts für Sie.

Das Fehlen der Details, nach denen ich oben gefragt habe, hat mich als gewöhnlichen Dummkopf bisher verblüfft. Ich habe den Artikel dreimal durchgelesen, aber die notwendigen Antworten nur im Forum gefunden.

fyords: Der zweite Teil wird sich im Moment mit der Arbeit mit mehrschichtigen neuronalen Netzen befassen, wenn Sie Wünsche zum Inhalt haben, schreiben Sie diese bitte kurz.
Nur eine Frage ist von Interesse: Wie kann man ein selbstlernendes Programm erstellen, das ohne einen "externen" Optimierer auskommt. Wenn so etwas in diesem Stadium möglich ist, natürlich.
 
fyords:

Nach einiger Überlegung wurde beschlossen, den zweiten Teil des Artikels zu schreiben.

Im Moment wird der zweite Teil die Arbeit mit mehrschichtigen neuronalen Netzen behandeln.
Wenn Sie Wünsche zum Inhalt haben, schreiben Sie sie bitte kurz auf.
Die Ideen, die ich mit meinen Fingern vermitteln kann, werden im Artikel beschrieben.

Ich danke Ihnen.

Ich würde gerne die Methode des Gradientenlernens an den Fingern beschrieben sehen.
 
Yedelkin:

Ich nehme "naiv" an, dass es unter russischen Muttersprachlern nicht üblich ist, den Prozess des unabhängigen Lernens als "Parameteranpassung" zu bezeichnen. Ebenso wenig ist es üblich, die Auswahl von Parametern (mit Hilfe von externen Prozessen) für ein beliebiges System als Lernen zu bezeichnen.

Wie auch immer man die Anpassung nennt, sie wird nicht aufhören, eine Anpassung zu sein.

Optimierung, Anpassung und Lernen für neuronale Netze, die mit nicht-stationären Daten arbeiten, sind Synonyme. Denn alle drei Begriffe bedeuten das Gleiche: die Auswahl von Gewichtungskoeffizienten für vergangene historische Daten (Trainingsstichprobe), um Fehler in der Ausgabe des neuronalen Netzes zu minimieren. Wenn es möglich wäre, das Netz mit zukünftigen Daten zu füttern, dann wäre es etwas anderes. Aber in den Geschäften für Büroausstattung gibt es noch keine Zeitmaschinen, also müssen wir die Vergangenheit anpassen.

 
Reshetov:

Wie auch immer Sie eine Anpassung nennen, sie wird nicht aufhören, eine Anpassung zu sein.

Die Umschulung wird auf elementare Weise definiert. Es gibt also keinen Grund, dem Spiegel die Schuld zu geben.
 
Yedelkin:

Nur eine Frage ist von Interesse: wie kann man ein selbstlernendes Programm erstellen, das ohne einen "externen" Optimierer auskommt. Wenn so etwas in diesem Stadium möglich ist, natürlich.

Das ist ganz einfach. Der EA-Code kann das Netz selbst und seinen Optimierer für die Gewichte enthalten, der automatisch gestartet werden kann, wenn neue Daten eintreffen. Unter neuronalen Netzen verstehen wir in den meisten Fällen solche selbstlernenden Netze. Netze, die extern trainiert werden, zum Beispiel durch den Optimierer des Testers, sind Spielzeuge.

 
Leute, helft mir! Habe ich richtig verstanden, dass die Normalisierung der Eingabedaten für den gesamten Trainingszeitraum des Netzes durchgeführt werden sollte? Ich meine, die maximalen und minimalen Werte von xi sollten aus dem gesamten Zeitraum genommen werden?
 
net:
Leute, helft mir! Habe ich richtig verstanden, dass die Normalisierung der Eingabedaten für den gesamten Trainingszeitraum des Netzes durchgeführt werden sollte? Ich meine, die maximalen und minimalen Werte von xi sollten aus dem gesamten Zeitraum genommen werden?
Das ist für die gesamte Trainingsstichprobe erforderlich.
  
//+------------------------------------------------------------------+
//|macd-neuro-example.mq5 |
//| Copyright 2012, MetaQuotes Software Corp. | |
//|http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Experteninitialisierungsfunktion|
//+------------------------------------------------------------------+

#define SIZE 1000

#include <Trade\Trade.mqh>        //Verbinden Sie die Bibliothek für die Durchführung von Handelsoperationen
#include <Trade\PositionInfo.mqh> //Verbinden Sie die Bibliothek, um Informationen über Positionen zu erhalten
#include <Indicators/TimeSeries.mqh>

//--- Werte der Gewichtungskoeffizienten 
input double w0=0.5;
input double w1=0.5;
input double w2=0.5;
input double w3=0.5;
input double w4=0.5;
input double w5=0.5;
input double w6=0.5;
input double w7=0.5;
input double w8=0.5;
input double w9=0.5;
input double w10=0.5;
input double w11=0.5;
input double w12=0.5;

string            my_symbol;         // Variable zum Speichern des Zeichens
double            inputsH[13];        // Array zum Speichern von Eingangssignalen
double            inputsL[13];        // Array zum Speichern von Eingangssignalen
int               periods[13]={2,3,5,8,13,21,34,55,89,144,233,377,610};
int B,Ba;
double            weight[13];        // Array zum Speichern von Gewichtskoeffizienten
double High[SIZE],Low[SIZE];

CTrade            m_Trade;           // Objekt zur Durchführung von Handelsoperationen
CPositionInfo     m_Position;        // Objekt für Positionsangaben
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
int OnInit()
  {

   weight[0]=w0;
   weight[1]=w1;
   weight[2]=w2;
   weight[3]=w3;
   weight[4]=w4;
   weight[5]=w5;
   weight[6]=w6;
   weight[7]=w7;
   weight[8]=w8;
   weight[9]=w9;
   weight[10]=w10;
   weight[11]=w11;
   weight[12]=w12;

   my_symbol=Symbol();
   B=Bars(my_symbol,0);

//--- Rückgabe 0, Initialisierung abgeschlossen
   return(0);
  }
//+------------------------------------------------------------------+
//| Experten-Deinitialisierungsfunktion|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {  }
//+------------------------------------------------------------------+
//| Experten-Tick-Funktion|
//+------------------------------------------------------------------+
void OnTick()
  {

   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);                   // bestes Angebot zum Kauf
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);                   // bestes Angebot zum Verkauf

   B=Bars(my_symbol,0);
   if(B!=Ba)
     {
      CiHigh hi;
      CiLow li;
      hi.Create(_Symbol,_Period);
      li.Create(_Symbol,_Period);
      hi.GetData(0,SIZE,High);
      li.GetData(0,SIZE,Low);
     }
   Ba=B;

     {
      for(int i=0; i<13; i++)
        {
         int HB = ArrayMaximum(High,SIZE-periods[i],periods[i]);
         int LB = ArrayMinimum(Low, SIZE-periods[i],periods[i]);
         if(Bid>=High[HB]) inputsH[i] =1;
         else inputsH[i]=0;
         if(Bid<=Low[LB]) inputsL[i]=1;
         else inputsL[i]=0;
        }

      double outH=CalculateNeuron(inputsH,weight);
      double outL=CalculateNeuron(inputsL,weight);

      //--- wenn der Ausgangswert des Neurons kleiner als 0 ist
      if(outL>0)
        {
         //--- wenn es bereits eine Position für dieses Zeichen gibt
         if(m_Position.Select(my_symbol))
           {
            //--- und der Typ dieser Position ist Verkaufen, dann schließen Sie sie
            if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(my_symbol);
            //--- und wenn der Typ dieser Position Kaufen ist, dann beenden.
            if(m_Position.PositionType()==POSITION_TYPE_BUY) return;
           }
         //--- wenn Sie hier sind, gibt es keine Position, öffnen Sie sie.
         m_Trade.Buy(0.1,my_symbol);
        }
      //--- wenn der Ausgangswert des Neurons größer als oder gleich 0 ist
      if(outH>0)
        {
         //--- wenn es bereits eine Position für dieses Zeichen gibt
         if(m_Position.Select(my_symbol))
           {
            //--- und der Typ dieser Position ist Kaufen, dann schließen Sie sie
            if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(my_symbol);
            //--- und wenn der Typ dieser Position "Verkaufen" ist, dann beenden.
            if(m_Position.PositionType()==POSITION_TYPE_SELL) return;
           }
         //--- wenn Sie hier sind, gibt es keine Position, öffnen Sie sie.
         m_Trade.Sell(0.1,my_symbol);
        }

      if(outH>0.0 || outL>0) Print(outH,"    ",outL);
     }

  }
//+------------------------------------------------------------------+
//|| Neuronenberechnungsfunktion|
//+------------------------------------------------------------------+
double CalculateNeuron(double &inputs[],double &w[])
  {
//--- Variable zur Speicherung der gewichteten Summe der Eingangssignale
   double NET=0.0;
//--- in der Schleife durch die Anzahl der Eingänge die gewichtete Durchschnittssumme der Eingänge ermitteln
   for(int n=0;n<ArraySize(inputs);n++)
     {
      NET+=inputs[n]*w[n];
     }
//--- die gewichtete durchschnittliche Summe der Eingaben mit dem additiven Faktor multiplizieren
   return(ActivateNeuron(NET));
  }
//+------------------------------------------------------------------+
//|| Neuronale Aktivierungsfunktion|
//+------------------------------------------------------------------+
double ActivateNeuron(double x)
  {
//--- Variable zum Speichern des Ergebnisses der Aktivierungsfunktion
   double Out;
//--- hyperbolische Tangensfunktion
   Out=(exp(x)-exp(-x))/(exp(x)+exp(-x));
//--- Rückgabe des Wertes der Aktivierungsfunktion
   return(Out);
  }
//+------------------------------------------------------------------+

Ich habe diese Eule geschrieben. Können wir sagen, dass es ein neuronales Netzwerk ist, denn ich habe meine Zweifel.

Eule für den Handel in den Kanal.

Algorithmus ist wie folgt: extremums sind für die Anzahl der Fibo-Balken (2,3,5,8,13....) genommen. Für jedes Neuron zu kaufen, zum Beispiel - wenn der Preis unter oder gleich dem Preis des Extremums LOW für einen Zeitraum, dann wieder 1 sonst - 0. Weitere, wie im Beispiel mit NeuronMACD. Zu verkaufen - spiegeln das Gegenteil.

Ich bin für die Kritik an den Code und Algorithmus warten.

 
dimeon:

Ich habe diese Eule geschrieben. Können wir sagen, dass es ein neuronales Netzwerk ist, denn ich habe meine Zweifel.

Eule für den Handel in den Kanal.

Algorithmus ist wie folgt: extremums sind für die Anzahl der Fibo-Balken (2,3,5,8,13....) genommen. Für jedes Neuron zu kaufen, zum Beispiel - wenn der Preis unter oder gleich dem Preis des LOW Extremum für einen Zeitraum, geben wir 1 sonst - 0. Weitere, wie im Beispiel mit NeuronMACD. Um zu verkaufen - spiegeln Sie das Gegenteil.

Ich warte auf Kritik an dem Code und Algorithmus.

In Ihrem Fall kann die Funktion der Neuronenaktivierung herausgeworfen werden, es ist eine unnötige Bremse.
return(NET);
Es ist kein neuronales Netz, es ist nur ein Perzeptron. Für ein Netzwerk braucht man mindestens ein paar Perceptrons.
 
her.human:
In Ihrem Fall kann die Neuronen-Aktivierungsfunktion ausgeschaltet werden, eine unnötige Bremse.
return(NET);
Es ist kein neuronales Netzwerk, sondern nur ein Perceptron. Für ein Netzwerk braucht man mindestens ein paar Perceptrons.
Können Sie mir ein Beispiel nennen, z. B. das Hinzufügen eines MA oder eines anderen Indikators oder etwas anderes, und wie man das alles vernetzt?
1234567891011
Neuer Kommentar