[python]Rete neuronale semplice

[$te]

ho provato a creare una semplice rete che possa riconoscere una lettera d'alfabeto, scritta in una matrice di 9x7.

Ecco il codice:

Codice PHP:

a = range(7)
w = [a,a,a,a,a,a,a,a,a]
for i in range(9):
    for i2 in range(7):
        w[i][i2]= 0;
alfa = 0.09
soglia = 1
t2 = 1
b = 0
t3 = [1,-1,-1,-1,-1,-1,-1]
x1 = [[-1,-1,1,1,1,1,1], [-1,1,-1,-1,-1,-1,1], t3,t3,t3,t3,t3,[-1,1,-1,-1,-1,-1,1], [-1,-1,1,1,1,1,-1]]
x2 = [[-1,-1,1,1,1,-1,-1], [-1,1,-1,-1,-1,1,-1],[1,-1,-1,-1,-1,-1,1], t3, t3, t3, [1,-1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,1,-1], [-1,-1,1,1,1,-1,-1]]
x3 = [[-1,-1,1,1,1,-1,1], [-1,1,-1,-1,-1,1,1],[1,-1,-1,-1,-1,-1,1], t3, t3, t3, [1,-1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,1,-1], [-1,-1,1,1,1,-1,-1]]
x4 = [[-1,1,1,1,1,-1,-1], [1,-1,-1,-1,-1,1,-1],[1,-1,-1,-1,-1,-1,1], t3, t3, t3, [1,-1,-1,-1,-1,-1,1], [1,-1,-1,-1,-1,1,-1], [-1,1,1,1,1,1,-1]]
x5 = [[-1,1,1,1,1,-1,-1], [1,-1,-1,-1,-1,1,-1],[1,-1,-1,-1,-1,-1,1], t3, t3, t3, [1,-1,-1,-1,-1,-1,1], [1,-1,-1,-1,-1,1,-1], [-1,1,1,1,1,1,-1]]


