Hallo,

 

Hier nun das Neurale Plugin.

 

function TNN_frm.anns_load(path: string):integer;
var ann: integer;
begin
ann:= -1;

ann:= f2M_create_from_file (path);

if ann > -1 then
 begin
    debug(1,'Nero: ' + path + ' loaded successfully ');
 end;
 	// Create ANN
 if ann = -1 then
  begin
  ann := f2M_create_standard (4, AnnInputs, AnnInputs, AnnInputs div 2 + 1, 1);
  f2M_set_act_function_hidden (ann, FANN_SIGMOID_SYMMETRIC_STEPWISE);
  f2M_set_act_function_output (ann, FANN_SIGMOID_SYMMETRIC_STEPWISE);
  	f2M_randomize_weights (ann, -1.0, 1.0);
   debug(1,'Nero: ' + path + ' created successfully with handler ');
  end;

 if ann = -1 then
  begin
  debug(0,'ERROR INITIALIZING NETWORK!');
  end;

  result:= ann;
end;

//------

procedure TNN_frm.ann_save(ann: TNetInteger; path: string);
var ret: integer;
begin
   ret := -1;
   ret := f2M_save (ann, path);
   debug(1,'f2M_save(' + inttostr(ann) + ', ' + path + ') returned: ' + inttostr(ret));
end;

//------

procedure  TNN_frm.ann_destroy(ann: TNetInteger);
var ret: integer;
begin
   ret := -1;
   ret := f2M_destroy(ann);
   //ret := f2M_destroy_all_anns();
   debug(1,'f2M_destroy(' + inttostr(ann) + ') returned: ' + inttostr(ret));
end;

//------

function  TNN_frm.ann_run(ann: TNetInteger; vector: TArrayofDouble): double;
var ret: integer;
   outp: double;
begin
   ret := f2M_run(ann, vector);
   if (ret < 0) then
    begin
     debug(0,'Network RUN ERROR! ann=' + inttostr(ann));
     result:= FANN_DOUBLE_ERROR;
    end;

   outp := f2M_get_output (ann, 0);
    debug(1,'f2M_get_output(' + inttostr(ann) + ') returned: ' + floattostr(outp));
   result:= outp;
end;

//------

function TNN_frm.anns_run_parallel(anns_count: TNetInteger; anns: TArrayofInteger; input_vector: TArrayofDouble): integer;
var ret: integer;
begin
   ret := f2M_run_parallel (anns_count, anns, input_vector);

   if (ret < 0) then
    begin
     debug(1,'f2M_run_parallel(' + inttostr(anns_count) + ') returned: ' + inttostr(ret));
    end;

   result:= ret;
end;

//------

procedure TNN_frm.ann_prepare_input(slr1, slr2: TStringlist);
var i: integer;
   res: double;
begin
  res:=0;

  for i := 0 to AnnInputs do   //for (i = 0; i <= AnnInputs - 1; i = i + 3)
   begin
    if (slr1[i] > '') and (slr2[i] > '') then
     begin
      InputVector[i]  := StrToFloat(StringReplace(slr1[i],'.',',',[rfReplaceAll]));
     end;
    end;

end;

//------

procedure TNN_frm.run_anns;
var i: integer;
begin

  if Parallel then
   begin
    anns_run_parallel(AnnsNumber, AnnsArray, InputVector);
   end;

  for i := 0 to AnnsNumber do
   begin
     if Parallel then
      begin
        AnnOutputs[i] := f2M_get_output (AnnsArray[i], 0);
      end else begin
        AnnOutputs[i] := ann_run(AnnsArray[i], InputVector);
      end;
   end;

end;

//------

procedure TNN_frm.ann_train(ann: Integer; input_vector, output_vector: TArrayofDouble);
begin
   if f2M_train (ann, input_vector, output_vector) = -1 then
    begin
    	debug(0,'Network TRAIN ERROR! ann=' + inttostr(ann));
    end;
     debug(1,'ann_train(' + inttostr(ann) + ') succeded');
end;

//------

function TNN_frm.ann_wise_long(): double;
var i: integer;
   ret: double;
