Il existe de nombreux types d'indicateurs techniques utilisés dans l'analyse de marché, mais fondamentalement, les quatre dernières valeurs sont utilisées comme données d'entrée, et certains calculs sont effectués et produits.
Ainsi, lorsque vous connaissez les données d'entrée et de sortie, pouvez-vous estimer le type de calcul que vous effectuez? Si vous connaissez le modèle de calcul et décidez simplement des paramètres qui y apparaissent, il existe différentes méthodes telles que l'identification du système et l'algorithme d'optimisation.
Cependant, il serait un peu difficile d'estimer même le modèle de calcul, mais si l'intelligence artificielle populaire et le deep learning sont "universels", ce sera possible. Non, si vous ne pouvez pas faire autant, vous ne devriez pas vous appeler intelligence artificielle.
En dehors de cela, cette fois j'ai essayé avec TFlearn pour voir si je pouvais apprendre les indicateurs techniques que je connaissais à l'avance.
L'indicateur technique le plus élémentaire est la moyenne mobile. C'est un processus linéaire simple, vous n'avez donc pas besoin d'utiliser un réseau de neurones, mais ce n'est pas trop simple. J'essaierai du très simple.
Je ne peux pas obtenir la moyenne avec une entrée, alors j'en utiliserai deux pour le moment. Cependant, changez les poids en 1/3 et 2/3.
Il s'agit de la moyenne mobile pondérée linéaire (LWMA) de la période 2, qui est MT5.
iMA(_Symbol, 0, 2, 0, MODE_LWMA, PRICE_CLOSE);
Il peut être calculé en utilisant la fonction de. Ce qui suit est la sortie de fichier avec les données quotidiennes de l'USDJPY dans MT5 Program.
Time,Open,High,Low,Close,Ind0
2015.01.02 00:00,120.416,120.74,119.805,120.458,120.257999999996
2015.01.05 00:00,120.531,120.646,119.371,119.631,119.906666666662
2015.01.06 00:00,119.285,119.504,118.05,118.363,118.785666666662
2015.01.07 00:00,118.587,119.647,118.504,119.249,118.953666666662
2015.01.08 00:00,119.314,119.961,119.157,119.652,119.517666666662
2015.01.09 00:00,119.727,119.876,118.415,118.509,118.889999999995
2015.01.12 00:00,118.315,119.315,118.098,118.346,118.400333333328
2015.01.13 00:00,118.363,118.849,117.534,117.925,118.065333333328
2015.01.14 00:00,117.89,117.937,116.067,117.335,117.531666666662
2015.01.15 00:00,117.257,117.941,116.151,116.165,116.554999999995
2015.01.16 00:00,116.183,117.764,115.849,117.541,117.082333333328
2015.01.19 00:00,117.426,117.78,116.919,117.557,117.551666666661
2015.01.20 00:00,117.654,118.866,117.64,118.766,118.362999999995
2015.01.21 00:00,118.67,118.759,117.179,117.956,118.225999999994
2015.01.22 00:00,117.917,118.665,117.245,118.469,118.297999999994
2015.01.23 00:00,118.633,118.813,117.534,117.754,117.992333333328
2015.01.26 00:00,117.634,118.497,117.263,118.447,118.215999999994
2015.01.27 00:00,118.413,118.657,117.334,117.861,118.056333333327
2015.01.28 00:00,117.746,118.262,117.249,117.536,117.644333333327
2015.01.29 00:00,117.489,118.486,117.385,118.257,118.016666666661
2015.01.30 00:00,118.336,118.459,117.296,117.542,117.780333333327
:
Lisez le fichier ci-dessus et créez les données de l'enseignant. Le fichier contient 4 valeurs et valeurs d'index, mais seuls le cours de clôture Close et la valeur d'index ʻInd0` sont utilisés ici.
Créez environ 200 échantillons de données d'entrée (2 dans ce cas) dans «X» et indexez la valeur de sortie dans «Y».
import numpy as np
import pandas as pd
import tensorflow as tf
import tflearn
file = 'USDJPY.f16408.txt'
ohlc = pd.read_csv(file, index_col='Time', parse_dates=True)
close = ohlc.Close.values
ind0 = ohlc.Ind0.values
N = 2
X = np.empty((0,N))
Y = np.empty((0,1))
for i in range(200):
X = np.vstack((X, close[i:i+N]))
Y = np.vstack((Y, ind0[i+N-1:i+N]))
La définition du graphe utilisée dans TFlearn, mais cette fois nous définirons celui qui est connecté linéairement à partir de la couche d'entrée, en supposant qu'il s'agit d'un modèle linéaire. De plus, je n'utilise pas de biais, alors définissez bias = False.
Cependant, pour la «régression», les résultats par défaut n'étaient pas très bons, j'ai donc ajusté le taux d'apprentissage pour diminuer progressivement en utilisant la méthode SGD.
# Graph definition
layer_in = tflearn.input_data(shape=[None, N])
layer1 = tflearn.fully_connected(layer_in, 1, activation='linear', bias=False)
sgd = tflearn.optimizers.SGD(learning_rate=0.01, lr_decay=0.95, decay_step=100)
regression = tflearn.regression(layer1, optimizer=sgd, loss='mean_square')
L'apprentissage est facile à écrire avec TFlearn. Apprenez jusqu'à 10 000 générations.
# Model training
m = tflearn.DNN(regression)
m.fit(X, Y, n_epoch=10000, snapshot_epoch=False, run_id='MAlearn')
Le coefficient de pondération est émis comme résultat d'apprentissage.
# Weights
print('\nweights')
for i in range(N):
print('W['+str(i)+'] =' ,m.get_weights(layer1.W)[i])
Ce qui suit est la sortie du résultat d'apprentissage.
---------------------------------
Run id: MAlearn
Log directory: /tmp/tflearn_logs/
---------------------------------
Training samples: 200
Validation samples: 0
--
Training Step: 40000 | total loss: 0.61673
| SGD | epoch: 10000 | loss: 0.61673 -- iter: 200/200
--
weights
W[0] = [ 0.43885291]
W[1] = [ 0.56114811]
Les poids exacts sont W [0] = 0,3333, W [1] = 0,6777, il ne semble donc pas que vous appreniez correctement.
Dans cet exemple, le modèle consistait simplement à trouver la somme linéaire de deux entrées, mais si la différence entre les deux données d'entrée était faible, l'erreur serait petite et l'apprentissage échouait. Par conséquent, cette fois, j'ai essayé d'utiliser uniquement les données de l'enseignant lorsque la différence entre les deux données est de 1 ou plus.
N = 2
X = np.empty((0,N))
Y = np.empty((0,1))
for i in range(200):
if abs(close[i]-close[i+1]) >= 1.0:
X = np.vstack((X, close[i:i+N]))
Y = np.vstack((Y, ind0[i+N-1:i+N]))
Le résultat.
---------------------------------
Run id: MAlearn
Log directory: /tmp/tflearn_logs/
---------------------------------
Training samples: 22
Validation samples: 0
--
Training Step: 10000 | total loss: 1.94699
| SGD | epoch: 10000 | loss: 1.94699 -- iter: 22/22
--
weights
W[0] = [ 0.33961287]
W[1] = [ 0.66053367]
Le nombre d'échantillons a diminué à 22, mais le poids est plus proche de la valeur réelle qu'auparavant.
En premier lieu, le réseau neuronal n'est pas destiné à la prédiction numérique précise, mais à la prédiction.
Par conséquent, cette fois, j'ai ajouté un bruit gaussien avec une moyenne de 0 et un écart type de 0,1 à la valeur de l'indice en tant que données de l'enseignant.
N = 2
X = np.empty((0,N))
Y = np.empty((0,1))
for i in range(200):
if abs(close[i]-close[i+1]) >= 1.0:
X = np.vstack((X, close[i:i+N]))
noise = np.random.normal(0,0.1)
Y = np.vstack((Y, ind0[i+N-1:i+N]+noise))
Le résultat.
---------------------------------
Run id: MAlearn
Log directory: /tmp/tflearn_logs/
---------------------------------
Training samples: 22
Validation samples: 0
--
Training Step: 10000 | total loss: 3.79990
| SGD | epoch: 10000 | loss: 3.79990 -- iter: 22/22
--
weights
W[0] = [ 0.32918188]
W[1] = [ 0.67114329]
Les résultats changeront légèrement à chaque fois, mais vous pouvez voir que vous apprenez généralement. Le mérite du réseau neuronal est qu'il peut en quelque sorte prédire même s'il y a du bruit.
Il est possible de traiter 3 données ou plus en changeant le "N" dans le code, mais en fait, le coefficient de poids ne pouvait pas être obtenu avec une très bonne précision lorsqu'il y avait 3 entrées ou plus. Le résultat est omis.
Il semble donc qu'il reste encore un long chemin à parcourir pour apprendre un index technique. Pour le moment, c'était un article sur la préparation.
Eh bien, l'avantage d'utiliser TFlearn est que vous pouvez vérifier rapidement si votre idée est bonne ou non.
Recommended Posts