L'apprendimento automatico nel trading: teoria, modelli, pratica e algo-trading - pagina 2510

Nuovo commento
 
elibrario #:

Sembra che abbiano riservato delle parole per i nuovi tipi.

Non solo riservato, alcune cose stanno già funzionando.

void OnStart()
{
  vector v(3);
  v[0] = 1.0;
  v[1] = 2.0;
  v[2] = 3.0;
  matrix m(3, 3);
  m.Random();
  Print("m = ", m);
  Print("m^-1 = ", m.Inverse());
  Print("Det(m) = ", m.Det());
  Print("m * v = ", m * v);
}
 
Aleksey Nikolayev #:

Non solo riservato, qualcosa sta già funzionando.

La ricerca di aiuto non produce nulla.
E le matrici saranno utili.
L'impostazione di una dimensione tramite variabili funziona

int m1=2; int m2=2;
matrice m(m1, m2);

Prima bisognava preoccuparsi degli array dinamici.

 
elibrario #:

La ricerca di aiuto non dà nulla.

Ho solo informazioni da qui.

elibrario #:

E le matrici saranno utili.
Lavorare con le variabili per impostare le dimensioni

int m1=2; int m2=2;
matrice m(m1, m2);

Prima si dovevano usare gli array dinamici.

Infatti, Renat ha promesso l'apprendimento automatico in MQL5, come il supporto ONNX. Vediamo)

 
Vladimir Baskakov #:
Nessuno ha mai battuto l'intersezione dei due mash-up

... e il ritardo può essere ridotto da un prefisso NS))

 
elibrarius #:
Se qualcuno usa il pacchetto di SanSanych https://www.mql5.com/ru/code/17468 per connettersi a R, allora:

Nel file R.mqh, i nomi delle variabili vettoriali e matriciali hanno iniziato a dare un errore durante la compilazione. Rinominateli con altri nomi e tutto funzionerà. Ho usato vectr e matr.

L'editor evidenzia queste parole in blu come un tipo di dati come int, double. Apparentemente parole riservate ai nuovi tipi.

Hmm, non sapevo nulla di questa biblioteca. Come usarlo, quali sono le sue funzionalità?

 
iwelimorn #:

Insomma, tutto inutile, con MO il mercato non può essere ingannato.

Trovati i tratti e l'obiettivo, la cui distribuzione in classi è mostrata nella prima figura.

La precisione sui modelli di test e di addestramento katbust addestrati utilizzando questo set di dati è stata del 93%.

La seconda figura mostra il grafico dell'equilibrio e del patrimonio netto del commercio di destinazione:

La terza figura mostra il grafico dell'equilibrio e del patrimonio netto del trading sui segnali del modello katbusta addestrato:

Quindi, signore e signori, disperdetevi.

Qual è l'obiettivo, come l'hai trovato?

Avete provato ad aggiungere un trall?

Se si guarda solo il bilancio degli errori (+1 giusto -1 sbagliato per la classe 1), il risultato è molto diverso?

 
Aleksey Vyazmikin #:

Hmm, non sapevo nulla di questa biblioteca. Come usarlo, qual è la sua funzionalità?


Trasmissione bidirezionale di variabili e array tra MT e R. Ci sono citazioni, risultati posteriori e comandi.
Descrizione della funzione:
/**
* Restituisce la versione della dll. I 16 bit superiori del valore di ritorno
* sono la versione maggiore e i 16 bit inferiori la minore. Questo
* è usato in RInit() per assicurarsi che questo file header e
* zz la dll si adattino insieme.
*/
int RGetDllVersion();

/**
* Questo non è pensato per essere chiamato direttamente, sarà
* chiamato da RInit() dopo il controllo di versione riuscito.
* Dovreste chiamare RInit() per iniziare una nuova sessione R.
*/
long RInit_(string commandline,int debuglevel);

/**
* Teminate la sessione R. Chiamatelo nella vostra funzione deinit().
* Dopo questo il manico non è più valido.
*/
void RDeinit(long rhandle);

/**
* restituisce true se la sessione R appartenente a questo handle è
* ancora in esecuzione. R terminerà su qualsiasi errore fatale nel codice
* che gli invierete. Dovreste controllare questo all'inizio
* della vostra funzione di avvio e fermare tutte le azioni. L'ultimo comando
* prima del crash sarà trovato nel log.
* Se R non è più in esecuzione, questa libreria non emetterà nessun
* altro messaggio di log e ignorerà silenziosamente tutti i comandi.
*/
bool RIsRunning(long rhandle);

/**
* ritorna true se R sta ancora eseguendo un comando (risultante
* da una chiamata a RExecuteAsync())
*/
bool RIsBusy(long rhandle);

/**
* esegue il codice e non aspetta. Qualsiasi chiamata successiva tuttavia
* aspetterà, poiché ci può essere solo un thread in esecuzione in
* qualsiasi momento. Usare RIsBusy() per controllare se è finito
*/
void RExecuteAsync(long rhandle,string code);

/**
* eseguire il codice e aspettare che sia finito. Questo non
* restituirà nulla. Potete fondamentalmente ottenere lo stesso con
* le funzioni RGet*(), valutando l'espressione è anche
* solo l'esecuzione del codice, l'unica differenza è che queste
* funzioni RGet*() cercheranno inoltre di analizzare e restituire
* l'output mentre RExecute() si limiterà ad eseguire, aspettare e
* ignorare tutti gli output.
*/
void RExecute(long rhandle,string code);

