Campionato di ottimizzazione degli algoritmi.

Dmitry Fedoseev 2016.06.21 23:50 #511

Perché importare nel secondo esempio?

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

Andrey Dik 2016.06.22 04:52 #512

Dmitry Fedoseev:

Beh, potrei scrivere anche questo - cosa c'è di così poco chiaro nella mia domanda?

Era più una domanda retorica, perché sono sicuro che lei capisce.

Dmitry Fedoseev:
Perché devo fare una domanda 10 volte?

È una domanda difficile, mi chiedo spesso la stessa cosa).

DmitryFedoseev:

Perché avete bisogno di importare nel secondo esempio?

Per controllare l'algoritmo dallo script, quante volte l'algoritmo ha effettivamente chiamato il FF.

Per la prima variante è chiaramente visibile, perché lo script stesso fa delle chiamate, ma per la seconda variante non è visibile, ed è per questo che abbiamo bisogno della possibilità di accedere alla libreria FF dallo script.

Qualsiasi domanda da principiante, L'apprendimento automatico nel trading: Domande dai principianti MQL5

Реter Konow 2016.06.22 06:29 #513

Ora, voglio fare appello a tutti i partecipanti che si considerano "nuovi arrivati" in questo argomento e non si aspettano seriamente di vincere.

Se lasciamo perdere tutta la folle "teoria" sulle dimensioni multiple dello spazio, che confonde il problema, e ci rivolgiamo alla matematica pura, vedremo che la FF è un'equazione.

Questa equazione diventa una funzione analitica solo se applicata a un grafico.

Un grafico aiuta semplicemente a visualizzare la relazione tra i parametri dell'equazione.

Dopo 158 pagine di discussione, possiamo già formulare l'essenza del problema:

Dobbiamo trovare i valori delle variabili sul lato destro dell' equazione ai quali il valore della variabile sul lato sinistro dell'equazione è maggiore.

L'obiettivo è cercare di farlo in modo più efficiente di una forza bruta completa.

Questo è tutto.

Il prossimo:

Per risolvere questo problema, è stata inventata una tecnica "evolutiva" per trovare i valori. Sono state costruite analogie e metodi provenienti dal darwinismo.

La questione dell'efficienza di questo approccio è discutibile. Probabilmente, ci sono modi più semplici ed efficaci per risolvere questo problema.

La mia pratica dimostra che gli approcci generalmente accettati non sono sempre i più efficaci.

Sono sicuro che possiamo aggirare gli "evoluzionisti" abbastanza bene...

Facciamo una prova!

Articolo: Previsione dei prezzi Una domanda puramente teorica Affittuario

Andrey Dik 2016.06.22 06:51 #514

Un esempio dell'algoritmo del partecipante per la seconda variante di chiamata del 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)));
}
//————————————————————————————————————————————————————————————————————

Il codice di base dell'algoritmo è lo stesso della prima variante, ma con la chiamata di FF dall'algoritmo invece che dallo script.

I risultati sono naturalmente simili a quelli della prima 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) Tempo: 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) Tempo: 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) Tempo: 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) Tempo: 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) Tempo: 180 µs; 0.00018000 c

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

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

Cioè - non è affatto male.

Algorithm Optimisation Championship. Analisi dei risultati dei Errori, bug, domande

Andrey Dik 2016.06.22 06:57 #515

Quindi, gli esempi precedenti mostrano il modo in cui gli algoritmi dei partecipanti sono collegati agli script di test attraverso funzioni di importazione.

Permettetemi di ricordare il motivo per cui si organizza esattamente questo modo di lavorare con gli algoritmi dei partecipanti: è necessario, da un lato, nascondere l'algoritmo del partecipante per proteggere la proprietà intellettuale, e dall'altro, permettere il controllo e la verifica sia da parte dei membri della giuria che degli spettatori.

Esperimento Graal. Il puzzle è Problemi con Time()

Igor Volodin 2016.06.22 07:07 #516

Lo testerò oggi.

Ma sarebbe consigliabile compilare (capisco, Andrei, che avevi fretta) e in un solo post, pubblicare le regole relative ai file, con gli allegati di questi stessi file. Non necessariamente adesso, ma per avere un punto di partenza.

Record sul mercato Econometria: previsione a un Sti

Andrey Dik 2016.06.22 07:08 #517

Реter Konow:

Ora, voglio fare appello a tutti i partecipanti che si considerano "nuovi arrivati" in questo argomento e non si aspettano seriamente di vincere.

Se lasciamo perdere tutta la folle "teoria" sulle dimensioni multiple dello spazio, che confonde selvaggiamente un problema già confuso, e ci rivolgiamo alla matematica pura, vediamo che la FF è un'equazione.

