Diskussion zum Artikel "Optimierungsmethoden der ALGLIB-Bibliothek (Teil II)" - Seite 2

Neuer Kommentar
 

Suchen Sie nach der Hautfunktion aus dem Artikel mit der lbfgs-Methode.




Ich habe nicht verstanden, über welche tausend Parameter wir sprechen. Wenn Sie ein Beispiel für eine solche Funktion haben, teilen Sie es bitte.

 

Ich weiß nicht, von welchem Skin wir sprechen, aber die ursprüngliche Skin-Testfunktion und einige andere wurden von @Andrey Dik in diesem Thread im Jahr 2010 entwickelt und seit etwa 2020 können Sie die Formel hier \MQL5\Experts\Examples\Math 3D\Functions.mqh und hier \MT5\MQL5\Experts\Examples\Math 3D Morpher\Functions.mqh finden und ansehen. Dies ist eine interessante Funktion, aber eine einfache Funktion. Später entwickelte er weitere Benchmarks wie Hilly, Forest und Megacity.

Was das Testen von zweidimensionalen und noch mehr eindimensionalen Funktionen angeht, so wurde oben gesagt, dass es keinen praktischen Sinn macht, da die meisten AOs sie elementar lösen, selbst die einfachsten Algos mit Zufallsgeneratoren (es gibt superschnelle PRNGs) zeigen überraschend hohe Ergebnisse, die eine Illusion von hoher Effizienz und Geschwindigkeit erzeugen. Daher werden Dimensionen von 10 und höher in Betracht gezogen. Eine Erhöhung der Dimensionalität kann erreicht werden, indem eindimensionale Benchmarks oder zweidimensionale Benchmarks dupliziert werden (die erhaltene Summe wird durch die Anzahl der Testfunktionen geteilt), so dass das Minimum und Maximum der Testfunktion unabhängig von der Dimensionalität immer bekannt sind. Dies ist eine gängige Technik, um die Dimensionalität zu erhöhen und dennoch den Definitionsbereich der Testfunktion zuverlässig zu kennen.

Über "ausgleichen". OK, machen wir es gleich, aber sie werden sich dadurch nicht besser fühlen. Die meisten Populations-AOs fühlen sich mit einer Populationsgröße von 50 gut an (manche kleiner, z.B. 10, manche größer, z.B. 100), wenn wir die Anzahl der FF-Läufe auf 10 000 Epochen begrenzen, betrachten wir Epochen = 10 000 / Populationsgröße, erhalten wir 10 000 / 50 = 200. Wir brauchen also nur 50 Mal Gradientenmethoden mit verschiedenen Ausgangspositionen im Raum laufen zu lassen und die beste Lösung daraus zu nehmen, um so die Population zu simulieren. Wir wiederholen dies mehrmals und berechnen den Durchschnitt dieser besten Werte. Auf diese Weise wird eine vollständige "Gleichheit der Bedingungen" erreicht, nur wenn die Methoden vorher eine Chance hatten, eine Lösung in 10.000 Iterationen zu finden, wird es jetzt 200 Iterationen geben, aber 50 Versuche.

Schauen wir mal, was dabei herauskommt. Wir setzen das Skript aus diesem Artikel für L-BGFS ein, um die Population zu simulieren.

