[PYTHON] Untersuchung der Austauschprognosemethode mit Deep Learning und Wavelet-Konvertierung - Teil 2-
Einführung
Diese Methode hat noch keine guten Ergebnisse erzielt. Ich bin gerade dabei, Ideen als Hobby auszuprobieren, daher denke ich nicht, dass dies für diejenigen nützlich sein wird, die nach einem Werkzeug suchen, das sofort verwendet werden kann. bitte beachte, dass. m (__) m [Vorheriger Artikel] Untersuchung der Austauschprognosemethode unter Verwendung von Deep Learning und Wavelet-Konvertierung
Überblick
Abbildung 1 fasst zusammen, was wir diesmal getan haben. Indem wir die Schlusskurse der 5-Minuten-Balken von USD / JPY und EUR / JPY kontinuierlich in Wavelets umwandeln, abbilden und AI (CNN) lernen lassen, werden wir untersuchen, ob es möglich ist, die Bewegung des Wechselkurses (nach oben oder unten) nach 12 Stunden vorherzusagen. tat. Die durchschnittliche korrekte Antwortrate für Testdaten mit der Anzahl der Lernvorgänge = 8000 oder mehr (selbst wenn die Anzahl der Lernvorgänge weiter erhöht wird, steigt die korrekte Antwortrate für die Trainingsdaten nicht an) betrug 53,7%.
Abbildung 1. Zusammenfassung dessen, was ich diesmal gemacht habe
Was ist Wavelet-Konvertierung?
2 zeigt ein schematisches Diagramm der Wavelet-Umwandlung. Die Fourier-Transformation 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 die Fourier-Transformation stationäre Signale gut analysieren kann, eignet sich die Wavelet-Transformation zur Analyse unregelmäßiger und instationärer Wellenformen.
Figur 2. 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 3. 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.
Änderungen gegenüber dem letzten Mal
Berücksichtigen Sie zusätzlich zu USD / JPY EUR / JPY
Letztes Mal haben wir die Preisbewegung von USD / JPY zu USD / JPY vorhergesagt, aber dieses Mal werden wir die Preisbewegung von USD / JPY und EUR / JPY zu USD / JPY vorhersagen. Ich möchte für jeden USD / JPY und EUR / JPY gleichzeitig ein Skalogramm aus Daten erstellen, aber die von mir verwendeten Austauschdaten hatten eine Zeit, in der die Daten fehlten. Daher mussten nur die Umtauschdaten der Zeit extrahiert werden, die sowohl in USD / JPY als auch in EUR / JPY vorhanden sind. Also habe ich den folgenden Code erstellt. Die von mir verwendeten Austauschdaten sind übrigens in Tabelle 1 aufgeführt.
Tabelle 1. USD / JPY 5 Minuten
align_USD_EUR
import numpy as np
def align_USD_EUR(USD_csv, EUR_csv):
"""
USD/JPY und EUR/Eine Funktion, die fehlende Daten in JPY löscht und den Schlusskurs der Zeit extrahiert, die in beiden vorhanden ist
USD_csv : USD/JPY 5-Minuten-Dateiname
EUR_csv : EUR/JPY 5-Minuten-Dateiname
"""
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])
#Indizes, bei denen die Zeiten nicht übereinstimmen(idx_mismatch)Bekommen
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]))
#Löschen Sie unnötige Daten
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
Erstellen Sie ein Skalogramm aus Daten aus verschiedenen Zeiträumen
Beim letzten Mal wurden alle Skalogramme aus täglichen Wellenformdaten erstellt. Die Personen, die tatsächlich handeln, ändern jedoch den Zeitraum der zu bewertenden Wellenform nach Bedarf. Daher habe ich dieses Mal ein Skalogramm aus den Daten verschiedener Perioden erstellt. Der Datenzeitraum wurde wie folgt ausgewählt. Es ist möglich, die Datenperiode feiner zu gestalten, dies war jedoch aufgrund von Speicherbeschränkungen die Grenze. Lerndaten: 1 Tag, 1,5 Tage, 2 Tage, 2,5 Tage, 3 Tage Testdaten: 1 Tag Das Problem hierbei ist nun, dass sich die Größe des Skalogramms ändert, wenn der Datenzeitraum geändert wird. CNN kann keine Bilder unterschiedlicher Größe lernen. Daher haben wir die Bildgröße mit der Bildverarbeitungsbibliothek "Pillow" auf 128x128 vereinheitlicht.
Figur 4. Schematische Darstellung der einheitlichen Bildgröße
Ändern Sie die Größe des Skalogramms mit Pillow
from PIL import Image
"""
original_scalogram :Originales Skalogramm(numpy Array)
width :Bildbreite nach Größenänderung(=128)
height :Bildhöhe nach Größenänderung(=128)
"""
img_scalogram = Image.fromarray(original_scalogram) #In Bildobjekt konvertieren
img_scalogram = img_scalogram.resize((width, height)) #Bildgröße ändern
array_scalogram = np.array(img_scalogram) #In numpy Array konvertieren
CNN-Struktur und Lernfluss
Die Struktur von CNN und der Lernfluss sind in Fig. 5 bzw. Fig. 6 gezeigt.
Abbildung 5. Struktur von CNN
Abbildung 6. Lernfluss
Berechnungsergebnis
Abbildung 7 zeigt den Übergang der richtigen Antwortrate für die Trainingsdaten und die Testdaten. Wenn die Anzahl der Trainings = 8000 oder mehr ist, erhöht sich die korrekte Antwortrate für die Trainingsdaten nicht. Die durchschnittliche Genauigkeitsrate für Testdaten mit der Anzahl der Lernergebnisse = 8000 bis 20000 betrug 53,7%. Es scheint, dass die korrekte Antwortrate der Testdaten steigt, wenn die Anzahl der Lernvorgänge zwischen 0 und 4000 liegt, aber ich kann nichts dazu sagen.
Abbildung 7. Übergang der richtigen Antwortrate
Das Ergebnis der KI-Vorhersage wird mit einer Wahrscheinlichkeit wie "hoch: 82%, runter: 18%" ausgegeben. Abbildung 8 zeigt den Übergang der Vorhersageergebnisse für die Testdaten. Zu Beginn des Lernens ist die Sicherheit für die meisten Daten gering, z. B. "Aufwärts: 52%, Abwärts: 48%". Mit zunehmender Anzahl von Lernprozessen werden es jedoch nur 90% bis 100%. Obwohl ich mit solcher Zuversicht geantwortet habe, scheint die richtige Antwortrate = 53,7% seltsam.
Abbildung 8. Übergang der Vorhersageergebnisse für Testdaten
Am Ende
Obwohl die richtige Antwortrate> 50% war, kann ich immer noch nicht sagen, ob es ein Zufall war oder ob ich die Merkmale erfassen konnte. .. .. Ich denke, es ist notwendig zu überprüfen, ob die gleiche Genauigkeitsrate durch Ändern des Studienzeitraums und des Testzeitraums erzielt werden kann. Wie in 8 gezeigt, bedeutet die Tatsache, dass die Vorhersageergebnisse mit hoher Sicherheit mit fortschreitendem Training zunehmen, dass die Trainingsdaten Skalogramme mit ähnlichen Eigenschaften wie die Testdaten enthalten. Ich denke, der Grund, warum sich die richtige Antwortrate nicht erhöht, ist, dass die zukünftigen Preisbewegungen nicht zwischen den Trainingsdaten und den Testdaten übereinstimmen, selbst wenn das Skalogramm in der KI als ähnlich beurteilt wird. Wir hoffen daher, dass durch die Berücksichtigung nicht nur des Euro, sondern auch anderer Währungen und Finanzdaten (Erhöhung der Anzahl der Datenkanäle) das Skalogramm diversifiziert und die oben genannten Fehlerrichter reduziert werden können. Derzeit gibt es zu viele Vorhersageergebnisse mit einem hohen Maß an Sicherheit im Vergleich zur richtigen Antwortrate. .. .. Lol
Yu-Nie
Appendix Die für die Analyse verwendeten Daten können wie folgt heruntergeladen werden. USDJPY_20160301_20170228_5min.csv USDJPY_20170301_20170731_5min.csv EURJPY_20160301_20170228_5min.csv EURJPY_20170301_20170731_5min.csv
Unten finden Sie den Code, der für die Analyse verwendet wird.
scalogram_test_7
# 20170731
# y.izumi
import tensorflow as tf
import numpy as np
import scalogram4 as sca #Modul zur Erstellung von FFT und Spektrogrammen
import time
"""Funktionen, die Parameterinitialisierung, Faltungsoperationen und Pooling-Operationen ausführen"""
#=============================================================================================================================================
#Gewichtsinitialisierungsfunktion
def weight_variable(shape, stddev=5e-3): # 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")
#=============================================================================================================================================
"""Bedingungen für die Erstellung von Skalogrammen"""
#=============================================================================================================================================
train_USD_csv = "USDJPY_20160301_20170228_5min.csv" #Name der Exchange-Datendatei, train
train_EUR_csv = "EURJPY_20160301_20170228_5min.csv"
# train_USD_csv = "USDJPY_20170301_20170731_5min.csv" #Name der Exchange-Datendatei, train, for debag
# train_EUR_csv = "EURJPY_20170301_20170731_5min.csv"
test_USD_csv = "USDJPY_20170301_20170731_5min.csv" #Name der Exchange-Datendatei, test
test_EUR_csv = "EURJPY_20170301_20170731_5min.csv"
# scales = np.arange(1,129)
predict_time_inc = 144 #Zeitinkrement zur Vorhersage von Preisbewegungen
# train_heights = [288] #Scallogram Höhe, num of time lines,Geben Sie in der Liste an
# test_heights = [288]
train_heights = [288, 432, 576, 720, 864] #Scallogram Höhe, num of time lines,Geben Sie in der Liste an
test_heights = [288]
base_height = 128 #Höhe des für Trainingsdaten verwendeten Skalogramms
width = 128 #Jakobsmuschelbreite, num of freq lines
ch_flag = 1 #Wählen Sie aus den vier Werten und dem Volumen die zu verwendenden Daten aus, ch_flag=1:close,Bauarbeiten im Gange(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 :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
wavelet = "gaus1" #Wavelet Name, 'gaus1', 'gaus2', 'gaus3', 'gaus4', 'gaus5', 'gaus6', 'gaus7', 'gaus8', 'mexh'
tr_over_lap_inc = 4 #Inkrementelle Zugdaten der CWT-Startzeit
te_over_lap_inc = 36 #CWT-Startzeitinkrement-Testdaten
#==============================================================================================================================================
"""Skalogramme und Beschriftungen erstellen"""
#==============================================================================================================================================
# 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))
#==============================================================================================================================================
"""Datenformverarbeitung"""
#==============================================================================================================================================
#Tauschen Sie die Abmessungen gegen 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
train_batch_size = 100 #Stapelgröße lernen
test_batch_size = 600 #Chargengröße testen
# 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))
#==============================================================================================================================================
"""CNN bauen"""
#==============================================================================================================================================
x = tf.placeholder(tf.float32, [None, input_dim[1], input_dim[2], 2]) # (num_data, height(time), width(freq_lines), ch),ch ist die Anzahl der Eingangsdatenkanäle, 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()))
#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_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)
#==============================================================================================================================================
"""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_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])
#==============================================================================================================================================
"""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
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)
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]
#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, 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}) #AI-Vorhersageergebnisse verwenden alle Daten
# AI_prediction = y_conv.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0}) #AI-Vorhersageergebnis Teststapel verwenden
# 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 use all data
# AI_correct_prediction = correct_prediction.eval(feed_dict={x: te_batch_xs, y_: te_batch_ys, keep_prob: 1.0}) #Richtige Antwort:TRUE,Falsche Antwort: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) #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})
#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, 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 = ",") #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
#==============================================================================================================================================
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 und EUR/Eine Funktion, die fehlende Daten in JPY löscht und den Schlusskurs der Zeit extrahiert, die in beiden vorhanden ist"""
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
#Indizes, bei denen die Zeiten nicht übereinstimmen(idx_mismatch)Bekommen
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]))
#Löschen Sie unnötige Daten
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):
"""
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
heights :Bildhöhe Anzahl der Zeitlinien,Geben Sie in der Liste an
width :Bildbreite Anzahl der Frequenzlinien
base_height :Höhe des für Trainingsdaten verwendeten Skalogramms
"""
"""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
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) #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,:]
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))
"""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:]
temp_label_array = predict_close > corrent_close
# print(temp_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
"""
"""temp_label_array(time),Schneiden Sie so, dass die Zeit durch die Höhe teilbar ist"""
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]
"""Extraktion von Etiketten, die jedem Skalogramm entsprechen, (Die Anzahl der Daten,Etikette)"""
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))
"""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_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
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 :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
heights :Bildhöhe Anzahl der Zeitlinien,Geben Sie in der Liste an
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
base_height :Höhe des für Trainingsdaten verwendeten Skalogramms
"""
scalogram = np.empty((0, ch_flag, base_height, width)) #Ein Array, in dem alle Skalogramme und Beschriftungen gespeichert sind
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) #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 = 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) #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))
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/Name der JPY Exchange-Datendatei
EUR_csv : EUR/Name der JPY 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
heights :Bildhöhe Anzahl der Zeitlinien,Geben Sie in der Liste an
width :Bildbreite Anzahl der Frequenzlinien
ch_flag :Anzahl der zu verwendenden Kanäle, ch_flag=1:close,Bauarbeiten im Gange(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
base_height :Höhe des für Trainingsdaten verwendeten Skalogramms
"""
scalogram = np.empty((0, 2, base_height, width)) #Ein Array, in dem alle Skalogramme und Beschriftungen gespeichert sind
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 und EUR/Löschen Sie fehlende Daten in JPY und extrahieren Sie den Schlusskurs der Zeit, die in beiden vorhanden ist
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:] #Ändern Sie die Startzeit von 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) #Kombinieren Sie alle Skalogramme und Beschriftungen in einem Array
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