Examen de la méthode de prévision des échanges utilisant le Deep Learning et la conversion en ondelettes
introduction
Cette méthode n'a pas encore obtenu de bons résultats. J'en suis au stade d'essayer des idées comme passe-temps, donc je ne pense pas que ce sera utile pour ceux qui recherchent des outils qui peuvent être utilisés immédiatement. veuillez noter que. m (__) m Dans les articles précédents et dans les deux articles précédents, j'ai utilisé une technologie d'analyse sonore appelée spectrogramme pour échanger des données d'images (USD / JPY) et l'ai apprise avec CNN. Le résultat fut une terrible défaite. Le taux d'exactitude des données de test n'a pas augmenté.
[Article précédent] Examen de la méthode de prévision des échanges utilisant le Deep Learning et le Spectrogramme [Article précédent] Examen de la méthode de prévision des échanges utilisant Deep Learning et Spectrogram-Part 2-
Lorsque je réfléchissais à la marche à suivre, j'ai trouvé un article selon lequel la conversion en ondelettes est plus compatible que la FFT pour l'analyse des données financières. Par conséquent, cette fois, j'ai examiné s'il était possible de prédire "le taux de change augmentera ou diminuera dans 30 minutes" en combinant la conversion en ondelettes et CNN.
Qu'est-ce que la conversion en ondelettes?
La figure 1 montre un diagramme schématique de la conversion en ondelettes. La FFT, qui a été utilisée jusqu'à l'article précédent, est une méthode d'analyse qui exprime une forme d'onde complexe en ajoutant des ondes sinusoïdales infiniment continues. D'autre part, la transformation en ondelettes exprime une forme d'onde compliquée en ajoutant des ondes localisées (ondelettes). Alors que la FFT est efficace pour analyser les signaux stationnaires, la transformation en ondelettes convient à l'analyse de formes d'onde irrégulières et non stationnaires.
Figure 1. Diagramme schématique de la conversion en ondelettes
Source: https://www.slideshare.net/ryosuketachibana12/ss-42388444
Un scalogramme est une cartographie de la force des ondelettes à chaque décalage (temps) et à chaque échelle (fréquence). La figure 2 est un scalogramme créé à partir du résultat de la conversion en ondelettes de y = sin (πx / 16). Des formes d'onde arbitraires peuvent être imagées en utilisant la conversion en ondelettes de cette manière.
Figure 2. Exemple de scalogramme, y = sin (πx / 16)
Il existe une conversion en ondelettes continue (CWT) et une conversion en ondelettes discrètes (DWT) en tant que conversion en ondelettes, mais cette fois, nous avons utilisé la conversion en ondelettes continue. Il existe différentes formes d'ondelettes, mais pour le moment, la fonction Gauss est utilisée.
Créer un scalogramme à partir des données monétaires
J'ai fait un scalogramme à partir du cours de clôture de la barre de 5 minutes USD / JPY. La procédure d'extraction de données sur 24 heures à partir d'une énorme quantité de données pendant plusieurs années et de création d'un scalogramme a été répétée plusieurs fois. Un scalogramme et le mouvement des prix (à la hausse ou à la baisse) 30 minutes après l'heure finale constituent un ensemble de données. Il y avait un problème ici. C'est que la limite (fin) du scalogramme est déformée. Cela se produit parce que vous perdez des données lorsque vous franchissez la limite.
Figure 3. Distorsion à la limite du scalogramme
Par conséquent, afin d'éliminer la distorsion, des données inversées gauche-droite ont été ajoutées aux deux extrémités des données brutes. Après conversion en ondelettes, seule la partie centrale correspondant aux données brutes a été extraite. Cette méthode est généralement utilisée pour supprimer la distorsion, mais il semble qu'il y ait des avantages et des inconvénients car cela signifie que des données fictives sont ajoutées.
Graphique 4. Comment supprimer la distorsion à la limite
Structure CNN et flux d'apprentissage
J'ai conçu un petit flux d'apprentissage. Jusqu'à la dernière fois, nous avons formé les données des 10 dernières années et vérifié l'exactitude avec les données des 3 derniers mois. Cette fois, après avoir formé les données au cours des 10 dernières années, nous avons formé les données des 5 dernières années, puis avons réduit la période des données d'entraînement à 2 ans et 1 an. La raison en est que nous devons mettre l'accent sur les derniers mouvements de prix afin de prédire l'avenir. Nous avons également augmenté la période des données de test à 5 mois. Les données de test ne sont pas utilisées pour la formation. En d'autres termes, ce sont des données inconnues pour l'IA.
Figure 5. Flux d'apprentissage
La figure 6 montre la structure du CNN utilisé cette fois.
Graphique 6. Structure de CNN utilisée cette fois
Résultat du calcul
Donc, je l'ai essayé en pensant que ça devrait bien se passer, mais le résultat est comme le montre la Fig.7. Cette fois également, le taux de précision des données de test n'a pas augmenté. À propos, le taux de réponse correct pour les données d'apprentissage chute à Itérations = 20000, 30000, ce qui coïncide avec le moment où la période de données d'apprentissage est commutée.
Graphique 7. Résultat du calcul
en conclusion
Je pense que le fait que les informations temporelles contenues dans un scalogramme soient constantes est l'une des raisons pour lesquelles cela ne fonctionne pas. Cette fois, chaque scalogramme est créé à partir de données de forme d'onde sur 24 heures. Les personnes qui négocient réellement changent la période de la forme d'onde pour être évaluée au besoin. Récemment, je me suis intéressé à la «théorie des jeux» et je l'étudie. Je vais donc faire une pause dans l'analyse des devises pendant un moment.
Yu-Nie
Appendix Les données utilisées pour l'analyse peuvent être téléchargées à partir de ce qui suit. Données d'entraînement USDJPY_20070301_20170228_5min.csv USDJPY_20120301_20170228_5min.csv USDJPY_20150301_20170228_5min.csv USDJPY_20160301_20170228_5min.csv données de test USDJPY_20170301_20170731_5min.csv
Voici le code utilisé pour l'analyse.
Jack_for_qiita_TF_version.py
# 20170821
# y.izumi
import tensorflow as tf
import numpy as np
import scalogram2 as sca
import time
"""Fonctions qui effectuent l'initialisation des paramètres, les opérations de convolution et les opérations de regroupement"""
#=============================================================================================================================================
#Fonction d'initialisation du poids
def weight_variable(shape, stddev=1e-4): # default stddev = 1e-4
initial = tf.truncated_normal(shape, stddev=stddev)
return tf.Variable(initial)
#Fonction d'initialisation du biais
def bias_variable(shape):
initial = tf.constant(0.0, shape=shape)
return tf.Variable(initial)
#Opération de pliage
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding="SAME")
# pooling
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
#=============================================================================================================================================
"""Fonctions qui effectuent l'apprentissage"""
#=============================================================================================================================================
def train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size):
"""
x_train :Données d'entraînement
t_train :Étiquette d'apprentissage, one-hot
x_test :données de test
t_test :Étiquette de test, one-hot
iters :Nombre d'apprentissage
acc_list :Liste pour enregistrer la progression du taux de réponse correct
num_data_each_conf :Une liste qui stocke la progression du nombre de données pour chaque certitude
acc_each_conf :Une liste qui enregistre la progression du taux de réponse correct pour chaque certitude
total_cal_time :Temps de calcul total
train_step :Classe d'apprentissage
train_batch_size :Taille du lot de données d'entraînement
test_batch_size :Taille du lot de données de test
"""
train_size = x_train.shape[0] #Nombre de données d'entraînement
test_size = x_test.shape[0] #Nombre de données de test
start_time = time.time()
iters = iters + 1
for step in range(iters):
batch_mask = np.random.choice(train_size, train_batch_size)
tr_batch_xs = x_train[batch_mask]
tr_batch_ys = t_train[batch_mask]
#Confirmation de l'exactitude lors de l'apprentissage
if step%100 == 0:
cal_time = time.time() - start_time #Compte de temps de calcul
total_cal_time += cal_time
# train
train_accuracy = accuracy.eval(feed_dict={x: tr_batch_xs, y_: tr_batch_ys, keep_prob: 1.0})
train_loss = cross_entropy.eval(feed_dict={x: tr_batch_xs, y_: tr_batch_ys, keep_prob: 1.0})
# test
# use all data
test_accuracy = accuracy.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0})
test_loss = cross_entropy.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0})
# use test batch
# batch_mask = np.random.choice(test_size, test_batch_size)
# te_batch_xs = x_test[batch_mask]
# te_batch_ys = t_test[batch_mask]
# test_accuracy = accuracy.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0})
# test_loss = cross_entropy.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0})
print("calculation time %d sec, step %d, training accuracy %g, training loss %g, test accuracy %g, test loss %g"%(cal_time, step, train_accuracy, train_loss, test_accuracy, test_loss))
acc_list.append([step, train_accuracy, test_accuracy, train_loss, test_loss])
AI_prediction = y_conv.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0}) #Résultat de la prédiction IA
# print("AI_prediction.shape " + str(AI_prediction.shape)) # for debag
# print("AI_prediction.type" + str(type(AI_prediction)))
AI_correct_prediction = correct_prediction.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0}) #Bonne réponse:TRUE,Réponse incorrecte:FALSE
# print("AI_prediction.shape " + str(AI_prediction.shape)) # for debag
# print("AI_prediction.type" + str(type(AI_prediction)))
AI_correct_prediction_int = AI_correct_prediction.astype(np.int) #Bonne réponse:1,Réponse incorrecte:0
#Calculez le nombre de données et le taux d'exactitude pour chaque certitude
# 50%c'est tout,60%La certitude suivante(or 40%c'est tout,50%La certitude suivante)
a = AI_prediction[:,0] >= 0.5
b = AI_prediction[:,0] <= 0.6
# print("a " + str(a)) # for debag
# print("a.shape " + str(a.shape))
cnf_50to60 = np.logical_and(a, b)
# print("cnf_50to60 " + str(cnf_50to60)) # for debag
# print("cnf_50to60.shape " + str(cnf_50to60.shape))
a = AI_prediction[:,0] >= 0.4
b = AI_prediction[:,0] < 0.5
cnf_40to50 = np.logical_and(a, b)
cnf_50to60 = np.logical_or(cnf_50to60, cnf_40to50)
cnf_50to60_int = cnf_50to60.astype(np.int)
# print("cnf_50to60_int " + str(cnf_50to60)) # for debag
# print("cnf_50to60.shape " + str(cnf_50to60.shape))
correct_prediction_50to60 = np.logical_and(cnf_50to60, AI_correct_prediction)
correct_prediction_50to60_int = correct_prediction_50to60.astype(np.int)
sum_50to60 = np.sum(cnf_50to60_int) #La confiance est de 50%À partir de 60%Nombre de données
acc_50to60 = np.sum(correct_prediction_50to60_int) / sum_50to60 #La confiance est de 50%À partir de 60%Taux de réponse correct
# 60%Plus grand,70%La certitude suivante(or 30%c'est tout,40%Moins de certitude)
a = AI_prediction[:,0] > 0.6
b = AI_prediction[:,0] <= 0.7
cnf_60to70 = np.logical_and(a, b)
a = AI_prediction[:,0] >= 0.3
b = AI_prediction[:,0] < 0.4
cnf_30to40 = np.logical_and(a, b)
cnf_60to70 = np.logical_or(cnf_60to70, cnf_30to40)
cnf_60to70_int = cnf_60to70.astype(np.int)
correct_prediction_60to70 = np.logical_and(cnf_60to70, AI_correct_prediction)
correct_prediction_60to70_int = correct_prediction_60to70.astype(np.int)
sum_60to70 = np.sum(cnf_60to70_int)
acc_60to70 = np.sum(correct_prediction_60to70_int) / sum_60to70
# 70%Plus grand,80%La certitude suivante(or 20%c'est tout,30%Moins de certitude)
a = AI_prediction[:,0] > 0.7
b = AI_prediction[:,0] <= 0.8
cnf_70to80 = np.logical_and(a, b)
a = AI_prediction[:,0] >= 0.2
b = AI_prediction[:,0] < 0.3
cnf_20to30 = np.logical_and(a, b)
cnf_70to80 = np.logical_or(cnf_70to80, cnf_20to30)
cnf_70to80_int = cnf_70to80.astype(np.int)
correct_prediction_70to80 = np.logical_and(cnf_70to80, AI_correct_prediction)
correct_prediction_70to80_int = correct_prediction_70to80.astype(np.int)
sum_70to80 = np.sum(cnf_70to80_int)
acc_70to80 = np.sum(correct_prediction_70to80_int) / sum_70to80
# 80%Plus grand,90%La certitude suivante(or 10%c'est tout,20%Moins de certitude)
a = AI_prediction[:,0] > 0.8
b = AI_prediction[:,0] <= 0.9
cnf_80to90 = np.logical_and(a, b)
a = AI_prediction[:,0] >= 0.1
b = AI_prediction[:,0] < 0.2
cnf_10to20 = np.logical_and(a, b)
cnf_80to90 = np.logical_or(cnf_80to90, cnf_10to20)
cnf_80to90_int = cnf_80to90.astype(np.int)
correct_prediction_80to90 = np.logical_and(cnf_80to90, AI_correct_prediction)
correct_prediction_80to90_int = correct_prediction_80to90.astype(np.int)
sum_80to90 = np.sum(cnf_80to90_int)
acc_80to90 = np.sum(correct_prediction_80to90_int) / sum_80to90
# 90%Plus grand,100%La certitude suivante(or 0%c'est tout,10%Moins de certitude)
a = AI_prediction[:,0] > 0.9
b = AI_prediction[:,0] <= 1.0
cnf_90to100 = np.logical_and(a, b)
a = AI_prediction[:,0] >= 0
b = AI_prediction[:,0] < 0.1
cnf_0to10 = np.logical_and(a, b)
cnf_90to100 = np.logical_or(cnf_90to100, cnf_0to10)
cnf_90to100_int = cnf_90to100.astype(np.int)
correct_prediction_90to100 = np.logical_and(cnf_90to100, AI_correct_prediction)
correct_prediction_90to100_int = correct_prediction_90to100.astype(np.int)
sum_90to100 = np.sum(cnf_90to100_int)
acc_90to100 = np.sum(correct_prediction_90to100_int) / sum_90to100
print("Number of data of each confidence 50to60:%g, 60to70:%g, 70to80:%g, 80to90:%g, 90to100:%g "%(sum_50to60, sum_60to70, sum_70to80, sum_80to90, sum_90to100))
print("Accuracy rate of each confidence 50to60:%g, 60to70:%g, 70to80:%g, 80to90:%g, 90to100:%g "%(acc_50to60, acc_60to70, acc_70to80, acc_80to90, acc_90to100))
print("")
num_data_each_conf.append([step, sum_50to60, sum_60to70, sum_70to80, sum_80to90, sum_90to100])
acc_each_conf.append([step, acc_50to60, acc_60to70, acc_70to80, acc_80to90, acc_90to100])
#Exporter des fichiers pour tensorboard
result = sess.run(merged, feed_dict={x:tr_batch_xs, y_: tr_batch_ys, keep_prob: 1.0})
writer.add_summary(result, step)
start_time = time.time()
#Exécution de l'apprentissage
train_step.run(feed_dict={x: tr_batch_xs, y_: tr_batch_ys, keep_prob: 0.5})
return acc_list, num_data_each_conf, acc_each_conf, total_cal_time
#==============================================================================================================================================
"""Fonctions pour créer des scalogrammes et des étiquettes"""
#==============================================================================================================================================
def make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc):
"""
train_file_name :Nom du fichier de données d'entraînement
test_file_name :Nom du fichier de données de test
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
height :Hauteur de l'image, num of time lines
width :Largeur de l'image, num of freq lines
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
ch_flag :Nombre de canaux à utiliser, ch_flag=1:close, ch_flag=5:start, high, low, close, volume
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
over_lap_inc :Incrément de l'heure de début CWT
"""
#Créer des scalogrammes et des étiquettes
# train
x_train, t_train, freq_train = sca.merge_scalogram(train_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
# x_train, t_train, freq_train = sca.merge_scalogram(test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc) # for debag
# test
x_test, t_test, freq_test = sca.merge_scalogram(test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
print("x_train shape " + str(x_train.shape))
print("t_train shape " + str(t_train.shape))
print("x_test shape " + str(x_test.shape))
print("t_test shape " + str(t_test.shape))
print("frequency " + str(freq_test))
#Échangez les dimensions pour tensorflow
x_train = x_train.transpose(0, 2, 3, 1) # (num_data, ch, height(time_lines), width(freq_lines)) ⇒ (num_data, height(time_lines), width(freq_lines), ch)
x_test = x_test.transpose(0, 2, 3, 1)
train_size = x_train.shape[0] #Nombre de données d'entraînement
test_size = x_test.shape[0] #Nombre de données de test
# labes to one-hot
t_train_onehot = np.zeros((train_size, 2))
t_test_onehot = np.zeros((test_size, 2))
t_train_onehot[np.arange(train_size), t_train] = 1
t_test_onehot[np.arange(test_size), t_test] = 1
t_train = t_train_onehot
t_test = t_test_onehot
# print("t train shape onehot" + str(t_train.shape)) # for debag
# print("t test shape onehot" + str(t_test.shape))
return x_train, t_train, x_test, t_test
#==============================================================================================================================================
"""Conditions de création du scalogramme"""
#=============================================================================================================================================
predict_time_inc = 6 #Incrément de temps pour prédire les mouvements de prix
height = 288 #Hauteur de l'image, num of time lines
width = 128 #Largeur de l'image, num of freq lines
ch_flag = 1 #Nombre de canaux à utiliser, ch_flag=1:close, ch_flag=5:start, high, low, close, volume
input_dim = (ch_flag, height, width) # channel = (1, 5), height(time_lines), width(freq_lines)
save_flag = 0 # save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
scales = np.linspace(0.2,80,width) #Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
# scales = np.arange(1,129)
wavelet = "gaus1" #Nom de l'ondelette, 'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
over_lap_inc = 72 #Incrément de l'heure de début CWT
#==============================================================================================================================================
"""Construire un CNN"""
#==============================================================================================================================================
x = tf.placeholder(tf.float32, [None, input_dim[1], input_dim[2], input_dim[0]]) # (num_data, height(time), width(freq_lines), ch)
y_ = tf.placeholder(tf.float32, [None, 2]) # (num_data, num_label)
print("input shape ", str(x.get_shape()))
with tf.variable_scope("conv1") as scope:
W_conv1 = weight_variable([5, 5, input_dim[0], 16])
b_conv1 = bias_variable([16])
h_conv1 = tf.nn.relu(conv2d(x, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
print("conv1 shape ", str(h_pool1.get_shape()))
with tf.variable_scope("conv2") as scope:
W_conv2 = weight_variable([5, 5, 16, 32])
b_conv2 = bias_variable([32])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
print("conv2 shape ", str(h_pool2.get_shape()))
h_pool2_height = int(h_pool2.get_shape()[1])
h_pool2_width = int(h_pool2.get_shape()[2])
with tf.variable_scope("fc1") as scope:
W_fc1 = weight_variable([h_pool2_height*h_pool2_width*32, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, h_pool2_height*h_pool2_width*32])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
print("fc1 shape ", str(h_fc1.get_shape()))
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
with tf.variable_scope("fc2") as scope:
W_fc2 = weight_variable([1024, 2])
b_fc2 = bias_variable([2])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
print("output shape ", str(y_conv.get_shape()))
#Visualisez les paramètres avec tensorboard
W_conv1 = tf.summary.histogram("W_conv1", W_conv1)
b_conv1 = tf.summary.histogram("b_conv1", b_conv1)
W_conv2 = tf.summary.histogram("W_conv2", W_conv2)
b_conv2 = tf.summary.histogram("b_conv2", b_conv2)
W_fc1 = tf.summary.histogram("W_fc1", W_fc1)
b_fc1 = tf.summary.histogram("b_fc1", b_fc1)
W_fc2 = tf.summary.histogram("W_fc2", W_fc2)
b_fc2 = tf.summary.histogram("b_fc2", b_fc2)
#==============================================================================================================================================
"""Spécification de la fonction d'erreur"""
#==============================================================================================================================================
# cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
cross_entropy = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(labels = y_, logits = y_conv))
loss_summary = tf.summary.scalar("loss", cross_entropy) # for tensorboard
#==============================================================================================================================================
"""Spécifier l'optimiseur"""
#==============================================================================================================================================
optimizer = tf.train.AdamOptimizer(1e-4)
train_step = optimizer.minimize(cross_entropy)
#Visualisez le dégradé avec un tensorboard
grads = optimizer.compute_gradients(cross_entropy)
dW_conv1 = tf.summary.histogram("dW_conv1", grads[0]) # for tensorboard
db_conv1 = tf.summary.histogram("db_conv1", grads[1])
dW_conv2 = tf.summary.histogram("dW_conv2", grads[2])
db_conv2 = tf.summary.histogram("db_conv2", grads[3])
dW_fc1 = tf.summary.histogram("dW_fc1", grads[4])
db_fc1 = tf.summary.histogram("db_fc1", grads[5])
dW_fc2 = tf.summary.histogram("dW_fc2", grads[6])
db_fc2 = tf.summary.histogram("db_fc2", grads[7])
# for i in range(8): # for debag
# print(grads[i])
#==============================================================================================================================================
"""Paramètres de vérification de l'exactitude"""
#==============================================================================================================================================
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
accuracy_summary = tf.summary.scalar("accuracy", accuracy) # for tensorboard
#==============================================================================================================================================
"""Exécution de l'apprentissage"""
#==============================================================================================================================================
acc_list = [] #Liste pour enregistrer le taux de précision et la progression de l'erreur
num_data_each_conf = [] #Une liste qui stocke la progression du nombre de données pour chaque certitude
acc_each_conf = [] #Une liste qui enregistre la progression du taux de réponse correct pour chaque certitude
start_time = time.time() #Compte de temps de calcul
total_cal_time = 0
iters = 10000 #Nombre de formations pour chaque donnée de formation
train_batch_size = 100 #Apprentissage de la taille du lot
test_batch_size = 100 #Taille du lot de test
with tf.Session() as sess:
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
#Exporter des fichiers pour tensorboard
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(r"temp_result", sess.graph)
print("learning term = 10year")
train_file_name = "USDJPY_20070301_20170228_5min.csv" #Nom du fichier de données d'échange, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Nom du fichier de données d'échange, test
#Créer un scalogramme
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Exécution de l'apprentissage
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
print("learning term = 5year")
train_file_name = "USDJPY_20120301_20170228_5min.csv" #Nom du fichier de données d'échange, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Nom du fichier de données d'échange, test
#Créer un scalogramme
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Exécution de l'apprentissage
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
print("learning term = 2year")
train_file_name = "USDJPY_20150301_20170228_5min.csv" #Nom du fichier de données d'échange, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Nom du fichier de données d'échange, test
#Créer un scalogramme
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Exécution de l'apprentissage
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
print("learning term = 1year")
train_file_name = "USDJPY_20160301_20170228_5min.csv" #Nom du fichier de données d'échange, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Nom du fichier de données d'échange, test
#Créer un scalogramme
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Exécution de l'apprentissage
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
#Taux de précision final des données de test
# use all data
print("test accuracy %g"%accuracy.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0}))
# use test batch
# batch_mask = np.random.choice(test_size, test_batch_size)
# te_batch_xs = x_test[batch_mask]
# te_batch_ys = t_test[batch_mask]
# test_accuracy = accuracy.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0})
print("total calculation time %g sec"%total_cal_time)
np.savetxt(r"temp_result\acc_list.csv", acc_list, delimiter = ",") #Écrire le taux de réponse correct et la progression de l'erreur
np.savetxt(r"temp_result\number_of_data_each_confidence.csv", num_data_each_conf, delimiter = ",") #Exporter la progression du nombre de données pour chaque certitude
np.savetxt(r"temp_result\accuracy_rate_of_each_confidence.csv", acc_each_conf, delimiter = ",") #Écrire la progression du taux de réponse correct pour chaque certitude
saver.save(sess, r"temp_result\spectrogram_model.ckpt") #Exporter les paramètres finaux
#==============================================================================================================================================
scalogram2.py
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 25 11:24:50 2017
@author: izumiy
"""
import pywt
import numpy as np
import matplotlib.pyplot as plt
def create_scalogram_1(time_series, scales, wavelet, predict_time_inc, save_flag, ch_flag, height, width):
"""
Fonction pour effectuer une transformation en ondelettes continue
Utiliser le cours de clôture
time_series :Échange de données,le dernier prix
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
ch_flag :Nombre de canaux à utiliser, ch_flag=1 : close
height :Hauteur de l'image nombre de lignes temporelles
width :Largeur de l'image nombre de lignes de fréquence
"""
"""Lecture des données de séries chronologiques d'échange"""
num_series_data = time_series.shape[0] #Obtenez le nombre de données
print("number of the series data : " + str(num_series_data))
close = time_series
"""Effectuer une conversion en ondelettes continue"""
# https://pywavelets.readthedocs.io/en/latest/ref/cwt.html
print("carry out cwt...")
time_start = 0
time_end = time_start + height
scalogram = np.empty((0, ch_flag, height, width))
# hammingWindow = np.hamming(height) #Fenêtre bourdonnante
# hanningWindow = np.hanning(height) #Fenêtre Hanning
# blackmanWindow = np.blackman(height) #Fenêtre Blackman
# bartlettWindow = np.bartlett(height) #Fenêtre Bartlett
while(time_end <= num_series_data - predict_time_inc):
# print("time start " + str(time_start)) for debag
temp_close = close[time_start:time_end]
#Avec fonction fenêtre
# temp_close = temp_close * hammingWindow
#miroir,Ajouter des données inversées avant et après les données
mirror_temp_close = temp_close[::-1]
x = np.append(mirror_temp_close, temp_close)
temp_close = np.append(x, mirror_temp_close)
temp_cwt_close, freq_close = pywt.cwt(temp_close, scales, wavelet) #Effectuer une conversion en ondelettes continue
temp_cwt_close = temp_cwt_close.T #Translocation CWT(freq, time) ⇒ CWT(time, freq)
#miroir,Extraire uniquement les données centrales
temp_cwt_close = temp_cwt_close[height:2*height,:]
temp_cwt_close = np.reshape(temp_cwt_close, (-1, ch_flag, height, width)) # num_data, ch, height(time), width(freq)
# print("temp_cwt_close_shape " + str(temp_cwt_close.shape)) # for debag
scalogram = np.append(scalogram, temp_cwt_close, axis=0)
# print("cwt_close_shape " + str(cwt_close.shape)) # for debag
time_start = time_end
time_end = time_start + height
"""Créer une étiquette"""
print("make label...")
#Comment comparer deux séquences
last_time = num_series_data - predict_time_inc
corrent_close = close[:last_time]
predict_close = close[predict_time_inc:]
label_array = predict_close > corrent_close
# print(label_array[:30]) # for debag
"""
#Comment utiliser pendant,lent
label_array = np.array([])
print(label_array)
time_start = 0
time_predict = time_start + predict_time_inc
while(time_predict < num_series_data):
if close[time_start] >= close[time_predict]:
label = 0 #Descendre
else:
label = 1 #Monter
label_array = np.append(label_array, label)
time_start = time_start + 1
time_predict = time_start + predict_time_inc
# print(label_array[:30]) # for debag
"""
"""label_array(time),Tranche de sorte que le temps soit divisible par la hauteur"""
raw_num_shift = label_array.shape[0]
num_shift = int(raw_num_shift / height) * height
label_array = label_array[0:num_shift]
"""Extraction des étiquettes correspondant à chaque scalogramme, (Le nombre de données,étiquette)"""
col = height - 1
label_array = np.reshape(label_array, (-1, height))
label_array = label_array[:, col]
"""Sortie de fichier"""
if save_flag == 1:
print("output the files")
save_cwt_close = np.reshape(scalogram, (-1, width))
np.savetxt("scalogram.csv", save_cwt_close, delimiter = ",")
np.savetxt("label.csv", label_array.T, delimiter = ",")
print("CWT is done")
return scalogram, label_array, freq_close
def create_scalogram_5(time_series, scales, wavelet, predict_time_inc, save_flag, ch_flag, height, width):
"""
Fonction pour effectuer une transformation en ondelettes continue
Utiliser le cours de clôture
time_series :Échange de données,le dernier prix
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
ch_flag :Nombre de canaux à utiliser, ch_flag=5 : start, high, low, close, volume
height :Hauteur de l'image nombre de lignes temporelles
width :Largeur de l'image nombre de lignes de fréquence
"""
"""Lecture des données de séries chronologiques d'échange"""
num_series_data = time_series.shape[0] #Obtenez le nombre de données
print("number of the series data : " + str(num_series_data))
start = time_series[:,0]
high = time_series[:,1]
low = time_series[:,2]
close = time_series[:,3]
volume = time_series[:,4]
"""Effectuer une conversion en ondelettes continue"""
# https://pywavelets.readthedocs.io/en/latest/ref/cwt.html
print("carry out cwt...")
time_start = 0
time_end = time_start + height
scalogram = np.empty((0, ch_flag, height, width))
while(time_end <= num_series_data - predict_time_inc):
# print("time start " + str(time_start)) for debag
temp_start = start[time_start:time_end]
temp_high = high[time_start:time_end]
temp_low = low[time_start:time_end]
temp_close = close[time_start:time_end]
temp_volume = volume[time_start:time_end]
temp_cwt_start, freq_start = pywt.cwt(temp_start, scales, wavelet) #Effectuer une conversion en ondelettes continue
temp_cwt_high, freq_high = pywt.cwt(temp_high, scales, wavelet)
temp_cwt_low, freq_low = pywt.cwt(temp_low, scales, wavelet)
temp_cwt_close, freq_close = pywt.cwt(temp_close, scales, wavelet)
temp_cwt_volume, freq_volume = pywt.cwt(temp_volume, scales, wavelet)
temp_cwt_start = temp_cwt_start.T #Translocation CWT(freq, time) ⇒ CWT(time, freq)
temp_cwt_high = temp_cwt_high.T
temp_cwt_low = temp_cwt_low.T
temp_cwt_close = temp_cwt_close.T
temp_cwt_volume = temp_cwt_volume.T
temp_cwt_start = np.reshape(temp_cwt_start, (-1, 1, height, width)) # num_data, ch, height(time), width(freq)
temp_cwt_high = np.reshape(temp_cwt_high, (-1, 1, height, width))
temp_cwt_low = np.reshape(temp_cwt_low, (-1, 1, height, width))
temp_cwt_close = np.reshape(temp_cwt_close, (-1, 1, height, width))
temp_cwt_volume = np.reshape(temp_cwt_volume, (-1, 1, height, width))
# print("temp_cwt_close_shape " + str(temp_cwt_close.shape)) # for debag
temp_cwt_start = np.append(temp_cwt_start, temp_cwt_high, axis=1)
temp_cwt_start = np.append(temp_cwt_start, temp_cwt_low, axis=1)
temp_cwt_start = np.append(temp_cwt_start, temp_cwt_close, axis=1)
temp_cwt_start = np.append(temp_cwt_start, temp_cwt_volume, axis=1)
# print("temp_cwt_start_shape " + str(temp_cwt_start.shape)) for debag
scalogram = np.append(scalogram, temp_cwt_start, axis=0)
# print("cwt_close_shape " + str(cwt_close.shape)) # for debag
time_start = time_end
time_end = time_start + height
"""Créer une étiquette"""
print("make label...")
#Comment comparer deux séquences
last_time = num_series_data - predict_time_inc
corrent_close = close[:last_time]
predict_close = close[predict_time_inc:]
label_array = predict_close > corrent_close
# print(label_array[:30]) # for debag
"""
#Comment utiliser pendant,lent
label_array = np.array([])
print(label_array)
time_start = 0
time_predict = time_start + predict_time_inc
while(time_predict < num_series_data):
if close[time_start] >= close[time_predict]:
label = 0 #Descendre
else:
label = 1 #Monter
label_array = np.append(label_array, label)
time_start = time_start + 1
time_predict = time_start + predict_time_inc
# print(label_array[:30]) # for debag
"""
"""label_array(time),Tranche de sorte que le temps soit divisible par la hauteur"""
raw_num_shift = label_array.shape[0]
num_shift = int(raw_num_shift / height) * height
label_array = label_array[0:num_shift]
"""Extraction des étiquettes correspondant à chaque scalogramme, (Le nombre de données,étiquette)"""
col = height - 1
label_array = np.reshape(label_array, (-1, height))
label_array = label_array[:, col]
"""Sortie de fichier"""
if save_flag == 1:
print("output the files")
save_cwt_close = np.reshape(scalogram, (-1, width))
np.savetxt("scalogram.csv", save_cwt_close, delimiter = ",")
np.savetxt("label.csv", label_array.T, delimiter = ",")
print("CWT is done")
return scalogram, label_array, freq_close
def CWT_1(time_series, scales, wavelet, predict_time_inc, save_flag):
"""
Fonction pour effectuer une transformation en ondelettes continue
Utiliser le cours de clôture
time_series :Échange de données,le dernier prix
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
"""
"""Lecture des données de séries chronologiques d'échange"""
num_series_data = time_series.shape[0] #Obtenez le nombre de données
print("number of the series data : " + str(num_series_data))
close = time_series
"""Effectuer une conversion en ondelettes continue"""
# https://pywavelets.readthedocs.io/en/latest/ref/cwt.html
print("carry out cwt...")
cwt_close, freq_close = pywt.cwt(close, scales, wavelet)
#Translocation CWT(freq, time) ⇒ CWT(time, freq)
cwt_close = cwt_close.T
"""Créer une étiquette"""
print("make label...")
#Comment comparer deux séquences
last_time = num_series_data - predict_time_inc
corrent_close = close[:last_time]
predict_close = close[predict_time_inc:]
label_array = predict_close > corrent_close
# print(label_array[:30]) # for debag
"""
#Comment utiliser pendant
label_array = np.array([])
print(label_array)
time_start = 0
time_predict = time_start + predict_time_inc
while(time_predict < num_series_data):
if close[time_start] >= close[time_predict]:
label = 0 #Descendre
else:
label = 1 #Monter
label_array = np.append(label_array, label)
time_start = time_start + 1
time_predict = time_start + predict_time_inc
# print(label_array[:30]) # for debag
"""
"""Sortie de fichier"""
if save_flag == 1:
print("output the files")
np.savetxt("CWT_close.csv", cwt_close, delimiter = ",")
np.savetxt("label.csv", label_array.T, delimiter = ",")
print("CWT is done")
return [cwt_close], label_array, freq_close
def merge_CWT_1(cwt_list, label_array, height, width):
"""
Utiliser le cours de clôture
cwt_list :Liste des résultats CWT
label_array :Tableau Numpy contenant des étiquettes
height :Hauteur de l'image nombre de lignes temporelles
width :Largeur de l'image nombre de lignes de fréquence
"""
print("merge CWT")
cwt_close = cwt_list[0] #Cours de clôture CWT(time, freq)
"""CWT(time, freq),Tranche de sorte que le temps soit divisible par la hauteur"""
raw_num_shift = cwt_close.shape[0]
num_shift = int(raw_num_shift / height) * height
cwt_close = cwt_close[0:num_shift]
label_array = label_array[0:num_shift]
"""Changement de forme, (Le nombre de données,Canal,la taille(time),largeur(freq))"""
cwt_close = np.reshape(cwt_close, (-1, 1, height, width))
"""Extraction des étiquettes correspondant à chaque scalogramme, (Le nombre de données,étiquette)"""
col = height - 1
label_array = np.reshape(label_array, (-1, height))
label_array = label_array[:, col]
return cwt_close, label_array
def CWT_2(time_series, scales, wavelet, predict_time_inc, save_flag):
"""
Fonction pour effectuer une transformation en ondelettes continue
le dernier prix,Utiliser le volume
time_series :Échange de données,le dernier prix, volume
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
"""
"""Lecture des données de séries chronologiques d'échange"""
num_series_data = time_series.shape[0] #Obtenez le nombre de données
print("number of the series data : " + str(num_series_data))
close = time_series[:,0]
volume = time_series[:,1]
"""Effectuer une conversion en ondelettes continue"""
# https://pywavelets.readthedocs.io/en/latest/ref/cwt.html
print("carry out cwt...")
cwt_close, freq_close = pywt.cwt(close, scales, wavelet)
cwt_volume, freq_volume = pywt.cwt(volume, scales, wavelet)
#Translocation CWT(freq, time) ⇒ CWT(time, freq)
cwt_close = cwt_close.T
cwt_volume = cwt_volume.T
"""Créer une étiquette"""
print("make label...")
#Comment comparer deux séquences
last_time = num_series_data - predict_time_inc
corrent_close = close[:last_time]
predict_close = close[predict_time_inc:]
label_array = predict_close > corrent_close
# print(label_array[:30]) # for debag
"""
#Comment utiliser pendant
label_array = np.array([])
print(label_array)
time_start = 0
time_predict = time_start + predict_time_inc
while(time_predict < num_series_data):
if close[time_start] >= close[time_predict]:
label = 0 #Descendre
else:
label = 1 #Monter
label_array = np.append(label_array, label)
time_start = time_start + 1
time_predict = time_start + predict_time_inc
# print(label_array[:30]) # for debag
"""
"""Sortie de fichier"""
if save_flag == 1:
print("output the files")
np.savetxt("CWT_close.csv", cwt_close, delimiter = ",")
np.savetxt("CWT_volume.csv", cwt_volume, delimiter = ",")
np.savetxt("label.csv", label_array.T, delimiter = ",")
print("CWT is done")
return [cwt_close, cwt_volume], label_array, freq_close
def merge_CWT_2(cwt_list, label_array, height, width):
"""
le dernier prix,Utiliser le volume
cwt_list :Liste des résultats CWT
label_array :Tableau Numpy contenant des étiquettes
height :Hauteur de l'image nombre de lignes temporelles
width :Largeur de l'image nombre de lignes de fréquence
"""
print("merge CWT")
cwt_close = cwt_list[0] #Cours de clôture CWT(time, freq)
cwt_volume = cwt_list[1] #Le volume
"""CWT(time, freq),Tranche de sorte que le temps soit divisible par la hauteur"""
raw_num_shift = cwt_close.shape[0]
num_shift = int(raw_num_shift / height) * height
cwt_close = cwt_close[0:num_shift]
cwt_volume = cwt_volume[0:num_shift]
label_array = label_array[0:num_shift]
"""Changement de forme, (Le nombre de données,Canal,la taille(time),largeur(freq))"""
cwt_close = np.reshape(cwt_close, (-1, 1, height, width))
cwt_volume = np.reshape(cwt_volume, (-1, 1, height, width))
"""Fusionner"""
cwt_close = np.append(cwt_close, cwt_volume, axis=1)
"""Extraction des étiquettes correspondant à chaque scalogramme, (Le nombre de données,étiquette)"""
col = height - 1
label_array = np.reshape(label_array, (-1, height))
label_array = label_array[:, col]
return cwt_close, label_array
def CWT_5(time_series, scales, wavelet, predict_time_inc, save_flag):
"""
Fonction pour effectuer une transformation en ondelettes continue
Prix d'ouverture, prix élevé, prix bas, prix de clôture,Utiliser le volume
time_series :Échange de données,Prix ouvert,Prix élevé,Bas prix,le dernier prix, volume
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
"""
"""Lecture des données de séries chronologiques d'échange"""
num_series_data = time_series.shape[0] #Obtenez le nombre de données
print("number of the series data : " + str(num_series_data))
start = time_series[:,0]
high = time_series[:,1]
low = time_series[:,2]
close = time_series[:,3]
volume = time_series[:,4]
"""Effectuer une conversion en ondelettes continue"""
# https://pywavelets.readthedocs.io/en/latest/ref/cwt.html
print("carry out cwt...")
cwt_start, freq_start = pywt.cwt(start, scales, wavelet)
cwt_high, freq_high = pywt.cwt(high, scales, wavelet)
cwt_low, freq_low = pywt.cwt(low, scales, wavelet)
cwt_close, freq_close = pywt.cwt(close, scales, wavelet)
cwt_volume, freq_volume = pywt.cwt(volume, scales, wavelet)
#Translocation CWT(freq, time) ⇒ CWT(time, freq)
cwt_start = cwt_start.T
cwt_high = cwt_high.T
cwt_low = cwt_low.T
cwt_close = cwt_close.T
cwt_volume = cwt_volume.T
"""Créer une étiquette"""
print("make label...")
#Comment comparer deux séquences
last_time = num_series_data - predict_time_inc
corrent_close = close[:last_time]
predict_close = close[predict_time_inc:]
label_array = predict_close > corrent_close
# print(label_array.dtype) >>> bool
"""
#Comment utiliser pendant
label_array = np.array([])
print(label_array)
time_start = 0
time_predict = time_start + predict_time_inc
while(time_predict < num_series_data):
if close[time_start] >= close[time_predict]:
label = 0 #Descendre
else:
label = 1 #Monter
label_array = np.append(label_array, label)
time_start = time_start + 1
time_predict = time_start + predict_time_inc
# print(label_array[:30]) # for debag
"""
"""Sortie de fichier"""
if save_flag == 1:
print("output the files")
np.savetxt("CWT_start.csv", cwt_start, delimiter = ",")
np.savetxt("CWT_high.csv", cwt_high, delimiter = ",")
np.savetxt("CWT_low.csv", cwt_low, delimiter = ",")
np.savetxt("CWT_close.csv", cwt_close, delimiter = ",")
np.savetxt("CWT_volume.csv", cwt_volume, delimiter = ",")
np.savetxt("label.csv", label_array.T, delimiter = ",")
print("CWT is done")
return [cwt_start, cwt_high, cwt_low, cwt_close, cwt_volume], label_array, freq_close
def merge_CWT_5(cwt_list, label_array, height, width):
"""
cwt_list :Liste des résultats CWT
label_array :Tableau Numpy contenant des étiquettes
height :Hauteur de l'image nombre de lignes temporelles
width :Largeur de l'image nombre de lignes de fréquence
"""
print("merge CWT")
cwt_start = cwt_list[0] #Prix ouvert
cwt_high = cwt_list[1] #Prix élevé
cwt_low = cwt_list[2] #Bas prix
cwt_close = cwt_list[3] #Cours de clôture CWT(time, freq)
cwt_volume = cwt_list[4] #Le volume
"""CWT(time, freq),Tranche de sorte que le temps soit divisible par la hauteur"""
raw_num_shift = cwt_close.shape[0]
num_shift = int(raw_num_shift / height) * height
cwt_start = cwt_start[0:num_shift]
cwt_high = cwt_high[0:num_shift]
cwt_low = cwt_low[0:num_shift]
cwt_close = cwt_close[0:num_shift]
cwt_volume = cwt_volume[0:num_shift]
label_array = label_array[0:num_shift]
"""Changement de forme, (Le nombre de données,Canal,la taille(time),largeur(freq))"""
cwt_start = np.reshape(cwt_start, (-1, 1, height, width))
cwt_high = np.reshape(cwt_high, (-1, 1, height, width))
cwt_low = np.reshape(cwt_low, (-1, 1, height, width))
cwt_close = np.reshape(cwt_close, (-1, 1, height, width))
cwt_volume = np.reshape(cwt_volume, (-1, 1, height, width))
"""Fusionner"""
cwt_start = np.append(cwt_start, cwt_high, axis=1)
cwt_start = np.append(cwt_start, cwt_low, axis=1)
cwt_start = np.append(cwt_start, cwt_close, axis=1)
cwt_start = np.append(cwt_start, cwt_volume, axis=1)
"""Extraction des étiquettes correspondant à chaque scalogramme, (Le nombre de données,étiquette)"""
col = height - 1
label_array = np.reshape(label_array, (-1, height))
label_array = label_array[:, col]
# print(label_array.dtype) >>> bool
return cwt_start, label_array
def make_scalogram(input_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc):
"""
input_file_name :Nom du fichier de données d'échange
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
height :Hauteur de l'image nombre de lignes temporelles
width :Largeur de l'image nombre de lignes de fréquence
ch_flag :Nombre de canaux à utiliser, ch_flag=1:close, ch_flag=2:close and volume, ch_flag=5:start, high, low, close, volume
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
over_lap_inc :Incrément de l'heure de début CWT
"""
scalogram = np.empty((0, ch_flag, height, width)) #Un tableau qui stocke tous les scalogrammes et étiquettes
label = np.array([])
over_lap_start = 0
over_lap_end = int((height - 1) / over_lap_inc) * over_lap_inc + 1
if ch_flag==1:
print("reading the input file...")
time_series = np.loadtxt(input_file_name, delimiter = ",", usecols = (5,), skiprows = 1) #Obtenez le cours de clôture sous forme de tableau numpy
for i in range(over_lap_start, over_lap_end, over_lap_inc):
print("over_lap_start " + str(i))
temp_time_series = time_series[i:] #Changer l'heure de début de CWT
cwt_list, label_array, freq = CWT_1(temp_time_series, scales, wavelet, predict_time_inc, save_flag) #Exécutez CWT
temp_scalogram, temp_label = merge_CWT_1(cwt_list, label_array, height, width) #Créer un scalogramme
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Combinez tous les scalogrammes et étiquettes dans un seul tableau
label = np.append(label, temp_label)
print("scalogram_shape " + str(scalogram.shape))
print("label shape " + str(label.shape))
print("frequency " + str(freq))
elif ch_flag==2:
print("reading the input file...")
time_series = np.loadtxt(input_file_name, delimiter = ",", usecols = (5,6), skiprows = 1) #le dernier prix,Obtenez du volume sous forme de tableau numpy
for i in range(over_lap_start, over_lap_end, over_lap_inc):
print("over_lap_start " + str(i))
temp_time_series = time_series[i:] #Changer l'heure de début de CWT
cwt_list, label_array, freq = CWT_2(temp_time_series, scales, wavelet, predict_time_inc, save_flag) #Exécutez CWT
temp_scalogram, temp_label = merge_CWT_2(cwt_list, label_array, height, width) #Créer un scalogramme
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Combinez tous les scalogrammes et étiquettes dans un seul tableau
label = np.append(label, temp_label)
print("scalogram_shape " + str(scalogram.shape))
print("label shape " + str(label.shape))
print("frequency " + str(freq))
elif ch_flag==5:
print("reading the input file...")
time_series = np.loadtxt(input_file_name, delimiter = ",", usecols = (2,3,4,5,6), skiprows = 1) #Prix ouvert,Prix élevé,Bas prix,le dernier prix,Obtenez du volume sous forme de tableau numpy
for i in range(over_lap_start, over_lap_end, over_lap_inc):
print("over_lap_start " + str(i))
temp_time_series = time_series[i:] #Changer l'heure de début de CWT
cwt_list, label_array, freq = CWT_5(temp_time_series, scales, wavelet, predict_time_inc, save_flag) #Exécutez CWT
temp_scalogram, temp_label = merge_CWT_5(cwt_list, label_array, height, width) #Créer un scalogramme
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Combinez tous les scalogrammes et étiquettes dans un seul tableau
label = np.append(label, temp_label)
# print(temp_label.dtype) >>> bool
# print(label.dtype) >>> float64
print("scalogram_shape " + str(scalogram.shape))
print("label shape " + str(label.shape))
print("frequency " + str(freq))
label = label.astype(np.int)
return scalogram, label
def merge_scalogram(input_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc):
"""
input_file_name :Nom du fichier de données d'échange
scales :Spécifiez l'échelle à utiliser avec un tableau numpy,L'échelle correspond à la fréquence de l'ondelette utilisée pour l'analyse,Échelles hautes et basses fréquences,S'il est petit, ce sera une fréquence élevée
wavelet :Nom de l'ondelette,Utilisez l'un des éléments suivants
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Incrément de temps pour prédire les mouvements de prix
height :Hauteur de l'image nombre de lignes temporelles
width :Largeur de l'image nombre de lignes de fréquence
ch_flag :Nombre de canaux à utiliser, ch_flag=1:close, ch_flag=2:close and volume, ch_flag=5:start, high, low, close, volume
save_flag : save_flag=1 :Enregistrez le coefficient CWT dans un fichier csv, save_flag=0 :Ne pas enregistrer le coefficient CWT en tant que fichier csv
over_lap_inc :Incrément de l'heure de début CWT
"""
scalogram = np.empty((0, ch_flag, height, width)) #Un tableau qui stocke tous les scalogrammes et étiquettes
label = np.array([])
over_lap_start = 0
over_lap_end = int((height - 1) / over_lap_inc) * over_lap_inc + 1
if ch_flag==1:
print("reading the input file...")
time_series = np.loadtxt(input_file_name, delimiter = ",", usecols = (5,), skiprows = 1) #Obtenez le cours de clôture sous forme de tableau numpy
for i in range(over_lap_start, over_lap_end, over_lap_inc):
print("over_lap_start " + str(i))
temp_time_series = time_series[i:] #Changer l'heure de début de CWT
temp_scalogram, temp_label, freq = create_scalogram_1(temp_time_series, scales, wavelet, predict_time_inc, save_flag, ch_flag, height, width)
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Combinez tous les scalogrammes et étiquettes dans un seul tableau
label = np.append(label, temp_label)
# print("scalogram_shape " + str(scalogram.shape))
# print("label shape " + str(label.shape))
# print("frequency " + str(freq))
if ch_flag==5:
print("reading the input file...")
time_series = np.loadtxt(input_file_name, delimiter = ",", usecols = (2,3,4,5,6), skiprows = 1) #Obtenez le cours de clôture sous forme de tableau numpy
for i in range(over_lap_start, over_lap_end, over_lap_inc):
print("over_lap_start " + str(i))
temp_time_series = time_series[i:] #Changer l'heure de début de CWT
temp_scalogram, temp_label, freq = create_scalogram_5(temp_time_series, scales, wavelet, predict_time_inc, save_flag, ch_flag, height, width)
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Combinez tous les scalogrammes et étiquettes dans un seul tableau
label = np.append(label, temp_label)
label = label.astype(np.int)
return scalogram, label, freq
Recommended Posts