begin
   if AnnsNumber < 1 then
    begin
     result:= -1;
    end;

   for i := 0 to AnnsNumber do
    begin
      ret:=  ret + AnnOutputs[i];
    end;

    ret:= 2 * ret / AnnsNumber;

   result:= ret;
end;

//------

function TNN_frm.ann_wise_short(): double;
var i: integer;
   ret: double;
begin

   if AnnsNumber < 1 then
    begin
     result:= -1;
    end;

   for i := 1 to AnnsNumber do
    begin
      ret:=  ret + AnnOutputs[i];
    end;

    ret:= 2 * ret / AnnsNumber;

   result:= ret;
end;

//-------

procedure TNN_frm.Start_Neuro(sl1, sl2: TStringlist);
var i : integer;
begin
if nn_Close then
 begin

 train_output[0]:= 0;

 ann_prepare_input(sl1, sl2);
 run_anns();


 if ann_wise_long() > 0 then
  begin
    Label1.Caption:= 'BUY';
  end;

 if ann_wise_long() < 0 then
  begin
    Label1.Caption:= 'SELL';
  end;


 Label7.Caption:= '.....................'+FormatFloat('0.0000', ann_wise_long());
 Label5.Caption:= '.....................'+FormatFloat('0.0000', ann_wise_short());
 end;


if Order_btn > 0 then
 begin
//---- ist Order Buy ? dann
 { if Order_btn = 1 then
   begin
       train_output[0]:= 1;
     end else begin
       train_output[0]:= -1;
   end; }
//---- ist Order Sell? dann
  if Order_btn = 2 then
   begin
      train_output[0]:= 1;
     end else begin
      train_output[0]:= -1;
   end;
//---- Training
 for i := 0 to AnnsNumber -1 do
  begin
   ann_train (AnnsArray[i], InputVector, train_output);
   Order_btn:=0;
  end;
 end;

end;

//--------

procedure TNN_frm.deinit_Neuro;
var i: integer;
begin

for i := AnnsNumber -1 downto 0 do
 begin
   ann_save(AnnsArray[i], AnnPath + 'CMS-Tradepanel.' + inttostr(i) + '.net');
   ann_destroy(AnnsArray[i]);
 end;
  f2M_parallel_deinit ();

end;


procedure TNN_frm.Einstellung1Click(Sender: TObject);
begin
Form2.Show;
end;

procedure TNN_frm.FormDestroy(Sender: TObject);
begin
nn_Close:= false;

//deinit_Neuro;

end;

procedure TNN_frm.FormShow(Sender: TObject);
var 	LReg:TRegistry;
begin
NN_frm.FormStyle:= fsStayOnTop;

 LReg := TRegistry.Create;
 LReg.RootKey:=HKEY_CURRENT_USER;

 if LReg.OpenKey('Software', True) then
 begin
   if not LReg.KeyExists('CMS_Comaso.de') then
     Exit;
   if LReg.OpenKey('CMS_Comaso.de',true) then
   begin
     if LReg.OpenKey('CMS_Tradepanel',true) then
     begin
       if LReg.OpenKey('Master_frm',true) then
       begin
        if LReg.ValueExists('Width') then
         begin
            Left:= LReg.ReadInteger('Width') + 30;
         end;
          if LReg.ValueExists('Pos_Y') then
           begin
             Top:= LReg.ReadInteger('Pos_Y');
         end;
       end;
     end;
   end;
 end;
init_Neuro;
end;

//-------

procedure TNN_frm.init_Neuro;
var i, ann: integer;
begin
   ann:= -1;
   nn_Close:= true;
   AnnPath := 'C:\ANN\';
   AnnsNumber:= strtoint(Form2.Edit2.Text);
   AnnInputs:= strtoint(Form2.Edit3.Text);

   // Initialize anns
   SetLength(AnnsArray, AnnsNumber +1);
   SetLength(AnnOutputs, AnnsNumber +1);
   SetLength(InputVector, AnnInputs +1);
   SetLength(train_output, 0 +1);

   for i := 0 to AnnsNumber -1 do
    begin
      ann:= anns_load(AnnPath  + 'CMS-Tradepanel.' + inttostr(i) + '.net');
       if ann < 0 then
        begin
          AnnsLoaded := false;
        end;
          AnnsArray[i] := ann;
    end;

   f2M_parallel_init ();

