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.

image.png 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.

image.png 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.

image.png 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.

image.png 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.

image.png Figure 5. Flux d'apprentissage

La figure 6 montre la structure du CNN utilisé cette fois.

image.png 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.

image.png 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

Examen de la méthode de prévision des échanges utilisant le Deep Learning et la conversion en ondelettes
Collecte et automatisation d'images érotiques à l'aide du deep learning
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Méthode de suppression du bruit utilisant la conversion en ondelettes
[Détection d'anomalies] Essayez d'utiliser la dernière méthode d'apprentissage à distance
Signification des modèles et paramètres d'apprentissage en profondeur
Un mémorandum d'étude et de mise en œuvre du Deep Learning
Conversion en ondelettes d'images avec PyWavelets et OpenCV
Méthode de régression linéaire utilisant Numpy
Suppression de la brume à l'aide de Python detailEnhanceFilter
Méthode de suppression du bruit utilisant la conversion en ondelettes
Dérivés appris en utilisant Python- (1) Calcul du taux de change à terme-
Bibliothèque DNN (Deep Learning): Comparaison de chainer et TensorFlow (1)
Une méthode concrète pour prédire les courses de chevaux et simuler le taux de récupération par apprentissage automatique
Classifier les ensembles de données d'image CIFAR-10 à l'aide de divers modèles d'apprentissage en profondeur
Vérification et mise en œuvre de la méthode de reconstruction vidéo en utilisant GRU et Autoencoder
Deep running 2 Réglage de l'apprentissage profond
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement