Examen de la méthode de prévision des échanges utilisant le Deep Learning et la conversion en ondelettes - Partie 2

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 un outil qui peut être utilisé immédiatement. veuillez noter que. m (__) m [Article précédent] Examen de la méthode de prévision des échanges utilisant le Deep Learning et la conversion en ondelettes

Aperçu

La figure 1 résume ce que nous avons fait cette fois. Nous examinerons s'il est possible de prédire le mouvement (à la hausse ou à la baisse) du taux de change après 12 heures en convertissant continuellement en ondelettes le prix de clôture de la barre de 5 minutes USD / JPY et EUR / JPY, en l'imaginant et en laissant AI (CNN) l'apprendre. fait. Le taux de précision moyen pour les données de test avec le nombre d'apprentissage = 8000 ou plus (même si le nombre d'apprentissage est encore augmenté, le taux de précision des données de formation n'augmente pas) était de 53,7%.

image.png Figure 1. Résumé de ce que j'ai fait cette fois

Qu'est-ce que la conversion en ondelettes?

La figure 2 montre un diagramme schématique de la conversion en ondelettes. La transformation de Fourier 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 transformée de Fourier est bonne pour analyser les signaux stationnaires, la transformée en ondelettes convient pour analyser les formes d'onde irrégulières et non stationnaires.

image.png Figure 2. 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 3. Exemple de scalogramme, y = sin (πx / 16)

Il existe deux types de conversion en ondelettes: la conversion en ondelettes continue (CWT) et la conversion en ondelettes discrètes (DWT), 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.

Changements depuis la dernière fois

Considérez l'EUR / JPY en plus de l'USD / JPY

La dernière fois, nous avons prédit le mouvement des prix de USD / JPY à USD / JPY, mais cette fois, nous prédirons le mouvement de prix de USD / JPY et EUR / JPY à USD / JPY. Je voudrais créer un scalogramme à partir de données en même temps pour chacun des USD / JPY et EUR / JPY, mais les données d'échange que j'ai utilisées avaient un temps où les données manquaient. Par conséquent, il était nécessaire d'extraire uniquement les données d'échange de l'époque qui existent à la fois en USD / JPY et en EUR / JPY. J'ai donc créé le code suivant. À propos, les données d'échange que j'ai utilisées sont présentées dans le tableau 1.

Tableau 1. USD / JPY 5 minutes image.png

align_USD_EUR


import numpy as np

