aggiunta grafici sia per il single layer che per il multilayer

grafico.py

@@ -1,57 +1,27 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
-""" #plt.style.use('_mpl-gallery')
+""" class Grafico:
 
-# plot
+    def __init__(self):
-fig, ax = plt.subplots()
+        self.x = np.linspace(-10, 10, 100)  #Variazione di X per disegnare la retta penso
         
-#AND Logico
+        plt.title('AND Logico')
-ax.plot(0, 0, 'o', markeredgewidth=2)
+        plt.xlabel('X1')
-ax.plot(0, 1, 'o', markeredgewidth=2)
+        plt.ylabel('X2')
-ax.plot(1, 0, 'o', markeredgewidth=2)
-ax.plot(1, 1, 'x', markeredgewidth=2)
 
+        plt.xlim(0, 2)
+        plt.ylim(0, 2)
 
-ax.plot(0.5, 0.7, linewidth=2.0)
+    def disegna_and(self):
-#ax.plot(x2, y2 - 2.5, 'o-', linewidth=2)
+        plt.plot(0, 0, 'o', color='red', markeredgewidth=10)
+        plt.plot(0, 1, 'o', color='red',markeredgewidth=10)
+        plt.plot(1, 0, 'o', color='red',markeredgewidth=10)
+        plt.plot(1, 1, 'o', color='green',markeredgewidth=10)
 
-#ax.set(xlim=(0, 8), xticks=np.arange(1, 8),
+    def mostra(self):
-#       ylim=(0, 8), yticks=np.arange(1, 8))
+        plt.show()
     
-plt.show() """
+grafico = Grafico()
-
+grafico.disegna_and()
-# Definisci i parametri della retta
+grafico.mostra() """
-m = 2  # coefficiente angolare
-q = 1  # intercetta
-
-# Crea un array di valori x
-x = np.linspace(0, 2, 100)  # 100 punti tra -10 e 10
-
-# Calcola i valori di y usando l'equazione della retta
-y = m * x + q
-
-# Crea il grafico
-#plt.figure(figsize=(8, 6)) #Grandezza finestra
-#plt.plot(x, y, label=f'y = {m}x + {q}', color='blue') # RETTA
-
-plt.title('AND Logico')
-plt.xlabel('X1')
-plt.ylabel('X2')
-
-#AND Logico
-plt.plot(0, 0, 'o', color='red', markeredgewidth=10)
-plt.plot(0, 1, 'o', color='red',markeredgewidth=10)
-plt.plot(1, 0, 'o', color='red',markeredgewidth=10)
-plt.plot(1, 1, 'o', color='green',markeredgewidth=10)
-
-plt.axhline(0, color='black',linewidth=0.5, ls='--')
-plt.axvline(0, color='black',linewidth=0.5, ls='--')
-
-#plt.grid(color = 'gray', linestyle = '--', linewidth = 0.5)
-plt.legend()
-
-plt.xlim(0, 2)
-plt.ylim(0, 2)
-
-plt.show()

multi_layer.py

@@ -1,5 +1,5 @@
 from percettrone import Percettrone
-from stampe_video import disegna_funzione, stampa_risultati_multilayer
+from stampe_video import disegna_funzione, stampa_risultati_multilayer, disegna_grafico_multi
 
 MAX_EPOCHE = 100000
 
@@ -16,6 +16,8 @@ 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)
@@ -54,6 +56,10 @@ for i in range(1, MAX_EPOCHE): #Epoche
         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]
@@ -73,3 +79,5 @@ for i in range(1, MAX_EPOCHE): #Epoche
         pinout.correggi_pesi(appoggio_w1, appoggio_w2, errore)
         #else:
         #    corrette += 1
+
+disegna_grafico_multi(discriminanti)

single_layer.py

@@ -1,5 +1,5 @@
 from percettrone import Percettrone
-from stampe_video import disegna_funzione, stampa_risultati_single_layer
+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
@@ -11,6 +11,8 @@ corrette = 0 #Fermo le epoche se termina prima
 soglia_errore_accettabile = 0.001
 soglia_funzione_attivazione = 0.5
 
