Algorithmus-Optimierung Meisterschaft. - Seite 52

Neuer Kommentar
 

Warum im zweiten Beispiel importieren?

//+------------------------------------------------------------------+
// тестовая фитнес функция чемпионата, не известна участникам
#import "\\Projects\\OAC\\lib\\ff.ex5"
// запросить количество параметров ФФ 
int    GetParamCountFF (); 
// запуск ФФ, получеие значения соответствующее параметроам ФФ
double FF (double &array []); 
// произведённое количество запусков ФФ
int    GetCountRunsFF (); 
#import
 
Dmitry Fedoseev:

Nun, das könnte ich auch schreiben - was ist an meiner Frage so unklar?

Das war eher eine rhetorische Frage, denn ich bin sicher, Sie verstehen das.

Dmitry Fedoseev:
Warum muss ich eine Frage 10 Mal stellen?

Das ist eine schwierige Frage, das frage ich mich auch oft).

DmitryFedoseev:

Warum brauchen Sie den Import im zweiten Beispiel?

Um den Algorithmus vom Skript aus zu steuern, wird angegeben, wie oft der Algorithmus den FF tatsächlich aufgerufen hat.

Bei der ersten Variante ist es deutlich sichtbar, weil das Skript selbst Aufrufe macht, aber bei der zweiten Variante ist es nicht sichtbar, weshalb wir die Möglichkeit brauchen, vom Skript aus auf die FF-Bibliothek zuzugreifen.

 

Nun möchte ich mich an alle Teilnehmer wenden, die sich als "Neulinge" in diesem Thema sehen und nicht ernsthaft erwarten zu gewinnen.

Wenn wir die ganze verrückte "Theorie" über die vielen Dimensionen des Raums, die das Problem so sehr verwirrt, beiseite lassen und uns der reinen Mathematik zuwenden, sehen wir, dass der FF eine Gleichung ist.

Diese Gleichung wird nur dann zu einer analytischen Funktion, wenn sie auf ein Diagramm angewendet wird.

Es stellt sich jedoch die Frage: SOLLTE es so sein? Ein Diagramm hilft einfach, die Beziehung zwischen den Parametern der Gleichung zu visualisieren.

Nach 158 Seiten Diskussion können wir bereits den Kern des Problems formulieren:

Wir müssen die Werte der Variablen auf der rechten Seite der Gleichung finden, bei denen der Wert der Variablen auf der linken Seite der Gleichung am größten ist.

Das Ziel ist es, dies effizienter zu tun als mit roher Gewalt.

Das war's.

Nächste:

Um dieses Problem zu lösen, wurde eine "evolutionäre" Technik zur Ermittlung von Werten erfunden. Es wurden Analogien und Methoden konstruiert, die aus dem Darwinismus stammen.

Die Frage der Effizienz dieses Ansatzes ist umstritten. Wahrscheinlich gibt es einfachere und effektivere Wege, dieses Problem zu lösen.

Meine Praxis beweist, dass allgemein akzeptierte Ansätze nicht immer die effektivsten sind.

Ich bin sicher, dass wir die "Evolutionisten" ganz gut umgehen können...

Versuchen wir es doch mal!

 

Ein Beispiel für den Algorithmus des Teilnehmers für die zweite Variante des Aufrufs der FF:

#property library
#property strict