def align_USD_EUR(USD_csv, EUR_csv):
    """
    USD/JPY et EUR/Une fonction qui supprime les données manquantes en JPY et extrait le cours de clôture du temps qui existe dans les deux
    USD_csv : USD/JPY nom de fichier de 5 minutes
    EUR_csv : EUR/JPY nom de fichier de 5 minutes
    """
    
    USD = np.loadtxt(USD_csv, delimiter = ",", usecols = (0,1,5), skiprows = 1, dtype="S8")
    EUR = np.loadtxt(EUR_csv, delimiter = ",", usecols = (0,1,5), skiprows = 1, dtype="S8")
    print("EUR shape " + str(EUR.shape)) # for debag
    print("USD shape " + str(USD.shape)) # for debag
    print("")

    USD_close = USD[:,2]
    EUR_close = EUR[:,2]
    USD = np.core.defchararray.add(USD[:,0], USD[:,1])
    EUR = np.core.defchararray.add(EUR[:,0], EUR[:,1])

    #Index où les heures ne correspondent pas(idx_mismatch)Obtenir
    if USD.shape[0] > EUR.shape[0]:
    
        temp_USD = USD[:EUR.shape[0]]
        coincidence = EUR == temp_USD
        idx_mismatch = np.where(coincidence == False)
        idx_mismatch = idx_mismatch[0][0]

    elif EUR.shape[0] > USD.shape[0]:
    
        temp_EUR = EUR[:USD.shape[0]]
        coincidence = USD == temp_EUR
        idx_mismatch = np.where(coincidence == False)
        idx_mismatch = idx_mismatch[0][0]

    elif USD.shape[0] == EUR.shape[0]:
    
        coincidence = USD == EUR
        idx_mismatch = np.where(coincidence == False)
        idx_mismatch = idx_mismatch[0][0]
    
    while USD.shape[0] != idx_mismatch:
    
        print("idx mismatch " + str(idx_mismatch)) # for debag
        print("USD[idx_mismatch] " + str(USD[idx_mismatch]))
        print("EUR[idx_mismatch] " + str(EUR[idx_mismatch]))
    
        #Supprimer les données inutiles
        if USD[idx_mismatch] > EUR[idx_mismatch]:
            EUR = np.delete(EUR, idx_mismatch)
            EUR_close = np.delete(EUR_close, idx_mismatch)
        elif EUR[idx_mismatch] > USD[idx_mismatch]:
            USD = np.delete(USD, idx_mismatch)
            USD_close = np.delete(USD_close, idx_mismatch)
        
        print("EUR shape " + str(EUR.shape)) # for debag
        print("USD shape " + str(USD.shape)) # for debag
        print("")
        
        if USD.shape[0] > EUR.shape[0]:
    
            temp_USD = USD[:EUR.shape[0]]
            coincidence = EUR == temp_USD
            idx_mismatch = np.where(coincidence == False)
            idx_mismatch = idx_mismatch[0][0]

        elif EUR.shape[0] > USD.shape[0]:
    
            temp_EUR = EUR[:USD.shape[0]]
            coincidence = USD == temp_EUR
            idx_mismatch = np.where(coincidence == False)
            idx_mismatch = idx_mismatch[0][0]

        elif USD.shape[0] == EUR.shape[0]:
        
            coincidence = USD == EUR
            if (coincidence==False).any():
                idx_mismatch = np.where(coincidence == False)
                idx_mismatch = idx_mismatch[0][0]
            else:
                idx_mismatch = np.where(coincidence == True)
                idx_mismatch = idx_mismatch[0].shape[0]
    
    USD = np.reshape(USD, (-1,1))
    EUR = np.reshape(EUR, (-1,1))
    USD_close = np.reshape(USD_close, (-1,1))
    EUR_close = np.reshape(EUR_close, (-1,1))
    
    USD = np.append(USD, EUR, axis=1)
    USD = np.append(USD, USD_close, axis=1)
    USD = np.append(USD, EUR_close, axis=1)
    np.savetxt("USD_EUR.csv", USD, delimiter = ",", fmt="%s")
    
    return USD_close, EUR_close

Créer un scalogramme à partir de données de différentes périodes

La dernière fois, tous les scalogrammes ont été créés à partir de données de forme d'onde quotidiennes. Cependant, les personnes qui négocient réellement changent la période de la forme d'onde pour être évaluée si nécessaire. Par conséquent, cette fois, j'ai créé un scalogramme à partir des données de différentes périodes. La période de données a été sélectionnée comme suit. Il est possible de rendre la période de données plus fine, mais c'était la limite en raison de contraintes de mémoire. Données d'apprentissage: 1 jour, 1,5 jour, 2 jours, 2,5 jours, 3 jours Données de test: 1 jour Maintenant, le problème ici est que la taille du scalogramme change lorsque la période de données est modifiée. CNN ne peut pas apprendre des images de tailles différentes. Par conséquent, nous avons unifié la taille de l'image à 128x128 en utilisant la bibliothèque de traitement d'image "Pillow".

image.png Graphique 4. Diagramme schématique de la taille d'image unifiée

Redimensionner le scalogramme avec oreiller


from PIL import Image
"""
original_scalogram :Scalogramme original(tableau numpy)
width              :Largeur de l'image après redimensionnement(=128)
height             :Hauteur de l'image après le redimensionnement(=128)
"""
img_scalogram = Image.fromarray(original_scalogram)   #Convertir en objet image
img_scalogram = img_scalogram.resize((width, height)) #Redimensionnement de l'image
array_scalogram = np.array(img_scalogram)             #Convertir en tableau numpy

