[PYTHON] Untersuchung der Austauschprognosemethode mittels Deep Learning und Wavelet-Konvertierung
Einführung
Diese Methode hat noch keine guten Ergebnisse erzielt. Ich probiere Ideen als Hobby aus, daher denke ich nicht, dass es für diejenigen nützlich sein wird, die nach einem Werkzeug suchen, das sofort verwendet werden kann. bitte beachte, dass. m (__) m Im vorherigen und zwei vorherigen Artikeln habe ich eine Tonanalysetechnologie namens Spektrogramm verwendet, um Datenaustauschdaten (USD / JPY) zu erhalten, und sie mit CNN gelernt. Das Ergebnis war eine schreckliche Niederlage. Die Genauigkeitsrate für die Testdaten stieg nicht an.
[Vorheriger Artikel] Untersuchung der Austauschprognosemethode mit Deep Learning und Spectrogram [Vorheriger Artikel] Untersuchung der Austauschprognosemethode unter Verwendung von Deep Learning und Spectrogram-Part 2-
Als ich darüber nachdachte, was ich als nächstes tun sollte, fand ich einen Artikel, in dem die Wavelet-Konvertierung für die Analyse von Finanzdaten kompatibler ist als die FFT. Daher habe ich diesmal untersucht, ob es möglich ist, durch Kombination von Wavelet-Umwandlung und CNN vorherzusagen, dass der Wechselkurs in 30 Minuten steigen oder fallen wird.
Was ist Wavelet-Konvertierung?
1 zeigt ein schematisches Diagramm der Wavelet-Umwandlung. FFT, die bis zum vorherigen Artikel verwendet wurde, ist eine Analysemethode, die eine komplexe Wellenform durch Hinzufügen unendlich kontinuierlicher Sinuswellen ausdrückt. Andererseits drückt die Wavelet-Transformation eine komplizierte Wellenform durch Hinzufügen lokalisierter Wellen (Wavelets) aus. Während FFT stationäre Signale gut analysieren kann, eignet sich die Wavelet-Transformation zur Analyse unregelmäßiger und instationärer Wellenformen.
Abbildung 1. Schematische Darstellung der Wavelet-Umwandlung
Quelle: https://www.slideshare.net/ryosuketachibana12/ss-42388444
Ein Skalogramm ist eine Abbildung der Wavelet-Stärke bei jeder Verschiebung (Zeit) und jeder Skala (Frequenz). Fig. 2 ist ein Skalogramm, das aus dem Wavelet-Umwandlungsergebnis von y = sin (πx / 16) erstellt wurde. Durch Verwendung der Wavelet-Umwandlung auf diese Weise können beliebige Wellenformen abgebildet werden.
Figur 2. Beispiel für ein Skalogramm: y = sin (πx / 16)
Es gibt zwei Arten der Wavelet-Umwandlung: die kontinuierliche Wavelet-Umwandlung (CWT) und die diskrete Wavelet-Umwandlung (DWT). Diesmal haben wir jedoch die kontinuierliche Wavelet-Umwandlung verwendet. Es gibt verschiedene Formen von Wavelets, aber vorerst wird die Gauß-Funktion verwendet.
Erstellen Sie ein Skalogramm aus Währungsdaten
Ich habe ein Skalogramm aus dem Schlusskurs des 5-Minuten-Balkens von USD / JPY erstellt. Das Verfahren, mehrere Jahre lang 24-Stunden-Daten aus einer großen Datenmenge zu extrahieren und ein Skalogramm zu erstellen, wurde viele Male wiederholt. Ein Skalogramm und die Preisbewegung (nach oben oder unten) 30 Minuten nach der Endzeit sind ein Datensatz. Hier gab es ein Problem. Es ist so, dass die Grenze (das Ende) des Skalogramms verzerrt ist. Dies geschieht, weil Sie beim Überschreiten der Grenze Daten verlieren.
Figur 3. Verzerrung an der Skalogrammgrenze
Um die Verzerrung zu beseitigen, wurden daher an beiden Enden der Rohdaten invertierte Daten von links nach rechts hinzugefügt. Nach der Wavelet-Konvertierung wurde nur der den Rohdaten entsprechende zentrale Teil extrahiert. Diese Methode wird im Allgemeinen verwendet, um Verzerrungen zu beseitigen. Es scheint jedoch Vor- und Nachteile zu geben, da fiktive Daten hinzugefügt werden.
Figur 4. So entfernen Sie Verzerrungen an der Grenze
CNN-Struktur und Lernfluss
Ich habe mir einen kleinen Lernfluss ausgedacht. Bis zum letzten Mal haben wir die Daten der letzten 10 Jahre trainiert und die Richtigkeit mit den Daten der letzten 3 Monate überprüft. Dieses Mal haben wir nach dem Training der Daten für die letzten 10 Jahre die Daten für die letzten 5 Jahre trainiert und dann den Trainingsdatenzeitraum auf 2 Jahre und 1 Jahr verkürzt. Der Grund dafür ist, dass wir die neuesten Preisbewegungen hervorheben sollten, um die Zukunft vorherzusagen. Wir haben auch den Testdatenzeitraum auf 5 Monate erhöht. Die Testdaten werden nicht für das Training verwendet. Mit anderen Worten, es sind unbekannte Daten für AI.
Abbildung 5. Lernfluss
Abbildung 6 zeigt die Struktur des diesmal verwendeten CNN.
Abbildung 6. Struktur von CNN verwendet dieses Mal
Berechnungsergebnis
Also habe ich es versucht, während ich dachte, dass es gut gehen sollte, aber das Ergebnis ist wie in Abb. 7 gezeigt. Auch diesmal stieg die Genauigkeitsrate für die Testdaten nicht an. Übrigens sinkt die korrekte Antwortrate für die Trainingsdaten bei Iterationen = 20000, 30000, was mit dem Zeitpunkt zusammenfällt, zu dem die Trainingsdatenperiode umgeschaltet wird.
Abbildung 7. Berechnungsergebnis
abschließend
Ich denke, dass die Tatsache, dass die in einem Skalogramm enthaltenen Zeitinformationen konstant sind, einer der Gründe ist, warum es nicht funktioniert. Dieses Mal wird jedes Skalogramm aus 24-Stunden-Wellenformdaten erstellt. Personen, die tatsächlich handeln, ändern den Zeitraum der zu bewertenden Wellenform nach Bedarf. Vor kurzem habe ich mich für "Spieltheorie" interessiert und studiere sie, also mache ich eine Weile Pause von der Währungsanalyse.
Yu-Nie
Appendix Die für die Analyse verwendeten Daten können wie folgt heruntergeladen werden. Trainingsdaten USDJPY_20070301_20170228_5min.csv USDJPY_20120301_20170228_5min.csv USDJPY_20150301_20170228_5min.csv USDJPY_20160301_20170228_5min.csv Testdaten USDJPY_20170301_20170731_5min.csv
Unten finden Sie den Code, der für die Analyse verwendet wird.
Jack_for_qiita_TF_version.py
# 20170821
# y.izumi
import tensorflow as tf
import numpy as np
import scalogram2 as sca
import time
"""Funktionen, die Parameterinitialisierung, Faltungsoperationen und Pooling-Operationen ausführen"""
#=============================================================================================================================================
#Gewichtsinitialisierungsfunktion
def weight_variable(shape, stddev=1e-4): # default stddev = 1e-4
initial = tf.truncated_normal(shape, stddev=stddev)
return tf.Variable(initial)
#Bias-Initialisierungsfunktion
def bias_variable(shape):
initial = tf.constant(0.0, shape=shape)
return tf.Variable(initial)
#Klappvorgang
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")
#=============================================================================================================================================
"""Funktionen, die das Lernen durchführen"""
#=============================================================================================================================================
def train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size):
"""
x_train :Trainingsdaten
t_train :Lernetikett, one-hot
x_test :Testdaten
t_test :Testetikett, one-hot
iters :Anzahl des Lernens
acc_list :Liste, um den Fortschritt der richtigen Antwortrate zu speichern
num_data_each_conf :Eine Liste, in der der Fortschritt der Anzahl der Daten für jede Sicherheit gespeichert wird
acc_each_conf :Eine Liste, die den Fortschritt der richtigen Antwortrate für jede Sicherheit speichert
total_cal_time :Gesamtberechnungszeit
train_step :Lernklasse
train_batch_size :Stapelgröße der Trainingsdaten
test_batch_size :Stapelgröße der Testdaten
"""
train_size = x_train.shape[0] #Anzahl der Trainingsdaten
test_size = x_test.shape[0] #Anzahl der Testdaten
start_time = time.time()
iters = iters + 1
for step in range(iters):
batch_mask = np.random.choice(train_size, train_batch_size)
tr_batch_xs = x_train[batch_mask]
tr_batch_ys = t_train[batch_mask]
#Bestätigung der Genauigkeit während des Lernens
if step%100 == 0:
cal_time = time.time() - start_time #Berechnungszeit zählen
total_cal_time += cal_time
# train
train_accuracy = accuracy.eval(feed_dict={x: tr_batch_xs, y_: tr_batch_ys, keep_prob: 1.0})
train_loss = cross_entropy.eval(feed_dict={x: tr_batch_xs, y_: tr_batch_ys, keep_prob: 1.0})
# test
# use all data
test_accuracy = accuracy.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0})
test_loss = cross_entropy.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0})
# use test batch
# batch_mask = np.random.choice(test_size, test_batch_size)
# te_batch_xs = x_test[batch_mask]
# te_batch_ys = t_test[batch_mask]
# test_accuracy = accuracy.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0})
# test_loss = cross_entropy.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0})
print("calculation time %d sec, step %d, training accuracy %g, training loss %g, test accuracy %g, test loss %g"%(cal_time, step, train_accuracy, train_loss, test_accuracy, test_loss))
acc_list.append([step, train_accuracy, test_accuracy, train_loss, test_loss])
AI_prediction = y_conv.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0}) #Ergebnis der KI-Vorhersage
# 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}) #Richtige Antwort:TRUE,Falsche Antwort:FALSE
# print("AI_prediction.shape " + str(AI_prediction.shape)) # for debag
# print("AI_prediction.type" + str(type(AI_prediction)))
AI_correct_prediction_int = AI_correct_prediction.astype(np.int) #Richtige Antwort:1,Falsche Antwort:0
#Berechnen Sie die Anzahl der Daten und die Genauigkeitsrate für jede Sicherheit
# 50%das ist alles,60%Die folgende Gewissheit(or 40%das ist alles,50%Die folgende Gewissheit)
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) #Vertrauen ist 50%Ab 60%Anzahl der Daten
acc_50to60 = np.sum(correct_prediction_50to60_int) / sum_50to60 #Vertrauen ist 50%Ab 60%Richtige Antwortrate
# 60%Größer,70%Die folgende Gewissheit(or 30%das ist alles,40%Weniger Sicherheit)
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%Größer,80%Die folgende Gewissheit(or 20%das ist alles,30%Weniger Sicherheit)
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%Größer,90%Die folgende Gewissheit(or 10%das ist alles,20%Weniger Sicherheit)
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%Größer,100%Die folgende Gewissheit(or 0%das ist alles,10%Weniger Sicherheit)
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])
#Exportieren Sie Dateien für 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()
#Ausführung des Lernens
train_step.run(feed_dict={x: tr_batch_xs, y_: tr_batch_ys, keep_prob: 0.5})
return acc_list, num_data_each_conf, acc_each_conf, total_cal_time
#==============================================================================================================================================
"""Funktionen zum Erstellen von Skalogrammen und Beschriftungen"""
#==============================================================================================================================================
def make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc):
"""
train_file_name :Name der Trainingsdatendatei
test_file_name :Name der Testdatendatei
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
height :Bildhöhe, num of time lines
width :Bild breite, num of freq lines
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
ch_flag :Anzahl der zu verwendenden Kanäle, ch_flag=1:close, ch_flag=5:start, high, low, close, volume
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
over_lap_inc :CWT-Startzeitinkrement
"""
#Skalogramme und Beschriftungen erstellen
# train
x_train, t_train, freq_train = sca.merge_scalogram(train_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
# x_train, t_train, freq_train = sca.merge_scalogram(test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc) # for debag
# test
x_test, t_test, freq_test = sca.merge_scalogram(test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
print("x_train shape " + str(x_train.shape))
print("t_train shape " + str(t_train.shape))
print("x_test shape " + str(x_test.shape))
print("t_test shape " + str(t_test.shape))
print("frequency " + str(freq_test))
#Tauschen Sie die Abmessungen für den Tensorfluss aus
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] #Anzahl der Trainingsdaten
test_size = x_test.shape[0] #Anzahl der Testdaten
# labes to one-hot
t_train_onehot = np.zeros((train_size, 2))
t_test_onehot = np.zeros((test_size, 2))
t_train_onehot[np.arange(train_size), t_train] = 1
t_test_onehot[np.arange(test_size), t_test] = 1
t_train = t_train_onehot
t_test = t_test_onehot
# print("t train shape onehot" + str(t_train.shape)) # for debag
# print("t test shape onehot" + str(t_test.shape))
return x_train, t_train, x_test, t_test
#==============================================================================================================================================
"""Bedingungen für die Erstellung von Skalogrammen"""
#=============================================================================================================================================
predict_time_inc = 6 #Zeitinkrement zur Vorhersage von Preisbewegungen
height = 288 #Bildhöhe, num of time lines
width = 128 #Bild breite, num of freq lines
ch_flag = 1 #Anzahl der zu verwendenden Kanäle, ch_flag=1:close, ch_flag=5:start, high, low, close, volume
input_dim = (ch_flag, height, width) # channel = (1, 5), height(time_lines), width(freq_lines)
save_flag = 0 # save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
scales = np.linspace(0.2,80,width) #Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
# scales = np.arange(1,129)
wavelet = "gaus1" #Wavelet Name, 'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
over_lap_inc = 72 #CWT-Startzeitinkrement
#==============================================================================================================================================
"""CNN bauen"""
#==============================================================================================================================================
x = tf.placeholder(tf.float32, [None, input_dim[1], input_dim[2], input_dim[0]]) # (num_data, height(time), width(freq_lines), ch)
y_ = tf.placeholder(tf.float32, [None, 2]) # (num_data, num_label)
print("input shape ", str(x.get_shape()))
with tf.variable_scope("conv1") as scope:
W_conv1 = weight_variable([5, 5, input_dim[0], 16])
b_conv1 = bias_variable([16])
h_conv1 = tf.nn.relu(conv2d(x, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
print("conv1 shape ", str(h_pool1.get_shape()))
with tf.variable_scope("conv2") as scope:
W_conv2 = weight_variable([5, 5, 16, 32])
b_conv2 = bias_variable([32])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
print("conv2 shape ", str(h_pool2.get_shape()))
h_pool2_height = int(h_pool2.get_shape()[1])
h_pool2_width = int(h_pool2.get_shape()[2])
with tf.variable_scope("fc1") as scope:
W_fc1 = weight_variable([h_pool2_height*h_pool2_width*32, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, h_pool2_height*h_pool2_width*32])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
print("fc1 shape ", str(h_fc1.get_shape()))
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
with tf.variable_scope("fc2") as scope:
W_fc2 = weight_variable([1024, 2])
b_fc2 = bias_variable([2])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
print("output shape ", str(y_conv.get_shape()))
#Visualisieren Sie Parameter mit Tensorboard
W_conv1 = tf.summary.histogram("W_conv1", W_conv1)
b_conv1 = tf.summary.histogram("b_conv1", b_conv1)
W_conv2 = tf.summary.histogram("W_conv2", W_conv2)
b_conv2 = tf.summary.histogram("b_conv2", b_conv2)
W_fc1 = tf.summary.histogram("W_fc1", W_fc1)
b_fc1 = tf.summary.histogram("b_fc1", b_fc1)
W_fc2 = tf.summary.histogram("W_fc2", W_fc2)
b_fc2 = tf.summary.histogram("b_fc2", b_fc2)
#==============================================================================================================================================
"""Angabe der Fehlerfunktion"""
#==============================================================================================================================================
# 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
#==============================================================================================================================================
"""Geben Sie den Optimierer an"""
#==============================================================================================================================================
optimizer = tf.train.AdamOptimizer(1e-4)
train_step = optimizer.minimize(cross_entropy)
#Visualisieren Sie den Verlauf mit einem Tensorboard
grads = optimizer.compute_gradients(cross_entropy)
dW_conv1 = tf.summary.histogram("dW_conv1", grads[0]) # for tensorboard
db_conv1 = tf.summary.histogram("db_conv1", grads[1])
dW_conv2 = tf.summary.histogram("dW_conv2", grads[2])
db_conv2 = tf.summary.histogram("db_conv2", grads[3])
dW_fc1 = tf.summary.histogram("dW_fc1", grads[4])
db_fc1 = tf.summary.histogram("db_fc1", grads[5])
dW_fc2 = tf.summary.histogram("dW_fc2", grads[6])
db_fc2 = tf.summary.histogram("db_fc2", grads[7])
# for i in range(8): # for debag
# print(grads[i])
#==============================================================================================================================================
"""Parameter zur Genauigkeitsüberprüfung"""
#==============================================================================================================================================
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
#==============================================================================================================================================
"""Ausführung des Lernens"""
#==============================================================================================================================================
acc_list = [] #Liste, um die Genauigkeitsrate und den Fortschritt des Fehlers zu speichern
num_data_each_conf = [] #Eine Liste, in der der Fortschritt der Anzahl der Daten für jede Sicherheit gespeichert wird
acc_each_conf = [] #Eine Liste, die den Fortschritt der richtigen Antwortrate für jede Sicherheit speichert
start_time = time.time() #Berechnungszeit zählen
total_cal_time = 0
iters = 10000 #Anzahl der Trainings für jede Trainingsdaten
train_batch_size = 100 #Stapelgröße lernen
test_batch_size = 100 #Chargengröße testen
with tf.Session() as sess:
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
#Exportieren Sie Dateien für Tensorboard
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(r"temp_result", sess.graph)
print("learning term = 10year")
train_file_name = "USDJPY_20070301_20170228_5min.csv" #Name der Exchange-Datendatei, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Name der Exchange-Datendatei, test
#Skalogramm erstellen
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Ausführung des Lernens
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
print("learning term = 5year")
train_file_name = "USDJPY_20120301_20170228_5min.csv" #Name der Exchange-Datendatei, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Name der Exchange-Datendatei, test
#Skalogramm erstellen
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Ausführung des Lernens
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
print("learning term = 2year")
train_file_name = "USDJPY_20150301_20170228_5min.csv" #Name der Exchange-Datendatei, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Name der Exchange-Datendatei, test
#Skalogramm erstellen
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Ausführung des Lernens
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
print("learning term = 1year")
train_file_name = "USDJPY_20160301_20170228_5min.csv" #Name der Exchange-Datendatei, train
# train_file_name = "USDJPY_20170301_20170731_5min.csv" # for debag
test_file_name = "USDJPY_20170301_20170731_5min.csv" #Name der Exchange-Datendatei, test
#Skalogramm erstellen
x_train, t_train, x_test, t_test = make_scalogram(train_file_name, test_file_name, scales, wavelet, height, width, predict_time_inc, ch_flag, save_flag, over_lap_inc)
#Ausführung des Lernens
acc_list, num_data_each_conf, acc_each_conf, total_cal_time = train(x_train, t_train, x_test, t_test, iters, acc_list, num_data_each_conf, acc_each_conf, total_cal_time, train_step, train_batch_size, test_batch_size)
#Endgültige Genauigkeitsrate für Testdaten
# use all data
print("test accuracy %g"%accuracy.eval(feed_dict={x: x_test, y_: t_test, keep_prob: 1.0}))
# use test batch
# batch_mask = np.random.choice(test_size, test_batch_size)
# te_batch_xs = x_test[batch_mask]
# te_batch_ys = t_test[batch_mask]
# test_accuracy = accuracy.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0})
print("total calculation time %g sec"%total_cal_time)
np.savetxt(r"temp_result\acc_list.csv", acc_list, delimiter = ",") #Schreiben Sie die richtige Antwortrate und den Fortschritt des Fehlers auf
np.savetxt(r"temp_result\number_of_data_each_confidence.csv", num_data_each_conf, delimiter = ",") #Exportieren des Fortschritts der Anzahl der Daten für jede Sicherheit
np.savetxt(r"temp_result\accuracy_rate_of_each_confidence.csv", acc_each_conf, delimiter = ",") #Schreiben Sie den Fortschritt der richtigen Antwortrate für jede Gewissheit auf
saver.save(sess, r"temp_result\spectrogram_model.ckpt") #Exportieren Sie die endgültigen Parameter
#==============================================================================================================================================
scalogram2.py
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 25 11:24:50 2017
@author: izumiy
"""
import pywt
import numpy as np
import matplotlib.pyplot as plt
def create_scalogram_1(time_series, scales, wavelet, predict_time_inc, save_flag, ch_flag, height, width):
"""
Funktion zur Durchführung einer kontinuierlichen Wavelet-Transformation
Schlusskurs verwenden
time_series :Daten austauschen,Schlusskurs
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
ch_flag :Anzahl der zu verwendenden Kanäle, ch_flag=1 : close
height :Bildhöhe Anzahl der Zeitlinien
width :Bildbreite Anzahl der Frequenzlinien
"""
"""Austausch von Zeitreihendaten"""
num_series_data = time_series.shape[0] #Holen Sie sich die Anzahl der Daten
print("number of the series data : " + str(num_series_data))
close = time_series
"""Führen Sie eine kontinuierliche Wavelet-Konvertierung durch"""
# 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) #Summen Fenster
# hanningWindow = np.hanning(height) #Hanning-Fenster
# blackmanWindow = np.blackman(height) #Blackman-Fenster
# bartlettWindow = np.bartlett(height) #Bartlett-Fenster
while(time_end <= num_series_data - predict_time_inc):
# print("time start " + str(time_start)) for debag
temp_close = close[time_start:time_end]
#Mit Fensterfunktion
# temp_close = temp_close * hammingWindow
#Spiegel,Fügen Sie vor und nach den Daten invertierte Daten hinzu
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) #Führen Sie eine kontinuierliche Wavelet-Konvertierung durch
temp_cwt_close = temp_cwt_close.T #Translokation CWT(freq, time) ⇒ CWT(time, freq)
#Spiegel,Extrahieren Sie nur die zentralen Daten
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
"""Etikett erstellen"""
print("make label...")
#So vergleichen Sie zwei Sequenzen
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
"""
#Wie man es benutzt,langsam
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 #Gehen
else:
label = 1 #Geh hinauf
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),Schneiden Sie so, dass die Zeit durch die Höhe teilbar ist"""
raw_num_shift = label_array.shape[0]
num_shift = int(raw_num_shift / height) * height
label_array = label_array[0:num_shift]
"""Extraktion von Etiketten, die jedem Skalogramm entsprechen, (Die Anzahl der Daten,Etikette)"""
col = height - 1
label_array = np.reshape(label_array, (-1, height))
label_array = label_array[:, col]
"""Dateiausgabe"""
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):
"""
Funktion zur Durchführung einer kontinuierlichen Wavelet-Transformation
Schlusskurs verwenden
time_series :Daten austauschen,Schlusskurs
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
ch_flag :Anzahl der zu verwendenden Kanäle, ch_flag=5 : start, high, low, close, volume
height :Bildhöhe Anzahl der Zeitlinien
width :Bildbreite Anzahl der Frequenzlinien
"""
"""Austausch von Zeitreihendaten"""
num_series_data = time_series.shape[0] #Holen Sie sich die Anzahl der Daten
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]
"""Führen Sie eine kontinuierliche Wavelet-Konvertierung durch"""
# 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) #Führen Sie eine kontinuierliche Wavelet-Konvertierung durch
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 #Translokation 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
"""Etikett erstellen"""
print("make label...")
#So vergleichen Sie zwei Sequenzen
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
"""
#Wie man es benutzt,langsam
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 #Gehen
else:
label = 1 #Geh hinauf
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),Schneiden Sie so, dass die Zeit durch die Höhe teilbar ist"""
raw_num_shift = label_array.shape[0]
num_shift = int(raw_num_shift / height) * height
label_array = label_array[0:num_shift]
"""Extraktion von Etiketten, die jedem Skalogramm entsprechen, (Die Anzahl der Daten,Etikette)"""
col = height - 1
label_array = np.reshape(label_array, (-1, height))
label_array = label_array[:, col]
"""Dateiausgabe"""
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):
"""
Funktion zur Durchführung einer kontinuierlichen Wavelet-Transformation
Schlusskurs verwenden
time_series :Daten austauschen,Schlusskurs
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
"""
"""Austausch von Zeitreihendaten"""
num_series_data = time_series.shape[0] #Holen Sie sich die Anzahl der Daten
print("number of the series data : " + str(num_series_data))
close = time_series
"""Führen Sie eine kontinuierliche Wavelet-Konvertierung durch"""
# https://pywavelets.readthedocs.io/en/latest/ref/cwt.html
print("carry out cwt...")
cwt_close, freq_close = pywt.cwt(close, scales, wavelet)
#Translokation CWT(freq, time) ⇒ CWT(time, freq)
cwt_close = cwt_close.T
"""Etikett erstellen"""
print("make label...")
#So vergleichen Sie zwei Sequenzen
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
"""
#Wie man es benutzt
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 #Gehen
else:
label = 1 #Geh hinauf
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
"""
"""Dateiausgabe"""
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):
"""
Schlusskurs verwenden
cwt_list :CWT-Ergebnisliste
label_array :Numpy Array mit Beschriftungen
height :Bildhöhe Anzahl der Zeitlinien
width :Bildbreite Anzahl der Frequenzlinien
"""
print("merge CWT")
cwt_close = cwt_list[0] #Schlusskurs CWT(time, freq)
"""CWT(time, freq),Schneiden Sie so, dass die Zeit durch die Höhe teilbar ist"""
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]
"""Formänderung, (Die Anzahl der Daten,Kanal,Höhe(time),Breite(freq))"""
cwt_close = np.reshape(cwt_close, (-1, 1, height, width))
"""Extraktion von Etiketten, die jedem Skalogramm entsprechen, (Die Anzahl der Daten,Etikette)"""
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):
"""
Funktion zur Durchführung einer kontinuierlichen Wavelet-Transformation
Schlusskurs,Verwenden Sie die Lautstärke
time_series :Daten austauschen,Schlusskurs, volume
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
"""
"""Austausch von Zeitreihendaten"""
num_series_data = time_series.shape[0] #Holen Sie sich die Anzahl der Daten
print("number of the series data : " + str(num_series_data))
close = time_series[:,0]
volume = time_series[:,1]
"""Führen Sie eine kontinuierliche Wavelet-Konvertierung durch"""
# 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)
#Translokation CWT(freq, time) ⇒ CWT(time, freq)
cwt_close = cwt_close.T
cwt_volume = cwt_volume.T
"""Etikett erstellen"""
print("make label...")
#So vergleichen Sie zwei Sequenzen
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
"""
#Wie man es benutzt
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 #Gehen
else:
label = 1 #Geh hinauf
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
"""
"""Dateiausgabe"""
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):
"""
Schlusskurs,Verwenden Sie die Lautstärke
cwt_list :CWT-Ergebnisliste
label_array :Numpy Array mit Beschriftungen
height :Bildhöhe Anzahl der Zeitlinien
width :Bildbreite Anzahl der Frequenzlinien
"""
print("merge CWT")
cwt_close = cwt_list[0] #Schlusskurs CWT(time, freq)
cwt_volume = cwt_list[1] #Volumen
"""CWT(time, freq),Schneiden Sie so, dass die Zeit durch die Höhe teilbar ist"""
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]
"""Formänderung, (Die Anzahl der Daten,Kanal,Höhe(time),Breite(freq))"""
cwt_close = np.reshape(cwt_close, (-1, 1, height, width))
cwt_volume = np.reshape(cwt_volume, (-1, 1, height, width))
"""Verschmelzen"""
cwt_close = np.append(cwt_close, cwt_volume, axis=1)
"""Extraktion von Etiketten, die jedem Skalogramm entsprechen, (Die Anzahl der Daten,Etikette)"""
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):
"""
Funktion zur Durchführung einer kontinuierlichen Wavelet-Transformation
Offener Preis, hoher Preis, niedriger Preis, enger Preis,Verwenden Sie die Lautstärke
time_series :Daten austauschen,Offener Preis,Hoher Preis,Niedriger Preis,Schlusskurs, volume
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
"""
"""Austausch von Zeitreihendaten"""
num_series_data = time_series.shape[0] #Holen Sie sich die Anzahl der Daten
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]
"""Führen Sie eine kontinuierliche Wavelet-Konvertierung durch"""
# 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)
#Translokation 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
"""Etikett erstellen"""
print("make label...")
#So vergleichen Sie zwei Sequenzen
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
"""
#Wie man es benutzt
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 #Gehen
else:
label = 1 #Geh hinauf
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
"""
"""Dateiausgabe"""
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 :CWT-Ergebnisliste
label_array :Numpy Array mit Beschriftungen
height :Bildhöhe Anzahl der Zeitlinien
width :Bildbreite Anzahl der Frequenzlinien
"""
print("merge CWT")
cwt_start = cwt_list[0] #Offener Preis
cwt_high = cwt_list[1] #Hoher Preis
cwt_low = cwt_list[2] #Niedriger Preis
cwt_close = cwt_list[3] #Schlusskurs CWT(time, freq)
cwt_volume = cwt_list[4] #Volumen
"""CWT(time, freq),Schneiden Sie so, dass die Zeit durch die Höhe teilbar ist"""
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]
"""Formänderung, (Die Anzahl der Daten,Kanal,Höhe(time),Breite(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))
"""Verschmelzen"""
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)
"""Extraktion von Etiketten, die jedem Skalogramm entsprechen, (Die Anzahl der Daten,Etikette)"""
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 :Name der Exchange-Datendatei
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
height :Bildhöhe Anzahl der Zeitlinien
width :Bildbreite Anzahl der Frequenzlinien
ch_flag :Anzahl der zu verwendenden Kanäle, ch_flag=1:close, ch_flag=2:close and volume, ch_flag=5:start, high, low, close, volume
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
over_lap_inc :CWT-Startzeitinkrement
"""
scalogram = np.empty((0, ch_flag, height, width)) #Ein Array, in dem alle Skalogramme und Beschriftungen gespeichert sind
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) #Holen Sie sich den Schlusskurs als numpy Array
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:] #Ändern Sie die Startzeit von CWT
cwt_list, label_array, freq = CWT_1(temp_time_series, scales, wavelet, predict_time_inc, save_flag) #Führen Sie CWT aus
temp_scalogram, temp_label = merge_CWT_1(cwt_list, label_array, height, width) #Skalogramm erstellen
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Kombinieren Sie alle Skalogramme und Beschriftungen in einem Array
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) #Schlusskurs,Holen Sie sich das Volumen als Numpy-Array
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:] #Ändern Sie die Startzeit von CWT
cwt_list, label_array, freq = CWT_2(temp_time_series, scales, wavelet, predict_time_inc, save_flag) #Führen Sie CWT aus
temp_scalogram, temp_label = merge_CWT_2(cwt_list, label_array, height, width) #Skalogramm erstellen
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Kombinieren Sie alle Skalogramme und Beschriftungen in einem Array
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) #Offener Preis,Hoher Preis,Niedriger Preis,Schlusskurs,Holen Sie sich das Volumen als Numpy-Array
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:] #Ändern Sie die Startzeit von CWT
cwt_list, label_array, freq = CWT_5(temp_time_series, scales, wavelet, predict_time_inc, save_flag) #Führen Sie CWT aus
temp_scalogram, temp_label = merge_CWT_5(cwt_list, label_array, height, width) #Skalogramm erstellen
scalogram = np.append(scalogram, temp_scalogram, axis=0) #Kombinieren Sie alle Skalogramme und Beschriftungen in einem Array
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 :Name der Exchange-Datendatei
scales :Geben Sie die Skala an, die mit einem Numpy-Array verwendet werden soll,Die Skala entspricht der Frequenz des für die Analyse verwendeten Wavelets,Hohe Skalen und niedrige Frequenzen,Wenn es klein ist, wird es hochfrequent sein
wavelet :Wavelet Name,Verwenden Sie eine der folgenden Möglichkeiten
'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh', 'morl'
predict_time_inc :Zeitinkrement zur Vorhersage von Preisbewegungen
height :Bildhöhe Anzahl der Zeitlinien
width :Bildbreite Anzahl der Frequenzlinien
ch_flag :Anzahl der zu verwendenden Kanäle, ch_flag=1:close, ch_flag=2:close and volume, ch_flag=5:start, high, low, close, volume
save_flag : save_flag=1 :Speichern Sie den CWT-Koeffizienten als CSV-Datei, save_flag=0 :Speichern Sie den CWT-Koeffizienten nicht als CSV-Datei
over_lap_inc :CWT-Startzeitinkrement
"""
scalogram = np.empty((0, ch_flag, height, width)) #Ein Array, in dem alle Skalogramme und Beschriftungen gespeichert sind
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) #Holen Sie sich den Schlusskurs als numpy Array
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:] #Ändern Sie die Startzeit von 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) #Kombinieren Sie alle Skalogramme und Beschriftungen in einem Array
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) #Holen Sie sich den Schlusskurs als numpy Array
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:] #Ändern Sie die Startzeit von 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) #Kombinieren Sie alle Skalogramme und Beschriftungen in einem Array
label = np.append(label, temp_label)
label = label.astype(np.int)
return scalogram, label, freq
Recommended Posts