# W DOCS
# *args -> w funkcji to jest lista
# **kwargs -> w funkcji to jest słownik
# [, arg] - >opcjonalny argument

import itertools
import numpy as npy
import pandas as pan

from sklearn.preprocessing import LabelEncoder

# Importing libraries for building the neural network
from keras.models import Sequential
from keras.layers import Dense


from sklearn.utils import shuffle
from keras.optimizers import SGD

from keras.utils import to_categorical



number_of_neurons = int(input("Podaj liczbę neuronów: "))
momentum_value = float(input("Podaj wartość momentum, wartość zero oznacza brak momentu, dopuszczalne liczby zmiennoprzecinkowe: "))

for counter in range(5):
    excel_data = pan.read_excel('data/oczyszczone.xls', sheet_name = 'daneSOB') #załadowanie arkusza daneSOB z pliku oczyszczone.xls
    column_headers = excel_data.columns.values #uzyskanie wartości jako listę/łączenie kolumn
    excel_data = shuffle(excel_data) #Metoda shuffle () losuje elementy listy na miejscu

    # one hot encoding – kodowanie etykiet jako tablicę numeryczną
    for i in column_headers:
        label_enc = LabelEncoder() #normalizacja etykiet - usuwa zbędne powtórzenia
        label_enc.fit(excel_data[str(i)]) # dopasuj koder etykiet.  Szacuje ona najlepszą reprezentatywną funkcję dla punktów danych, Znajduje współczynniki dla równania określonego za pomocą używanego algorytmu
        excel_data[str(i)] = label_enc.transform(excel_data[str(i)]) #Przekształć etykiety w znormalizowane kodowanie
        encoded = to_categorical(excel_data[str(i)]) #Konwertuje wektor klasy (liczby całkowite) na macierz klas binarnych.

        if len(encoded[0]) > 2 and i != 'Klasy diagnozy':
            insert_loc = npy.where(column_headers==i) #zwraca elementy jeżeli column_headers = 1
            insert_loc = insert_loc[0][0]

            excel_data = excel_data.drop(columns = i) #usuwa kolumnę 1
            for label in range(len(encoded[0])):
                excel_data.insert(int(insert_loc), str(i) + "_" + str(label), encoded[:,label])
    #print(insert_loc)
    #print(excel_data.head())
    #excel_data.head()
    Y_data = excel_data['Klasy diagnozy']
    X_data = excel_data.drop(columns = 'Klasy diagnozy')
     # ratio 1/2 to 1/2
    X_train = X_data[:238] # bierzecie wartości od indeksu 0 do 238 (bez 238)
    Y_train = Y_data[:238]

    #print(X_train)
    #print(Y_train)
    X_test = X_data[238:] # od 238 do konca
    Y_test = Y_data[238:]

    kfold = [[X_train, Y_train, X_test, Y_test], [ X_test, Y_test, X_train, Y_train]]
    # kfold[0] == [X_train, Y_train, X_test, Y_test]
    # kfold[1] == [ X_test, Y_test, X_train, Y_train]
    cvscores = []
   # print(kfold)

    #Dense - każde wejście połączone jest z wyjściem.
    model = Sequential() #Opcjonalnie pierwsza warstwa może otrzymać argument `input_shape`
    model.add(Dense(units = 106,activation = 'relu',input_dim = 106)) # warstwa wejściowa. units - Dodatnia liczba całkowita, wymiarowość przestrzeni wyjściowej. input_dim -Ma zastosowanie tylko wtedy, gdy warstwa ma dokładnie jedno wejście, tj. Jeśli jest połączona z jedną warstwą wejściową.
    model.add(Dense(units = number_of_neurons, activation = 'relu')) # warstwa ukryta, activation - funkcja aktywacji do użycia
    model.add(Dense(units = 8, activation = 'softmax')) # warstwa wyjściowa. softmax, zamienia logikę na prawdopodobieństwo

    for X_train, Y_train, X_test, Y_test in kfold:
        #Metoda compile () Konfiguruje model do treningu.
        #SGD() - oblicza gradient i aktualizuje naszą macierz wagową W na małych partiach danych treningowych,
        #a nie cały zestaw treningowy

        model.compile(optimizer= SGD(lr = 0.07, momentum=momentum_value),loss= 'sparse_categorical_crossentropy', metrics= ['accuracy'])
        #model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
        #SGD - trenuje na małych partiach danych treningowych, a nie na cały zestaw treningowy. - doczytać

        model.fit(X_train, Y_train, epochs = 5,shuffle = True, verbose = 0, validation_data=(X_test, Y_test)) #trenuje model

        scores = model.evaluate(X_test, Y_test, verbose=0)
        #Zwraca wartość strat i wartości metryk dla modelu w trybie testowym.
        #print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) #wyświetli etykiety dla wyjść skalarnych
        #Ustawienie pełnej wartości (verbose) na True w konfiguracji spowoduje, że usługa wygeneruje więcej danych wyjściowych
        #Jeśli shuffle jest True, całe dane są najpierw tasowane, a następnie dzielone
        #sufferpart2: Tasowanie” jest głównie przydatne, jeśli twoje dane są w jakiś sposób posortowane według klas, ponieważ wtedy każda fałda może zawierać tylko próbki z jednej klasy
        #validation_data - ocenia się stratę i wszelkie metryki modelu na końcu każdej epoki.

        cvscores.append(scores[1] * 100)

    print("%.2f%% (+/- %.2f%%)" % (npy.mean(cvscores), npy.std(cvscores))) # mean - Zwraca średnią elementów tablicy , std -Zwraca odchylenie standardowe, miarę rozprzestrzeniania się rozkładu elementów tablic

print (model.summary())