Structure CNN et flux d'apprentissage

La structure de CNN et le flux d'apprentissage sont représentés sur la figure 5 et la figure 6, respectivement.

image.png Figure 5. Structure de CNN

image.png Graphique 6. Flux d'apprentissage

Résultat du calcul

La figure 7 montre la transition du taux de réponse correct pour les données d'apprentissage et les données de test. Si le nombre de formations = 8000 ou plus, le taux de réponse correct pour les données de formation n'augmentera pas. Le taux de précision moyen pour les données de test avec le nombre d'apprentissage = 8000 à 20000 était de 53,7%. Il semble que le taux de réponse correcte des données de test augmente lorsque le nombre d'apprentissage = 0 à 4000, mais je ne peux rien dire à ce sujet.

image.png Graphique 7. Transition du taux de réponse correcte

Le résultat de la prédiction AI est émis avec une probabilité telle que "up: 82%, down: 18%". La figure 8 montre la transition des résultats de prédiction pour les données de test. Au début de l'apprentissage, la certitude est faible pour la plupart des données, par exemple «en hausse: 52%, en baisse: 48%». Cependant, à mesure que le nombre d'apprentissage augmente, il ne devient que 90% à 100%. Même si j'ai répondu avec une telle confiance, le taux de réponse correcte = 53,7% semble étrange.

image.png Figure 8. Transition des résultats de prédiction pour les données de test

À la fin

Ainsi, même si le taux de réponse correcte était> 50%, je ne peux toujours pas dire si c'était une coïncidence ou si je pouvais saisir les caractéristiques. .. .. Je pense qu'il est nécessaire de vérifier si le même taux de précision peut être obtenu en modifiant la période d'apprentissage et la période de test. Comme le montre la figure 8, le fait que les résultats de prédiction augmentent avec une certitude élevée à mesure que l'apprentissage progresse signifie que les données d'apprentissage contiennent des scalogrammes avec des caractéristiques similaires aux données de test. Je pense que la raison pour laquelle le taux de réponse correct n'augmente pas est que les futurs mouvements de prix ne correspondent pas entre les données d'entraînement et les données de test, même si le scalogramme est jugé similaire en IA. Par conséquent, en considérant non seulement l'euro mais aussi d'autres devises et données financières (augmentant le nombre de canaux de données), nous espérons que le scalogramme sera diversifié et que les juges d'erreur mentionnés ci-dessus pourront être réduits. Pour le moment, il y a trop de résultats de prédiction avec un degré de certitude élevé par rapport au taux de réponse correct. .. .. Lol

Yu-Nie

Appendix Les données utilisées pour l'analyse peuvent être téléchargées à partir de ce qui suit. USDJPY_20160301_20170228_5min.csv USDJPY_20170301_20170731_5min.csv EURJPY_20160301_20170228_5min.csv EURJPY_20170301_20170731_5min.csv

Voici le code utilisé pour l'analyse.

scalogram_test_7


# 20170731
# y.izumi

import tensorflow as tf
import numpy as np
import scalogram4 as sca #Module pour la création de FFT et de spectrogramme
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=5e-3): # 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")
#=============================================================================================================================================

