Discussione sull’articolo "Reti neurali: dalla teoria alla pratica" - pagina 6

Nuovo commento
 
fyords: Naturalmente, non sono contrario a discutere le sottigliezze delle reti neurali in questo thread, ma in origine l'articolo era pensato per i principianti. Omette alcuni dettagli, perché proprio questi dettagli sono in grado di confondere un neofita delle reti neurali. Naturalmente, l'articolo non specifica i vari metodi di addestramento (fitting) delle reti neurali, ma non è necessario nella fase iniziale. Se vi rendete conto che le reti neurali non sono poi così difficili, non è una scusa per allontanarvi e dire "questo è molto difficile e non fa per me". Se ne sapete di più, è fantastico, ma probabilmente l'articolo non fa per voi.

Finora, è l'assenza di quei dettagli che ho chiesto sopra che mi ha messo, come un normale dummies, in torpore. Ho riletto l'articolo tre volte, ma ho trovato le risposte necessarie solo sul forum.

fyords: Al momento la seconda parte riguarderà il lavoro con le reti neurali multistrato. Se avete dei desideri sul suo contenuto, scriveteli brevemente.
Una sola domanda è interessante: come creare un programma di autoapprendimento che possa fare a meno di un ottimizzatore "esterno". Se una cosa del genere è possibile in questa fase, naturalmente.
 
fyords:

Dopo alcune riflessioni, si è deciso di scrivere la seconda parte dell'articolo.

Al momento, la seconda parte riguarderà il lavoro con le reti neurali multistrato.
Se avete dei desideri sul contenuto, scriveteli brevemente.
Le idee che sarò in grado di trasmettere con le mie dita saranno descritte nell'articolo.

Grazie.

Vorrei che il metodo di apprendimento a gradiente fosse descritto sulle dita.
 
Yedelkin:

Presumo "ingenuamente" che tra i madrelingua russi non sia consuetudine chiamare il processo di apprendimento indipendente "adattamento dei parametri". Così come non è accettato chiamare apprendimento la selezione dei parametri (con l'aiuto di processi esterni) per qualsiasi sistema.

Non importa come si chiami l'adattamento, esso non cesserà di essere tale.

Ottimizzazione, adattamento e apprendimento per le reti neurali che trattano dati non stazionari sono sinonimi. Perché tutti e tre i termini significano la stessa cosa: selezione dei coefficienti di ponderazione per i dati storici passati (campione di addestramento) al fine di minimizzare gli errori nell'output della rete neurale. Se fosse possibile alimentare la rete con dati futuri, allora la questione sarebbe diversa. Ma non vendono ancora macchine del tempo nei negozi di attrezzature per ufficio, quindi dobbiamo adattarci al passato.

 
Reshetov:

Qualunque cosa si chiami un adattamento, non cesserà di essere un adattamento.

La riqualificazione è definita in modo elementare. Quindi non c'è nulla da rimproverare allo specchio.
 
Yedelkin:

Una sola domanda è interessante: come creare un programma di autoapprendimento che possa fare a meno di un ottimizzatore "esterno". Se una cosa del genere è possibile in questa fase, ovviamente.

È semplice. Il codice EA può contenere la rete stessa e il suo ottimizzatore di pesi, che può essere lanciato automaticamente quando arrivano nuovi dati. Per reti neurali nella maggior parte dei casi si intendono reti ad autoapprendimento. Le reti addestrate esternamente, ad esempio dall'ottimizzatore del tester, sono giocattoli.

 
Ragazzi, aiutatemi! Ho capito bene che la normalizzazione dei dati di input deve essere fatta per tutto il periodo di allenamento della rete? Cioè i valori massimi e minimi di xi devono essere presi dall'intero periodo?
 
net:
Ragazzi, aiutatemi! Ho capito bene che la normalizzazione dei dati di input deve essere fatta per tutto il periodo di allenamento della rete? Cioè i valori massimi e minimi di xi devono essere presi dall'intero periodo?
È necessario sull'intero campione di addestramento.
  
//+------------------------------------------------------------------+
//|macd-neuro-example.mq5 |
//| Copyright 2012, MetaQuotes Software Corp. | |
//|http://www.mql5.com
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Funzione di inizializzazione dell'esperto|
//+------------------------------------------------------------------+

#define SIZE 1000

#include <Trade\Trade.mqh>        //collegare la libreria per eseguire le operazioni commerciali
#include <Trade\PositionInfo.mqh> //collegare la libreria per ottenere informazioni sulle posizioni
#include <Indicators/TimeSeries.mqh>

//--- valori dei coefficienti di ponderazione 
input double w0=0.5;
input double w1=0.5;
input double w2=0.5;
input double w3=0.5;
input double w4=0.5;
input double w5=0.5;
input double w6=0.5;
input double w7=0.5;
input double w8=0.5;
input double w9=0.5;
input double w10=0.5;
input double w11=0.5;
input double w12=0.5;

string            my_symbol;         // variabile per memorizzare il carattere
double            inputsH[13];        // array per la memorizzazione dei segnali di ingresso
double            inputsL[13];        // array per la memorizzazione dei segnali di ingresso
int               periods[13]={2,3,5,8,13,21,34,55,89,144,233,377,610};
int B,Ba;
double            weight[13];        // array per la memorizzazione dei coefficienti di peso
double High[SIZE],Low[SIZE];

CTrade            m_Trade;           // oggetto per eseguire operazioni commerciali
CPositionInfo     m_Position;        // oggetto per le informazioni sulla posizione
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
int OnInit()
  {

   weight[0]=w0;
   weight[1]=w1;
   weight[2]=w2;
   weight[3]=w3;
   weight[4]=w4;
   weight[5]=w5;
   weight[6]=w6;
   weight[7]=w7;
   weight[8]=w8;
   weight[9]=w9;
   weight[10]=w10;
   weight[11]=w11;
   weight[12]=w12;

   my_symbol=Symbol();
   B=Bars(my_symbol,0);

//--- ritorno 0, inizializzazione completata
   return(0);
  }
//+------------------------------------------------------------------+
//| Funzione di deinizializzazione dell'esperto|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {  }
//+------------------------------------------------------------------+
//| Funzione tick dell'esperto|
//+------------------------------------------------------------------+
void OnTick()
  {

   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);                   // migliore offerta per l'acquisto
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);                   // migliore offerta per la vendita

   B=Bars(my_symbol,0);
   if(B!=Ba)
     {
      CiHigh hi;
      CiLow li;
      hi.Create(_Symbol,_Period);
      li.Create(_Symbol,_Period);
      hi.GetData(0,SIZE,High);
      li.GetData(0,SIZE,Low);
     }
   Ba=B;

     {
      for(int i=0; i<13; i++)
        {
         int HB = ArrayMaximum(High,SIZE-periods[i],periods[i]);
         int LB = ArrayMinimum(Low, SIZE-periods[i],periods[i]);
         if(Bid>=High[HB]) inputsH[i] =1;
         else inputsH[i]=0;
         if(Bid<=Low[LB]) inputsL[i]=1;
         else inputsL[i]=0;
        }

      double outH=CalculateNeuron(inputsH,weight);
      double outL=CalculateNeuron(inputsL,weight);

      //--- se il valore di uscita del neurone è inferiore a 0
      if(outL>0)
        {
         //--- se esiste già una posizione per questo carattere
         if(m_Position.Select(my_symbol))
           {
            //--- e il tipo di questa posizione è Sell, allora chiuderla
            if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(my_symbol);
            //--- e se il tipo di posizione è Buy, uscire.
            if(m_Position.PositionType()==POSITION_TYPE_BUY) return;
           }
         //--- se siete arrivati qui, non c'è nessuna posizione, apritela.
         m_Trade.Buy(0.1,my_symbol);
        }
      //--- se il valore di uscita del neurone è maggiore o uguale a 0
      if(outH>0)
        {
         //--- se esiste già una posizione per questo carattere
         if(m_Position.Select(my_symbol))
           {
            //--- e il tipo di questa posizione è Buy, allora chiuderla
            if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(my_symbol);
            //--- e se il tipo di questa posizione è Sell, uscire.
            if(m_Position.PositionType()==POSITION_TYPE_SELL) return;
           }
         //--- se siete arrivati qui, non c'è nessuna posizione, apritela.
         m_Trade.Sell(0.1,my_symbol);
        }

      if(outH>0.0 || outL>0) Print(outH,"    ",outL);
     }

  }
