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