end;

 

Änderungen und Verbesserungen Erwünscht :)

 

So weit so gut. Ich denke, so richtig Intelegend wäre es, wenn das Netzwerk auch den Ausstieg erlernen könnte.

 

Oder was meint Ihr.

 

Gruß Bernd

Hi,

 

kurze Frage: Was für eine Sprache ist das?

 

Bin noch immer nicht ganz schlau geworden was deine Inputparameter sind. Also welche Werte kommen in den InputVector?

Soweit ich das verstehe hast du 4 Schichten wobei die ersten 2 Parametergröße haben, dann halb und 1 Output. Richtig?

Wieso so komplex?

 

So weit so gut. Ich denke, so richtig Intelegend wäre es, wenn das Netzwerk auch den Ausstieg erlernen könnte.

 

sorry aber da musste ich kurz schmunzeln. Natürlich, es wäre super wenn das Netz aufgrund von ein paar Samples (also unter 1000) deine gesamte Strategie lernt inkl. Ausstiege. Aber meine Erfahrung sagt das es schon fast unmachbar ist ihm sowas simples wie die Einstiege beizubringen.

Es handelt sich um Delphi 2010.

 

Hab gesehen das ich noch einen fehler drin hab undzwar hier.

 

procedure TNN_frm.ann_prepare_input(slr1, slr2: TStringlist);
var i: integer;
   res: double;
begin
  res:=0;

  for i := 0 to AnnInputs do   //for (i = 0; i <= AnnInputs - 1; i = i + 3)
   begin
    if (slr1[i] > '') then
     begin
      res  := StrToFloat(StringReplace(slr1[i],'.',',',[rfReplaceAll]));
       if abs(res) > 1 then
        begin
          if res > 0 then
           begin
            InputVector[i] := 1.0;
           end;
           if res < 0 then
            begin
             InputVector[i] := -1.0;
            end;
          end else begin
          InputVector[i] := res;
        end;
     end;
    end;

end;  // so ist es richtig

 

Der input ist ein iRSI(Symbol(), 0, 30, PRICE_OPEN, i)-50/50;

Die daten ligen in einer Stringlist.

 

Gruß Bernd

Was den Ausstieg angeht. deshalb meinte ich ja das Fann2Mql nicht dynamisch genug ist.

Man müsste logischer weise ein zweiten Netz anlegen für den Ausstieg und dann eine Verbindung zwischen den beiden schaffen.

 

Theoretisch müsste es gehen.

 

Bernd

Hier mal der Original Code aus dem Metatrader Forum.

 

//+------------------------------------------------------------------+
//|                                                      FANN-EA.mq4 |
//|                              Mariusz Woloszyn & Yury V. Reshetov |
//|                                           Fann2MQL.wordpress.com |
//|                                       Modify by Yury V. Reshetov |
//+------------------------------------------------------------------+
// 21.12.2009 Äîáàâëåí ïåðåêëþ÷àòåëü TrainOnTesting

#property copyright "Mariusz Woloszyn & Yury V. Reshetov"
#property link      "Fann2MQL.wordpress.com"

// Include Neural Network package
#include <Fann2MQL.mqh>

// Global defines
#define ANN_PATH	"C:\\ANN\\"
// EA Name
#define NAME		"NM"

//---- input parameters
extern double StopLoss = 180.0;
extern int x = 500;
extern double Lots = 0.1;
extern bool TrainOnTesting = True;
extern int DebugLevel = 2;
extern double MaximumRisk        = 0.02;
extern double DecreaseFactor     = 3;
extern int    MagicNumber        = 13053;

static int prevtime = 0;
static int AnnsNumber = 16;
static int AnnInputs = 30;
//static bool NeuroFilter = true;

static double MinimalBalance = 200;
static bool Parallel = false;
static bool SaveAnn = true;

// Global variables

// Path to anns folder
static string AnnPath = "";

// Trade magic number
static int id = 0;

// AnnsArray[ann#] - Array of anns
static int AnnsArray[];

// All anns loded properly status
static bool AnnsLoaded = true;

// AnnOutputs[ann#] - Array of ann returned returned
static double AnnOutputs[];

