L'Apprentissage Automatique dans le trading : théorie, modèles, pratique et trading algo - page 2510

Nouveau commentaire
 
elibrarius #:

Apparemment, ils ont réservé des mots pour les nouveaux types.

Pas seulement réservé, certaines choses fonctionnent déjà.

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 seulement réservé, quelque chose fonctionne déjà.

La recherche d'aide ne donne rien.
Et les matrices seront utiles.
La définition d'une taille via des variables fonctionne

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

Avant, il fallait s'embêter avec des tableaux dynamiques.

 
elibrarius #:

La recherche d'aide ne donne rien.

Je n'ai que des informations d'ici.

elibrarius #:

Et les matrices seront utiles.
Utilisation de variables pour définir la taille

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

Auparavant, vous deviez utiliser des tableaux dynamiques.

En fait, Renat a promis l'apprentissage automatique dans MQL5, comme le support ONNX. Voyons voir)

 
Vladimir Baskakov #:
Personne n'a jamais battu l'intersection des deux mash-up

... et le décalage peut être réduit par un préfixe NS))

 
elibrarius #:
Si quelqu'un utilise le paquet de SanSanych https://www.mql5.com/ru/code/17468 pour se connecter à R, alors :

Dans le fichier R.mqh, les noms des variables vectorielles et matricielles ont commencé à donner une erreur pendant la compilation. Renommez-les avec d'autres noms et tout fonctionnera. J'ai utilisé vectr et matr.

L'éditeur souligne ces mots en bleu comme un type de données comme int, double. Des mots apparemment réservés aux nouveaux types.

Hmm, je ne savais rien de cette bibliothèque. Comment l'utiliser, quelles sont ses fonctionnalités ?

 
iwelimorn #:

Bref, tout cela en vain, avec MO le marché ne peut être dupé.

On a trouvé les traits et la cible, dont la distribution des classes est présentée dans la première figure.

La précision des modèles katbust de test et d'entraînement formés à l'aide de cet ensemble de données était de 93 %.

La deuxième figure montre le graphique de la balance et des fonds propres du commerce cible :

La troisième figure montre le graphique du solde et de l'équité de la négociation sur les signaux du modèle katbusta formé :

Alors, mesdames et messieurs, dispersez-vous.

Quelle est la cible, comment l'avez-vous trouvée ?

Avez-vous essayé d'ajouter un trall ?

Si vous ne regardez que le bilan des erreurs (+1 bien -1 mal pour la classe 1), le résultat est-il très différent ?

 
Aleksey Vyazmikin #:

Hmm, je ne savais rien de cette bibliothèque. Comment l'utiliser, quelle est sa fonctionnalité ?


Transmission bidirectionnelle des variables et des tableaux entre MT et R. Il y a des citations, des résultats de retour et des commandes.
Description de la fonction :
/**
* Renvoie la version de la dll. Les 16 bits supérieurs de la valeur de retour
* sont la version majeure et les 16 bits inférieurs la version mineure. Ce fichier
* est utilisé dans RInit() pour s'assurer que ce fichier d'en-tête et
* zzthe dll vont bien ensemble.
*/
int RGetDllVersion() ;

/**
* Cette fonction n'est pas censée être appelée directement, elle sera
* appelée par RInit() après la vérification réussie de la version.
* Vous devriez appeler RInit() pour démarrer une nouvelle session R.
*/
long RInit_(string commandline,int debuglevel) ;

/**
* Teminate the R session. Appelez cette fonction dans votre fonction deinit().
* Après cela, la poignée n'est plus valide.
*/
void RDeinit(long rhandle) ;

/**
* retourne vrai si la session R appartenant à ce handle est
* toujours en cours d'exécution. R se terminera sur toute erreur fatale dans le code
* que vous lui envoyez. Vous devez vérifier cela au début
* de votre fonction de démarrage et arrêter toutes les actions. La dernière commande
* avant le crash sera trouvée dans le journal.
* Si R n'est plus en cours d'exécution, cette bibliothèque n'émettra plus aucun
* message de journal et ignorera silencieusement toutes les commandes.
*/
bool RIsRunning(long rhandle) ;

/**
* retourne vrai si R est toujours en train d'exécuter une commande (résultant
* d'un appel à RExecuteAsync())
*/
bool RIsBusy(long rhandle) ;

/**
* exécute le code et n'attend pas. Cependant, tout appel ultérieur à
* attendra puisqu'il ne peut y avoir qu'un seul thread en cours d'exécution à
* à un moment donné. Utilisez RIsBusy() pour vérifier s'il est terminé
*/
void RExecuteAsync(long rhandle,string code) ;

/**
* exécute le code et attend qu'il soit terminé. Ceci ne retournera rien à
*. Vous pouvez obtenir la même chose avec
* les fonctions RGet*(), l'évaluation de l'expression est également
* l'exécution du code, la seule différence est que ces
* fonctions RGet*() essaieront en plus d'analyser et de renvoyer
* la sortie alors que RExecute() se contentera d'exécuter, d'attendre et
* d'ignorer toute sortie.
*/
void RExecute(long rhandle,string code) ;

/**
* assigne un bool au nom de la variable. En R, ce type est appelé "logique"
*/
void RAssignBool(long rhandle,string variable,bool value) ;