"""Conditions de création du scalogramme"""
#=============================================================================================================================================
train_USD_csv = "USDJPY_20160301_20170228_5min.csv"   #Nom du fichier de données d'échange, train
train_EUR_csv = "EURJPY_20160301_20170228_5min.csv"
# train_USD_csv = "USDJPY_20170301_20170731_5min.csv"   #Nom du fichier de données d'échange, train, for debag
# train_EUR_csv = "EURJPY_20170301_20170731_5min.csv"
test_USD_csv = "USDJPY_20170301_20170731_5min.csv"    #Nom du fichier de données d'échange, test
test_EUR_csv = "EURJPY_20170301_20170731_5min.csv"
# scales = np.arange(1,129)
predict_time_inc = 144                          #Incrément de temps pour prédire les mouvements de prix
# train_heights = [288]                         #Hauteur du scallogramme, num of time lines,Précisez dans la liste
# test_heights = [288]
train_heights = [288, 432, 576, 720, 864]       #Hauteur du scallogramme, num of time lines,Précisez dans la liste
test_heights = [288]
base_height = 128                               #Hauteur du scalogramme utilisé pour les données d'entraînement
width = 128                                     #Largeur du scalogramme,  num of freq lines
ch_flag = 1                                     #Sélectionnez les données à utiliser parmi les quatre valeurs et le volume, ch_flag=1:close,En construction(ch_flag=2:close and volume, ch_flag=5:start, high, low, close, volume)
input_dim = (ch_flag, base_height, width)       # channel = (1, 2, 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, il devient haute fréquence
wavelet = "gaus1"                               #Nom de l'ondelette, 'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh'
tr_over_lap_inc = 4                             #Données de train incrémentielles de l'heure de début CWT
te_over_lap_inc = 36                            #Données de test d'incrémentation de l'heure de début CWT
#==============================================================================================================================================

"""Créer des scalogrammes et des étiquettes"""
#==============================================================================================================================================
# carry out CWT and make labels
print("Making the train data.")
x_train, t_train, freq = sca.merge_scalogram3(train_USD_csv, train_EUR_csv, scales, wavelet, train_heights, base_height, width, predict_time_inc, ch_flag, save_flag, tr_over_lap_inc)
# x_train, t_train, freq = sca.merge_scalogram3(test_USD_csv, test_EUR_csv, scales, wavelet, train_heights, base_height, width, predict_time_inc, ch_flag, save_flag, tr_over_lap_inc) # for debag

print("Making the test data.")
x_test, t_test, freq = sca.merge_scalogram3(test_USD_csv, test_EUR_csv, scales, wavelet, test_heights, base_height, width, predict_time_inc, ch_flag, save_flag, te_over_lap_inc)

# save scalograms and labels
print("Save scalogarams and labels")
np.savetxt(r"temp_result\x_train.csv", x_train.reshape(-1, 2*base_height*width), delimiter = ",")
np.savetxt(r"temp_result\x_test.csv", x_test.reshape(-1, 2*base_height*width), delimiter = ",")
np.savetxt(r"temp_result\t_train.csv", t_train, delimiter = ",", fmt = "%.0f")
np.savetxt(r"temp_result\t_test.csv", t_test, delimiter = ",", fmt = "%.0f")
np.savetxt(r"temp_result\frequency.csv", freq, delimiter = ",")

# load scalograms and labels
# print("Load scalogarams and labels")
# x_train = np.loadtxt(r"temp_result\x_train.csv", delimiter = ",")
# x_test = np.loadtxt(r"temp_result\x_test.csv", delimiter = ",")
# t_train = np.loadtxt(r"temp_result\t_train.csv", delimiter = ",", dtype = "i8")
# t_test = np.loadtxt(r"temp_result\t_test.csv", delimiter = ",", dtype = "i8")
# x_train = x_train.reshape(-1, 2, base_height, width)
# x_test = x_test.reshape(-1, 2, base_height, width)
# freq = np.loadtxt(r"temp_result\frequency.csv", delimiter = ",")

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("mean_t_train " + str(np.mean(t_train)))
print("mean_t_test " + str(np.mean(t_test)))
print("frequency " + str(freq))

#==============================================================================================================================================

"""Traitement de la forme des données"""
#==============================================================================================================================================
#É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
train_batch_size = 100          #Apprentissage de la taille du lot
test_batch_size = 600           #Taille du lot 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))
#==============================================================================================================================================

"""Construire un CNN"""
#==============================================================================================================================================
x  = tf.placeholder(tf.float32, [None, input_dim[1], input_dim[2], 2]) # (num_data, height(time), width(freq_lines), ch),ch est le nombre de canaux de données d'entrée, USD/JPY, EUR/JPY ⇒ ch = 2
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, 2, 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("conv3") as scope:
    W_conv3 = weight_variable([5, 5, 32, 64])
    b_conv3 = bias_variable([64])
    h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3)
    h_pool3 = max_pool_2x2(h_conv3)
    print("conv3 shape ", str(h_pool3.get_shape()))
    h_pool3_height = int(h_pool3.get_shape()[1])
    h_pool3_width = int(h_pool3.get_shape()[2])    
    