// InputVector[] - Array of ann input data
static double InputVector[];
//static double InputVector1[];

// Remembered long and short network inputs

void debug (int level, string text) {
   if (DebugLevel >= level) {
     if (level == 0) {
        text = "ERROR: " + text;
     }
     Print (text);
   }
}



/* Load the ANN */

int ann_load (string path) {
   int ann = -1;

   ann = f2M_create_from_file (path);
   if (ann != -1) {
  debug (1, "ANN: '" + path + "' loaded successfully with handler " + ann);
   }
   if (ann == -1) {

     /* Create ANN */
     ann = f2M_create_standard (4, AnnInputs, AnnInputs, AnnInputs / 2 + 1, 1);
     f2M_set_act_function_hidden (ann, FANN_SIGMOID_SYMMETRIC_STEPWISE);
     f2M_set_act_function_output (ann, FANN_SIGMOID_SYMMETRIC_STEPWISE);
     f2M_randomize_weights (ann, -0.4, 0.4);
     debug (1, "ANN: '" + path + "' created successfully with handler " + ann);
                                    //  !!!
   }
   if (ann == -1) {
     debug (0, "ERROR INITIALIZING NETWORK!");
   }
   return (ann);
}


/* Save the ANN */

void ann_save (int ann, string path) {
  if (!SaveAnn) {
     return(0);
  }
  int ret = -1;
  ret = f2M_save (ann, path);
  debug (1, "f2M_save(" + ann + ", " + path + ") returned: " + ret);
}

void ann_destroy (int ann) {
   int ret = -1;
   ret = f2M_destroy (ann);
   debug (1, "f2M_destroy(" + ann + ") returned: " + ret);
}



double ann_run (int ann, double &vector[]) {
   int ret;
   double out;
   ret = f2M_run (ann, vector);
   if (ret < 0) {
     debug (0, "Network RUN ERROR! ann=" + ann);
     return (FANN_DOUBLE_ERROR);
   }
   out = f2M_get_output (ann, 0);
   debug (3, "f2M_get_output(" + ann + ") returned: " + out);
   return (out);
}

int anns_run_parallel (int anns_count, int &anns[], double &input_vector[]) {
   int ret;

   ret = f2M_run_parallel (anns_count, anns, input_vector);

   if (ret < 0) {
     debug (0, "f2M_run_parallel(" + anns_count + ") returned: " + ret);
   }
   return (ret);
}

void ann_prepare_input () {
   int i;
   double res = 0;
 for(i = 0; i < AnnInputs; i++) {
     res = (iRSI(Symbol(), 0, 30, PRICE_OPEN, i) - 50.0) / 50.0; 
     if (MathAbs(res) > 1) {
        if (res > 0) {
           InputVector[i] = 1.0;            
        } else {
           InputVector[i] = -1.0;            
        }
     } else {
        InputVector[i] = res;            
     }
   }
   
   for (i = 0; i < AnnInputs; i++) 
	{
     debug (6, "ann_prepare_input.  Array InputVector(" + i + ") = " + InputVector[i]);
     }
}

// Get Outpust

void run_anns () {
  int i;

  if (Parallel) {
  anns_run_parallel (AnnsNumber, AnnsArray, InputVector);
  }

  for (i = 0; i < AnnsNumber; i++) {
  if (Parallel) {
    AnnOutputs[i] = f2M_get_output (AnnsArray[i], 0);
  } else {
    AnnOutputs[i] = ann_run (AnnsArray[i], InputVector);
  }
 }
}

void ann_train (int ann, double &input_vector[], double &output_vector[]) {
   if (f2M_train (ann, input_vector, output_vector) == -1) {
     debug (0, "Network TRAIN ERROR! ann=" + ann);
   }
   debug (3, "ann_train(" + ann + ") succeded");
}

// PNN section

double ann_pnn() {
   int i;
   double ret;

   if (AnnsNumber < 1) {
     return (-1);
 }

   for (i = 0; i < AnnsNumber; i++) {
     ret += AnnOutputs[i];
   }

   ret = 2 * ret / AnnsNumber;

   Print("Wise result: " + ret);
   return (ret);
}