+discriminanti = []
+
 for i in range(1,10000): #Epoche
 
     if corrette == 4:
@@ -37,6 +39,10 @@ for i in range(1,10000): #Epoche
         print("\n")
         disegna_funzione(p, y, x[j][0], x[j][1], True, errore)
 
+        m = -(p.w1 * x[j][0])/p.w2
+        q = -(p.bias/p.w2)
+        discriminanti.append([m,q])
+
         if errore != 0:
             appoggio_w1 = errore * y * (1-y) * p.w1 * x[j][0]
             appoggio_w2 = errore * y * (1-y) * p.w1 * x[j][1]
@@ -44,3 +50,5 @@ for i in range(1,10000): #Epoche
             p.correggi_pesi(appoggio_w1, appoggio_w2, appoggio_bias)
         else:
             corrette += 1
+
+disegna_grafico_singolo(discriminanti)

stampe_video.py

@@ -23,3 +23,74 @@ def stampa_risultati_multilayer(pin_est_1, pin_est_2, pinout):
     print(f"\t W1: {pin_est_2.w1}, W2: {pin_est_2.w2}, bias: {pin_est_2.bias}")
     print("Percettrone OUT:")
     print(f"\t W1: {pinout.w1}, W2: {pinout.w2}, bias: {pinout.bias}")
+
+
+def disegna_grafico_singolo(lista_rette):
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    # m: coefficiente angolare
+    # q: intercetta
+
+    # Crea un array di valori ascissa per disegnare la retta penso
+    x = np.linspace(-10, 10, 100)
+
+    plt.title('AND Logico')
+    plt.xlabel('X1')
+    plt.ylabel('X2')
+
+    #AND Logico
+    plt.plot(0, 0, 'o', color='red', markeredgewidth=10)
+    plt.plot(0, 1, 'o', color='red',markeredgewidth=10)
+    plt.plot(1, 0, 'o', color='red',markeredgewidth=10)
+    plt.plot(1, 1, 'o', color='green',markeredgewidth=10)
+
+    plt.xlim(0, 2)
+    plt.ylim(0, 2)
+
+    for discriminante in lista_rette:
+        # Calcola i valori di y usando l'equazione della retta
+        y = discriminante[0] * x + discriminante[1]
+        discriminante, = plt.plot(x, y, label=f'y = mx + q', color='blue') # RETTA
+        plt.pause(0.0001)
+        discriminante.remove()
+
+    plt.show()
+
+def disegna_grafico_multi(lista_rette):
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    # Crea un array di valori ascissa per disegnare la retta penso
+    x = np.linspace(-10, 10, 100)
+
+    plt.title('XOR Logico')
+    plt.xlabel('X1')
+    plt.ylabel('X2')
+
+    #XOR Logico
+    plt.plot(0, 0, 'o', color='red', markeredgewidth=5)
+    plt.plot(0, 1, 'o', color='green',markeredgewidth=5)
+    plt.plot(1, 0, 'o', color='green',markeredgewidth=5)
+    plt.plot(1, 1, 'o', color='red',markeredgewidth=5)
+    
+    plt.xlim(0, 2)
+    plt.ylim(0, 2)
+
+    discriminanti_p1 = lista_rette["P1"]
+    discriminanti_p2 = lista_rette["P2"]
+    discriminanti_pout = lista_rette["POUT"]
+
+    size_vettori = len(discriminanti_pout)
+
+    for i in range(0, size_vettori):
+        plot_uno, = plt.plot(x, discriminanti_p1[i][0] * x + discriminanti_p1[i][1], label=f'percettrone 1', color='green') # RETTA
+        plot_due, = plt.plot(x, discriminanti_p2[i][0] * x + discriminanti_p2[i][1], label=f'percettrone 2', color='red') # RETTA
+        plot_out, = plt.plot(x, discriminanti_pout[i][0] * x + discriminanti_pout[i][1], label=f'percettrone out', color='blue') # RETTA
+
+        plt.pause(0.0001)
+        plot_uno.remove()
+        plot_due.remove()
+        plot_out.remove()
+
+    plt.show()