L'apprentissage automatique dans la négociation : théorie, modèles, pratique et algo-trading - page 2882

Nouveau commentaire
 
Uladzimir Izerski #:

Je ne peux que vous conseiller de ne pas suivre la voie des faux prophètes.

C'est ce que je fais.
 

Bonne année !!!

il est important d' examiner attentivement les compromis entre la précision et l'efficacité est de l'IA

D'une manière générale, il me semble que c'est la règle absolue de la vie. Il n'y a pas de précision dans les mesures sans erreur. Et l'erreur dépend du moment de la mesure et de la moyenne.... pour ainsi dire...

 
Eh bien, ils l'ont fait et l'ont interdit. L'essentiel a été effacé, comment fabriquer une carte SIM néerlandaise pour quelques dollars))))
 
Valeriy Yastremskiy #:
Eh bien, ils l'ont fait et l'ont interdit. L'essentiel a été effacé, comment fabriquer une carte SIM néerlandaise pour quelques dollars))))

et Dieu merci).

 

Existe-t-il des scripts de gestion des manips pour mt5 ?

comme

1) si vous entrez dans une transaction, le stop est fixé automatiquement.

2) si vous avez une perte sur le compte, il ne vous permet pas d'ouvrir d'autres transactions, etc.

 
mytarmailS #:

Existe-t-il des scripts de gestion pour mt5 ?

comme

1) si vous entrez dans un trade, le stop est fixé automatiquement

2) si vous subissez une perte sur votre compte, il ne vous permet pas d'ouvrir d'autres transactions, etc.

C'est drôle, pas plus tard qu'hier, je me disais "Et si le MO était utilisé non pas pour la direction de l'entrée sur le marché, mais pour la gestion, en particulier, pour gérer le transfert vers le seuil de rentabilité, fixer des stops et des take-outs".

Il devrait y avoir beaucoup de choses de ce genre dans la base de code - cherchez-les.

 
mytarmailS #:

Alexey, je pense que tu sais, mais peut-être pas, alors je vais te montrer comment fonctionnent les algorithmes qui prennent des feuilles/vecteurs de longueur variable en entrée.


Nous avons une feuille avec des vecteurs de longueur variable, un vecteur == une observation.

Que fait le modèle, l'algorithme "sous le capot" lorsqu'il prend ces données ? Il les transforme en une matrice.

Mais comme pour les données réelles, la matrice est énorme, l'algorithme transforme les données en une matrice clairsemée peu gourmande en mémoire.

Il s'agit donc toujours d'une matrice sous le capot). (données prudentes)


Tous les paniers de marchandises sont naturellement réduits à des vecteurs de taille fixe connue, égale au nombre d'articles dans le magasin.

Notre cas est assez différent. Pour simplifier, prenons les prix comme une séquence de barres de renko, chacune étiquetée 1 ou -1. Pour chaque barre à l'emplacement numéro N, le vecteur de caractéristiques est constitué de toutes les barres précédentes - un vecteur de 1 et de -1 de longueur N-1. Il n'y a aucune contrainte a priori sur la longueur du vecteur de caractéristiques. L'utilisation d'un nombre fixe (par nous) de barres pour les caractéristiques est une mesure forcée. Nous souhaitons nous affranchir de cette restriction et construire des algorithmes capables de traiter des vecteurs de longueur arbitraire.

Je trouve que les fonctions récursives sont une source de matériel mathématique pour de tels algorithmes. Elles prennent en entrée un vecteur de n'importe quelle taille, mais elles sont définies par des fonctions ayant un nombre fixe d'arguments. L'exemple le plus simple est la moyenne exponentielle.

 
Aleksey Nikolayev #:

Tous les paniers de produits sont naturellement réduits à des vecteurs de taille connue et fixée à l'avance, égale au nombre d'articles de tous les produits du magasin.

Notre cas est tout à fait différent. Pour simplifier, prenons les prix comme une séquence de barres de renko, chacune étiquetée comme 1 ou -1. Pour chaque barre à l'emplacement numéro N, le vecteur de caractéristiques est constitué de toutes les barres précédentes - un vecteur de 1 et de -1 de longueur N-1. Il n'y a aucune contrainte a priori sur la longueur du vecteur de caractéristiques. L'utilisation d'un nombre fixe (par nous) de barres pour les caractéristiques est une mesure forcée. Nous aimerions nous affranchir de cette restriction et construire des algorithmes capables de traiter des vecteurs de longueur arbitraire.

Je trouve que les fonctions récursives sont une source de matériel mathématique pour de tels algorithmes. Elles prennent en entrée un vecteur de n'importe quelle taille, mais elles sont définies par des fonctions ayant un nombre fixe d'arguments. L'exemple le plus simple est la moyenne exponentielle.

Que voulez-vous rechercher exactement et de quelle manière ?

Par exemple, nous avons un modèle, trois pics, ou autre (règle, événement, modèle, grappe).


Il peut se passer n'importe quoi entre ces pics, nous le considérons comme du bruit et n'en tenons pas compte.

Nous prenons un vecteur/matrice bruité en entrée et vérifions s'il y a un modèle ou non....

Considérez-vous ce concept ou autre chose ?

========================================================

Je le vois comme une séquence d'événements qui doivent se produire et qui sont décrits par des règles logiques...

événement = = règle logique.

Par exemple : si l'événement 1 s'est produit et qu'il n'y a pas eu d'événement 2, nous attendons l' événement 3 etc....

Il existe donc deux types de règles/événements, les événements "go" lorsque la recherche se poursuit et les événements "stop" lorsque tout est annulé.


L'architecture est la suivante

1) les règles sont générées par la grammaire

2) l'algorithme de génération recherche et améliore les règles à l'aide de fonctions d'aptitude.