//+------------------------------------------------------------------+
// тестовая фитнес функция чемпионата, не известна участникам
#import "\\Projects\\OAC\\lib\\ff.ex5"
// запросить количество параметров ФФ 
int    GetParamCountFF (); 
// запуск ФФ, получеие значения соответствующее параметроам ФФ
double FF (double &array []); 
// произведённое количество запусков ФФ
int    GetCountRunsFF (); 
#import
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void InitAO (int paramCount, int maxFFruns) export
{
  params = paramCount;
  maxFFrunsPossible = maxFFruns;
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void StartAlgo () export
{
  double param []; 
  ArrayResize (param, params);
  double ffVolue = 0.0; 
  
  //------------------------------------------------------------------
  for(int i=0; i< maxFFrunsPossible; i++) 
  {
    GenerateParam (param);
    ffVolue = FF(param);
    if(ffVolue > maxFFvolue) 
      maxFFvolue = ffVolue;
  }
  //------------------------------------------------------------------
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
double GetMaxFF () export
{
  return(maxFFvolue);
}
//+------------------------------------------------------------------+

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Все функции выше этой строки - обязательны! Именно они будут импортированы 
// и использованы тестовым скриптом. Они нужны для доступа к алгоритму оптимизации.
// Содержимое - произвольное, на усмотрение участника
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!



//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Ниже этой строки пример алгоритма оптимизации участника
//————————————————————————————————————————————————————————————————————
int    params     = 0;
int    maxFFrunsPossible = 0;
double maxFFvolue = - DBL_MAX;
double minParam   = -10.0;
double maxParam   = 10.0;
double stepParam  = 0.1;
//————————————————————————————————————————————————————————————————————

//————————————————————————————————————————————————————————————————————
// Генерация значений оптимизируемых параметров
void GenerateParam (double &param[])
{
  int size = ArraySize (param);
  double paramVolue = 0.0;
  for(int i = 0; i < size; i++) 
  {
    paramVolue = RNDfromCI (minParam, maxParam);
    param [i] = SeInDiSp (paramVolue, minParam, maxParam, stepParam); 
  }
}
//————————————————————————————————————————————————————————————————————

//————————————————————————————————————————————————————————————————————
// Выбор в дискретном пространстве
double SeInDiSp (double in, double inMin, double inMax, double step) 
{ 
  if(in <= inMin) 
    return (inMin); 
  if(in >= inMax) 
    return (inMax); 
  if(step == 0.0) 
    return (in); 
  else 
    return (inMin + step * (double)MathRound ((in - inMin) / step));
}
//————————————————————————————————————————————————————————————————————

//————————————————————————————————————————————————————————————————————
// ГСЧ в заданном интервале
double RNDfromCI (double min, double max) 
{ 
  if(min == max) 
    return (min); 
  double Min, Max; 
  if(min > max) 
  {
    Min = max; 
    Max = min;
  }
  else 
  {
    Min = min; 
    Max = max;
  }
  return (double(Min + ((Max - Min) * (double)MathRand () / 32767.0)));
}
//————————————————————————————————————————————————————————————————————

Der Grundcode des Algorithmus ist derselbe wie in der ersten Variante, aber mit dem Aufruf der FF aus dem Algorithmus statt aus dem Skript.

Die Ergebnisse sind natürlich ähnlich wie bei der ersten Variante:

2016.06.22 11:47:45.321 OAC Variante 2 (GBPUSD,M30) ---------------------------------

2016.06.22 11:47:45.321 OAC Variante 2 (GBPUSD,M30) Zeit: 135 µs; 0.00013500 c

2016.06.22 11:47:45.321 OAC Variante 2 (GBPUSD,M30) FF Runs: 1000

2016.06.22 11:47:45.321 OAC Variante 2 (GBPUSD,M30) Max: 2.94159260

2016.06.22 11:47:41.404 OAC Variante 2 (GBPUSD,M30) ---------------------------------

2016.06.22 11:47:41.404 OAC Variante 2 (GBPUSD,M30) Zeit: 136 µs; 0.00013600 c

2016.06.22 11:47:41.404 OAC Variante 2 (GBPUSD,M30) FF Runs: 1000

2016.06.22 11:47:41.404 OAC Variante 2 (GBPUSD,M30) Max: 3.10159260

2016.06.22 11:47:37.309 OAC Variante 2 (GBPUSD,M30) ---------------------------------

2016.06.22 11:47:37.309 OAC Variante 2 (GBPUSD,M30) Zeit: 133 µs; 0.00013300 c

2016.06.22 11:47:37.309 OAC Variante 2 (GBPUSD,M30) FF Runs: 1000

2016.06.22 11:47:37.309 OAC Variante 2 (GBPUSD,M30) Max: 3.06159260

2016.06.22 11:47:32.933 OAC Variante 2 (GBPUSD,M30) ---------------------------------

2016.06.22 11:47:32.933 OAC Variante 2 (GBPUSD,M30) Zeit: 133 µs; 0.00013300 c

2016.06.22 11:47:32.933 OAC Variante 2 (GBPUSD,M30) FF Runs: 1000

2016.06.22 11:47:32.933 OAC Variante 2 (GBPUSD,M30) Max: 3.10159260

2016.06.22 11:47:07.584 OAC Variante 2 (GBPUSD,M30) ---------------------------------

2016.06.22 11:47:07.584 OAC Variante 2 (GBPUSD,M30) Zeit: 180 µs; 0.00018000 c

2016.06.22 11:47:07.584 OAC Variante 2 (GBPUSD,M30) FF runs: 1000

2016.06.22 11:47:07.584 OAC Variante 2 (GBPUSD,M30) Max: 3.04159260

Das heißt - gar nicht schlecht.

 

Die obigen Beispiele zeigen also, wie die Algorithmen der Teilnehmer durch Importfunktionen mit den Testskripten verbunden werden.

Lassen Sie mich daran erinnern, warum genau diese Art der Arbeit mit den Algorithmen der Teilnehmer organisiert ist: Einerseits ist es notwendig, den Algorithmus des Teilnehmers zu verbergen, um das geistige Eigentum zu schützen, und andererseits, um die Kontrolle und Überprüfung sowohl durch die Jurymitglieder als auch durch die Zuschauer zu ermöglichen.

 

Ich werde es heute testen.

Aber es wäre ratsam, die Regeln für die Dateien zusammenzustellen (ich verstehe, Andrei, dass du es eilig hattest) und in einem einzigen Beitrag zu veröffentlichen, mit Anhängen für eben diese Dateien. Nicht unbedingt jetzt, aber um einen Ausgangspunkt zu haben.

 
Реter Konow:

Nun möchte ich an alle Teilnehmer appellieren, die sich als "Neulinge" in diesem Thema sehen und nicht ernsthaft erwarten, zu gewinnen.

Wenn wir all die verrückte "Theorie" über die vielen Dimensionen des Raums, die ein ohnehin schon verwirrendes Problem noch weiter verwirrt, beiseite lassen und uns der reinen Mathematik zuwenden, sehen wir, dass der FF eine Gleichung ist.

Diese Gleichung wird nur dann zu einer analytischen Funktion, wenn sie auf einen Graphen angewendet wird.

Es stellt sich jedoch die Frage, ob dies der Fall sein sollte. Ein Diagramm hilft lediglich dabei, die Beziehungsmuster der Gleichungsparameter zu visualisieren.

Nach 158 Seiten Diskussion können wir bereits den Kern des Problems formulieren:

Wir müssen die Werte der Variablen auf der rechten Seite der Gleichung finden, bei denen der Wert der Variablen auf der linken Seite der Gleichung am größten ist.

Das Ziel ist es, dies effizienter zu tun als mit roher Gewalt.

Das war's.

Nächste:

Um dieses Problem zu lösen, wurde eine "evolutionäre" Technik zur Ermittlung von Werten erfunden. Es wurden Analogien und Methoden konstruiert, die aus dem Darwinismus stammen.

Die Frage der Effizienz dieses Ansatzes ist umstritten. Wahrscheinlich gibt es einfachere und effektivere Wege, dieses Problem zu lösen.

Meine Praxis zeigt, dass die allgemein akzeptierten Ansätze nicht immer die wirksamsten sind.

Ich bin sicher, dass wir die "Evolutionisten" ganz gut umgehen können...

Versuchen wir es doch mal!

Wenn man die emotionale Färbung des Beitrags beiseite lässt, ist das, was Sie gesagt haben, im Grunde wahr. Das Einzige, was Sie vergessen haben zu erwähnen, ist, dass die FF-Gleichung selbst im Rahmen der gegebenen Meisterschaft unbekannt ist (im Leben kann sie bekannt sein oder auch nicht).

Zu den "nicht fiktiven Theorien" - ich habe in diesem Thread klare Hinweise auf die Prinzipien des Optimierungsalgorithmus gegeben, die nirgendwo sonst verwendet werden und noch nie verwendet wurden (zumindest in den verfügbaren Quellen). Und die Wahl bleibt immer dem Forscher überlassen - wie und was er in den Algorithmus einbringt. Im obigen Beispiel geht es um einen Algorithmus, der nicht einmal indirekt mit Darwin zu tun hat. Es gibt viele Optimierungsmethoden und niemand, zumindest habe ich nicht behauptet, dass "von Darwin stammend" besser ist.

Also, viel Glück für die Beginner! Vorwärts, zum Sieg!

 
Ich habe noch nie auf einem Fünfer programmiert und habe auch keine Erfahrung mit Export/Import-Vorgängen. Bitte sagen Sie mir, ob ich Ihr Beispiel richtig verstehe. Ich habe meine Kommentare in den Code eingefügt. Eine andere Frage. Wenn der FF durch eine Formel gegeben wird, dann werden Divisions- oder Wurzelziehoperationen durchgeführt. Eine Null oder ein negativer Wert führt zu einem kritischen Fehler und hält das Programm an.
// -- данный код находится на стороне жюри (организатора)---------------------
#property library    //EX5-файл будет являться библиотекой
#property strict
int  countRuns    = 0;  // число обращений к ФФ. Фитнес функции это, как я понимаю неизвестная никому функция у которой 500 параметров
 // и нужно найти такие значения параметров при которой значение фф= максимальному 
//+------------------------------------------------------------------+
int GetParamCountFF () export //функция задачи участникам количества параметров фф  модификатор export указывает что функция доступна
// алгоритму участника  
{ 
  return (2);// возвращает количество параметров участнику 2 для данного примера 
  // участник в своём коде прописывает  int NumberParam=GetParamCountFF();
}

double FF (double &array []) export // сама фф 
{ 
  countRuns++;
  int sizeArray = ArraySize (array);//количество элементов массива
  //-------дальше не пойму логику----------------- 
  if(sizeArray != 2) 
    return (-DBL_MAX); 
  return (-(pow (2.4 + array [0], 2.0) + pow (array [1] - 2.3, 2.0))+3.1415926);
 //--------------вероятно нужно так --------------
    if(sizeArray != 2){ // возвращает минимальное double ( или может лучше ошибку)
    // если количество элементов в массиве пользователя не равно заданному)
    return (-DBL_MAX);
    } 
    else{ // возвращает значение функции
  return (-(pow (2.4 + array [0], 2.0) + pow (array [1] - 2.3, 2.0))+3.1415926);
  }
  //------------------------------------------------------------------
}

int GetCountRunsFF () export
{ 
  return (countRuns);// возвращает кол. обращений к фф
}
 
Yuri Evseenkov:
Ich programmiere nicht auf A und habe keine Erfahrung mit Export-Import-Vorgängen. Bitte sagen Sie mir, ob ich Ihr Beispiel richtig verstehe. Ich habe meine Kommentare in den Code eingefügt. Eine andere Frage. Wenn der FF durch eine Formel gegeben wird, dann werden Divisions- oder Wurzelziehoperationen durchgeführt. Eine Null oder ein negativer Wert führt zu einem kritischen Fehler und hält das Programm an.

Ja, Sie haben richtig verstanden, wie die FF-Meisterschaft funktioniert.

Die einzige Korrektur betrifft die Rückgabe von Ergebnissen im Falle einer falschen Größe des Parameter-Arrays - der Algorithmus des Teilnehmers kennt die Anzahl der FF-Parameter, und wenn er ein Array falscher Größe an den FF sendet, ist dies das Problem des Algorithmus des Teilnehmers, nicht des FF. Denken Sie über diesen Punkt nach, wenn Sie den Markt als Beispiel nehmen - der Markt wird Sie niemals darüber informieren, dass Sie die "falsche" Anzahl von Strategieparametern bei Ihrem Handel verwenden, Sie werden einfach ein negatives Handelsergebnis erhalten und das war's, ohne dass der Markt eine Erklärung für Ihre Fehler gibt.

Sie können das Wort Dein durch das Wort Unser ersetzen, und Sie können das Wort Du durch Wir ersetzen - nichts wird sich ändern und nichts wird wahr bleiben.

 
Igor Volodin:

Ich werde es heute testen.

Aber es wäre ratsam, die Regeln für die Dateien zusammenzustellen (ich verstehe, Andrei, dass du es eilig hattest) und in einem Beitrag zu veröffentlichen, mit Anhängen für eben diese Dateien. Nicht unbedingt jetzt, aber um einen Ausgangspunkt zu haben.

Wahrscheinlich wäre es praktisch, die Beispieldateien in einem zugänglichen Dateispeicher abzulegen, damit man nicht ständig auf der Suche nach ihnen ist, und einen Link zu diesem Speicher am Anfang des Zweigs zu platzieren.

Ja, ich werde das tun.

1...454647484950515253545556575859...132
Neuer Kommentar