//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init () {
   int i, ann;
   
   MagicNumber = subGenerateMagicNumber(MagicNumber, Symbol(), Period());    

   prevtime = Time[0];

   if (AnnInputs < 3) {
     debug (0, "AnnInputs too low!");
   }
   // Compute AnnPath
   id = StopLoss;
   
   AnnPath = StringConcatenate (ANN_PATH, Symbol(), "-", id);

   // Initialize anns
   ArrayResize (AnnsArray, AnnsNumber);
   for (i = 0; i < AnnsNumber; i++) {
     ann = ann_load (AnnPath + "." + i + ".net");
     if (ann < 0) {
        AnnsLoaded = false;
     }
     AnnsArray[i] = ann;
   }
   ArrayResize (AnnOutputs, AnnsNumber);
   ArrayResize (InputVector, AnnInputs);

   // Initialize Intel TBB threads
   f2M_parallel_init ();              // !!!

   return (0);
}

//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit () {
   int i;

   // Deinitialize anns
   for (i = AnnsNumber - 1; i >= 0; i--) {
     ann_save (AnnsArray[i], AnnPath + "." + i + ".net");
     ann_destroy (AnnsArray[i]);
   }

   // Deinitialize Intel TBB threads
   f2M_parallel_deinit ();

   return (0);
}

bool trade_allowed () {
  if (!AnnsLoaded) {
  return (false);
}

   /* Trade only on first tick of a bar and there's enough funds */
   if (IsTradeAllowed() && AccountBalance () > MinimalBalance) {
     return (true);
   }

   return (false);
}

//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start () {
 return(0);
   if (prevtime == Time[0]) {
     return(0);
   }
   prevtime = Time[0];
   
   int i = 0;

   double train_output[1];
   
   

   /* Is trade allowed? */
   if (!trade_allowed ()) {
     return (-1);
   }


  int total = OrdersTotal();
  for (i = 0; i < total; i++) {
     OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
     if (OrderSymbol() == Symbol()) {
        return(0);      
     }
  }

  // Adaptive part
  if (IsOptimization()  || (IsTesting() && TrainOnTesting )  ) {  // || IsTesting()  !!!
     total = OrdersHistoryTotal();
     if (total > 0) {
        OrderSelect(total - 1, SELECT_BY_POS, MODE_HISTORY);   
        if (OrderProfit() < 0) 
        {
           if (OrderType() == OP_SELL) 
           {
              train_output[0] = 1; 
           } 
           else 
           {
              train_output[0] = -1; 
           }
           // Learning
           for (i = 0; i < AnnInputs; i++) 
	        {
             debug (6, "Before train.  Array InputVector(" + i + ") = " + InputVector[i]);
             }
           
           for (i = 0; i < AnnsNumber; i++) {
	       ann_train (AnnsArray[i], InputVector, train_output);
	      }
           
        }
     }
  }
  
  /* Prepare and run neural networks */
  ann_prepare_input ();
  // Get Outputs
  run_anns ();
  // Get Results
  double res = ann_pnn();
  
  // Trade
  
  int ticket = 0;
  
  RefreshRates();
  if (res > 0) {
     ticket = OrderSend(Symbol(), OP_BUY, LotsOptimized(), Ask, 2, Ask -  StopLoss * Point, Ask + StopLoss * Point, WindowExpertName(), 0, 0, Blue);
  } else {
     ticket = OrderSend(Symbol(), OP_SELL, LotsOptimized(), Bid, 2, Bid +  StopLoss * Point, Bid - StopLoss * Point, WindowExpertName(), 0, 0, Red);
  }
  if (ticket >= 0) {
     ann_prepare_input ();
  }
  return (0);
}

//******************************************************************************************************