with tf.variable_scope("fc1") as scope:
    W_fc1 = weight_variable([h_pool3_height*h_pool3_width*64, 1024])
    b_fc1 = bias_variable([1024])
    h_pool3_flat = tf.reshape(h_pool3, [-1, h_pool3_height*h_pool3_width*64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool3_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_conv3 = tf.summary.histogram("W_conv3", W_conv3)
b_conv3 = tf.summary.histogram("b_conv3", b_conv3)
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_conv3 = tf.summary.histogram("dW_conv3", grads[4])
db_conv3 = tf.summary.histogram("db_conv3", grads[5])
dW_fc1 = tf.summary.histogram("dW_fc1", grads[6])
db_fc1 = tf.summary.histogram("db_fc1", grads[7])
dW_fc2 = tf.summary.histogram("dW_fc2", grads[8])
db_fc2 = tf.summary.histogram("db_fc2", grads[9])

# 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

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)
    
    for step in range(20001):
        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, replace=False)
            # 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}) #Les résultats de prédiction IA utilisent toutes les données
            # AI_prediction = y_conv.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0}) #Batch de test d'utilisation des résultats de 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 use all data
            # AI_correct_prediction = correct_prediction.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0}) #Bonne réponse:TRUE,Réponse incorrecte:FALSE use test batch
            
            # 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})

    #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, replace=False)
    # 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
#==============================================================================================================================================

scalogram4.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
from PIL import Image

def align_USD_EUR(USD_csv, EUR_csv):
    """USD/JPY et EUR/Une fonction qui supprime les données manquantes en JPY et extrait le cours de clôture du temps qui existe dans les deux"""
    
    USD = np.loadtxt(USD_csv, delimiter = ",", usecols = (0,1,5), skiprows = 1, dtype="S8")
    EUR = np.loadtxt(EUR_csv, delimiter = ",", usecols = (0,1,5), skiprows = 1, dtype="S8")
    # print("USD time " + str(USD[:,1])) # for debag
    print("EUR shape " + str(EUR.shape)) # for debag
    print("USD shape " + str(USD.shape)) # for debag
    print("")
                        
    # USD_num_data = USD.shape[0]
    # EUR_num_data = EUR.shape[0]
    # idx_difference = abs(USD_num_data - EUR_num_data)
    # print("USD num data " + str(USD_num_data)) # for debag

    USD_close = USD[:,2]
    EUR_close = EUR[:,2]
    USD = np.core.defchararray.add(USD[:,0], USD[:,1])
    EUR = np.core.defchararray.add(EUR[:,0], EUR[:,1])
    # print("USD " + str(USD)) # for debag

    #Index où les heures ne correspondent pas(idx_mismatch)Obtenir
    if USD.shape[0] > EUR.shape[0]:
    
        temp_USD = USD[:EUR.shape[0]]
#       print("EUR shape " + str(EUR.shape))           # for debag
#       print("temp USD shape " + str(temp_USD.shape)) # for debag
        coincidence = EUR == temp_USD
        idx_mismatch = np.where(coincidence == False)
        idx_mismatch = idx_mismatch[0][0]

    elif EUR.shape[0] > USD.shape[0]:
    
        temp_EUR = EUR[:USD.shape[0]]