x11 = [[1,-1,-1,-1,-1,1,-1], [1,-1,-1,-1,1,-1,-1],[1,-1,-1,1,-1,-1,-1], [1,-1,1,-1,-1,-1,-1], [1,1,-1,-1,-1,-1,-1], [1,-1,1,-1,-1,-1,-1], [1,-1,-1,1,-1,-1,-1], [1,-1,-1,-1,1,-1,-1], [1,-1,-1,-1,-1,1,-1]]
x12 = [[-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,1,-1],[-1,1,-1,-1,1,-1,-1], [-1,1,-1,1,-1,-1,-1], [-1,1,1,-1,-1,-1,-1], [-1,1,-1,1,-1,-1,-1], [-1,1,-1,-1,1,-1,-1], [-1,1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,-1,1]]
x13 = [[1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1],[-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [-1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [1,1,1,1,1,1,-1]]
x14 = [[1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1],[-1,1,-1,-1,-1,-1,1], [-1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1],[-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [1,1,1,1,1,1,-1]]
x15 = [[-1,-1,-1,1,1,1,1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1],[-1,-1,1,1,1,-1,-1]]
x16 = [[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1],[-1,-1,1,1,1,-1,-1]]
x17 = [[-1,-1,-1,-1,1,1,1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1],[-1,-1,1,1,1,-1,-1]]

x21 = [[1,-1,-1,-1,-1,1,-1], [1,-1,-1,-1,1,-1,-1],[1,-1,-1,1,-1,-1,-1], [1,-1,1,-1,-1,-1,-1], [1,1,-1,-1,-1,-1,-1], [1,-1,1,-1,-1,-1,-1], [1,-1,-1,1,-1,-1,-1], [1,-1,-1,-1,1,-1,-1], [1,-1,-1,-1,-1,1,-1]]
x22 = [[-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,1,-1],[-1,1,-1,-1,1,-1,-1], [-1,1,-1,1,-1,-1,-1], [-1,1,1,-1,-1,-1,-1], [-1,1,-1,1,-1,-1,-1], [-1,1,-1,-1,1,-1,-1], [-1,1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,-1,1]]
x23 = [[1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1],[-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [-1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [1,1,1,1,1,1,-1]]
x24 = [[1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1],[-1,1,-1,-1,-1,-1,1], [-1,1,1,1,1,1,-1], [-1,1,-1,-1,-1,-1,1],[-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [-1,1,-1,-1,-1,-1,1], [1,1,1,1,1,1,-1]]
x25 = [[-1,-1,-1,1,1,1,1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1],[-1,-1,1,1,1,-1,-1]]
x26 = [[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1],[-1,-1,1,1,1,-1,-1]]
x27 = [[-1,-1,-1,-1,1,1,1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1],[-1,-1,-1,-1,-1,1,-1], [-1,-1,-1,-1,-1,1,-1], [-1,1,-1,-1,-1,1,-1],[-1,-1,1,1,1,-1,-1]]


x=[x1,x2,x3,x4]
xx=[x11,x12, x13,x14, x15, x16, x17, x21,x22,x23,x24,x25,x26,x27]

for x1 in x:
    y=0
    for i in range(9):
        for i2 in range(7):
            y = y + x1[i][i2]*w[i][i2]
    y = y + b
    if y > soglia:
        y = 1
    if -soglia<= y <= soglia:
        y = 0
    if y < -soglia:
        y = -1
    if y != 1:
        for i in range(9):
            for i2 in range(7):
                w[i][i2] = w[i][i2] + alfa*t2*x1[i][i2]
                b = b + alfa*t2
                print w[i][i2]
for x1 in xx:                
    y=0
    t2 = -1
    for i in range(9):
        for i2 in range(7):
            y = y + x1[i][i2]*w[i][i2]
    y = y + b
    if y > soglia:
        y = 1
    if -soglia<= y <= soglia:
        y = 0
    if y < -soglia:
        y = -1
    if y != 1:
        for i in range(9):
            for i2 in range(7):
                w[i][i2] = w[i][i2] + alfa*t2*x1[i][i2]
                b = b + alfa*t2
                print "ecco",w[i][i2]

test = [[1,-1,-1,-1,-1,1,-1], [1,-1,-1,-1,1,-1,-1],[1,-1,-1,1,-1,-1,-1], [1,-1,1,-1,-1,-1,-1], [1,1,-1,-1,-1,-1,-1], [1,-1,1,-1,-1,-1,-1], [1,-1,-1,1,-1,-1,-1], [1,-1,-1,-1,1,-1,-1], [1,-1,-1,-1,-1,1,-1]]

y=0
for i in range(9):
    for i2 in range(7):
        y = y + x1[i][i2]*w[i][i2]
y = y + b
if y > soglia:
    y2 = 1
if -soglia<= y <= soglia:
    y2 = 0
if y < -soglia:
    y2 = -1
print  "SI:",y, y2

y=0
for i in range(9):
    for i2 in range(7):
        y = y + test[i][i2]*w[i][i2]
y = y + b
if y > soglia:
    y2 = 1
if -soglia<= y <= soglia:
    y2 = 0
if y < -soglia:
    y2 = -1
print  "NO:",y, y2 


Dove sbaglio???

perché i pesi sono troppo grandi..

grazie

[-MiStO-]

li hai calcolati correttamente i pesi?

edit: i pesi van calcolati così Wij= (1/M)* Σ (Xi*Xj)

con M: num pattern da memorizzare
i,j indici da 1 a num neuroni

[$te]

io i nuovi pesi li calcolavo cosi:

wnew = wold + alfa*target*x

con m cosa intendi nel mio caso? poi non capisco...xké Xi*Xj?

[-MiStO-]

Originariamente inviato da $te

io i nuovi pesi li calcolavo cosi:

wnew = wold + alfa*target*x

con m cosa intendi nel mio caso? poi non capisco...xké Xi*Xj?

ok pensavo usassi un altro modello di rete, quelle di hopfield
(tra l'altro magari questo tipo di reti potrebbe esserti utile se quello che ti serve è un riconoscimento di pattern prefissati,prova a darci un occhiata)

spe provo a leggere un attimo il tuo codice vediamo cosa ne esce

[$te]

ho visto un attimo hopfield, e mi pare sia proprio il tipo di rete per riconoscere un'immagine mio caso una lettera).
Io sto leggendo il libro "Fausett Fundamentals of Neural Networks-Architectures Algorithms Applications", e sono al secondo capitolo, dove fanno appunto un esempio di rete per riconoscere una lettera, e ho provato a creare il codice e provare (senza grandi risultati). Vorrei appunto creare una rete semplice che possa riconoscere una lettera (disegnata su una matrice 9x7).

Come faccio a sapere che tipo di rete usare? devo conoscerle tutte e sapere le loro caratteristiche?

grazie

[-MiStO-]

Originariamente inviato da $te

ho visto un attimo hopfield, e mi pare sia proprio il tipo di rete per riconoscere un'immagine mio caso una lettera).
Io sto leggendo il libro "Fausett Fundamentals of Neural Networks-Architectures Algorithms Applications", e sono al secondo capitolo, dove fanno appunto un esempio di rete per riconoscere una lettera, e ho provato a creare il codice e provare (senza grandi risultati). Vorrei appunto creare una rete semplice che possa riconoscere una lettera (disegnata su una matrice 9x7).

Come faccio a sapere che tipo di rete usare? devo conoscerle tutte e sapere le loro caratteristiche?

grazie

alùra: il libro non lo conosco, prova,se riesci, a postare l'esempio che fan loro (sarà sicuramente corretto) e vediamo insieme se l'implementazione è corretta

per le reti in generale, ti dico quello che ho imparato io seguendo un corso all'università l'anno scorso: per problemi legati a classificazione si usano reti semplici o mutlilayer(a seconda che il problema sia linearmente separabile o meno), come riconoscimento pattern / memorie associative si usa hopfield.

comunque sono soggettive sia l'architettura che la scelta dei pesi che la soglia, si prova finchè non si ha un risultato accettabile

[nico159]

Premetto dicendo che non ho visto tutto il codice, ma stai attento ad alcune cose
Prima di tutto:

a = range(7)
w = [a,a,a,a,a,a,a,a,a]
for i in range(9):
    for i2 in range(7):
        w[i][i2]= 0;

Senza contare il punto e virgola facendo così avrai il problema delle referenze condivise

a = range(7)
w = [a,a,a,a,a,a,a,a,a]
for i in range(9):
    for i2 in range(7):
        w[i][i2]= 0

print a
print w
a.append(1)
print a
print w

[0, 0, 0, 0, 0, 0, 0]
[[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]
[0, 0, 0, 0, 0, 0, 0, 1]
[[0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1]]

Bisogna prestare un pò di attenzione in Python quando si ha a che fare con le liste
Inoltre il codice sembra poco pythonic
Un

lista = [ [0]*7 ]*9

Avresti risolto il problema senza problemi di referenze condivise, e con una sola riga di codice

[$te]

Originariamente inviato da nico159

Premetto dicendo che non ho visto tutto il codice, ma stai attento ad alcune cose
Prima di tutto:

a = range(7)
w = [a,a,a,a,a,a,a,a,a]
for i in range(9):
    for i2 in range(7):
        w[i][i2]= 0;

Senza contare il punto e virgola facendo così avrai il problema delle referenze condivise

a = range(7)
w = [a,a,a,a,a,a,a,a,a]
for i in range(9):
    for i2 in range(7):
        w[i][i2]= 0

print a
print w
a.append(1)
print a
print w

[0, 0, 0, 0, 0, 0, 0]
[[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]
[0, 0, 0, 0, 0, 0, 0, 1]
[[0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1]]

Bisogna prestare un pò di attenzione in Python quando si ha a che fare con le liste
Inoltre il codice sembra poco pythonic
Un

lista = [ [0]*7 ]*9

Avresti risolto il problema senza problemi di referenze condivise, e con una sola riga di codice

xké il punto e virgola?
cosa intendi con referenze condivise? io all'inizio creo solo una matrice 9x7 con gli zeri, che sono i pesi.

Nel libro non cé un esempio di codice, ma dicono:

y_in = b + somma(XiWi)
y = 1 se y_in > soglia, 0 se tra il meno soglia e la soglia, -1 se é minore del meno soglia e i pesi vengono calcolati come ho postato

[$te]

se qualcuno ha un esempio migliore da postare (anche in C, C++, VisualBasic,ecc) lo faccia pure

[cdimauro]

Visto che non hai ricevuto altre risposto, faccio io velocemente per quel che mi compete.

Originariamente inviato da $te

xké il punto e virgola?

Perché "il punto e virgola è il MALE".

In Python le istruzioni sono delimitate dal newline non dal punto e virgola. Quest'ultimo lo puoi usare se vuoi mettere più istruzioni sulla stessa riga, ma non è "pythonic", e men che meno lasciarne uno alla fine di un'istruzionne.

cosa intendi con referenze condivise?

Vuol dire questo:

>>> l = [1, 2, 3, 4]
>>> m = [l, l, l, l]
>>> m
[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
>>> m[1][2] = 'SPAM!'
>>> m
[[1, 2, 'SPAM!', 4], [1, 2, 'SPAM!', 4], [1, 2, 'SPAM!', 4], [1, 2, 'SPAM!', 4]]
>>> l
[1, 2, 'SPAM!', 4]

In soldoni: la lista a cui "punta" l è la stessa a cui puntano i 4 riferimenti con cui è stata creata m.

Nel tuo caso mi pare che tu non debba usare riferimenti, ma lavorare con matrici come faresti con altri linguaggi di programmazione, quindi evita di "riciclare" una lista e creane sempre una nuova, anche se identica a un'altra.

P.S. Per adesso smanetta pure con le liste. Se ti servirà una matrice più efficienti in spazio e velocità poi potrai usare la classe Array del rispettivo modulo, ma... adesso è PREMATURO!

[$te]

Originariamente inviato da cdimauro

Vuol dire questo:

>>> l = [1, 2, 3, 4]
>>> m = [l, l, l, l]
>>> m
[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
>>> m[1][2] = 'SPAM!'
>>> m
[[1, 2, 'SPAM!', 4], [1, 2, 'SPAM!', 4], [1, 2, 'SPAM!', 4], [1, 2, 'SPAM!', 4]]
>>> l
[1, 2, 'SPAM!', 4]

In soldoni: la lista a cui "punta" l è la stessa a cui puntano i 4 riferimenti con cui è stata creata m.

Nel tuo caso mi pare che tu non debba usare riferimenti, ma lavorare con matrici come faresti con altri linguaggi di programmazione, quindi evita di "riciclare" una lista e creane sempre una nuova, anche se identica a un'altra.

P.S. Per adesso smanetta pure con le liste. Se ti servirà una matrice più efficienti in spazio e velocità poi potrai usare la classe Array del rispettivo modulo, ma... adesso è PREMATURO!

ma va?quindi quello ke ho fatto é sbagliato!!!
quindi questa parte é sempre sbagliata? for i in range(9):
for i2 in range(7):
w[i][i2] = w[i][i2] + alfa*t2*x1[i][i2]
poi anche quando uso t3....
aiuto!!! sempre piu problemi:P

[cdimauro]

La parte sbagliata è l'inizializzazione e "nico" t'aveva già suggerito la soluzione:

w = [ [0]*7 ]*9

[$te]

ok!quello l'ho fatto..ma anke in seguito ho sbagliato? quando dichiaro
t3 = [1,-1,-1,-1,-1,-1,-1]
e poi lo uso cosi:
x1 = [[-1,-1,1,1,1,1,1], [-1,1,-1,-1,-1,-1,1], t3,t3,t3,t3,t3,[-1,1,-1,-1,-1,-1,1], [-1,-1,1,1,1,1,-1]]

e quando faccio cosi?:
for i in range(9):
for i2 in range(7):
w[i][i2] = w[i][i2] + alfa*t2*x1[i][i2]

grazie per la pazienza:P

[cdimauro]

Se, come sembra, usi la matrice x1 a sola lettura, allora puoi avere tutti i riferimenti che vuoi: non succede nulla (anzi, risparmi memoria ).

La regoletta che devi usare è la seguente: se devi modificare gli elementi di una lista, generalmente è meglio non usare riferimenti.

Per questo motivo io preferisco utilizzare le tuple quando ho "liste" a sola lettura (potendo usare tutti i riferimenti che voglio), e liste quando devo poterle modificare.

Tornando al tuo programma, w la definirei come lista SENZA riferimenti, mentre le altre sequenze immodificabili li definirei come tuple:

t3 = 1,-1,-1,-1,-1,-1,-1
x1 = ((-1,-1,1,1,1,1,1), (-1,1,-1,-1,-1,-1,1), t3,t3,t3,t3,t3,(-1,1,-1,-1,-1,-1,1), (-1,-1,1,1,1,1,-1))

ecc.

P.S. Non ti preoccupare: chiedi pure. Nel limite del possibile proviamo a risponderti, ma non garantiamo sui tempi di risposta.

[$te]

ah ok. Ma quindi qnd pero cambio i valori, quindi nn uso un tuple, come faccio?
cosi é sbagliato?:
for i in range(9):
for i2 in range(7):
w[i][i2] = w[i][i2] + alfa*t2*x1[i][i2]

grazie

[cdimauro]

Così va benissimo se w l'hai creato e inizializzato come detto in precedenza.

[$te]

ok.
pero qlc non funziona xké non da i risultati esatti.
Come imposto alfa? e la soglia?

[cdimauro]

Questo non lo so: non mi sono mai occupato di reti neurali.

[$te]

eheh....ah ok:P

allora kiedo a ki lo sa

[$te]

...nessuno lo sa???