//+------------------------------------------------------------------+
//|Funzione di calcolo dei neuroni|
//+------------------------------------------------------------------+
double CalculateNeuron(double &inputs[],double &w[])
  {
//--- variabile per memorizzare la somma ponderata dei segnali di ingresso
   double NET=0.0;
//--- nel ciclo per il numero di ingressi ottenere la media ponderata della somma degli ingressi
   for(int n=0;n<ArraySize(inputs);n++)
     {
      NET+=inputs[n]*w[n];
     }
//--- moltiplicare la somma media ponderata degli input per il fattore additivo
   return(ActivateNeuron(NET));
  }
//+------------------------------------------------------------------+
//|Funzione di attivazione del neurone|
//+------------------------------------------------------------------+
double ActivateNeuron(double x)
  {
//--- variabile per memorizzare il risultato della funzione di attivazione
   double Out;
//--- funzione tangente iperbolica
   Out=(exp(x)-exp(-x))/(exp(x)+exp(-x));
//--- restituire il valore della funzione di attivazione
   return(Out);
  }
//+------------------------------------------------------------------+

Ho scritto questo gufo. Possiamo dire che è una rete neurale, perché ho i miei dubbi.

Gufo per il trading nel canale.

L'algoritmo è il seguente: gli estremi sono presi per il numero di barre Fibo (2,3,5,8,13....). Per ogni neurone da acquistare, ad esempio - se il prezzo è inferiore o uguale al prezzo dell'estremo LOW per un periodo, allora restituisce 1 altrimenti - 0. Inoltre, come nell'esempio con NeuronMACD. Per vendere - rispecchiare il contrario.

Attendo critiche al codice e all'algoritmo.

 
dimeon:

Ho scritto questo gufo. Possiamo dire che è una rete neurale, perché ho i miei dubbi.

Gufo per il trading nel canale.

L'algoritmo è il seguente: gli estremi sono presi per il numero di barre Fibo (2,3,5,8,13....). Per ogni neurone da acquistare, ad esempio - se il prezzo è inferiore o uguale al prezzo dell'estremo LOW per un periodo, allora restituisce 1 altrimenti - 0. Inoltre, come nell'esempio con NeuronMACD. Per vendere - rispecchiare il contrario.

Attendo critiche al codice e all'algoritmo.

Nel vostro caso, la funzione di attivazione del neurone può essere buttata via, è un freno inutile.
return(NET);
Non è una rete neurale, è solo un perceptron. Per una rete sono necessari almeno un paio di perceptron.
 
her.human:
Nel vostro caso, la funzione di attivazione dei neuroni può essere eliminata, un freno inutile.
return(NET);
Non è una rete neurale, è solo un perceptron. Per una rete sono necessari almeno un paio di perceptron.
Può farmi un esempio, come l'aggiunta di una MA o di un altro indicatore o altro, e come collegare il tutto in rete?
1234567891011
Nuovo commento