/**
* assegna un bool al nome della variabile. In R questo tipo è chiamato "logico"
*/
void RAssignBool(long rhandle,string variable,bool value);

/**
* assegna un intero al nome della variabile.
*/
void RAssignInteger(long rhandle,string variable,int value);

/**
* assegna un doppio al nome della variabile.
*/
void RAssignDouble(long rhandle,string variable,double value);

/**
* assegna una stringa alla variabile namd. In R questo tipo è chiamato "carattere"
*/
void RAssignString(long rhandle,string variable,string value);

/**
* assegna un vettore al nome della variabile. Se la dimensione non corrisponde a
* la vostra dimensione reale dell'array, allora potrebbero accadere brutte cose.
*/
void RAssignVector(long rhandle,string variable,double &vectr[],int size);

/**
* assegna un vettore di caratteri (un array di stringhe) alla variabile. Se avete bisogno di
* un fattore, allora dovreste eseguire il codice per convertirlo dopo questo comando. In
* versioni recenti di R un vettore di stringhe non richiede più memoria di
* un fattore ed è più facile aggiungervi nuovi elementi.
*/
void RAssignStringVector(long rhandle,string variable,string &vectr[],int size);

/**
* assegna una matrice al nome della variabile. La matrice deve avere il numero di riga come
* prima dimensione (byrow=TRUE sarà usato sui dati grezzi). Questa funzione è molto
* più veloce che costruire una matrice enorme (centinaia di righe) da zero aggiungendo
* nuove righe alla fine con RRowBindVector() per ogni riga. Questa funzione è ottimizzata
* per un enorme throughput con una singola chiamata di funzione utilizzando file-IO con i dati binari
* grezzi. Per matrici molto piccole e vettori con solo una manciata di elementi
* questo potrebbe essere troppo overhead e le altre funzioni saranno più veloci. Una volta che
* avete la matrice con possibilmente migliaia di righe trasferite in R dovreste poi
* usare solo RRowBindVector() per farla crescere lentamente all'arrivo di singoli nuovi
* vettori di dati invece di inviare sempre una nuova copia dell'intera matrice.
*/
void RAssignMatrix(long rhandle,string variable,double &matr[],int rows,int cols);

/**
* aggiunge una riga a una matrice o a un dataframe. Questo eseguirà
* variabile <- rbind(variabile, vettore)
* se la dimensione non corrisponde alla dimensione effettiva dell'array potrebbero accadere brutte cose.
*/
void RAppendMatrixRow(long rhandle,string variable,double &vectr[],int size);

/**
* ritorna true se la variabile esiste, false altrimenti.
*/
bool RExists(long rhandle,string variable);

/**
* valuta l'espressione e restituisce un bool. L'espressione può essere qualsiasi codice R
* che valuterà a logico. Se si tratta di un vettore logico, allora viene restituito solo
* il primo elemento.
*/
bool RGetBool(long rhandle,string expression);

/**
* valuta l'espressione e restituisce un intero. Un'espressione può essere qualsiasi codice R
* che valuterà un intero. Se è una virgola mobile sarà
* arrotondato, se è un vettore allora solo il primo elemento sarà restituito.
*/
int RGetInteger(long rhandle,string expression);

/**
* valuta l'espressione e restituisce un doppio. L'espressione può essere qualsiasi codice R
* che valuterà un numero in virgola mobile, se è un vettore allora
* viene restituito solo il primo elemento.
*/
double RGetDouble(long rhandle,string expression);

/**
* valuta l'espressione e restituisce un vettore di doppi. L'espressione può
* essere qualsiasi cosa che valuti un vettore di numeri in virgola mobile.
* Il valore di ritorno è il numero di elementi che potrebbero essere copiati nell'array
*. Non sarà mai più grande delle dimensioni, ma potrebbe essere più piccolo.
* gli avvertimenti sono emessi a livello di debug 1 se le dimensioni non corrispondono.
>>> Limitato a 100000 elementi
*/
int RGetVector(long rhandle,string expression,double &vectr[],int size);

/**
* fare un print(expression) per scopi di debug. L'outout sarà
* inviato al monitor di debug su debuglevel 0.
*/

void RPrint(long rhandle,string expression);

 
elibrarius #:

Trasferimento bidirezionale di variabili e array tra MT e R. Ci sono citazioni, risultati posteriori e comandi.
Grazie per l'informazione, sarò consapevole di questa possibilità. Quanto ritardo di andata e ritorno c'è comunque?
 
Aleksey Vyazmikin #:
Grazie per le informazioni, sarò consapevole di questa possibilità. Quanto è lungo il ritardo di andata e ritorno?
Molto veloce. Tramite scambio di memoria. Non file o pip.
 
Vladimir Baskakov #:
Nessuno ha mai battuto l'intersezione delle due forme d'onda.
Non ci crederete.
Se si usa la media, il risultato sarà identico a quello dei tamponi, e il tempo di rollover del segnale sarà lo stesso fino a pochi secondi.
---
Io stesso sono rimasto scioccato ;)
1...250325042505250625072508250925102511251225132514251525162517...3399
Nuovo commento