#       print("temp EUR shape " + str(temp_EUR.shape)) # for debag
#       print("USD shape " + str(USD.shape))           # for debag
        coincidence = USD == temp_EUR
        idx_mismatch = np.where(coincidence == False)
        idx_mismatch = idx_mismatch[0][0]

    elif USD.shape[0] == EUR.shape[0]:
    
        coincidence = USD == EUR
        idx_mismatch = np.where(coincidence == False)
        idx_mismatch = idx_mismatch[0][0]
    
    while USD.shape[0] != idx_mismatch:
    
        print("idx mismatch " + str(idx_mismatch)) # for debag
        print("USD[idx_mismatch] " + str(USD[idx_mismatch]))
        print("EUR[idx_mismatch] " + str(EUR[idx_mismatch]))
    
        #Supprimer les données inutiles
        if USD[idx_mismatch] > EUR[idx_mismatch]:
            EUR = np.delete(EUR, idx_mismatch)
            EUR_close = np.delete(EUR_close, idx_mismatch)
        elif EUR[idx_mismatch] > USD[idx_mismatch]:
            USD = np.delete(USD, idx_mismatch)
            USD_close = np.delete(USD_close, idx_mismatch)
        
        print("EUR shape " + str(EUR.shape)) # for debag
        print("USD shape " + str(USD.shape)) # for debag
        print("")
        
        if USD.shape[0] > EUR.shape[0]:
    
            temp_USD = USD[:EUR.shape[0]]
#           print("EUR shape " + str(EUR.shape))           # for debag
#           print("temp USD shape " + str(temp_USD.shape)) # for debag
            coincidence = EUR == temp_USD
            idx_mismatch = np.where(coincidence == False)
            idx_mismatch = idx_mismatch[0][0]

        elif EUR.shape[0] > USD.shape[0]:
    
            temp_EUR = EUR[:USD.shape[0]]
#           print("temp EUR shape " + str(temp_EUR.shape)) # for debag
#           print("USD shape " + str(USD.shape))           # for debag
            coincidence = USD == temp_EUR
            idx_mismatch = np.where(coincidence == False)
            idx_mismatch = idx_mismatch[0][0]

        elif USD.shape[0] == EUR.shape[0]:
        
            coincidence = USD == EUR
            if (coincidence==False).any():
                idx_mismatch = np.where(coincidence == False)
                idx_mismatch = idx_mismatch[0][0]
            else:
                idx_mismatch = np.where(coincidence == True)
                idx_mismatch = idx_mismatch[0].shape[0]
    
    USD = np.reshape(USD, (-1,1))
    EUR = np.reshape(EUR, (-1,1))
    USD_close = np.reshape(USD_close, (-1,1))
    EUR_close = np.reshape(EUR_close, (-1,1))
    
    USD = np.append(USD, EUR, axis=1)
    USD = np.append(USD, USD_close, axis=1)
    USD = np.append(USD, EUR_close, axis=1)
    np.savetxt("USD_EUR.csv", USD, delimiter = ",", fmt="%s")
    
    return USD_close, EUR_close

