def testuj_wartosci_norm(siec):
testowe = dc.wczytaj_csv(".\\test.csv")
testowe = dc.konwertuj_na_liczby(testowe)
testowe = dc.normalizuj_dane(testowe)
ilosc_walut = len(testowe)
print("Wybierz z " + str(ilosc_walut) +
" walut numer waluty do przetestowania")
wybor = ""
dlugosc_pakietu = 100
odleglosc_out = 24
offset = 1
while True:
print("")
wybor = input("Wpisz numer waluty")
if ilosc_walut > int(wybor) > -1:
waluta = testowe[int(wybor)]
waluta = np.array(waluta)
pred = []
real = []
for i, row in enumerate(waluta):
if i >= len(waluta) - dlugosc_pakietu - odleglosc_out:
break
pred.append(waluta[i:i + 100])
real.append(waluta[i + 100 + odleglosc_out][1])
pred = np.array(pred)
predicted = siec.testuj(pred)
x = np.linspace(0, len(real), len(real))
plt.plot(x, real, "g-", x, predicted, "r-")
plt.grid(True)
plt.show()
else:
print("Nie ma takiej waluty, wybierz ponownie")
def zrob_dane(sciezka_csv, trybwartosci, dl_pak=480):
dane = dc.wczytaj_csv(sciezka_csv)
dane = dc.konwertuj_na_liczby(dane)
dane = dc.normalizuj_dane(dane)
dane = np.array(dane)
dc.dodaj_ruchoma_srednia(dane, 24)
dc.dodaj_ruchoma_srednia(dane, 60)
dane_test, dane_tren = dc.przygotuj_dane_tren_i_test(dane, offset=24)
# dane_test, dane_tren = dc.zrob_dane_eksperymentalne()
tren_input = []
tren_output = []
dlug_pak = dl_pak
for i, pakiet in enumerate(dane_tren):
# pakiet_in = pakiet[0:dlug_pak]
pakiet_in = []
for j in range(0, dlug_pak):
pakiet_in.append([pakiet[j][0], pakiet[j][1]])
if trybwartosci:
pakiet_out = [pakiet[dlug_pak + 1 * 24 - 1][1]]
else:
a = wsp_a_reg_lin(pakiet[dlug_pak:dlug_pak + 5 * 24])
if a > 0: # 1 / 200000:
pakiet_out = [1, 0]
else:
pakiet_out = [0, 1]
tren_input.append(pakiet_in)
tren_output.append(pakiet_out)
return tren_input, tren_output
def testuj_trendy(siec, typ_sieci='lstm', na_treningowych=False):
if na_treningowych:
sciezka = ".\\trening.csv"
else:
sciezka = ".\\test.csv"
testowe = dc.wczytaj_csv(sciezka)
testowe = dc.konwertuj_na_liczby(testowe)
trendy_calk = 0.0
dlugosc_pakietu = 100
odleglosc_out = 5
offset = 1
for i in range(0, len(testowe)):
waluta = testowe[i]
procentowo = dc.procentowo(waluta)
procentowo = np.array(procentowo)
inputreal, tmp, min, max = dc.przygotuj_input_output_wartosci(
[waluta],
offset=offset,
sekwencja_danych=dlugosc_pakietu,
odleglosc_out=odleglosc_out)
testinput, rzeczywisteproc, minproc, maxproc = dc.przygotuj_input_output_wartosci(
[procentowo],
offset=offset,
sekwencja_danych=dlugosc_pakietu,
odleglosc_out=odleglosc_out)
rzeczproc = []
wartosci = []
for j in range(0, len(inputreal)):
wartosci.append(inputreal[j][dlugosc_pakietu - 1][1] *
(max[j] - min[j]) + min[j])
for j in range(0, len(rzeczywisteproc)):
rzeczproc.append((rzeczywisteproc[j][0] *
(maxproc[j] - minproc[j])) + minproc[j])
if typ_sieci == 'ff':
testinput = dc.przeksztalc_dane_na_ff(testinput)
predicted = siec.testuj(testinput)
for j in range(0, len(predicted)):
predicted[j] = (predicted[j] *
(maxproc[j] - minproc[j])) + minproc[j]
predictedoutput = []
realoutput = []
ilosc = len(waluta) - 1
if ilosc > dlugosc_pakietu + odleglosc_out:
liczba_pakietow = int(
(ilosc - dlugosc_pakietu - odleglosc_out) / offset)
for j in range(0, len(inputreal)):
predictedoutput.append((predicted[j] + 1) * wartosci[j])
realoutput.append((rzeczproc[j] + 1) * wartosci[j])
zgod = wyznacz_poprawnosc_trendu(realoutput, predictedoutput, wartosci)
trendy_calk = trendy_calk + zgod
zgodnosc_calk = trendy_calk / len(testowe)
return zgodnosc_calk
def zrob_trening_wartosci(dane,
l_warstw=2,
l_kom_ukr=32,
bias='true',
akt_przejsc='tanh',
learn_rate=0.3,
momentum=0.3,
decay=0.0,
batch_size=15,
l_epok=3,
l_powtorz_tren=10,
typ='lstm'):
treningowe = dc.wczytaj_csv(".\\files\\" + dane)
treningowe = dc.konwertuj_na_liczby(treningowe)
treningowe = dc.procentowo_dane(treningowe)
treningowe = np.array(treningowe)
input, output, min, max = dc.przygotuj_input_output_wartosci(treningowe)
print("Dane treningowe gotowe")
if typ == 'lstm':
siec = SiecLstmRegresja(l_warstw,
l_kom_ukr,
bias,
l_wejsc=2,
f_aktyw=akt_przejsc,
dl_pak=100)
elif typ == 'ff':
siec = SiecFFRegresja(l_warstw,
l_kom_ukr,
bias,
l_wejsc=2,
f_aktyw=akt_przejsc,
dl_pak=100)
else:
print("Błąd: Wybrano nieprawidłowy typ sieci")
return None
siec.trenuj(input, output, learn_rate, momentum, decay, batch_size, l_epok,
l_powtorz_tren)
siec.zapisz_model()
return siec
def zrob_testy_stat(siec, dane, typ_sieci='lstm'):
sciezka = ".\\files\\" + dane
testowe = dc.wczytaj_csv(sciezka)
testowe = dc.konwertuj_na_liczby(testowe)
liczba_walut = len(testowe)
trendy = []
bledy = []
trendy_calk = 0.0
trend_max = 0.0
trend_min = 100.0
blad_calk = 0.0
blad_max = 0.0
blad_min = 100.0
dlugosc_pakietu = 100
odleglosc_out = 5
offset = 1
for i in range(0, liczba_walut):
waluta = testowe[i]
procentowo = dc.procentowo(waluta)
procentowo = np.array(procentowo)
inputreal, tmp, min, max = dc.przygotuj_input_output_wartosci(
[waluta],
offset=offset,
sekwencja_danych=dlugosc_pakietu,
odleglosc_out=odleglosc_out)
testinput, rzeczywisteproc, minproc, maxproc = dc.przygotuj_input_output_wartosci(
[procentowo],
offset=offset,
sekwencja_danych=dlugosc_pakietu,
odleglosc_out=odleglosc_out)
rzeczproc = []
wartosci = []
for j in range(0, len(inputreal)):
wartosci.append(inputreal[j][dlugosc_pakietu - 1][1] *
(max[j] - min[j]) + min[j])
for j in range(0, len(rzeczywisteproc)):
rzeczproc.append((rzeczywisteproc[j][0] *
(maxproc[j] - minproc[j])) + minproc[j])
if typ_sieci == 'ff':
testinput = dc.przeksztalc_dane_na_ff(testinput)
predicted = siec.testuj(testinput)
for j in range(0, len(predicted)):
predicted[j] = (predicted[j] *
(maxproc[j] - minproc[j])) + minproc[j]
predictedoutput = []
realoutput = []
ilosc = len(waluta) - 1
if ilosc > dlugosc_pakietu + odleglosc_out:
liczba_pakietow = int(
(ilosc - dlugosc_pakietu - odleglosc_out) / offset)
for j in range(0, len(inputreal)):
predictedoutput.append((predicted[j] + 1) * wartosci[j])
realoutput.append((rzeczproc[j] + 1) * wartosci[j])
zgod = wyznacz_poprawnosc_trendu(realoutput, predictedoutput, wartosci)
trendy.append(zgod)
if zgod > trend_max:
trend_max = zgod
if zgod < trend_min:
trend_min = zgod
trendy_calk = trendy_calk + zgod
blad = wyznacz_sredni_blad(realoutput, predictedoutput, wartosci)
bledy.append(blad)
if blad > blad_max:
blad_max = blad
if blad < blad_min:
blad_min = blad
blad_calk = blad_calk + blad
blad_sred = blad_calk / liczba_walut
zgodnosc_calk = trendy_calk / liczba_walut
print("Średnia zgodność trendów: " + str(zgodnosc_calk) +
"%, a średni błąd procentowy: " + str(blad_sred) + "%")
print("Max zgodność trendów: " + str(trend_max) + "%, a min: " +
str(trend_min) + "%")
print("Max błąd dla waluty: " + str(blad_max) + "%, a min: " +
str(blad_min) + "%")
plt.hist(bledy, 15, normed=1, facecolor='green', alpha=0.75)
# plt.plot(x, rzeczproc, 'g-', x, predicted, 'r-')
plt.grid(True)
plt.show()
plt.hist(trendy, 15)
# plt.plot(x, rzeczproc, 'g-', x, predicted, 'r-')
plt.grid(True)
plt.show()
return zgodnosc_calk, blad_sred
def testuj_wartosci_proc(siec, dane, typ_sieci='lstm'):
sciezka = ".\\files\\" + dane
testowe = dc.wczytaj_csv(sciezka)
testowe = dc.konwertuj_na_liczby(testowe)
ilosc_walut = len(testowe)
print("Wybierz z " + str(ilosc_walut) +
" walut numer waluty do przetestowania")
wybor = ""
dlugosc_pakietu = 100
odleglosc_out = 5
offset = 1
while True:
print("")
wybor = input("Wpisz numer waluty (lub 0 by wyjść z programu)")
if int(wybor) == 0:
break
if ilosc_walut > int(wybor) - 1 > -1:
waluta = testowe[int(wybor) - 1]
procentowo = dc.procentowo(waluta)
procentowo = np.array(procentowo)
inputreal, tmp, min, max = dc.przygotuj_input_output_wartosci(
[waluta],
offset=offset,
sekwencja_danych=dlugosc_pakietu,
odleglosc_out=odleglosc_out)
testinput, rzeczywisteproc, minproc, maxproc = dc.przygotuj_input_output_wartosci(
[procentowo],
offset=offset,
sekwencja_danych=dlugosc_pakietu,
odleglosc_out=odleglosc_out)
rzeczproc = []
wartosci = []
for j in range(0, len(inputreal)):
wartosci.append(inputreal[j][dlugosc_pakietu - 1][1] *
(max[j] - min[j]) + min[j])
for j in range(0, len(rzeczywisteproc)):
rzeczproc.append((rzeczywisteproc[j][0] *
(maxproc[j] - minproc[j])) + minproc[j])
print("Dane testowe gotowe")
if typ_sieci == 'ff':
testinput = dc.przeksztalc_dane_na_ff(testinput)
predicted = siec.testuj(testinput)
for j in range(0, len(predicted)):
predicted[j] = (predicted[j] *
(maxproc[j] - minproc[j])) + minproc[j]
predictedoutput = []
realoutput = []
ilosc = len(waluta) - 1
if ilosc > dlugosc_pakietu + odleglosc_out:
liczba_pakietow = int(
(ilosc - dlugosc_pakietu - odleglosc_out) / offset)
for j in range(0, len(inputreal)):
predictedoutput.append((predicted[j] + 1) * wartosci[j])
realoutput.append((rzeczproc[j] + 1) * wartosci[j])
zgod = wyznacz_poprawnosc_trendu(realoutput, predictedoutput,
wartosci)
print("Poprawnosc trendu to: " + str(zgod) + "%")
x = np.linspace(0, len(realoutput), len(realoutput))
plt.plot(x, realoutput, 'g-', x, predictedoutput, 'r-')
# plt.plot(x, rzeczproc, 'g-', x, predicted, 'r-')
plt.grid(True)
plt.show()
else:
print("Nie ma takiej waluty, wybierz ponownie")
def main():
sciezka_csv = ".\gielda.csv"
dane = dc.wczytaj_csv(sciezka_csv)
dane = dc.konwertuj_na_liczby(dane)
dane = dc.normalizuj(dane)
dane_test, dane_tren = dc.przygotuj_dane_tren_i_test(dane)
# TODO: Zrobić, żeby było mniej tych zmiennych, bo dużo miejsca w pamięci
# bo mam dane, dane_test, dane_tren, tren_input i tren_output, a wszystkie w zasadzie zawierają ten sam zestaw
# danych, tylko w różnych wersjach.
tren_input = []
tren_output = []
for i, pakiet in enumerate(dane_tren):
pakiet_in = pakiet[0:720]
pakiet_out = [
pakiet[743][1], pakiet[767][1], pakiet[791][1], pakiet[815][1],
pakiet[839][1]
]
tren_input.append(pakiet_in)
tren_output.append(pakiet_out)
dlugosc_pakietu = 720
batch_size = 10
liczba_ukrytych = 24 # Liczba komorek LSTM w warstwie
l_warstw = 3
dane_wej = tf.placeholder(tf.float32, [None, dlugosc_pakietu, 2])
oczekiwane = tf.placeholder(tf.float32, [None, 5])
weights = tf.Variable(
tf.truncated_normal([liczba_ukrytych,
int(oczekiwane.get_shape()[1])]))
bias = tf.Variable(tf.constant(0.1, shape=[oczekiwane.get_shape()[1]]))
# TODO: Zrobić (jakoś) wiele komórek połączonych warstwami, tak jak opisywaliśmy w konspekcie
komorka = tf.nn.rnn_cell.LSTMCell(liczba_ukrytych, state_is_tuple=True)
wyjscia, state = tf.nn.dynamic_rnn(komorka, dane_wej, dtype=tf.float32)
val = tf.transpose(wyjscia, [1, 0, 2])
last = tf.gather(val, int(val.get_shape()[0]) - 1)
prediction = tf.matmul(last, weights) + bias
loss = tf.reduce_sum(tf.square(prediction - oczekiwane))
optimizer = tf.train.AdamOptimizer().minimize(loss)
###############################################################################################################
# mistakes = tf.not_equal(oczekiwane, prediction)
# accuracy = tf.reduce_mean(tf.cast(mistakes, tf.float32))
# TODO: Zrobić lepszą wersję dokładności, lub pominąć i po prostu oceniać loss
# Chwilowo źle, wykomentowuje żeby nie spowalniało
# To jest źle, ale nie wiem jak oceniać dokładność jeśli chodzi o floaty. Powinna mieścić się w zakresie 0 - 1.
# Im jest większa tym oczywiście lepiej. Poniżej jest wersja dla klasyfikacji używającej kodowania 1 z n,
# która do naszego projektu się ani trochę nie nadaje, ale chwilowo zostaje, do celów edukacyjnych.
###############################################################################################################
init = tf.global_variables_initializer()
tf.summary.scalar("loss", loss)
tf.summary.histogram("weights", weights)
tf.summary.histogram("biases", bias)
summary_op = tf.summary.merge_all()
with tf.Session() as sess:
it = 1
writer = tf.summary.FileWriter('./graphs',
graph=tf.get_default_graph())
batch_num = 0
sess.run(init)
while it < 3000:
#######################################################################################################
# TODO: Zmienić sposób wyznaczania batchy.
# W tym momencie próbki podawane są zestawami po kolei tak jak leżą w tablicy. Może warto zmienić na
# jakiś losowy sposób, ale tak do końca nie wiem.
batch_x = tren_input[batch_num:batch_num + batch_size]
batch_y = tren_output[batch_num:batch_num + batch_size]
_, summary = sess.run([optimizer, summary_op],
feed_dict={
dane_wej: batch_x,
oczekiwane: batch_y
})
if it % 10 == 0:
writer.add_summary(summary, it)
# Chwilowo wykomentowałem acc, bo i tak nasza wersja nic nie pokazuje sensownego, po co ma spowalniać.
# Odkomentować, jak będą poprawione węzły accuracy i mistakes parenaście linijek wyżej
# acc = sess.run(accuracy, feed_dict={dane_wej: batch_x, oczekiwane: batch_y})
los = sess.run(loss,
feed_dict={
dane_wej: batch_x,
oczekiwane: batch_y
})
wynik = sess.run(prediction,
feed_dict={
dane_wej: tren_input[10:11],
oczekiwane: tren_output[10:11]
})
print('Uzyskane: ' + str(wynik))
print('Rzeczywiste: ' + str(tren_output[10:11]))
print("Iteracja ", it)
# print("Accuracy ", acc)
print("Blad ", los)
print("__________________")
it = it + 1
batch_num += 1
if batch_num >= len(tren_input) - batch_size - 1:
batch_num = 0