Championnat d'optimisation des algorithmes. - page 52

Nouveau commentaire
 

Pourquoi importer dans le deuxième exemple ?

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

Je pourrais écrire cela aussi - qu'est-ce qui est si peu clair dans ma question ?

C'était plus une question rhétorique, parce que je suis sûr que vous comprenez.

Dmitry Fedoseev:
Pourquoi dois-je poser une question 10 fois ?

C'est une question difficile, je me demande souvent la même chose).

DmitryFedoseev:

Pourquoi avez-vous besoin de l'importation dans le deuxième exemple ?

Afin de contrôler l'algorithme à partir du script, combien de fois l'algorithme a effectivement appelé le FF.

Pour la première variante, c'est clairement visible, car le script lui-même fait des appels, mais pour la deuxième variante, ce n'est pas visible, c'est pourquoi nous avons besoin de la possibilité d'accéder à la bibliothèque FF à partir du script.

 

Maintenant, je veux lancer un appel à tous les participants qui se considèrent comme des "nouveaux venus" dans ce domaine et qui ne s'attendent pas sérieusement à gagner.

Si nous laissons tomber toute la "théorie" insensée sur les dimensions multiples de l'espace, qui embrouille le problème, et que nous nous tournons vers les mathématiques pures, nous verrons que le FF est une équation.

Cette équation ne devient une fonction analytique que si elle est appliquée à un graphique.

Un graphique permet simplement de visualiser la relation entre les paramètres de l'équation.

Après 158 pages de discussion, nous pouvons déjà formuler l'essence du problème :

Nous devons trouver les valeurs des variables du côté droit del'équation pour lesquelles la valeur de la variable du côté gauche de l'équation est la plus grande.

L'objectif est d'essayer de le faire plus efficacement qu'une force brute complète.

C'est tout.

Suivant :

Pour résoudre ce problème, une technique "évolutive" de recherche de valeurs a été inventée. Des analogies et des méthodes issues du darwinisme ont été construites.

La question de l'efficacité de cette approche est discutable. Il existe probablement des moyens plus simples et plus efficaces de résoudre ce problème.

Ma pratique prouve que les approches généralement admises ne sont pas toujours les plus efficaces.

Je suis sûr que nous pouvons contourner les "évolutionnistes" assez bien...

Faisons un essai !

 

Un exemple de l'algorithme du participant pour la deuxième variante d'appel du 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)));
}
//————————————————————————————————————————————————————————————————————

Le code de base de l'algorithme est le même que dans la première variante, mais avec l'appel du FF depuis l'algorithme au lieu du script.

Les résultats sont naturellement similaires à ceux de la première variante :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016.06.22 11:47:07.584 OAC variant 2 (GBPUSD,M30) FF exécutions : 1000

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

C'est-à-dire - pas mal du tout.

 

Ainsi, les exemples ci-dessus montrent la manière dont les algorithmes des participants sont connectés aux scripts de test par le biais de fonctions d'importation.

Permettez-moi de vous rappeler pourquoi cette façon de travailler avec les algorithmes des participants est organisée : il est nécessaire, d'une part, de cacher l'algorithme du participant pour protéger la propriété intellectuelle, et d'autre part, de permettre le contrôle et la vérification par les membres du jury et les spectateurs.

 

Je vais le tester aujourd'hui.

Mais il serait souhaitable de compiler (je comprends, Andrei, que vous étiez pressé) et de publier en un seul post les règles concernant les fichiers, avec les pièces jointes de ces mêmes fichiers. Pas nécessairement tout de suite, mais pour avoir un point de départ.

 
Реter Konow:

Maintenant, je veux lancer un appel à tous les participants qui se considèrent comme des "nouveaux venus" dans ce domaine et qui ne s'attendent pas sérieusement à gagner.

Si nous laissons de côté toute la "théorie" insensée sur les dimensions multiples de l'espace, qui embrouille énormément un problème déjà confus, et que nous nous tournons vers les mathématiques pures, nous constatons que le FF est une équation.

Cette équation ne devient une fonction analytique que si elle est appliquée à un graphique.

Un graphique aide simplement à visualiser les modèles de relation des paramètres de l'équation.

