La Fuzzy Logic in Mql4

Ciao trader!
In questo articolo Giovanni “Zoster” Riccobene ti mostra come poter implementare la Fuzzy Logic direttamente nel codice Mql. Cos’è la Fuzzy Logic? Se vuoi dare una rinfrescata al concetto di “logica sfumata” o “logica sfocata”, puoi trovare una breve descrizione sull’intramontabile Wiki (Fuzzy Logic su Wikipedia).

ArticleUse

Naturalmente, potrai approfondire questo argomenti direttamente con noi, nel gruppo Telegram gratuito dedicato alla programmazione Mql4 e 5.

In breve, la Fuzzy Logic vuole interpretare il concetto naturale di “verità”, ovvero che un fatto sia vero o falso non con le semplici logiche di Bool (le tabelle di verità), bensì con una soglia di verità generata da una serie di fatti, veri o falsi, di cui una data percentuale deve essere necessariamente vera.

Per esempio, date 8 condizioni, almeno 5 devono essere vere per considerare l’insieme “vero”.

Scopri come implementare la Fuzzy Logic nel tuo EA.

Quando programmiamo un expert advisor, che sia per il day trading o per lo swing trading, cerchiamo sempre un segnale “perfetto”, ipotizzando che il nostro edge derivi da una formulazione perfetta di condizioni di ingresso a mercato.

Ci focalizziamo spesso su singoli segnali di ingresso che possano dare alla nostra strategia una meccanicità assoluta e ripetitiva, e che sia in grado di generare profitti costantemente nel tempo.

Questa logica, tuttavia, può essere troppo stringente in alcune fasi di mercato o perdere di efficacia nel tempo.

Altre volte applichiamo dei filtri che in modo altalenante la rendono proficua o addirittura non profittevole limitando in modo eccessivo i segnali di ingresso, facendoci perdere anche quelli che avrebbero generato dei buoni trade.

In generale, noi retail trader cerchiamo una meccanicità assoluta che possa portarci profitti in modo costante e duraturo nel tempo, ma dovremmo essere consapevoli che il mercato ForEx non è esattamente il nostro amico ideale.

Ad esempio, se costruissimo una strategia basata sul valore di un classico RSI noteremmo che il nostri livelli di iper-comprato e iper-venduto potrebbero variare il loro valore ideale in modo molto diverso nel tempo a seconda delle fasi di mercato e della volatilità.

In questo articolo non vi darò alcun tipo di segnale o strategia, cercherò di passarvi un’informazione molto più preziosa:

un metodo di sviluppo

Parliamoci chiaro, il nostro fine è trarre profitto dal mercato in modo costante e duraturo, ma ciò che viene prima a noi piace un sacco, perché solo chi come noi sonda il mercato in modo scrupoloso sa quanta soddisfazione si prova quando si trova qualcosa.

Siamo generalmente abituati a cercare un segnale di ingresso seguendo delle scrupolose e rigide condizioni di validazione, in genere il sistema più classico è quello di definire un segnale di base e in seguito cercare di migliorare l’equity line con un eventuale filtro, questo come sistema non sempre però risulta efficace, vuoi perché il segnale non è sempre il massimo, vuoi perché il filtro in certe condizioni di mercato può diventare troppo stringente. Quindi in soldoni di seguito un breve esempio classico per un ingresso a mercato :

bool SL = SegnaleLong(),
     FL = FiltroLong();

bool SS = SegnaleShort(),
     FS = FiltroShort(); 

if(SL && FL)
   {
       //ENTRA A MERCATO LONG 
   }

if(SS && FS) 
   {
       //ENTRA A MERCATO SHORT
   }

Qui ho usato il classico approccio di base, quindi ho una funzione di tipo bool per il controllo della presenza del mio segnale ed un eventuale filtro da applicare, il costrutto if si attiva se il consenso arriva da entrambe le mie funzioni: segnale E filtro.

Come detto poco fa, questa è una logica molto selettiva e stringente, che non sempre dà i risultati sperati, a volte perché la volatilità e la “natura” del mercato cambiano, a volte perché abbiamo creato un sistema eccessivamente rigido.

Cosa succederebbe se invece prendessimo in esame una serie di segnali e filtri e valutassimo come vera la condizione di mercato in modo un po’ diverso dal normale?

Ecco che arriva in nostro aiuto la logica fuzzy, un modo in cui il nostro segnale non si limita più ad un vero/falso, ma un modo in cui raggiunta una soglia minima il nostro segnale diventa valido.

Per fare un semplice esempio, ipotizziamo di aver trovato diversi segnali interessanti, qualche filtro e di volerli utilizzare secondo una logica dinamica non sempre precisa ed esatta.

