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%.
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.
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.
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
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".
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.
Figure 5. Structure de CNN
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.
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.
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