Galateo del mercato o buone maniere in un campo minato - pagina 16
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Neutron, mi prendo un breve time-out. Devo ripensare tutto di nuovo e metterlo in codice per almeno un neurone. Comunque, un giorno o due e poi continueremo.
Lo apprezzo molto!
Ok.
Ok.
Ciao Neutron. Ecco, ho fatto qualcosa.
Ho fatto una griglia così piccola per l'algoritmo ORO:
Infatti, ecco il codice della griglia stessa (questo è il file header Neyro_test.mqh):
extern int in = 5;
double Data[3][5] = {0.0,0.0,0.0,0.0,1.0,
0.0,0.0,0.0,0.0,1.0,
0.0,0.0,0.0,0.0,1.0 };
double W[4][5] = {-0.786, 0.359,-0.186, 0.891, 0.238,
0.711,-0.923, 0.088, 0.417,-0.112,
-0.867,-0.229, 0.321, 0.921,-0.941,
0.995,-0.712, 0.012,-0.625, 0.0 };
//----------------------------
double OUT(int bar = 1)
{
int i;
double res = 0.0;
GetInd(bar);
res = W[3,0]*RSI_1() + W[3,1]*RSI_2() + W[3,2]*RSI_3() + W[3,3];
return(res);
}
double RSI_1()
{
int i;
double res = 0.0;
for(i = 0; i < 5; i++)
res += W[0,i] * Data[0,i];
return(th(res));
}
double RSI_2()
{
int i;
double res = 0.0;
for(i = 0; i < 5; i++)
res += W[1,i] * Data[0,i];
return(th(res));
}
double RSI_3()
{
int i;
double res = 0.0;
for(i = 0; i < 5; i++)
res += W[2,i] * Data[0,i];
return(th(res));
}
//----------
void OPO(double de)
{
int i;
for(i = 0; i < 4; i++)
W[3,i] += de;
}
//---------------------------------------------------------------------
void GetInd(int i)
{
int dt = 7,per = 14, prc = 0;
double ue_in = 0.02,kf = 3.0;
Data[0,0] = th((iRSI(NULL,0,per,prc,i)*ue_in - 1.0)*kf);
Data[0,1] = th((iRSI(NULL,0,per,prc,i+dt)*ue_in - 1.0)*kf);
Data[0,2] = th((iRSI(NULL,0,per,prc,i+dt*2)*ue_in - 1.0)*kf);
Data[0,3] = th((iRSI(NULL,0,per,prc,i+dt*3)*ue_in - 1.0)*kf);
}
//-------------------------------------------
double th(double x)
{
double sh,ch;
sh = MathExp(x) - MathExp(-x);
ch = MathExp(x) + MathExp(-x);
return(sh/ch);
}
Ecco come ho cercato di insegnarlo in un Expert Advisor vuoto:
extern int cikl = 10;
static int prevtime = 0;
#include <Neyro_test.mqh>
//-----------------------------------
int init()
{
return(0);
}
int deinit()
{
return(0);
}
//-------------------------------------
int start()
{
static double test, control;
if(Time[0] == prevtime)
return(0);
prevtime = Time[0];
int pr = 14, pc = 0, i;
double in = 0.02, k = 3.0;
for(i = cikl; i > 2; i--)
{
test = OUT(i);
control = th((iRSI(NULL,0,pr,pc,i-1)*in - 1.0)*k);
OPO(test - control);
}
Comment("\r\n ВЕСА ВЫХОДНОГО НЕЙРОНА : ",W[3,0],", ",W[3,1],", ",W[3,2],", ",W[3,3]);
return(0);
}
In pratica, questa griglia va "fuori asse". I coefficienti di ponderazione diventano ridicolmente alti dopo 10 passi (barre). Ho cercato a lungo un errore nel codice e ho scoperto che funziona come dovrebbe.
Cioè, se aggiungiamo semplicemente un errore ottenuto all'uscita della griglia a tutti i pesi dello strato di uscita, allora questi coefficienti tendono a crescere troppo rapidamente.
Lo scalimetro non può contenere... -:) Finora ho solo provato a propagare l'errore ai pesi dello strato di uscita.
Prima domanda: cosa ho fatto di male?
Seconda domanda:
Voglio ottenere la probabilità di successo di acquisto/vendita nell'uscita della griglia o una raccomandazione per fumare il bambù. Ma questa griglia è addestrata per prevedere il valore di RSI a n+1 barre...
Cosa ci guadagno?
nella funzione ORO, i pesi non sono modificati correttamente
Leggi la teoria, almeno qui
nella funzione ORO, i pesi non sono modificati correttamente
leggere la teoria, almeno qui
Grazie, ma non ci capisco niente.
l'errore nello strato di uscita dovrebbe essere calcolato usando la formula e=OUT*(1-OUT)*(TEST-OUT) (questo è per la funzione di trasferimento logistica, per la tangente iperbolica la formula sembra essere un po' diversa, ma anche non troppo complicata)
il peso del neurone dovrebbe essere modificato secondo w+=nju*e*OUT, dove nju è un passo di apprendimento
se il passo è troppo grande - la rete sarà instabile e ci sarà un aumento infinito dei pesi (come nel tuo caso, stai usando (TEST-OUT) senza tutti gli altri moltiplicatori)
Se troppo piccola - la rete impiegherà troppo tempo per imparare e potrebbe colpire un minimo locale
l'errore nello strato di uscita dovrebbe essere calcolato usando la formula e=OUT*(1-OUT)*(TEST-OUT) (questo è per la funzione di trasferimento logistica, per la tangente iperbolica la formula sembra essere un po' diversa, ma anche non troppo complicata)
il peso del neurone dovrebbe essere modificato secondo w+=nju*e*OUT, dove nju è un passo di apprendimento
se il passo è troppo grande - la rete sarà instabile e ci sarà un aumento infinito dei pesi (come nel tuo caso, stai usando (TEST-OUT) senza tutti gli altri moltiplicatori)
Se è troppo piccolo, ci vorrà troppo tempo per imparare e potrebbe colpire un minimo locale.
Grazie, lo proverò ora.
Se il passo è troppo grande - la rete sarà instabile e ci sarà un aumento infinito dei pesi (come nel tuo caso, usi (TEST-OUT) senza tutti gli altri moltiplicatori)
Se è troppo piccolo, ci vorrà troppo tempo per imparare e potrebbe colpire un minimo locale.
Sono leggermente confuso dal fatto che la modifica comporta che la "posizione relativa" dei pesi rimanga invariata. Questo perché tutti i pesi in entrata, come risultato della modifica, cambiano della stessa quantità. In questo caso, il rapporto originale dei pesi è stato impostato in modo casuale. Dovrebbe essere così?
Ciao, paralocus.
Facciamo un passo alla volta. Si ha un vettore di addestramento di lunghezza n, e abbiamo bisogno di generare un vettore di errore per correggere tutti i pesi della rete. È chiaro che la lunghezza del vettore sarà uguale al numero di pesi w contando i pesi di livello costante. Il vettore di errore sarà generato solo alla fine della prima (seconda, terza, ecc.) epoca di allenamento. Il metodo della sua formazione è il seguente:
1. Al primo passo della formazione (ci sono un totale di n in ogni epoca), formiamo un errore individuale per ogni peso e non correggiamo i pesi. Poi, al secondo passo, avendo formato una correzione simile, la si aggiunge alla precedente, ecc. n-volte. Si ottiene una correzione totale (tenendo conto del segno di ogni termine) per ogni peso. Ecco un punto importante. Questa correzione finale non dovrebbe essere usata - i pesi andranno in pezzi! Dovrebbe essere diviso per la norma del vettore di correzione. Per fare questo, contate la somma dei quadrati di ogni correzione in un'epoca di allenamento per ogni peso separatamente. Non appena finiamo un'epoca(n-cicli all'interno di essa), prendiamo la radice quadrata della somma dei quadrati per ogni peso separatamente, e personalmente dividiamo ogni correzione per questa norma. Correggiamo ogni peso.
2. Da 10 a 1000 epoche di allenamento, a seconda dello scopo dell'allenamento (segno o ampiezza). Procedere allo stesso modo. Punto importante: quando si procede di epoca in epoca, si dovrebbe osservare rigorosamente una diminuzione monotona dell'ampiezza della correzione dei pesi. La griglia non dovrebbe essere pigra per cercare un minimo sempre più profondo nella funzione di errore potenziale. Si realizza semplicemente. Alla fine di un'epoca, prima della correzione del peso, moltiplicare il correttore per il valore 1-j/N, dove N è il numero di epoche di allenamento e j è il numero di epoca corrente.
3. Per prevenire l'inevitabile effetto di saturazione di alcuni pesi del CETI durante la sua formazione, è necessario influenzare tutti i pesi con una tangente iperbolica immediatamente dopo la successiva correzione dei pesi. Questa procedura non è ovvia, ma estremamente efficace. A causa della morbidezza e monotonicità della FA utilizzata, tutti i pesi rimarranno sempre nell'intervallo +/-1 e l'atto di agire non provoca "isteria" nella ragazza.
Questo è tutto per ora. Digerite e fate domande.
Per quanto riguarda la domanda su come passare da RSI a Buy/Sell, questa è più una domanda per te - dopo tutto, sei stato tu stesso ad inventare la mossa. Per esempio, quello che "prevedo", lo uso anche per l'entrata (e sto prevedendo esattamente per Buy/Sell). Ecco perché non c'è contraddizione. E tu stai cercando di prevedere il colore della carta da parati in un appartamento arbitrario dal colore di un'auto davanti alla finestra della sua cucina...
Mentre scrivevo il post ricordando i dettagli dell'implementazione, c'erano alcune imprecisioni.
Ho guardato il codice e si è scoperto che stavo influenzando FA sui pesi una volta quando si passava a una nuova previsione, cioè non ogni epoca, ma quando era necessario riaddestrare la rete quando arrivavano nuovi dati.
Un'altra cosa. La correzione del peso è il prodotto dell'errore dall'uscita del neurone dalla derivata FA e dall'uscita del neurone (ampiezza, tenendo conto del segno) da cui il segnale è entrato.
Ecco come appare per un perseptron con un'uscita non lineare (per esempio):
Qui le epoche sono numerate dall'indice L. Lo mostro volutamente in MathCad, è più chiaro. In - numero di ingressi, x - vettore di ingressi. Il resto sembra essere chiaro.
Per quanto riguarda il modo di passare da RSI a Buy/Sell, questa è più una domanda per te - tu stesso hai inventato questa mossa. Io, per esempio, quello che prevedo, lo inserisco anche (e prevedo esattamente il Buy/Sell). Ecco perché non c'è contraddizione. E tu stai cercando di prevedere il colore della carta da parati di un appartamento arbitrario in base al colore dell'auto di fronte alla finestra della cucina di quell'appartamento...
Ciao, Neutron.
Ho a che fare con quello che hai scritto in questo momento. È che la matematica mi sta davvero scricchiolando in testa. La programmazione è un po' più semplice. E riguardo alla carta da parati - hai assolutamente ragione - ma non so ancora cosa mettere nella griglia, a parte tutta la stessa carta da parati, ma un'altra fabbrica (penso che il risultato sarà lo stesso). Qui sul forum ho letto questo articolo, che ha iniziato il mio interesse per le reti neurali. E in quell'articolo, come sapete, su un input povero perceptron, i compagni intelligenti del forum spingono l'indice AO (o AC - li confondo costantemente), e per avere qualcosa da guardare, lo hanno diviso in "cluster" dividendo gli input di Perceptron sul grafico dell'indice menzionato(dt/dl ). Chiamano il tutto "NEUROSETTING" o anche "TRADING CON I PAESI BASSI O... (no, non è quello che intendevo) SLIVE AUTOMATIZATION". Sono un sacco di soldi... in un tester.
Va bene... Questa era una digressione.
Così, dopo quell'articolo e un paio di altri simili (per i link da esso) ho iniziato a sperimentare con i perceptrons in modi diversi. Comunque, è come quella canzone:
"Vanka si siede sulla panchina e si fa tre copechi con il suo cazzo.
Vuole fare tre rubli - Non esce niente!".
Tuttavia, il mio interesse per i non coltivatori allo scopo di utilizzarli nel trading è rimasto e persino cresciuto nel tempo. Il fatto che non riesco ancora a pensare a qualcosa di meglio del clustering RSI - non è colpa di mio zio, ma è "un bastone con due estremità". Cioè, per sapere cosa e come mettere nelle maglie di input, ho bisogno di sapere come sono disposte queste maglie e non solo di sapere, ma anche di poterle fare. Almeno in alcune forme non molto complicate, ma sufficienti per un lavoro stabile sul reale. Ecco perché mi sono rivolto a voi.
P.S. Niente che sia andato su un "voi"? È più gentile così.