int subGenerateMagicNumber(int MagicNumber, string symbol, int timeFrame)
{
  int isymbol = 0;
  if (symbol == "EURUSD.")       isymbol = 1;
  else if (symbol == "GBPUSD.")  isymbol = 2;
  else if (symbol == "USDJPY.")  isymbol = 3;
  else if (symbol == "USDCHF.")  isymbol = 4;
  else if (symbol == "AUDUSD.")  isymbol = 5;
  else if (symbol == "USDCAD.")  isymbol = 6;
  else if (symbol == "EURGBP.")  isymbol = 7;
  else if (symbol == "EURJPY.")  isymbol = 8;
  else if (symbol == "EURCHF.")  isymbol = 9;
  else if (symbol == "EURAUD.")  isymbol = 10;
  else if (symbol == "EURCAD.")  isymbol = 11;
  else if (symbol == "GBPUSD.")  isymbol = 12;
  else if (symbol == "GBPJPY.")  isymbol = 13;
  else if (symbol == "GBPCHF.")  isymbol = 14;
  else if (symbol == "GBPAUD.")  isymbol = 15;
  else if (symbol == "GBPCAD.")  isymbol = 16;
  else                          isymbol = 17;
  if(isymbol<10) MagicNumber = MagicNumber * 10;
  return (StrToInteger(StringConcatenate(MagicNumber, isymbol, timeFrame)));
  
} 

//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double LotsOptimized()
 {
  double lot=Lots;
  int    orders=HistoryTotal();     // history orders total
  int    losses=0;                  // number of losses orders without a break
//---- select lot size
  lot=NormalizeDouble(AccountFreeMargin()*MaximumRisk/1000.0,1);
//---- calcuulate number of losses orders without a break
  if(DecreaseFactor>0)
    {
     for(int i=orders-1;i>=0;i--)
       {
        if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) { Print("Error in history!"); break; }
        if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
        //----
        if(OrderProfit()>0) break;
        if(OrderProfit()<0) losses++;
       }
     if(losses>1) lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
    }
//---- return lot size
  if(lot<0.1) lot=0.1;
  return(lot);
 }

 

Mit leichten veränderungen.

 

Bernd

Der input ist ein iRSI(Symbol(), 0, 30, PRICE_OPEN, i)-50/50;

Die daten ligen in einer Stringlist.

 

D.h. du entscheidest über den Einstieg rein aufgrund des RSI Verlaufs? Geht das dann nicht einfacher zu automatisieren? ;)

 

 

Man müsste logischer weise ein zweiten Netz anlegen für den Ausstieg und dann eine Verbindung zwischen den beiden schaffen.

 

Theoretisch müsste es gehen.

 

Theoretisch vielleicht, aber einerseits die "Verbindung zwischen den beiden" klingt für mich schwierig andererseits bin ich ehrlich gesagt immer noch skeptisch ob das Netz allein die Entrys lernen kann.

D.h. du entscheidest über den Einstieg rein aufgrund des RSI Verlaufs?

Genau darin sehe ich auch das Problem. Die Anzahl an Parametern aus denen Zusammenhänge erlernt werden sollen ist zu groß, bzw. nur mit dem RSI zu gering. Nach dem Motto: immer wenn ich eine Autobahnauffahrt nehme, beschleunige ich von 50km/h auf (natürlich nur) 120km/h. Wenn ich aber mal von 50km/h auf 120km/h beschleunige, dann muss ich nicht zwangsläufig gerade auf eine Autobahn auffahren

@Mythos

 

Das es auch anders geht ist mir klar. Ich will es ja selber wissen ob das Netz meine Strategie erlernt.

 

Mal eine andere Idee, zwecks Verbinden.

 

 

Ich werd mal versuchen das Umzusetzen.

 

Gruß Bernd

Hallo,

 

Hab mir jetzt mal die Fann2Mql vorgennommen. Es handelt sich meiner meinung nach um ein Recurrentes Netzwerk.

Okay damit geht es wirklich nicht. Dazu benötigt man schon ein Recurrentes Cascade Correlation Netzwerk.

 

Mit diesen sollte es klappen.

 

Gruß Bernd

Mal eine andere Idee, zwecks Verbinden.

 

Die Zeichnung versteh ich nicht ganz. Jeder Kreis ein NN? Sind die Pfeile Outputs?

Hi Mythos,

 

So wie ich es aufgezeichnet habe geht es nicht. Die Daten mengen waren Enorm. Aber wenn ich es hin bekomme ein Recurrentes Cascade Correlation Netzwerk zu entwerfen dann brauche ich die 3 Netzwerke nicht.

 

Gruß Bernd

@Mythos,

 

Was meinst du dazu? Bis jetzt ist ja alles noch Theorie.

 

 