def variable_timelines_scalogram_1(time_series, scales, wavelet, predict_time_inc, save_flag, ch_flag, heights, base_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, il devient haute fréquence
    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
    heights          :Hauteur de l'image nombre de lignes temporelles,Précisez dans la liste
    width            :Largeur de l'image nombre de lignes de fréquence
    base_height      :Hauteur du scalogramme utilisé pour les données d'entraînement
    """
    
    """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
    scalogram = np.empty((0, ch_flag, base_height, width))
    label_array = np.array([])
    
    for height in heights:
        print("   time line = ", height)
        print("   carry out cwt...")
        time_start = 0
        time_end = time_start + height
        # 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,:]
            
            if height != base_height:
                img_scalogram = Image.fromarray(temp_cwt_close)
                img_scalogram = img_scalogram.resize((width, base_height))
                temp_cwt_close = np.array(img_scalogram)
            
            temp_cwt_close = np.reshape(temp_cwt_close, (-1, ch_flag, base_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
            
        print("      scalogram shape " + str(scalogram.shape))
    
        """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:]
        temp_label_array = predict_close > corrent_close
        # print(temp_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
        """
    
        """temp_label_array(time),Tranche de sorte que le temps soit divisible par la hauteur"""
        raw_num_shift = temp_label_array.shape[0]
        num_shift = int(raw_num_shift / height) * height
        temp_label_array = temp_label_array[0:num_shift]
        
        """Extraction d'étiquettes correspondant à chaque scalogramme, (Le nombre de données,étiquette)"""
        col = height - 1
        temp_label_array = np.reshape(temp_label_array, (-1, height))
        temp_label_array = temp_label_array[:, col]
        label_array = np.append(label_array, temp_label_array)
        
        print("      label shape " + str(label_array.shape))

    """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_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, il devient haute fréquence
    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 d'é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, il devient haute fréquence
    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 d'é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, il devient haute fréquence
    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 #
        else:
            label = 1 #
            
        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
    """
      
    """"""
    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):
    """

    cwt_list    :
    label_array :
    height      :Sortie de fichier à monter Utiliser le prix de clôture Liste de résultats CWT tableau numpy contenant des étiquettes 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 d'é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, il devient haute fréquence
    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 d'é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, il devient haute fréquence
    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 d'é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, il devient haute fréquence
    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 en 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 en 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 en 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, il devient haute fréquence
    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 en 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 en un seul tableau
            label = np.append(label, temp_label)
        
    label = label.astype(np.int)
    return scalogram, label, freq

def merge_scalogram2(input_file_name, scales, wavelet, heights, base_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, il devient haute fréquence
    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
    heights          :Hauteur de l'image nombre de lignes temporelles,Précisez dans la liste
    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
    base_height      :Hauteur du scalogramme utilisé pour les données d'entraînement
    """

    scalogram = np.empty((0, ch_flag, base_height, width)) #Un tableau qui stocke tous les scalogrammes et étiquettes
    label = np.array([])
    over_lap_start = 0
    over_lap_end = int((base_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 = variable_timelines_scalogram_1(temp_time_series, scales, wavelet, predict_time_inc, save_flag, ch_flag, heights, base_height, width)
            scalogram = np.append(scalogram, temp_scalogram, axis=0) #Combinez tous les scalogrammes et étiquettes en 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))
        
    label = label.astype(np.int)
    return scalogram, label, freq

def merge_scalogram3(USD_csv, EUR_csv, scales, wavelet, heights, base_height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc):
    """
    USD_csv          : USD/JPY Exchange nom du fichier de données
    EUR_csv          : EUR/JPY Exchange nom du fichier de données
    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, il devient haute fréquence
    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
    heights          :Hauteur de l'image nombre de lignes temporelles,Précisez dans la liste
    width            :Largeur de l'image nombre de lignes de fréquence
    ch_flag          :Nombre de canaux à utiliser, ch_flag=1:close,En construction(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
    base_height      :Hauteur du scalogramme utilisé pour les données d'entraînement
    """

    scalogram = np.empty((0, 2, base_height, width)) #Un tableau qui stocke tous les scalogrammes et étiquettes
    label = np.array([])
    over_lap_start = 0
    over_lap_end = int((base_height - 1) / over_lap_inc) * over_lap_inc + 1
    
    if ch_flag==1:
        
        print("Reading the input file...")    
        USD_close, EUR_close = align_USD_EUR(USD_csv, EUR_csv) # USD/JPY et EUR/Supprimer les données manquantes en JPY et extraire le cours de clôture du temps qui existe dans les deux
        
        for i in range(over_lap_start, over_lap_end, over_lap_inc):
            print("Over Lap Start " + str(i))
            temp_USD_close = USD_close[i:] #Changer l'heure de début de CWT
            temp_EUR_close = EUR_close[i:]
            print("CWT USD/JPY")
            temp_USD_scalogram, temp_USD_label, USD_freq = variable_timelines_scalogram_1(temp_USD_close, scales, wavelet, predict_time_inc, save_flag, ch_flag, heights, base_height, width)
            print("CWT EUR/JPY")
            temp_EUR_scalogram, temp_EUR_label, EUR_freq = variable_timelines_scalogram_1(temp_EUR_close, scales, wavelet, predict_time_inc, save_flag, ch_flag, heights, base_height, width)
            
            # print("temp USD scalogram shape " + str(temp_USD_scalogram.shape))
            # print("temp EUR scalogram shape " + str(temp_EUR_scalogram.shape))
            
            temp_scalogram = np.append(temp_USD_scalogram, temp_EUR_scalogram, axis=1)
            
            # print("temp scalogram shape " + str(temp_scalogram.shape))
            
            scalogram = np.append(scalogram, temp_scalogram, axis=0) #Combinez tous les scalogrammes et étiquettes en un seul tableau
            label = np.append(label, temp_USD_label)
            # label = np.append(label, temp_EUR_label)
            
            print("Scalogram shape " + str(scalogram.shape))
            print("Label shape " + str(label.shape))
            print("")
        
        # print("scalogram_shape " + str(scalogram.shape))
        # print("label shape " + str(label.shape))
        # print("frequency " + str(freq))
        
    label = label.astype(np.int)
    return scalogram, label, USD_freq

Recommended Posts

Examen de la méthode de prévision des échanges utilisant le Deep Learning et la conversion en ondelettes - Partie 2
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
[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
Apprentissage parallèle du deep learning par Keras et Kubernetes
Deep learning 1 Pratique du deep learning
Bibliothèque DNN (Deep Learning): Comparaison de chainer et TensorFlow (1)
Deep running 2 Réglage de l'apprentissage profond
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
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Avantages et exemples d'utilisation de Rabbit Mq
Importance de l'apprentissage automatique et de l'apprentissage par mini-lots
Méthode de suppression du bruit utilisant la conversion en ondelettes
Organisez des plateformes d'apprentissage automatique et d'apprentissage en profondeur
J'ai essayé l'apprentissage en profondeur avec Theano
Prévisions des ventes de collations avec apprentissage en profondeur
Graphique de l'historique du nombre de couches de deep learning et du changement de précision
Analyser émotionnellement les données de bouche-à-oreille d'entreprise des réunions de changement de carrière à l'aide de l'apprentissage en profondeur
Procédure d'apprentissage automatique de base: ③ Comparez et examinez la méthode de sélection de la quantité de caractéristiques
J'ai essayé l'histoire courante de l'utilisation du Deep Learning pour prédire la moyenne Nikkei
Les débutants du Deep Learning ont essayé les prévisions météorologiques à partir d'images satellitaires météorologiques à l'aide de Keras
J'ai essayé l'histoire courante de prédire la moyenne Nikkei à l'aide du Deep Learning (backtest)
Mise en œuvre et expérience de la méthode de clustering convexe
Apprentissage semi-supervisé des étiquettes avec DBN et Label Spreading
Exemple d'utilisation de variables de classe et de méthodes de classe
Othello-De la troisième ligne de "Implementation Deep Learning" (3)
Introduction au Deep Learning ~ Pliage et mise en commun ~
Modèle de reconnaissance d'image utilisant l'apprentissage profond en 2016
Essayez les prévisions de prix Bitcoin avec Deep Learning
Prévision du cours des actions à l'aide du Deep Learning (TensorFlow)
Essayez l'apprentissage profond de la génomique avec Kipoi
Visualisez les effets de l'apprentissage profond / de la régularisation
Analyse émotionnelle des tweets avec apprentissage en profondeur
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
Note récapitulative sur l'apprentissage profond -4.3 Méthode de gradient
Othello-De la troisième ligne de "Implementation Deep Learning" (2)
[Pour les débutants en intelligence artificielle] Parcours d'apprentissage et de référence en apprentissage automatique / programmation en profondeur
Deep Learning from scratch La théorie et la mise en œuvre de l'apprentissage profond appris avec Python Chapitre 3
Créez un environnement python pour apprendre la théorie et la mise en œuvre de l'apprentissage profond
[Deep Learning from scratch] Valeur initiale du poids du réseau neuronal utilisant la fonction sigmoïde
Un mémorandum de méthode souvent utilisé dans l'apprentissage automatique utilisant scikit-learn (pour les débutants)