Questa equazione diventa una funzione analitica solo se applicata a un grafico.

Ma c'è una domanda - DOVREBBE essere così? - Un grafico aiuta semplicemente a visualizzare i modelli di relazione dei parametri dell'equazione.

Dopo 158 pagine di discussione, possiamo già formulare l'essenza del problema:

Dobbiamo trovare i valori delle variabili sul lato destro dell' equazione ai quali il valore della variabile sul lato sinistro dell'equazione è maggiore.

L'obiettivo è cercare di farlo in modo più efficiente di una forza bruta completa.

Questo è tutto.

Il prossimo:

Per risolvere questo problema, è stata inventata una tecnica "evolutiva" per trovare i valori. Sono state costruite analogie e metodi provenienti dal darwinismo.

La questione dell'efficienza di questo approccio è discutibile. Probabilmente, ci sono modi più semplici ed efficaci per risolvere questo problema.

La mia pratica dimostra che gli approcci generalmente accettati non sono sempre i più efficaci.

Sono sicuro che possiamo aggirare gli "evoluzionisti" abbastanza bene...

Facciamo una prova!

Se metti da parte la connotazione emotiva del post, quello che hai detto è fondamentalmente vero. L'unica cosa che hai dimenticato di dire è che l'equazione FF stessa è sconosciuta all'interno del campionato dato (nella vita può essere conosciuta o meno).

A proposito di "teorie non narrative" - ho dato in questo thread chiari suggerimenti sui principi dell'algoritmo di ottimizzazione che non sono usati da nessun'altra parte e non sono mai stati usati prima (almeno nelle fonti disponibili). E la scelta spetta sempre al ricercatore - come e cosa userà nell'algoritmo. Nell'esempio qui sopra c'è un algoritmo che non ha niente a che fare con Darwin, nemmeno indirettamente. Ci sono un sacco di metodi di ottimizzazione e nessuno, almeno io non ho sostenuto che "originato da Darwin" è meglio.

Quindi, buona fortuna ai principianti! Avanti, verso la vittoria!

Teoria del flusso casuale Errori, bug, domande una strategia di trading

Yuri Evseenkov 2016.06.22 07:14 #518

Non ho codificato su un cinque e non ho nemmeno esperienza in operazioni di esportazione/importazione. Per favore, dimmi se ho capito bene il tuo esempio. Ho messo i miei commenti nel codice. Un'altra domanda. Se il FF sarà dato da una formula, ci saranno operazioni di divisione o di estrazione di radici. Un valore zero o negativo causerà un errore critico e fermerà il programma.

// -- данный код находится на стороне жюри (организатора)---------------------
#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);// возвращает кол. обращений к фф
}

una strategia di trading Qualsiasi domanda da principiante, Domande dai principianti MQL5

Andrey Dik 2016.06.22 07:29 #519

Yuri Evseenkov:
Non codifico su A e non ho esperienza con le operazioni di esportazione-importazione. Per favore, dimmi se ho capito bene il tuo esempio. Ho messo i miei commenti nel codice. Un'altra domanda. Se il FF sarà dato da una formula, ci saranno operazioni di divisione o di estrazione di radici. Un valore zero o negativo causerà un errore critico e fermerà il programma.

Sì, avete capito bene come funziona il campionato FF.

L'unica correzione sulla restituzione dei risultati in caso di dimensioni errate dell'array di parametri - l'algoritmo del partecipante conosce il numero di parametri del FF e se invia l'array di dimensioni sbagliate al FF, è un problema dell'algoritmo del partecipante, non del FF. Pensate a questo punto, se prendete il mercato come esempio - il mercato non vi informerà mai che state usando il numero "sbagliato" di parametri della strategia nel vostro trading, otterrete solo un risultato di trading negativo e questo è tutto, senza alcuna spiegazione da parte del mercato per i vostri errori.

Puoi sostituire la parola Tuo con la parola Nostro, e puoi sostituire la parola Tu con Noi - nulla cambierà e nulla rimarrà vero.

Euro ratto Tutte le domande dei Algoritmi, metodi di soluzione,

Andrey Dik 2016.06.22 08:03 #520

Igor Volodin:

Lo testerò oggi.

Ma sarebbe consigliabile compilare (capisco, Andrei, che avevi fretta) e in un solo post, pubblicare le regole relative ai file, con gli allegati di questi stessi file. Non necessariamente adesso, ma per avere un punto di partenza.

Probabilmente, sarebbe conveniente mettere i file degli esempi in un archivio accessibile, in modo da non saltare alla loro ricerca, e mettere un link all'archivio all'inizio del ramo.

Sì, lo farò.

Campionato di ottimizzazione degli algoritmi. - pagina 52