Gruß Bernd

Was meinst du dazu? Bis jetzt ist ja alles noch Theorie.

 

Ehrlich gesagt weiß ich immer noch nicht wie du das jetzt konkret machen willst.

 

Also Entrys nur aufgrund der RSI Werte mit Output Long/Short/None.

Und die Exits? Auch mit RSIs + aktuelle Position als Parameter?

 

Wie Rainworm schon gesagt hat bin ich auch ein bissl skeptisch ob es rein mit den RSIs geht. Man muss auch immer bedenken was ein NN kann/können kann. Zu simple Netze können nit genug, zu komplexe können viel (was man sich dann auch nimmer gut vorstellen kann), neigen daher aber auch dazu auswendig zu lernen.

Hab mal versucht rein aufgrund der letzten Kursdaten einem Netz automatisch per reinforcing traden zu lernen. Hat auf der Trainingsmenge dann auch super geklappt. Aber bei neuen Daten keine Chance.

@Mythos,

 

Du solltest von dem Recurrentes Netwerk wech. Das was du gerade beschrieben hast, ist genau das Pronlem von diesen Netzen.

 

Ich kann es dir ja mal Kurz erklären.

 

Gruß Bernd

@Mythos,

 

Der RSI dient hier nur um eine Simple Daten menge zu bekommen, rein nur zu test zwecken.

 

das Recurrentes Netwerk hat ein (Ein-Taktzyklus Verzögerung), sprich sie speichert den letzten Status

des Neurons und nutzt diesen zur Berechnung der nachfolgendenden Aktivierung.Dies wäre dann vergleichbar mit einem Kurzzeit-Gedächtnis.

 

Nach dem anlegen dieses parallelen Inputs wird der Output berechnet.

Danach ist für das Netz alles berechnet und vergessen.

 

 

Ganz anders bei einem Recurrentes Cascade Correlation Netzwerk.

Darüber hinaus legt dieses netzwerk selbst die Neuronen an.

Es kopiert gute Neuronen, es kann diese auch vervielfältigen.

Es lässt, Bildlich geschrieben, Nervenzellen wachsen und serben.

 

Gruß Bernd

Habs mir grad durchgelesen, klingt spannend.

 

Hast du das Netz selber implementiert oder verwendest eine lib? Und welchen Trainingsalgo verwendest du?

 

Bin auf alle Fälle gespannt obs funktioniert.

@Mythos,

 

Momentan versuche ich, mein eigenes Netz um zu Programieren. Ich hab mir dazu alte Studien Unterlagen raus gesucht.

Man findet leider sehr wenig im Internet dazu.

 

Gruß Bernd

Ich vermute mal in Delphi oder?

Ja was konkrete Implementierungen angeht gibts nicht so viele Dokus. Mir fällt auf die Schnelle auch nix besseres ein als das ganze als Graph zu verwalten.

 

Hast du Infos über den Lernalgo bzw. schon Ideen wie du ihn implementieren willst?

@Mythos

 

Ja Klar,

 

dafür benutzt man eine Abart von genetischen Algorithmen. Statt also immer nur ein Neuron nach dem anderen zu trainieren

und ins Netzwerk einzufügen, werden nun mehrere Kandidaten-Neuron in parallel trainiert. Der beste Kandidat wird nach eine kurzen Trainingsphase ausgewhält.Innerhalb dieser Trainingsphase werden nach und nach bestimmte besonders schlechte

Neuronen-Kandidaten absterben. Andere wiederum werden durch Kreuzung mit den besten Kandidaten genetisch verändert.

 

Also wenn ich das jetzt mathematisch ausdrücke könnte ich ne Doktor Arbeit schreiben. :)

 

Welche Programmiersprache benutzt du?

 

Gruß Bernd

Bearbeitet 7. März 201115 Jr. von Mythos
Beiträge zusammengefügt

Also wenn ich das jetzt mathematisch ausdrücke könnte ich ne Doktor Arbeit schreiben. :)

 

*G* Parallel zu lernen und die besten auswählen klingt gut. Die Frage die bleibt: Welchen Algo verwendet man um jeden einzelnen zu trainieren? Backprop (is leider schon ein bissl her das ich die Vorlesungen hatte, is der einzige der mir noch einfällt, dafür könnt ich den mit Skript mathematisch beweisen ;)?

 

 

