Système de trading automatique FX réalisé avec python et algorithme génétique Partie 1
Les choses que j'ai faites
J'ai essayé d'implémenter les fonctions suivantes
- Un programme qui ne cesse de bénéficier des derniers taux de change
- Programme qui exploite l'IA et achète et vend automatiquement
- Un programme qui utilise un algorithme génétique pour générer une nouvelle IA basée sur les dernières données
- Un programme qui mesure les performances de l'IA et gère les unités monétaires de retrait et de transaction
Contexte
L'API de trading fournie par OANDA avait l'air plutôt bonne, j'ai donc pu le faire. En particulier, puisque vous pouvez acheter et vendre en 1 unité monétaire (1 unité de dollar), même si vous déplacez 100 IA et répétez des transactions, la perte se situera à quelques dizaines de yens par jour. Il est sûr même si le système commercial devient incontrôlable en raison d'un bug lors du test. Je pense que c'est un bon moment car je ne pourrais pas le réaliser moi-même sans cette API. http://developer.oanda.com/rest-live/development-guide/
Caractéristiques de l'algorithme génétique
La solution semi-optimale du problème d'optimisation peut être résolue en peu de temps. Si vous vous interrogez sur des problèmes d'optimisation ou des solutions sous-optimales, vous pouvez le trouver en regardant une vidéo qui capture Mario avec un algorithme génétique. → [Nikodo] J'ai essayé d'apprendre Super Mario Brothers
Obtenez le tarif
En essayant l'API Oanda avec curl, je l'écrirai avec python lorsque j'aurai fini d'essayer
request
curl -X GET "https://api-sandbox.oanda.com/v1/candles?instrument=EUR_USD&count=100&candleFormat=midpoint&granularity=D&dailyAlignment=0&alignmentTimezone=America%2FNew_York"
response
{
"instrument" : "EUR_USD",
"granularity" : "D",
"candles" : [
{
"time" : "2015-06-22T04:00:00.000000Z",
"openMid" : 1.24121,
"highMid" : 1.241535,
"lowMid" : 1.240145,
"closeMid" : 1.24113,
"volume" : 24144,
"complete" : true
}
]
}
Code python d'acquisition de taux
base_domain = MODE.get('production')
url_base = 'https://{}/v1/candles?'.format(base_domain)
url = url_base + 'instrument={}&'.format(currency_pair.name) + \
'count=5000&' +\
'candleFormat=midpoint&' +\
'granularity={}&'.format(granularity.name) +\
'dailyAlignment=0&' +\
'alignmentTimezone=Asia%2FTokyo&' +\
'start={}T00%3A00%3A00Z'.format(start)
response = requests_api(url)
def requests_api(url, payload=None):
auth = 'Bearer {}'.format(get_password('OandaRestAPIToken'))
headers = {'Accept-Encoding': 'identity, deflate, compress, gzip',
'Accept': '*/*', 'User-Agent': 'python-requests/1.2.0',
'Content-type': 'application/json; charset=utf-8',
'Authorization': auth}
if payload:
requests.adapters.DEFAULT_RETRIES = 2
response = requests.post(url, headers=headers, data=payload, timeout=10)
else:
requests.adapters.DEFAULT_RETRIES = 2
response = requests.get(url, headers=headers, timeout=10)
print 'REQUEST_API: {}'.format(url)
return response
Faisons un simple achat et vente d'IA
■ Spécifications Comparez le taux actuel avec le taux moyen sur 24 heures, et s'il y a un écart de 30 pip ou plus, définissez la marge bénéficiaire et la perte de 30 pip et effectuez des transactions.
■ Exemple d'opération Monnaie: Dollar Yen Heure actuelle: 1 octobre 2015 10:00:00 Taux actuel: 120,00 yens Tarif moyen sur 24 heures: 119,40 yens Unité monétaire d'achat: 100 Détails de la commande: 120 yens pour 100 unités ACHETER, prise de bénéfices 120,30 yens, réduction des pertes 119,70 yens
code
# -*- coding: utf-8 -*-
import datetime
from enum import Enum
class OrderType(Enum):
Buy = 1
Wait = 0
Sell = -1
class Rate(object):
start_at = datetime.datetime(2015, 10, 1, 10, 0, 0)
bid = float(120.00)
h24 = float(119.40)
base_tick = float(0.01)
@classmethod
def get(cls, currency=None, start_at=None):
return Rate()
def get_rate(self, tick, is_add):
if is_add:
return self.bid + float(tick * self.base_tick)
else:
return self.bid - float(tick * self.base_tick)
class AIOrder(object):
def __init__(self, order_type, limit, stop_limit):
self.order_type = order_type
self.limit = limit
self.stop_limit = stop_limit
class AI(object):
DIFF = 30
LIMIT = 30
STOP_LIMIT = 30
def __init__(self, rate):
self.rate = rate
def order(self):
"""
Commande.
"""
if self._can_order():
order(self._get_order())
def _can_order(self):
"""
Pouvez-vous commander ou retourner
rtype: bool
"""
point = (self.rate.bid - self.rate.h24) / self.rate.base_tick
return int(point / self.DIFF) not in [0]
def _get_order(self):
"""
Classe d'ordre de retour
rtype: AIOrder
"""
limit_rate = self.rate.get_rate(AI.LIMIT, True)
stop_limit_rate = self.rate.get_rate(AI.STOP_LIMIT, False)
return AIOrder(self._get_order_type(), limit_rate, stop_limit_rate)
def _get_order_type(self):
if self.rate.bid > self.rate.h24:
return OrderType.Buy
if self.rate.h24 > self.rate.bid:
return OrderType.Sell
return OrderType.Wait
def order(ai_order):
_base = "OrderDone:{}, Limit:{}, Stop-Limit:{}"
print _base.format(ai_order.order_type,
ai_order.limit,
ai_order.stop_limit)
#Obtenir le taux
rate = Rate.get(currency='USDJPY', start_at=datetime.datetime.now())
#Génération IA
ai = AI(rate)
#Commande
ai.order()
>>> OrderDone:True, Limit:120.3, Stop-Limit:119.7
Essayez de comparer l'achat et la vente d'IA
Faisons une analyse comparative avec des données de 5 minutes pour voir si cette IA est une bonne et rentable IA. J'ai essayé de définir la définition d'une excellente IA comme suit
- Le nombre de transactions a été d'au moins 100 au cours des 10 dernières années.
- Le bénéfice est de 1 million de yens ou plus dans le prix du marché au cours des 10 dernières années
- La perte maximale au cours des 10 dernières années est de 500 000 yens ou moins
Un benchmark qui remonte au passé s'appelle un backtest. Dans le cas de l'achat et de la vente de programmes, la condition 3 est importante. Parce qu'il est essentiellement laissé sans surveillance, cela rapporte beaucoup d'argent, mais je n'aime pas les programmes qui font beaucoup de pertes. 3 est appelé tirage maximal.
Optimiser l'achat et la vente d'IA avec des algorithmes génétiques
L'achat et la vente d'IA se composent de trois paramètres. Optimisons cette valeur. En d'autres termes, l'achat et la vente d'IA ont été définis comme un problème d'optimisation.
class AI(object):
#Le facteur qui détermine l'ordre, la différence par rapport à la moyenne sur 24h est supérieure à cette valeur.
DIFF = 30
#Facteurs qui déterminent le taux de prise de bénéfices au moment de la commande
LIMIT = 30
#Facteurs qui déterminent le taux de réduction des pertes au moment de la commande
STOP_LIMIT = 30
En supposant que les limites supérieure et inférieure de ces trois paramètres sont 400 et 10, le nombre de calculs pour tous les modèles est 390 ^ 3 = 59 319 000 fois. Si vous effectuez un backtest pendant 10 ans sur une base de 5 minutes, cela prendra environ 10 secondes car python est lent à calculer. CPU: Le temps de calcul requis pour le calcul parallèle sur un ordinateur personnel à 8 cœurs est le suivant. 59 319 000/8 cpu * 10 secondes / 3600 secondes / 24 heures = 858 jours
Le temps de calcul est de 858 jours. Même si le calcul de la distribution est effectué sur 100 PC, cela prendra 9 jours. Le calcul de tous les modèles est appelé recherche linéaire.
Eh bien, ce n'est pas le numéro un, mais l'IA avec le 30e bénéfice le plus élevé sur 59 319 000 IA est-elle dénuée de sens? Les algorithmes génétiques fonctionnent bien pour trouver des solutions sous-optimales.
Préparation avant de calculer avec un algorithme génétique
Déterminez les règles lors du calcul avec un algorithme génétique.
- Déterminez aléatoirement les paramètres initiaux entre 10 et 400
- Calculez jusqu'à 200 générations.
- Améliorez le profit commercial en tant que score.
- Définissez le nombre d'individus dans une génération sur 20
- Réglez le taux de mutation sur 1% ... etc.
L'efficacité du calcul varie en fonction du nombre d'individus et du taux de mutation. Il existe également des articles du point de vue des valeurs à utiliser pour l'efficacité, donc si vous êtes intéressé, vous voudrez peut-être les lire.
Échecs courants dans l'optimisation partielle des algorithmes génétiques
Si vous ne terminez pas le calcul à la 200ème génération et que vous ne le faites pas évoluer à l'infini, il sera partiellement optimisé et l'efficacité diminuera.
Résultat du calcul par algorithme génétique
Finalement, des données comme celles-ci seront collectées.
Implémentation avec algorithme génétique
Comment implémenter le croisement / mutation dans l'algorithme génétique Comment générer la population initiale Algorithme de backtest Construction réelle du système commercial
Je n'ai pas encore fini de l'écrire, je voudrais donc l'introduire dans la partie 2 à une date ultérieure.