Del resto il mercato non è né esatto né preciso!

Implementiamo la Fuzzy Logic

Fuzzy Logic


Ipotizziamo 3 segnali e 2 filtri per un totale di 5 condizioni, li scriviamo sotto forma di 5 funzioni di tipo booleano (bool), in questo caso stiamo scegliendo questi numeri in modo assolutamente arbitrario, potrebbero essere anche 10,7,3 o 20, questo dipende da ciò che stiamo cercando sul mercato.

Prese le nostre 5 condizioni di esempio, stabiliamo la regola secondo cui basterà che almeno 3 di esse siano vere per confermare il nostro segnale.

Se fossero state 10 le condizioni possibili, avremmo potuto scegliere 6 o 7 come soglia di validità.

Possiamo perfino inserire il tutto come parametro esterno e lasciar fare al nostro ottimizzatore lo sporco lavoro di cercare l’optimum.

Stabilito un numero X di condizioni, valutiamo la soglia percentuale per la validazione del nostro segnale, nel nostro caso abbiamo 5 possibili condizioni, e la nostra soglia di verità ha base 3, per cui ne vogliamo almeno 3 vere.

Faremo un semplice controllo delle condizioni utilizzando un contatore, come si può vedere nel il proto-codice qui di seguito:

//+------------------------------------------------------------------+
//|SEGNALE LONG                                                      |
//+------------------------------------------------------------------+
bool SegnaleLong()
{
   int contatore=0,     //Contatore 
       soglia = 3;      //Soglia di verità
       
   
   if(CondizioneLong_1) contatore++;
   if(CondizioneLong_2) contatore++;
   if(CondizioneLong_3) contatore++;
   if(CondizioneLong_4) contatore++;
   if(CondizioneLong_5) contatore++;
  
   return (contatore >= soglia ? true : false );
}
//+------------------------------------------------------------------+
//|SEGNALE SHORT                                                     |
//+------------------------------------------------------------------+
bool SegnaleShort()
{
   int contatore=0,     //Contatore 
       soglia = 3;      //Soglia di verità
       
   
   if(CondizioneShort_1) contatore++;
   if(CondizioneShort_2) contatore++;
   if(CondizioneShort_3) contatore++;
   if(CondizioneShort_4) contatore++;
   if(CondizioneShort_5) contatore++;
  
   return (contatore >= soglia ? true : false );
}
//+------------------------------------------------------------------+

Come possiamo vedere, non facciamo nient’altro che aumentare un semplice contatore per ogni funzione che risulti vera.

Ma solo se il contatore avrà raggiunto il livello di soglia predeterminato, la funzione restituirà vero. Se non lo raggiunge, restituirà falso.

Il primo codice che hai visto, potrebbe diventare così: più compatto e più chiaro.

if(SegnaleLong())
   {
      //ENTRA A MERCATO LONG 
   }

if(SegnaleLong())
   {
      //ENTRA A MERCATO SHORT
   }

A quali conclusioni possiamo arrivare?

La logica fuzzy altro non è che un’espansione della più classica logica booleana di base, dove ciò che prima era assoluto ora lo rendiamo più sfumato, perché non ci importa più che una logica sia sempre esatta nel tempo, piuttosto ci importa che almeno un certo numero di condizioni sia vero, affidando a questa flessibilità la possibilità di adattarsi a fasi alterne di mercato.

Come si può proseguire in questo studio?

Si possono pesare le varie singole condizioni, facendo in modo che alcune siano “più vere” di altre, nel nostro conteggio, oppure si può inserire una piramidazione di logiche Fuzzy, come se fosse un frattale di tabelle di verità.

Si possono perfino creare intere librerie di condizioni logiche, collezionando decine se non centinaia di potenziali segnali, e metterli al vaglio di una singola logica fuzzy.

Insomma, come sempre di ricette “prefabbricate” non ce n’è, e i pasti nei mercati bisogna sudarseli, eppure sono convinto che questo concetto, relativamente facile da implementare, possa appassionarti nella ricerca e offrirti un’arma in più nel tuo arsenale.

Al tuo trading!

Zoster

Se questo articolo ti è piaciuto, considera l’opportunità di condividerlo con i tuoi contatti, vieni a trovarci su Facebook e su YouTube!

Scopri anche le nostre numerose RISORSE GRATUITE

SPAZIO PUBBLICITARIO:
XM è un broker che mi sta piacendo molto,
ha una bella politica di rebates e bonus di benvenuto molto importanti.

A me piace la rapidità di versamento e di prelievo con Carta di Credito, che non fa problemi nemmeno con la Revolut (15€ gratis se ti iscrivi da qui)

Leave a Reply