=========================

Voici un exemple de grammaire simple pour des données multidimensionnelles, dans ce cas OHLC.

library(gramEvol)

Xcolnames <- c("open","high","low","close")

ruleDef <- list(
  res = grule(t(as.data.frame(multi.expr))),
  
  multi.expr = grule( c(single.expr, single.expr, single.expr,
                        single.expr, single.expr, single.expr)),
  
  single.expr = grule(list(r=c( go_rules   = as.character(expression(Expr)),
                                stop_rules = as.character(expression(Expr))))),
  
  
  Expr     = grule(expr, expr & expr ),
  
  expr     = grule(logy_op(one_var,one_var) ),
  one_var  = gsrule('X[<id>,<var_name>]'),
  
  id       = grule(i,numb,i+numb),
  numb     = gvrule(1:10),
  var_name = gvrule(Xcolnames),
  logy_op  = grule(">","<"))

grammarDef <- CreateGrammar(ruleDef)
gr <- GrammarRandomExpression(grammarDef, 1)
rbind.data.frame(eval(gr))


Les règles générées par la grammaire.

Ce bloc de règles est comme une règle unique avec un ensemble de conditions.

"X" est une matrice avec des attributs, la boucle "i" s'y promène et choisit ce qu'elle veut, un système très flexible.

                                                       go_rules
r   X[i, "low"] < X[2, "close"] & X[i + 3, "low"] > X[i + 2, "low"]
r.1                             X[i + 2, "open"] < X[i + 8, "high"]
r.2   X[2, "open"] < X[i + 3, "high"] & X[i, "high"] < X[8, "high"]
r.3                                   X[1, "low"] < X[i + 8, "low"]
r.4   X[3, "open"] > X[3, "close"] & X[i + 1, "open"] < X[2, "low"]
r.5                                 X[i, "high"] < X[i + 2, "open"]
                                                       stop_rules
r                                    X[i, "open"] > X[2, "close"]
r.1  X[i, "low"] > X[i, "high"] & X[i + 2, "high"] < X[i, "high"]
r.2                                  X[3, "high"] < X[2, "close"]
r.3    X[1, "high"] > X[2, "open"] & X[i, "high"] > X[i, "close"]
r.4                                  X[4, "open"] < X[2, "close"]
r.5 X[i, "high"] < X[1, "high"] & X[2, "low"] < X[i + 2, "close"]

En principe, tout est déjà implémenté, s'il y a un intérêt, je peux vous le soumettre.



PS : il n'y a aucune restriction sur la taille de la matrice d'attributs, chaque instance peut être de n'importe quelle taille, l'essentiel ici est que toutes les règles fonctionnent dans l'ordre, il n'y a pas de contrainte de temps.

 
mytarmailS #:

Que voulez-vous rechercher exactement et de quelle manière ?

Par exemple, nous avons un modèle, trois pics ou autre chose (règle, événement, modèle, grappe).


Il peut se passer n'importe quoi entre ces trois pics, nous le considérons comme du bruit et n'en tenons pas compte.

Nous prenons donc un vecteur/matrice bruité en entrée et vérifions s'il y a un modèle ou non....

S'agit-il d'un concept que vous envisagez ou d'autre chose ?

Mon concept est aussi large que possible, étant donné qu'il n'y a pas de restrictions particulières imposées et que beaucoup de choses y correspondent. Votre exemple y correspond probablement aussi. Le fait qu'il n'y ait pas de longueur de modèle définie de manière rigide est particulièrement important.

Quoi qu'il en soit, pour moi, l'essentiel est qu'au SB, la probabilité de 1 ou de -1 est toujours de 0,5 et que vous devez rechercher les endroits où la probabilité (fréquence) s'écarte fortement de cette valeur. Dans votre modèle, cela pourrait être, par exemple, les pentes du troisième pic.

Je suppose que la règle "nous sommes sur la pente gauche du troisième pic" peut être exprimée par des fonctions récursives. Mais je ne crois pas vraiment que ces fonctions puissent être facilement écrites explicitement, et il faut donc des algorithmes de MO pour les construire.

 
Aleksey Nikolayev #:

Mais je ne crois pas vraiment que ces fonctions puissent être facilement écrites explicitement, et nous avons donc besoin d'algorithmes de MO pour les construire.

Eh bien, je vous ai proposé un algorithme qui répond à vos besoins


1) pas de contrainte de temps, puisque nous écrivons nous-mêmes ce dont nous avons besoin

2) aucune logique de recherche de régularités, puisque nous écrivons nous-mêmes ce dont nous avons besoin

3) tout choix de description de la régularité, soit par des règles logarithmiques, soit par des fonctions , car nous écrivons nous-mêmesce dont nous avons besoin.


Ainsi, dans le concept que je propose.

ces modèles seront équivalents, et les modèles eux-mêmes peuvent être de n'importe quelle complexité.

     open high low close
[1,]    1    0   0     0
[2,]    0    1   0     0
[3,]    0    0   1     0
[4,]    0    0   0     1
[5,]    0    0   0     0
      open high low close
 [1,]    0    0   0     0
 [2,]    0    0   0     0
 [3,]    1    0   0     0
 [4,]    0    0   0     0
 [5,]    0    0   0     0
 [6,]    0    1   0     0
 [7,]    0    0   1     0
 [8,]    0    0   0     0
 [9,]    0    0   0     0
[10,]    0    0   0     1

et aucune AMO ne peut le faire.

et il y a des règles "d'arrêt", et aucun OMA ne peut le faire non plus.

Je veux parler d'un OMA polyvalent avec des données tabulaires en entrée.

1...287528762877287828792880288128822883288428852886288728882889...3399
Nouveau commentaire