/**
* assigne un entier au nom de la variable.
*/
void RAssignInteger(long rhandle,string variable,int value) ;

/**
* assigne un double au nom de la variable.
*/
void RAssignDouble(long rhandle,string variable,double value) ;

/**
* assigne une chaîne à la variable namd. En R, ce type est appelé "caractère"
*/
void RAssignString(long rhandle,string variable,string value) ;

/**
* assigne un vecteur au nom de la variable. Si la taille ne correspond pas à
* la taille réelle de votre tableau, de mauvaises choses peuvent se produire.
*/
void RAssignVector(long rhandle,string variable,double &vectr[],int size) ;

/**
* assigne un vecteur de caractères (un tableau de chaînes) à la variable. Si vous avez besoin de
* un facteur, vous devez exécuter le code pour le convertir après cette commande. Dans
* les versions récentes de R, un vecteur de chaînes de caractères ne nécessite pas plus de mémoire que
* un facteur et il est plus facile d'y ajouter de nouveaux éléments.
*/
void RAssignStringVector(long rhandle,string variable,string &vectr[],int size) ;

/**
* assigne une matrice au nom de la variable. La matrice doit avoir le numéro de ligne comme première dimension
* (byrow=TRUE sera utilisé sur les données brutes). Cette fonction est beaucoup plus rapide
* que de construire une énorme matrice (des centaines de lignes) à partir de zéro en ajoutant
* de nouvelles lignes à la fin avec RRowBindVector() pour chaque ligne. Cette fonction est optimisée
* pour un débit énorme avec un seul appel de fonction en utilisant file-IO avec les
* données binaires brutes. Pour les très petites matrices et les vecteurs avec seulement une poignée d'éléments
* cela pourrait être trop de surcharge et les autres fonctions seront plus rapides. Une fois que vous
* avez transféré la matrice avec éventuellement des milliers de lignes vers R, vous devriez alors
* seulement utiliser RRowBindVector() pour la faire croître lentement à l'arrivée de nouveaux vecteurs de données uniques
* au lieu de toujours envoyer une nouvelle copie de la matrice entière.
*/
void RAssignMatrix(long rhandle,string variable,double &matr[],int rows,int cols) ;

/**
* ajoute une ligne à une matrice ou à un cadre de données. Cela va exuter
* variable <- rbind(variable, vecteur)
* si la taille ne correspond pas à la taille réelle du tableau, de mauvaises choses pourraient se produire.
*/
void RAppendMatrixRow(long rhandle,string variable,double &vectr[],int size) ;

/**
* return true if the variable exists, false otherwise.
*/
bool RExists(long rhandle,string variable) ;

/**
* évalue l'expression et renvoie un bool. L'expression peut être n'importe quel code R
* qui sera évalué comme logique. S'il s'agit d'un vecteur de logique, alors seul
* le premier élément est renvoyé.
*/
bool RGetBool(long rhandle,string expression) ;

/**
* évalue l'expression et renvoie un entier. Une expression peut être n'importe quel code R
* qui sera évalué à un nombre entier. S'il s'agit d'une valeur flottante, elle sera arrondie à
*, s'il s'agit d'un vecteur, seul le premier élément sera renvoyé.
*/
int RGetInteger(long rhandle,string expression) ;

/**
* évalue l'expression et retourne un double. L'expression peut être n'importe quel code R
* qui sera évalué à un nombre à virgule flottante, si c'est un vecteur alors
* seul le premier élément est retourné.
*/
double RGetDouble(long rhandle,string expression) ;

/**
* évalue l'expression et renvoie un vecteur de doubles. L'expression peut
* être n'importe quoi qui s'évalue à un vecteur de nombres à virgule flottante.
* La valeur de retour est le nombre d'éléments qui ont pu être copiés dans le tableau
*. Il ne sera jamais plus grand que la taille mais pourrait être plus petit.
* Des avertissements sont émis au niveau de débogage 1 si les tailles ne correspondent pas.
>>> Limité à 100000 éléments
*/
int RGetVector(long rhandle,string expression,double &vectr[],int size) ;

/**
* faire un print(expression) à des fins de débogage. La sortie sera
* envoyée au moniteur de débogage au niveau de débogage 0.
*/

void RPrint(long rhandle,string expression) ;

 
elibrarius #:

Transfert bidirectionnel de variables et de tableaux entre MT et R. Il y a des citations, des résultats antérieurs et des commandes.
Merci pour l'info, je serai attentif à cette possibilité. Quel est le délai aller-retour ?
 
Aleksey Vyazmikin #:
Merci pour cette information, je serai attentif à cette possibilité. Quelle est la durée du délai aller-retour ?
Très rapide. Par un échange de mémoire. Pas de fichiers ou de pips.
 
Vladimir Baskakov #:
Personne n'a jamais battu l'intersection des deux formes d'onde.
Tu ne vas pas le croire.
Si la moyenne est utilisée, le résultat sera identique à celui des écouvillons et le temps de retournement du signal sera le même à quelques secondes près.
---
J'ai été moi-même choqué ;)
1...250325042505250625072508250925102511251225132514251525162517...3399
Nouveau commentaire