Après 158 pages de discussion, nous pouvons déjà formuler l'essence du problème :

Nous devons trouver les valeurs des variables du côté droit del'équation pour lesquelles la valeur de la variable du côté gauche de l'équation est la plus grande.

L'objectif est d'essayer de le faire plus efficacement qu'une force brute complète.

C'est tout.

Suivant :

Pour résoudre ce problème, une technique "évolutive" de recherche de valeurs a été inventée. Des analogies et des méthodes issues du darwinisme ont été construites.

La question de l'efficacité de cette approche est discutable. Il existe probablement des moyens plus simples et plus efficaces de résoudre ce problème.

Ma pratique prouve que les approches généralement admises ne sont pas toujours les plus efficaces.

Je suis sûr que nous pouvons contourner les "évolutionnistes" assez bien...

Faisons un essai !

Si l'on met de côté la coloration émotionnelle du message, ce que vous avez dit est fondamentalement vrai. La seule chose que vous avez oublié de mentionner est que l'équation FF elle-même est inconnue dans le championnat donné (dans la vie, elle peut être connue ou non).

À propos des "théories non fictionnelles" - j'ai donné dans ce fil des indications claires sur les principes de l'algorithme d'optimisation qui ne sont utilisées nulle part ailleurs et n'ont jamais été utilisées auparavant (du moins dans les sources disponibles). Et le choix appartient toujours au chercheur - comment et ce qu'il va utiliser dans l'algorithme. Dans l'exemple ci-dessus, on trouve un algorithme qui n'a rien à voir avec Darwin, même indirectement. Il y a beaucoup de méthodes d'optimisation et personne, au moins je n'ai pas prétendu que "issu de Darwin" est meilleur.

Alors, bonne chance aux débutants ! Allez, à la victoire !

 
Je n'ai pas codé sur un cinq et je n'ai pas non plus d'expérience dans les opérations d'exportation/importation. Veuillez me dire si j'ai bien compris votre exemple. J'ai mis mes commentaires dans le code. Une autre question . Si le FF est donné par une formule, y aura-t-il des opérations de division ou d'extraction de racine. Une valeur nulle ou négative provoquera une erreur critique et arrêtera le programme.
// -- данный код находится на стороне жюри (организатора)---------------------
#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:
Je ne code pas sur A et n'ai aucune expérience des opérations d'exportation-importation. Veuillez me dire si j'ai bien compris votre exemple. J'ai mis mes commentaires dans le code. Une autre question . Si le FF est donné par une formule, y aura-t-il des opérations de division ou d'extraction de racine. Une valeur nulle ou négative provoquera une erreur critique et arrêtera le programme.

Oui, vous avez bien compris le fonctionnement du championnat de France.

La seule correction concernant le retour des résultats en cas de taille incorrecte du tableau de paramètres - l'algorithme du participant connaît le nombre de paramètres du FF et s'il envoie un tableau de taille incorrecte au FF, c'est le problème de l'algorithme du participant, pas du FF. Réfléchissez à ce point, si vous prenez le marché comme exemple - le marché ne vous informera jamais que vous utilisez le "mauvais" nombre de paramètres de stratégie dans votre trading, vous obtiendrez juste un résultat de trading négatif et c'est tout, sans aucune explication du marché pour vos erreurs.

Vous pouvez remplacer le mot Votre par le mot Notre, et vous pouvez remplacer le mot Vous par Nous, rien ne changera et rien ne restera vrai.

 
Igor Volodin:

Je vais le tester aujourd'hui.

Mais il serait souhaitable de compiler (je comprends, Andrei, que tu étais pressé) et de publier en un seul post les règles concernant les fichiers, avec les pièces jointes de ces mêmes fichiers. Pas nécessairement tout de suite, mais pour avoir un point de départ.

Il serait sans doute pratique de placer les fichiers d'exemples dans un entrepôt de fichiers accessible, afin de ne pas avoir à sauter à la recherche de ceux-ci, et de placer un lien vers cet entrepôt au début de la branche.

Oui, je le ferai.

1...454647484950515253545556575859...132
Nouveau commentaire