int epochCount = NumbTestFuncRuns_P / PopSize_P;

  for (int test = 0; test < NumberRepetTest_P; test++)
  {
    double bestInPop = -DBL_MAX; // Beste in der Bevölkerung

    for (int p = 0; p < PopSize_P; p++)
    {
      for (int i = 0; i < funcCount; i++)
      {
        x [i * 2] = Ut.RNDfromCI (bndl [i * 2], bndu [i * 2]);
        x [i * 2 + 1] = Ut.RNDfromCI (bndl [i * 2 + 1], bndu [i * 2 + 1]);
      }

      //------------------------------------------------------------------------
      C_OptimizedFunction  fFunc; fFunc.Init (params, epochCount, PopSize_P, clrConv);
      CObject              obj;
      CNDimensional_Rep    frep;
      CMinLBFGSReportShell rep;

      double epsg = 1 e-16;
      double epsf = 1 e-16;

      CAlglib::MinLBFGSCreateF  (1, x, DiffStep_P, fFunc.state);
      CAlglib::MinLBFGSSetCond  (fFunc.state, epsg, epsf, ArgumentStep_P, epochCount);
      CAlglib::MinLBFGSSetScale (fFunc.state, s);
      CAlglib::MinLBFGSOptimize (fFunc.state, fFunc, frep, 0, obj);
      CAlglib::MinLBFGSResults  (fFunc.state, x, rep);
      //------------------------------------------------------------------------

      if (fFunc.fB > bestInPop) bestInPop = fFunc.fB;
    }

    aveResult += bestInPop;
  }

  aveResult /= NumberRepetTest_P;

Und wir erhalten diese Ergebnisse:

LBFGS|limited memory BFGS method for large scale optimization|0.9|
=============================
5 Hilly's; Func runs: 10000; Ergebnis: 0.52942166492675
25 Hilly's; Func runs: 10000; Ergebnis: 0.30437018399902754
500 Hilly's; Func läuft: 10000; Ergebnis: 0.253457675831117
=============================
5 Forest's; Func läuft: 10000; Ergebnis: 0.46775770774270276
25 Forest's; Func läuft: 10000; Ergebnis: 0.20030246823425313
500 Forest's; Func läuft: 10000; Ergebnis: 0.15436391164477226
=============================
5 Megacity's; Func läuft: 10000; Ergebnis: 0.3046153846153846
25 Megacity's; Func läuft: 10000; Ergebnis: 0.13384615384615386
500 Megacity's; Func läuft: 10000; Ergebnis: 0.09492307692307773
=============================
Alle Ergebnisse: 2.44306 (27.15%)

27,15% ist ungefähr der 42. Platz in der aktuellen Rangliste von 45 Plätzen.

Jetzt sind alle auf dem gleichen Stand.

Das Skript für diesen Test ist dem Beitrag beigefügt. Alle notwendigen Einschlüsse sind im Archiv zum Artikel zu finden.

Dateien:
Test_minLBFGS_special.mq5  18 kb
 
Maxim Dmitrievsky #:

Suchen Sie die Haut ph-i aus dem Artikel mit der lbfgs-Methode.

Ich habe nicht verstanden, über welche tausend Parameter wir sprechen. Wenn Sie ein Beispiel für eine solche Funktion haben, teilen Sie es bitte.

Es ist die gleiche wie in dem Artikel. Sie wurde dem Terminal entnommen. Dort steht, dass es sich um eine der kompliziertesten Funktionen handelt. Dann heißt es, sie sei sehr einfach.

https://www.mql5.com/ru/forum/118887/page2#comment_3150124

Es ist nicht klar, welche Teilpersönlichkeit man ernst nehmen soll.

Wo kann ich den Code einer komplexen Funktion für 1000 Parameter finden?

 
Maxim Dmitrievsky #:
Wie in dem Artikel. Aus dem Terminal entnommen. Da steht, es sei eines der kompliziertesten. Dann heißt es, es sei sehr einfach.

h ttps:// www.mql5.com/ru/forum/118887/page2#comment_3150124

Es ist nicht klar, welche Teilpersönlichkeit man ernst nehmen soll.

Wo kann ich den Code einer komplexen Funktion für 1000 Parameter finden?

Lesen Sie genauer, Hilly wurde später entwickelt und ist komplexer als Skin. Skin gehört zur Gruppe der einfachen Funktionen (wie Rastrigin und die meisten anderen bekannten), weil 50% der Fläche genau 50% der Höhe entspricht. Alles wird in den Artikeln gesagt.

Alle notwendigen Quellen sind im Archiv zum Artikel, studieren Sie sie.

Wo steht geschrieben, dass es "sehr" einfach ist?
 
Andrey Dik #:

