90 lines
3.6 KiB
Python
90 lines
3.6 KiB
Python
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_funzione_attivazione = 0.5
|
|
|
|
#XOR
|
|
""" pin_est_1 = Percettrone(w1=1.7453135346642987, w2=1.6392557285802016, bias=-2.8396189093513544, lre=0.2)
|
|
pin_est_2 = Percettrone(w1=2.0579802021958487, w2=2.0049998768936956,bias=-1.510128337351728, lre=0.2)
|
|
pinout = Percettrone(w1=-4.872221528209076, w2=2.863271416125622, bias=-0.2593053838395353, lre=0.2) """
|
|
|
|
""" pin_est_1 = Percettrone(w1=5.057571564186738, w2=-5.572150383812219, bias=-3.1715170666210444)
|
|
pin_est_2 = Percettrone(w1=-2.1393104621179835, w2=1.6774379439199167, bias=-0.7542487269674267)
|
|
pinout = Percettrone(w1=3.2061105491734967, w2=1.9571327990877703, bias=-1.319795396902547) """
|
|
|
|
rette = {"P1":[], "P2":[], "POUT":[]}
|
|
|
|
#Pesi per AND, OR e XOR (sigmoide)
|
|
|
|
pin_est_1 = Percettrone()
|
|
pin_est_2 = Percettrone()
|
|
pinout = Percettrone()
|
|
|
|
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
|
|
|
|
# Calcolo le funzioni di attivazione
|
|
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)
|
|
errore = -(output[j] - yout)
|
|
|
|
# Determino la previsione
|
|
if yout >= soglia_funzione_attivazione:
|
|
previsione = 1
|
|
else:
|
|
previsione = 0
|
|
|
|
# Stampo a video e preparo per il plot
|
|
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)
|
|
try:
|
|
rette["P1"].append([-(pin_est_1.w1 * x[j][0])/pin_est_1.w2, -(pin_est_1.bias/pin_est_1.w2)])
|
|
rette["P2"].append([-(pin_est_2.w1 * x[j][0])/pin_est_2.w2, -(pin_est_2.bias/pin_est_2.w2)])
|
|
rette["POUT"].append([-(pinout.w1 * x[j][0])/pinout.w2, -(pinout.bias/pinout.w2)])
|
|
except ZeroDivisionError:
|
|
pass
|
|
|
|
# Confronto la previsione con l'output atteso
|
|
if previsione == output[j]:
|
|
corrette += 1
|
|
else:
|
|
# Calcolo i gradienti e correggo i pesi
|
|
# Gradienti Percettrone 1
|
|
gradiente_w1 = errore * y_est_1 * (1-y_est_1) * x[j][0]
|
|
gradiente_w2 = errore * y_est_1 * (1-y_est_1) * x[j][1]
|
|
gradiente_bias = errore * y_est_1 * (1-y_est_1)
|
|
pin_est_1.correggi_pesi(gradiente_w1, gradiente_w2, gradiente_bias)
|
|
|
|
# Gradienti Percettrone 2
|
|
gradiente_w1 = errore * yout * (1-yout) * y_est_2 * (1-y_est_2) * x[j][0]
|
|
gradiente_w2 = errore * yout * (1-yout) * y_est_2 * (1-y_est_2) * x[j][1]
|
|
gradiente_bias = errore * yout * (1-yout) * y_est_2 * (1-y_est_2)
|
|
pin_est_2.correggi_pesi(gradiente_w1, gradiente_w2, gradiente_bias)
|
|
|
|
# Gradienti Percettrone out
|
|
gradiente_w1 = errore * yout * (1-yout) * y_est_1
|
|
gradiente_w2 = errore * yout * (1-yout) * y_est_2
|
|
gradiente_bias = gradiente_bias = errore * yout * (1-yout)
|
|
pinout.correggi_pesi(gradiente_w1, gradiente_w2, errore)
|
|
|
|
disegna_grafico_multi(rette) |