from percettrone import Percettrone
from stampe_video import disegna_funzione, stampa_risultati_single_layer, disegna_grafico_singolo

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

p = Percettrone()
corrette = 0 #Fermo le epoche se termina prima

soglia_funzione_attivazione = 0.5

rette = []

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

    if corrette == 4:
        print(f"Epoche necessarie: {i-1}")
        stampa_risultati_single_layer(p)
        break
    
    print(f"EPOCA {i}")
    corrette = 0;

    for j in range(0,4): #Combinazioni
        y = p.funzione_sigmoide(x[j][0], x[j][1])
        
        if y >= soglia_funzione_attivazione:
            previsione = 1
        else:
            previsione = 0

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

        #La formula del costo è sicuro questa, la retta scappa se tolgo il meno
        #Y è confermato, se metto la previsione invece di y la retta non corrisponde
        errore = -(output[j] - y)

        #Il gradiente può non essere calcolato nel percettrone singolo, funziona lo stesso
        gradiente_w1 = errore * y * (1-y) * x[j][0]
        gradiente_w2 = errore * y * (1-y) * x[j][1]
        gradiente_bias = errore * y * (1-y)
        p.correggi_pesi(gradiente_w1, gradiente_w2, gradiente_bias)
        
        if errore != 0:
            pass
        else:
            corrette += 1

        print("\n")
        disegna_funzione(p, y, x[j][0], x[j][1], True, errore)

        try:
            m = -(p.w1 * x[j][0])/p.w2
            q = -(p.bias/p.w2)
            rette.append([m,q])
        except ZeroDivisionError:
            pass

disegna_grafico_singolo(rette)