Lesen Sie genauer, Hilly wurde später entwickelt und ist komplexer als Skin. Skin gehört zur einfachen Gruppe (wie Rastrigin und die meisten anderen berühmten), da 50% der Fläche genau 50% in der Höhe liegt. Alles gesagt in den Artikeln.

Alle notwendigen Quellen sind im Archiv zum Artikel, studieren Sie sie.

Ich prüfe in Python, ich brauche nur den Code der Funktion, die komplex ist.

Ich benutze MQL nur auf der Ebene der Eröffnung-Schließung Trades.
 
Maxim Dmitrievsky #:

Ich prüfe in Python, ich brauche nur den Code einer Funktion, die komplex ist.

Ich verwende MQL nur auf der Ebene der Eröffnung-Schließung von Geschäften.

Nehmen Sie die Hilly-Code aus dem Artikel, führen Sie es durch Chat, es wird ein Python-Code sein.

Oder Megacity, es ist eine sehr komplexe Funktion für jede AO.

 
Andrey Dik #:

Nehmen Sie den Hilly-Code aus dem Artikel, lassen Sie ihn durch den Chat laufen, es wird Python-Code sein.

Oder Megacity, es ist sehr komplex für jede AO-Funktion.

Und C_dimentional oder wie auch immer es heißt, wo bekommt man es her? Um eine Menge Parameter zu haben

 
Maxim Dmitrievsky #:

Und C_dimentional oder was auch immer es ist, woher bekommen Sie es? Um viele Parameter zu haben.

hier ist eine frische (der Artikel hat es im Archiv) Kerntestfunktionsklasse:

double CalcFunc (double &args []) //Funktionsargumente
  {
    int numbOfFunctions = ArraySize (args) / 2;
    if (numbOfFunctions < 1) return GetMinFunValue ();

    double x, y;
    double sum = 0.0;
    for (int i = 0; i < numbOfFunctions; i++)
    {
      x = args [i * 2];
      y = args [i * 2 + 1];

      if (!MathIsValidNumber (x)) return GetMinFunValue ();
      if (!MathIsValidNumber (y)) return GetMinFunValue ();

      //double u = 0,5;
      //x = x * cos (u) - y * sin (u);
      //y = x * sin (u) + y * cos (u);

      if (x < GetMinRangeX ()) return GetMinFunValue ();
      if (x > GetMaxRangeX ()) return GetMinFunValue ();

      if (y < GetMinRangeY ()) return GetMinFunValue ();
      if (y > GetMaxRangeY ()) return GetMinFunValue ();

      sum += Core (x, y);
    }
    
    sum /= numbOfFunctions;

    return sum;
  }

Wirf einfach ein mehrdimensionales (ich meine - in einer Dimension des Arrays gibt es viele Zellen, mehrdimensionaler Raum) Array beliebiger Dimensionalität in args, die Methode wird Argumente aus dem Array auf zweidimensionale Funktionen verteilen. Es ist klar, dass, wenn Sie ein Array mit ungerader Dimensionalität werfen, wird eine Zelle verworfen werden und wird nicht in den Berechnungen teilnehmen. D.h., dies ist eine mehrdimensionale Testfunktion mit gerader Anzahl von Dimensionen.

Ich werde sie später auf der Basis von eindimensionalen Funktionen veröffentlichen, das wird praktischer sein und es wird möglich sein, Graphen klarer zu erstellen.

Der kommentierte Code ist die Möglichkeit, die Funktion um einen bestimmten Winkel zu drehen. Dies ist für viele AOs ein Kopfschüttler. Sie wird noch nirgends verwendet.

 
Es wäre gut, dem Benchmark die Zeit hinzuzufügen, in der der Algorithmus das Problem löst. Ich zum Beispiel bin in erster Linie an der Zeit interessiert.
 
Evgeniy Chernish #:
Es wäre gut, dem Benchmark die Zeit hinzuzufügen, in der der Algorithmus das Problem löst. Ich zum Beispiel bin in erster Linie an der Zeit interessiert.
Danke, ich werde diese Möglichkeit in Betracht ziehen.
12345
Neuer Kommentar