from percettrone import Percettrone
from stampe_video import disegna_funzione, stampa_risultati_multilayer, disegna_grafico_multi

MAX_EPOCHE = 100000

x = [(0,0),(0,1),(1,0),(1,1)] # Combinazioni
output = (0,1,1,0) # XOR Logico
#output = (0,0,0,1) # AND Logico
#output = (0,1,1,1) # OR Logico
corrette = 0

soglia_errore_accettabile = 0.001
soglia_funzione_attivazione = 0.5

pin_est_1 = Percettrone(w1=1, w2=1, bias=-2.5, lre=0.2)
pin_est_2 = Percettrone(w1=1, w2=1,bias=-1, lre=0.2)
pinout = Percettrone(w1=1, w2=1, bias=-1, lre=0.2)

discriminanti = {"P1":[], "P2":[], "POUT":[]}

'''
#Pesi per AND, OR e XOR (sigmoide)
pin_est_1 = Percettrone(w1=1, w2=1, bias=-2.5, lre=0.2)
pin_est_2 = Percettrone(w1=1, w2=1,bias=-1, lre=0.2)
pinout = Percettrone(w1=1, w2=1, bias=-1, lre=0.2)
'''

for i in range(1, MAX_EPOCHE): #Epoche

    if corrette == 4:
        print(f"Epoche necessarie: {i-1}")
        stampa_risultati_multilayer(pin_est_1, pin_est_2, pinout)
        break

    corrette = 0;
    print(f"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tEPOCA {i}")

    for j in range(0,4): #Combinazioni
        previsione = -1
        y_est_1 = pin_est_1.funzione_sigmoide(x[j][0], x[j][1])
        y_est_2 = pin_est_2.funzione_sigmoide(x[j][0], x[j][1])
        yout = pinout.funzione_sigmoide(y_est_1, y_est_2)

        if yout >= soglia_funzione_attivazione:
            previsione = 1
        else:
            previsione = 0

        if previsione == output[j]:
            corrette += 1

        errore = -(output[j] - yout)

        print("\n")
        disegna_funzione(pin_est_1, y_est_1, x[j][0], x[j][1], False)
        disegna_funzione(pinout, previsione, y_est_1, y_est_2, True, errore)
        disegna_funzione(pin_est_2, y_est_2, x[j][0], x[j][1], False)

        discriminanti["P1"].append([-(pin_est_1.w1 * x[j][0])/pin_est_1.w2, -(pin_est_1.bias/pin_est_1.w2)])
        discriminanti["P2"].append([-(pin_est_2.w1 * x[j][0])/pin_est_2.w2, -(pin_est_2.bias/pin_est_2.w2)])
        discriminanti["POUT"].append([-(pinout.w1 * x[j][0])/pinout.w2, -(pinout.bias/pinout.w2)])

        #if errore != 0:
            # Gradienti Percettrone 1
        appoggio_w1 = errore * yout * (1-yout) * pinout.w1 * y_est_1 * (1-y_est_1) * x[j][0]
        appoggio_w2 = errore * yout * (1-yout) * pinout.w1 * y_est_1 * (1-y_est_1) * x[j][1]
        appoggio_bias = errore * yout * (1-yout) * pinout.bias * y_est_1 * (1-y_est_1)
        pin_est_1.correggi_pesi(appoggio_w1, appoggio_w2, appoggio_bias)

            # Gradienti Percettrone 2
        appoggio_w1 = errore * yout * (1-yout) * pinout.w2 * y_est_2 * (1-y_est_2) * x[j][0]
        appoggio_w2 = errore * yout * (1-yout) * pinout.w2 * y_est_2 * (1-y_est_2) * x[j][1]
        appoggio_bias = errore * yout * (1-yout) * pinout.bias * y_est_2 * (1-y_est_2)
        pin_est_2.correggi_pesi(appoggio_w1, appoggio_w2, appoggio_bias)

            # Gradienti Percettrone out
        appoggio_w1 = errore * y_est_1
        appoggio_w2 = errore * y_est_2
        pinout.correggi_pesi(appoggio_w1, appoggio_w2, errore)
        #else:
        #    corrette += 1

disegna_grafico_multi(discriminanti)