Welche Programmiersprache benutzt du?

 

Kommt drauf an für was. Derzeit arbeit ich vermehrt auf Java wegen der "Einfachheit" (vor allem für die TEFEx). Bei NNs hätt ich mit java aber Angst bzgl. Performance. Meine Versuche damals waren in MatLab da es eine praktische NN-Toolbox gibt. Immer einfacher wenn mans nicht selber coden muss ;)

Wenn ichs selber schreiben müsste dann vermutlich in C++.

@Mythos

 

Ich hab dir ne PN geschickt. schau dir das mal an. Und deine Fragen sind beantwortet. :)

 

 

Gruß Bernd

Ich möchte mich nicht einmischen, aber ein Netz ist nur so gut wie sein Anwender.

 

Es geht bei ganz einfachen Aspekten (wie Transferfunktionen) los und hört ggfs. mit der Anzahl der Neuronen auf.

Das "Overfitting" bzw. "Was man falsch machen kann" ist enorm.

 

Meine Empfehlung um sich in dieses Thema einzuarbeiten:

 

1. Matlab Tutorials über ANN durcharbeiten - sehr gute Doku

2. Machine Learning + Code Samples --> http://www-ist.massey.ac.nz/smarsland/MLbook.html

3. google code fragen

 

Dann ggfs. mal schauen, was ist machbar. C# bietet auch ein schönes Framework mit Buch an --> http://www.heatonresearch.com/encog.

Alternativ findet man genug C/C++ Bibliotheken.

 

Hier lese ich mal quer:

 

http://blog.revolutionanalytics.com/2009/09/machine-learning-in-r-in-a-nutshell.html

http://intelligenttradingtech.blogspot.com/ (Buchempfehlungen anschauen)

...

 

http://ecx.images-amazon.com/images/I/41r%2BuNktwnL._SL500_AA300_.jpg

 

PS. Mehrwert vom Netz erkennen, sonst gleich verwerfen. Viele assoziieren so ein Netz mit dem Heiligen Gral bzw. einer Cash-Machine. So ist es definitiv nicht.

 

Alternativ: Daten in eine MySQL besser PostGreSQL Datenbank pumpen bzw. KISS - CSV: PGSQL, RPostGreSQL, R-Bibiliotheken ...

Klassiches Datamining + ANN in R, Weka, Matlab, Python ... Wenn erfolgreich, dann in Delphi, C++ oder implementieren, also für den Produkteinsatz.

 

So kann ein Zauberkasten aussehen (blau - Close, rot - Forecast) Stand Sonntag 6.5.11 Daily EurUsd:

Viele assoziieren so ein Netz mit dem Heiligen Gral bzw. einer Cash-Machine. So ist es definitiv nicht.

So kann ein Zauberkasten aussehen (blau - Close, rot - Forecast) Stand Sonntag 6.5.11 Daily EurUsd:

Dein angehängtes Zauberkastenbild sieht aber schon stark nach denm wh-nischen Gral aus.

Hi wh,

 

Das stimmt, ein Neurales Netz sollte eine trefferquote von über 50% erzielen.

Alles andere wäre nur gut geraten. :)

 

Gruß Bernd

So kann ein Zauberkasten aussehen (blau - Close, rot - Forecast) Stand Sonntag 6.5.11 Daily EurUsd:

 

Blöde Frage: Sicher das nicht blau-Forecast? Weil sonst hast du da ein System das Richtungsänderungen sogar einen Tag zu früh anzeigt. Das wär dann doch sehr interessant!

Kurze Zwischenfrage: welchen Vorteil hat ein neuronales Netzwerk im Gegensatz zum rollierenden Backtest (also z.B. Parameteroptimierung jeden Tag mit den neuen Daten)? Beide basieren auf Vergangenheitswerten. Beide verarbeiten nur die Input-Parameter, mit denen sie gefüttert werden. Der Backtest geht brute-force heran (oder manchmal auch mit einem "cleveren" brute-force), ein neuronales Netzwerk erhängt sich irgendwann an der Datenfülle...